eslint-plugin-markdown-preferences 0.23.0 → 0.25.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";
@@ -109,13 +109,20 @@ function getThematicBreakMarker(sourceCode, node) {
 * Get the source location from a range in a node.
 */
 function getSourceLocationFromRange(sourceCode, node, range) {
-	const [nodeStart] = sourceCode.getRange(node);
+	const nodeRange = sourceCode.getRange(node);
+	const loc = sourceCode.getLoc(node);
+	if (nodeRange[1] <= range[0]) return getSourceLocationFromRangeAndSourcePosition(sourceCode, nodeRange[1], loc.end, range);
+	return getSourceLocationFromRangeAndSourcePosition(sourceCode, nodeRange[0], loc.start, range);
+}
+/**
+* Get the source location from a range
+*/
+function getSourceLocationFromRangeAndSourcePosition(sourceCode, startIndex, startLoc, range) {
 	let startLine, startColumn;
-	if (nodeStart <= range[0]) {
-		const loc = sourceCode.getLoc(node);
-		const beforeLines = sourceCode.text.slice(nodeStart, range[0]).split(/\n/u);
-		startLine = loc.start.line + beforeLines.length - 1;
-		startColumn = (beforeLines.length === 1 ? loc.start.column : 1) + (beforeLines.at(-1) || "").length;
+	if (startIndex <= range[0]) {
+		const beforeLines = sourceCode.text.slice(startIndex, range[0]).split(/\n/u);
+		startLine = startLoc.line + beforeLines.length - 1;
+		startColumn = (beforeLines.length === 1 ? startLoc.column : 1) + (beforeLines.at(-1) || "").length;
 	} else {
 		const beforeLines = sourceCode.text.slice(0, range[0]).split(/\n/u);
 		startLine = beforeLines.length;
@@ -364,15 +371,23 @@ function getParsedLines(sourceCode) {
 }
 
 //#endregion
-//#region src/utils/get-text-width.ts
+//#region src/utils/text-width.ts
 let segmenter;
 /**
 * Get the width of a text string.
 */
-function getTextWidth(text) {
-	if (!text.includes("	")) return stringWidth(text);
+function getTextWidth(text, start = 0, end = text.length) {
+	if (!text.includes("	")) return stringWidth(text.slice(start, end));
 	if (!segmenter) segmenter = new Intl.Segmenter("en");
-	let width = 0;
+	const prefixWidth = getTextWidthBySegment(text.slice(0, start), 0);
+	return getTextWidthBySegment(text.slice(start, end), prefixWidth);
+}
+/**
+* Get the width of a text string by segmenter.
+*/
+function getTextWidthBySegment(text, startWidth) {
+	if (!segmenter) segmenter = new Intl.Segmenter("en");
+	let width = startWidth;
 	for (const { segment: c } of segmenter.segment(text)) if (c === "	") width += 4 - width % 4;
 	else width += stringWidth(c);
 	return width;
@@ -386,7 +401,7 @@ var atx_heading_closing_sequence_length_default = createRule("atx-heading-closin
 		docs: {
 			description: "enforce consistent length for the closing sequence (trailing #s) in ATX headings.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -524,7 +539,7 @@ var atx_heading_closing_sequence_default = createRule("atx-heading-closing-seque
 		docs: {
 			description: "enforce consistent use of closing sequence in ATX headings.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -600,12 +615,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 +649,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", {
@@ -626,7 +715,7 @@ var blockquote_marker_alignment_default = createRule("blockquote-marker-alignmen
 		docs: {
 			description: "enforce consistent alignment of blockquote markers",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -655,38 +744,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 +798,7 @@ function getOtherMarker(unavailableMarker) {
 /**
 * Parse rule options.
 */
-function parseOptions$2(options) {
+function parseOptions$4(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}").`);
@@ -746,7 +830,7 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 		docs: {
 			description: "enforce consistent bullet list (unordered list) marker style",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -782,7 +866,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$4(context.options[0] || {});
 		let containerStack = {
 			node: sourceCode.ast,
 			level: 1,
@@ -1045,7 +1129,7 @@ var code_fence_length_default = createRule("code-fence-length", {
 		docs: {
 			description: "enforce consistent code fence length in fenced code blocks.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -1182,7 +1266,7 @@ var code_fence_style_default = createRule("code-fence-style", {
 		docs: {
 			description: "enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -1229,7 +1313,7 @@ var definitions_last_default = createRule("definitions-last", {
 		docs: {
 			description: "require link definitions and footnote definitions to be placed at the end of the document",
 			categories: [],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -3353,7 +3437,7 @@ var emphasis_delimiters_style_default = createRule("emphasis-delimiters-style",
 		docs: {
 			description: "enforce a consistent delimiter style for emphasis and strong emphasis",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -3535,7 +3619,7 @@ var hard_linebreak_style_default = createRule("hard-linebreak-style", {
 		docs: {
 			description: "enforce consistent hard linebreak style.",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -4334,275 +4418,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 +4686,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 +4859,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 +4917,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 +4976,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,386 +4997,1438 @@ 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]];
-	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
+	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)
 	};
-}
-/**
-* Parse the link definition from the given text.
-*/
-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
+	if (node.checked == null) return {
+		marker: parsedMarker,
+		taskListItemMarker: null
 	};
-	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
+	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)
+			}
 		};
 	}
-	skipSpaces();
-	if (text.length <= index) return {
-		label,
-		destination,
-		title: null
-	};
-	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
+		marker: parsedMarker,
+		taskListItemMarker: null
 	};
-	/**
-	* 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
-//#region src/rules/link-bracket-newline.ts
-var link_bracket_newline_default = createRule("link-bracket-newline", {
+//#region src/rules/indent.ts
+/**
+* Parse options.
+*/
+function parseOptions$3(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 linebreaks after opening and before closing link brackets",
+			description: "enforce consistent indentation in Markdown files",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
 		schema: [{
 			type: "object",
-			properties: {
-				newline: { enum: [
-					"always",
-					"never",
-					"consistent"
-				] },
-				multiline: { type: "boolean" }
-			},
+			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: {
-			expectedNewlineAfterOpeningBracket: "Expected a linebreak after this opening bracket.",
-			unexpectedNewlineAfterOpeningBracket: "Unexpected linebreak after this opening bracket.",
-			expectedNewlineBeforeClosingBracket: "Expected a linebreak before this closing bracket.",
-			unexpectedNewlineBeforeClosingBracket: "Unexpected linebreak before this closing bracket."
+			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 optionProvider = parseOptions$3(context.options[0]);
-		/**
-		* Parse the options.
-		*/
-		function parseOptions$3(option) {
-			const newline = option?.newline ?? "never";
-			const multiline = option?.multiline ?? false;
-			return (bracketsRange) => {
-				if (multiline) {
-					if (sourceCode.text.slice(bracketsRange[0] + 1, bracketsRange[1] - 1).trim().includes("\n")) return "always";
+		const options = parseOptions$3(context.options[0]);
+		class AbsBlockStack {
+			violations = [];
+			getCurrentBlockquote() {
+				let block = this;
+				while (block) {
+					if (block.type === "blockquote") return block;
+					block = block.upper;
 				}
-				return newline;
-			};
+				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;
+			}
 		}
-		/**
-		* Verify the newline around the brackets.
-		*/
-		function verifyNewlineAroundBrackets(node, bracketsRange) {
-			const newline = optionProvider(bracketsRange);
-			const openingBracketIndex = bracketsRange[0];
-			const spaceAfterOpeningBracket = getSpaceAfterOpeningBracket(openingBracketIndex);
-			verifyNewlineAfterOpeningBracket(node, spaceAfterOpeningBracket, openingBracketIndex, newline);
-			const closingBracketIndex = bracketsRange[1] - 1;
-			const newlineOptionBeforeClosingBracket = newline === "consistent" ? getSpaceAfterOpeningBracket(bracketsRange[0]).includes("\n") ? "always" : "never" : newline;
-			verifyNewlineBeforeClosingBracket(node, getSpaceBeforeClosingBracket(closingBracketIndex), openingBracketIndex, closingBracketIndex, newlineOptionBeforeClosingBracket);
+		class RootStack extends AbsBlockStack {
+			type = "root";
+			node;
+			upper = null;
+			constructor(node) {
+				super();
+				this.node = node;
+			}
+			getExpectedIndent() {
+				return 0;
+			}
 		}
-		/**
-		* Verify the newline after the opening bracket and before the closing bracket.
-		*/
-		function verifyNewlineAfterOpeningBracket(node, spaceAfterOpeningBracket, openingBracketIndex, newline) {
-			if (newline === "always") {
-				if (spaceAfterOpeningBracket.includes("\n")) return;
-				const loc = getSourceLocationFromRange(sourceCode, node, [openingBracketIndex, openingBracketIndex + 1]);
-				context.report({
-					node,
-					loc,
-					messageId: "expectedNewlineAfterOpeningBracket",
-					fix: (fixer) => fixer.insertTextAfterRange([openingBracketIndex, openingBracketIndex + 1], `\n${" ".repeat(loc.start.column)}${spaceAfterOpeningBracket}`)
-				});
-			} else if (newline === "never") {
-				if (!spaceAfterOpeningBracket.includes("\n")) return;
-				context.report({
-					node,
-					loc: getSourceLocationFromRange(sourceCode, node, [openingBracketIndex + 1, openingBracketIndex + 1 + spaceAfterOpeningBracket.length]),
-					messageId: "unexpectedNewlineAfterOpeningBracket",
-					fix: (fixer) => fixer.replaceTextRange([openingBracketIndex + 1, openingBracketIndex + 1 + spaceAfterOpeningBracket.length], " ")
-				});
+		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;
 			}
 		}
-		/**
-		* Verify the newline before the closing bracket.
-		*/
-		function verifyNewlineBeforeClosingBracket(node, spaceBeforeClosingBracket, openingBracketIndex, closingBracketIndex, newline) {
-			if (openingBracketIndex + 1 === closingBracketIndex - spaceBeforeClosingBracket.length) return;
-			if (newline === "always") {
-				if (spaceBeforeClosingBracket.includes("\n")) return;
-				context.report({
-					node,
-					loc: getSourceLocationFromRange(sourceCode, node, [closingBracketIndex, closingBracketIndex + 1]),
-					messageId: "expectedNewlineBeforeClosingBracket",
-					fix: (fixer) => {
-						const openingBracketLoc = getSourceLocationFromRange(sourceCode, node, [openingBracketIndex, openingBracketIndex + 1]);
-						return fixer.insertTextBeforeRange([closingBracketIndex, closingBracketIndex + 1], `\n${" ".repeat(openingBracketLoc.start.column)}`);
+		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
 				});
-			} else if (newline === "never") {
-				if (!spaceBeforeClosingBracket.includes("\n")) return;
-				context.report({
-					node,
-					loc: getSourceLocationFromRange(sourceCode, node, [closingBracketIndex - spaceBeforeClosingBracket.length, closingBracketIndex]),
-					messageId: "unexpectedNewlineBeforeClosingBracket",
-					fix: (fixer) => fixer.replaceTextRange([closingBracketIndex - spaceBeforeClosingBracket.length, closingBracketIndex], " ")
-				});
+				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) {
-				if (getLinkKind(sourceCode, node) !== "inline") return;
-				const parsed = parseInlineLink(sourceCode, node);
-				if (!parsed) return;
-				verifyNewlineAroundBrackets(node, parsed.text.range);
+				verifyLink(node);
+				blockStack = new LinkStack(node);
 			},
 			linkReference(node) {
-				const parsed = parseLinkReference(sourceCode, node);
-				if (!parsed) return;
-				verifyNewlineAroundBrackets(node, parsed.text.range);
-				if (parsed.label?.type === "full") verifyNewlineAroundBrackets(node, parsed.label.range);
-			},
-			image(node) {
-				const parsed = parseImage(sourceCode, node);
-				if (!parsed) return;
-				verifyNewlineAroundBrackets(node, parsed.text.range);
+				verifyLinkReference(node);
+				blockStack = new LinkStack(node);
 			},
-			imageReference(node) {
-				const parsed = parseImageReference(sourceCode, node);
-				if (!parsed) return;
-				verifyNewlineAroundBrackets(node, parsed.text.range);
-				if (parsed.label?.type === "full") verifyNewlineAroundBrackets(node, parsed.label.range);
+			"blockquote, listItem, footnoteDefinition, link, linkReference:exit"() {
+				flushViolations(blockStack);
+				blockStack = blockStack.upper;
 			},
-			definition(node) {
-				const parsed = parseLinkDefinition(sourceCode, node);
-				if (!parsed) return;
-				verifyNewlineAroundBrackets(node, parsed.label.range);
+			"root:exit"() {
+				flushViolations(blockStack);
 			}
 		};
 		/**
-		* Get the spaces after the opening bracket.
+		* Verify a thematic break node.
 		*/
-		function getSpaceAfterOpeningBracket(openingBracketIndex) {
-			for (let i = openingBracketIndex + 1; i < sourceCode.text.length; i++) {
-				const char = sourceCode.text[i];
-				if (isWhitespace(char)) continue;
-				return sourceCode.text.slice(openingBracketIndex + 1, i);
-			}
-			return sourceCode.text.slice(openingBracketIndex + 1);
+		function verifyThematicBreak(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent(lineNumbersFromRange(loc.start.line, loc.end.line), (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
 		}
 		/**
-		* Get the spaces before the closing bracket.
+		* Verify a heading node.
 		*/
-		function getSpaceBeforeClosingBracket(closingBracketIndex) {
-			for (let i = closingBracketIndex - 1; i >= 0; i--) {
-				const char = sourceCode.text[i];
-				if (isWhitespace(char)) continue;
-				return sourceCode.text.slice(i + 1, closingBracketIndex);
-			}
-			return sourceCode.text.slice(0, closingBracketIndex);
-		}
-	}
-});
-
-//#endregion
-//#region src/rules/link-bracket-spacing.ts
-/**
-* The basic option for links and images.
-*/
-function parseOptions$1(option) {
-	const space = option?.space ?? "never";
-	const imagesInLinks = option?.imagesInLinks;
-	return {
-		space,
-		spaceForText: getOptionForText
-	};
-	/**
-	* Get the spacing option for the given node.
-	*/
-	function getOptionForText(node) {
-		if (imagesInLinks != null) {
-			const children = [...node.children];
-			let child;
-			while (children.length && (child = children[0]) && child.type === "text" && isWhitespace(child.value)) children.shift();
-			while (children.length && (child = children[children.length - 1]) && child.type === "text" && isWhitespace(child.value)) children.pop();
-			const loneChild = children.length === 1 ? children[0] : null;
-			if (loneChild?.type === "image" || loneChild?.type === "imageReference") return imagesInLinks ? "always" : "never";
-		}
-		if (node.children.length === 0 || node.children.length === 1 && node.children[0]?.type === "text" && isWhitespace(node.children[0].value)) return "ignore";
-		return space;
-	}
-}
-var link_bracket_spacing_default = createRule("link-bracket-spacing", {
-	meta: {
-		type: "layout",
-		docs: {
-			description: "enforce consistent spacing inside link brackets",
-			categories: ["standard"],
-			listCategory: "Stylistic"
-		},
-		fixable: "whitespace",
-		hasSuggestions: false,
-		schema: [{
-			type: "object",
-			properties: {
-				space: { enum: ["always", "never"] },
-				imagesInLinks: { type: "boolean" }
-			},
-			additionalProperties: false
-		}],
-		messages: {
-			unexpectedSpaceAfterOpeningBracket: "Unexpected space after opening bracket.",
-			expectedSpaceAfterOpeningBracket: "Expected space after opening bracket.",
-			unexpectedSpaceBeforeClosingBracket: "Unexpected space before closing bracket.",
-			expectedSpaceBeforeClosingBracket: "Expected space before closing bracket."
+		function verifyHeading(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent(lineNumbersFromRange(loc.start.line, loc.end.line), (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
 		}
-	},
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const options = parseOptions$1(context.options[0]);
 		/**
-		* Verify the space after the opening bracket and before the closing bracket.
+		* Verify a code block node.
 		*/
-		function verifySpaceAfterOpeningBracket(node, openingBracketIndex, spaceOption) {
-			const space = getSpaceAfterOpeningBracket(openingBracketIndex);
-			if (space.includes("\n")) return;
-			if (spaceOption === "always") {
-				if (space.length > 0) return;
-				context.report({
-					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 underline of a setext heading.
+*/
+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;
+		}
+	}
+	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
+		}
+	};
+	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
+		}
+	};
+}
+
+//#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: "Notation"
+		},
+		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: "Notation"
+		},
+		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/rules/link-bracket-newline.ts
+var link_bracket_newline_default = createRule("link-bracket-newline", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce linebreaks after opening and before closing link brackets",
+			categories: ["standard"],
+			listCategory: "Whitespace"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				newline: { enum: [
+					"always",
+					"never",
+					"consistent"
+				] },
+				multiline: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			expectedNewlineAfterOpeningBracket: "Expected a linebreak after this opening bracket.",
+			unexpectedNewlineAfterOpeningBracket: "Unexpected linebreak after this opening bracket.",
+			expectedNewlineBeforeClosingBracket: "Expected a linebreak before this closing bracket.",
+			unexpectedNewlineBeforeClosingBracket: "Unexpected linebreak before this closing bracket."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const optionProvider = parseOptions$5(context.options[0]);
+		/**
+		* Parse the options.
+		*/
+		function parseOptions$5(option) {
+			const newline = option?.newline ?? "never";
+			const multiline = option?.multiline ?? false;
+			return (bracketsRange) => {
+				if (multiline) {
+					if (sourceCode.text.slice(bracketsRange[0] + 1, bracketsRange[1] - 1).trim().includes("\n")) return "always";
+				}
+				return newline;
+			};
+		}
+		/**
+		* Verify the newline around the brackets.
+		*/
+		function verifyNewlineAroundBrackets(node, bracketsRange) {
+			const newline = optionProvider(bracketsRange);
+			const openingBracketIndex = bracketsRange[0];
+			const spaceAfterOpeningBracket = getSpaceAfterOpeningBracket(openingBracketIndex);
+			verifyNewlineAfterOpeningBracket(node, spaceAfterOpeningBracket, openingBracketIndex, newline);
+			const closingBracketIndex = bracketsRange[1] - 1;
+			const newlineOptionBeforeClosingBracket = newline === "consistent" ? getSpaceAfterOpeningBracket(bracketsRange[0]).includes("\n") ? "always" : "never" : newline;
+			verifyNewlineBeforeClosingBracket(node, getSpaceBeforeClosingBracket(closingBracketIndex), openingBracketIndex, closingBracketIndex, newlineOptionBeforeClosingBracket);
+		}
+		/**
+		* Verify the newline after the opening bracket and before the closing bracket.
+		*/
+		function verifyNewlineAfterOpeningBracket(node, spaceAfterOpeningBracket, openingBracketIndex, newline) {
+			if (newline === "always") {
+				if (spaceAfterOpeningBracket.includes("\n")) return;
+				const loc = getSourceLocationFromRange(sourceCode, node, [openingBracketIndex, openingBracketIndex + 1]);
+				context.report({
+					node,
+					loc,
+					messageId: "expectedNewlineAfterOpeningBracket",
+					fix: (fixer) => fixer.insertTextAfterRange([openingBracketIndex, openingBracketIndex + 1], `\n${" ".repeat(loc.start.column)}${spaceAfterOpeningBracket}`)
+				});
+			} else if (newline === "never") {
+				if (!spaceAfterOpeningBracket.includes("\n")) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [openingBracketIndex + 1, openingBracketIndex + 1 + spaceAfterOpeningBracket.length]),
+					messageId: "unexpectedNewlineAfterOpeningBracket",
+					fix: (fixer) => fixer.replaceTextRange([openingBracketIndex + 1, openingBracketIndex + 1 + spaceAfterOpeningBracket.length], " ")
+				});
+			}
+		}
+		/**
+		* Verify the newline before the closing bracket.
+		*/
+		function verifyNewlineBeforeClosingBracket(node, spaceBeforeClosingBracket, openingBracketIndex, closingBracketIndex, newline) {
+			if (openingBracketIndex + 1 === closingBracketIndex - spaceBeforeClosingBracket.length) return;
+			if (newline === "always") {
+				if (spaceBeforeClosingBracket.includes("\n")) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [closingBracketIndex, closingBracketIndex + 1]),
+					messageId: "expectedNewlineBeforeClosingBracket",
+					fix: (fixer) => {
+						const openingBracketLoc = getSourceLocationFromRange(sourceCode, node, [openingBracketIndex, openingBracketIndex + 1]);
+						return fixer.insertTextBeforeRange([closingBracketIndex, closingBracketIndex + 1], `\n${" ".repeat(openingBracketLoc.start.column)}`);
+					}
+				});
+			} else if (newline === "never") {
+				if (!spaceBeforeClosingBracket.includes("\n")) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [closingBracketIndex - spaceBeforeClosingBracket.length, closingBracketIndex]),
+					messageId: "unexpectedNewlineBeforeClosingBracket",
+					fix: (fixer) => fixer.replaceTextRange([closingBracketIndex - spaceBeforeClosingBracket.length, closingBracketIndex], " ")
+				});
+			}
+		}
+		return {
+			link(node) {
+				if (getLinkKind(sourceCode, node) !== "inline") return;
+				const parsed = parseInlineLink(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundBrackets(node, parsed.text.range);
+			},
+			linkReference(node) {
+				const parsed = parseLinkReference(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundBrackets(node, parsed.text.range);
+				if (parsed.label?.type === "full") verifyNewlineAroundBrackets(node, parsed.label.range);
+			},
+			image(node) {
+				const parsed = parseImage(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundBrackets(node, parsed.text.range);
+			},
+			imageReference(node) {
+				const parsed = parseImageReference(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundBrackets(node, parsed.text.range);
+				if (parsed.label?.type === "full") verifyNewlineAroundBrackets(node, parsed.label.range);
+			},
+			definition(node) {
+				const parsed = parseLinkDefinition(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundBrackets(node, parsed.label.range);
+			}
+		};
+		/**
+		* Get the spaces after the opening bracket.
+		*/
+		function getSpaceAfterOpeningBracket(openingBracketIndex) {
+			for (let i = openingBracketIndex + 1; i < sourceCode.text.length; i++) {
+				const char = sourceCode.text[i];
+				if (isWhitespace(char)) continue;
+				return sourceCode.text.slice(openingBracketIndex + 1, i);
+			}
+			return sourceCode.text.slice(openingBracketIndex + 1);
+		}
+		/**
+		* Get the spaces before the closing bracket.
+		*/
+		function getSpaceBeforeClosingBracket(closingBracketIndex) {
+			for (let i = closingBracketIndex - 1; i >= 0; i--) {
+				const char = sourceCode.text[i];
+				if (isWhitespace(char)) continue;
+				return sourceCode.text.slice(i + 1, closingBracketIndex);
+			}
+			return sourceCode.text.slice(0, closingBracketIndex);
+		}
+	}
+});
+
+//#endregion
+//#region src/rules/link-bracket-spacing.ts
+/**
+* The basic option for links and images.
+*/
+function parseOptions$2(option) {
+	const space = option?.space ?? "never";
+	const imagesInLinks = option?.imagesInLinks;
+	return {
+		space,
+		spaceForText: getOptionForText
+	};
+	/**
+	* Get the spacing option for the given node.
+	*/
+	function getOptionForText(node) {
+		if (imagesInLinks != null) {
+			const children = [...node.children];
+			let child;
+			while (children.length && (child = children[0]) && child.type === "text" && isWhitespace(child.value)) children.shift();
+			while (children.length && (child = children[children.length - 1]) && child.type === "text" && isWhitespace(child.value)) children.pop();
+			const loneChild = children.length === 1 ? children[0] : null;
+			if (loneChild?.type === "image" || loneChild?.type === "imageReference") return imagesInLinks ? "always" : "never";
+		}
+		if (node.children.length === 0 || node.children.length === 1 && node.children[0]?.type === "text" && isWhitespace(node.children[0].value)) return "ignore";
+		return space;
+	}
+}
+var link_bracket_spacing_default = createRule("link-bracket-spacing", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent spacing inside link brackets",
+			categories: ["standard"],
+			listCategory: "Whitespace"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				space: { enum: ["always", "never"] },
+				imagesInLinks: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			unexpectedSpaceAfterOpeningBracket: "Unexpected space after opening bracket.",
+			expectedSpaceAfterOpeningBracket: "Expected space after opening bracket.",
+			unexpectedSpaceBeforeClosingBracket: "Unexpected space before closing bracket.",
+			expectedSpaceBeforeClosingBracket: "Expected space before closing bracket."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = parseOptions$2(context.options[0]);
+		/**
+		* Verify the space after the opening bracket and before the closing bracket.
+		*/
+		function verifySpaceAfterOpeningBracket(node, openingBracketIndex, spaceOption) {
+			const space = getSpaceAfterOpeningBracket(openingBracketIndex);
+			if (space.includes("\n")) return;
+			if (spaceOption === "always") {
+				if (space.length > 0) return;
+				context.report({
+					node,
 					loc: getSourceLocationFromRange(sourceCode, node, [openingBracketIndex, openingBracketIndex + 1]),
 					messageId: "expectedSpaceAfterOpeningBracket",
 					fix: (fixer) => fixer.insertTextAfterRange([openingBracketIndex, openingBracketIndex + 1], " ")
@@ -5524,7 +6561,7 @@ var link_destination_style_default = createRule("link-destination-style", {
 		docs: {
 			description: "enforce a consistent style for link destinations",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -5649,7 +6686,7 @@ var link_paren_newline_default = createRule("link-paren-newline", {
 		docs: {
 			description: "enforce linebreaks after opening and before closing link parentheses",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -5674,11 +6711,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$5(context.options[0]);
 		/**
 		* Parse the options.
 		*/
-		function parseOptions$3(option) {
+		function parseOptions$5(option) {
 			const newline = option?.newline ?? "never";
 			const multiline = option?.multiline ?? false;
 			return (openingParenIndex, closingParenIndex) => {
@@ -5793,7 +6830,7 @@ var link_paren_spacing_default = createRule("link-paren-spacing", {
 		docs: {
 			description: "enforce consistent spacing inside link parentheses",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -5928,7 +6965,7 @@ var link_title_style_default = createRule("link-title-style", {
 		docs: {
 			description: "enforce a consistent style for link titles",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -6010,7 +7047,7 @@ var list_marker_alignment_default = createRule("list-marker-alignment", {
 		docs: {
 			description: "enforce consistent alignment of list markers",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -6044,10 +7081,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 +7110,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 +7118,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;
 					}
 				});
@@ -6096,7 +7146,7 @@ var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 		docs: {
 			description: "disallow laziness in blockquotes",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: void 0,
 		hasSuggestions: true,
@@ -6193,7 +7243,194 @@ var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 			reportInvalidLines(invalidLines, base);
 		} };
 	}
-});
+});
+
+//#endregion
+//#region src/utils/table.ts
+/**
+* Parse the table.
+*/
+function parseTable(sourceCode, node) {
+	const headerRow = parseTableRow(sourceCode, node.children[0]);
+	if (!headerRow) return null;
+	const delimiterRow = parseTableDelimiterRow(sourceCode, node);
+	if (!delimiterRow) return null;
+	const bodyRows = [];
+	for (const child of node.children.slice(1)) {
+		const bodyRow = parseTableRow(sourceCode, child);
+		if (!bodyRow) return null;
+		bodyRows.push(bodyRow);
+	}
+	return {
+		headerRow,
+		delimiterRow,
+		bodyRows
+	};
+}
+/**
+* Parse the table delimiter row.
+*/
+function parseTableDelimiterRow(sourceCode, node) {
+	const headerRow = node.children[0];
+	const headerRange = sourceCode.getRange(headerRow);
+	const delimiterEndIndex = node.children.length > 1 ? sourceCode.getRange(node.children[1])[0] : sourceCode.getRange(node)[1];
+	const delimiterText = sourceCode.text.slice(headerRange[1], delimiterEndIndex);
+	const parsed = parseTableDelimiterRowFromText(delimiterText);
+	if (!parsed) return null;
+	const delimiters = parsed.delimiters.map((d) => {
+		let leadingPipe = null;
+		if (d.leadingPipe) {
+			const leadingPipeRange = [headerRange[1] + d.leadingPipe.range[0], headerRange[1] + d.leadingPipe.range[1]];
+			leadingPipe = {
+				text: d.leadingPipe.text,
+				range: leadingPipeRange,
+				loc: getSourceLocationFromRange(sourceCode, headerRow, leadingPipeRange)
+			};
+		}
+		const delimiterRange = [headerRange[1] + d.delimiter.range[0], headerRange[1] + d.delimiter.range[1]];
+		return {
+			leadingPipe,
+			delimiter: {
+				text: d.delimiter.text,
+				align: d.delimiter.text.startsWith(":") ? d.delimiter.text.endsWith(":") ? "center" : "left" : d.delimiter.text.endsWith(":") ? "right" : "none",
+				range: delimiterRange,
+				loc: getSourceLocationFromRange(sourceCode, headerRow, delimiterRange)
+			}
+		};
+	});
+	let trailingPipe = null;
+	if (parsed.trailingPipe) {
+		const trailingPipeRange = [headerRange[1] + parsed.trailingPipe.range[0], headerRange[1] + parsed.trailingPipe.range[1]];
+		trailingPipe = {
+			text: parsed.trailingPipe.text,
+			range: trailingPipeRange,
+			loc: getSourceLocationFromRange(sourceCode, headerRow, trailingPipeRange)
+		};
+	}
+	const firstToken = delimiters[0].leadingPipe ?? delimiters[0].delimiter;
+	const lastToken = trailingPipe ?? delimiters[delimiters.length - 1].delimiter;
+	return {
+		delimiters,
+		trailingPipe,
+		range: [firstToken.range[0], lastToken.range[1]],
+		loc: {
+			start: firstToken.loc.start,
+			end: lastToken.loc.end
+		}
+	};
+}
+/**
+* Parse the table row.
+*/
+function parseTableRow(sourceCode, node) {
+	const cells = [];
+	let trailingPipe = null;
+	for (const cell of node.children) {
+		const cellRange = sourceCode.getRange(cell);
+		const cellLoc = sourceCode.getLoc(cell);
+		const leadingPipe = sourceCode.text[cellRange[0]] === "|" ? {
+			text: "|",
+			range: [cellRange[0], cellRange[0] + 1],
+			loc: {
+				start: cellLoc.start,
+				end: {
+					line: cellLoc.start.line,
+					column: cellLoc.start.column + 1
+				}
+			}
+		} : null;
+		if (trailingPipe && leadingPipe) return null;
+		let parsedCell = null;
+		if (cell.children.length > 0) {
+			const firstChild = cell.children[0];
+			const lastChild = cell.children[cell.children.length - 1];
+			parsedCell = {
+				range: [sourceCode.getRange(firstChild)[0], sourceCode.getRange(lastChild)[1]],
+				loc: {
+					start: sourceCode.getLoc(firstChild).start,
+					end: sourceCode.getLoc(lastChild).end
+				}
+			};
+		}
+		cells.push({
+			leadingPipe,
+			cell: parsedCell
+		});
+		trailingPipe = sourceCode.text[cellRange[1] - 1] === "|" ? {
+			text: "|",
+			range: [cellRange[1] - 1, cellRange[1]],
+			loc: {
+				start: {
+					line: cellLoc.end.line,
+					column: cellLoc.end.column - 1
+				},
+				end: cellLoc.end
+			}
+		} : null;
+	}
+	const firstToken = cells[0].leadingPipe ?? cells[0].cell;
+	const lastToken = trailingPipe ?? cells[cells.length - 1].cell ?? cells[cells.length - 1].leadingPipe;
+	return {
+		cells,
+		trailingPipe,
+		range: [firstToken.range[0], lastToken.range[1]],
+		loc: {
+			start: firstToken.loc.start,
+			end: lastToken.loc.end
+		}
+	};
+}
+/**
+* Parse the table delimiter row from the text.
+*/
+function parseTableDelimiterRowFromText(text) {
+	const cursor = new ForwardCharacterCursor(text);
+	cursor.skipSpaces();
+	while (cursor.curr() === ">") {
+		cursor.next();
+		cursor.skipSpaces();
+	}
+	const delimiters = [];
+	let pipe = consumePipe();
+	while (!cursor.finished()) {
+		const delimiterStart = cursor.currIndex();
+		cursor.skipUntilEnd((c) => c === "|" || isSpaceOrTab(c) || c === "\n" || c === "\r");
+		const delimiterRange = [delimiterStart, cursor.currIndex()];
+		const delimiterText = text.slice(...delimiterRange);
+		if (!/^:?-+:?$/u.test(delimiterText)) return null;
+		if (delimiters.length > 0 && pipe == null) return null;
+		delimiters.push({
+			leadingPipe: pipe,
+			delimiter: {
+				text: delimiterText,
+				range: delimiterRange
+			}
+		});
+		pipe = consumePipe();
+	}
+	return {
+		delimiters,
+		trailingPipe: pipe
+	};
+	/**
+	* Consume a pipe if exists.
+	*/
+	function consumePipe() {
+		cursor.skipSpaces();
+		if (cursor.curr() === "|") {
+			const pipeStart = cursor.currIndex();
+			cursor.next();
+			const pipeRange = [pipeStart, cursor.currIndex()];
+			const result = {
+				text: text.slice(...pipeRange),
+				range: pipeRange
+			};
+			cursor.skipSpaces();
+			return result;
+		}
+		return null;
+	}
+}
 
 //#endregion
 //#region src/rules/no-multi-spaces.ts
@@ -6203,7 +7440,7 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 		docs: {
 			description: "disallow multiple spaces",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -6212,6 +7449,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,7 +7459,9 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 			link: verifyLink,
 			linkReference: verifyLinkReference,
 			listItem: verifyListItem,
-			text: verifyText
+			blockquote: processBlockquote,
+			text: verifyText,
+			table: verifyTable
 		};
 		/**
 		* Verify a text node.
@@ -6230,6 +7470,14 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 			verifyTextInNode(node);
 		}
 		/**
+		* Verify a table node.
+		*/
+		function verifyTable(node) {
+			const parsedDelimiterRow = parseTableDelimiterRow(sourceCode, node);
+			if (!parsedDelimiterRow) return;
+			verifyTextInRange(node, parsedDelimiterRow.range);
+		}
+		/**
 		* Verify a definition node.
 		*/
 		function verifyLinkDefinition(node) {
@@ -6294,7 +7542,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 +7558,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 +7596,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 +7613,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 +7623,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;
@@ -6379,7 +7653,7 @@ var no_multiple_empty_lines_default = createRule("no-multiple-empty-lines", {
 		docs: {
 			description: "disallow multiple empty lines in Markdown files.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -6538,7 +7812,7 @@ var no_text_backslash_linebreak_default = createRule("no-text-backslash-linebrea
 		docs: {
 			description: "disallow text backslash at the end of a line.",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: void 0,
 		hasSuggestions: true,
@@ -6583,7 +7857,7 @@ var no_trailing_spaces_default = createRule("no-trailing-spaces", {
 		docs: {
 			description: "disallow trailing whitespace at the end of lines in Markdown files.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -6709,7 +7983,7 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 		docs: {
 			description: "enforce that ordered list markers use sequential numbers",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: true,
@@ -6923,7 +8197,7 @@ function markerToKind(marker) {
 /**
 * Parse rule options.
 */
-function parseOptions(options) {
+function parseOptions$1(options) {
 	const prefer = markerToKind(options.prefer) || ".";
 	const overrides = (options.overrides ?? []).map((override) => {
 		const preferForOverride = markerToKind(override.prefer) || ".";
@@ -6950,7 +8224,7 @@ var ordered_list_marker_style_default = createRule("ordered-list-marker-style",
 		docs: {
 			description: "enforce consistent ordered list marker style",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -6984,7 +8258,7 @@ var ordered_list_marker_style_default = createRule("ordered-list-marker-style",
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions(context.options[0] || {});
+		const options = parseOptions$1(context.options[0] || {});
 		let containerStack = {
 			node: sourceCode.ast,
 			level: 1,
@@ -7169,7 +8443,7 @@ var padding_line_between_blocks_default = createRule("padding-line-between-block
 		docs: {
 			description: "require or disallow padding lines between blocks",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Whitespace"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
@@ -7367,7 +8641,7 @@ var prefer_autolinks_default = createRule("prefer-autolinks", {
 		docs: {
 			description: "enforce the use of autolinks for URLs",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -7405,7 +8679,7 @@ var prefer_fenced_code_blocks_default = createRule("prefer-fenced-code-blocks",
 		docs: {
 			description: "enforce the use of fenced code blocks over indented code blocks",
 			categories: ["recommended", "standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -7635,7 +8909,7 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 		docs: {
 			description: "enforce using link reference definitions instead of inline links",
 			categories: [],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -7914,9 +9188,9 @@ var setext_heading_underline_length_default = createRule("setext-heading-underli
 		docs: {
 			description: "enforce setext heading underline length",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
-		fixable: "whitespace",
+		fixable: "code",
 		schema: [{
 			type: "object",
 			properties: {
@@ -8152,7 +9426,7 @@ var sort_definitions_default = createRule("sort-definitions", {
 		docs: {
 			description: "enforce a specific order for link definitions and footnote definitions",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -8425,7 +9699,7 @@ var strikethrough_delimiters_style_default = createRule("strikethrough-delimiter
 		docs: {
 			description: "enforce a consistent delimiter style for strikethrough",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -8444,151 +9718,869 @@ var strikethrough_delimiters_style_default = createRule("strikethrough-delimiter
 			const actualDelimiter = ["~~", "~"].find((d) => sourceCode.text.startsWith(d, range[0]) && sourceCode.text.endsWith(d, range[1]));
 			if (!actualDelimiter || actualDelimiter === delimiter) return;
 			context.report({
-				node,
-				messageId: "wrongDelimiter",
+				node,
+				messageId: "wrongDelimiter",
+				data: {
+					expected: delimiter,
+					actual: actualDelimiter
+				},
+				fix(fixer) {
+					return [fixer.replaceTextRange([range[0], range[0] + actualDelimiter.length], delimiter), fixer.replaceTextRange([range[1] - actualDelimiter.length, range[1]], delimiter)];
+				}
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/table-header-casing.ts
+var table_header_casing_default = createRule("table-header-casing", {
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			description: "enforce consistent casing in table header cells.",
+			categories: [],
+			listCategory: "Preference"
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				style: { enum: ["Title Case", "Sentence case"] },
+				preserveWords: {
+					type: "array",
+					items: { type: "string" },
+					description: "Words that should be preserved as-is (case-insensitive matching)"
+				},
+				ignorePatterns: {
+					type: "array",
+					items: { type: "string" },
+					description: "Regular expression patterns for words to ignore during casing checks"
+				},
+				minorWords: {
+					type: "array",
+					items: { type: "string" },
+					description: "Words that should not be capitalized in Title Case (unless they're the first or last word)"
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			expectedTitleCase: "Expected \"{{actual}}\" to be \"{{expected}}\" (Title Case).",
+			expectedTitleCaseMinorWord: "Expected \"{{actual}}\" to be \"{{expected}}\" (Title Case - minor word).",
+			expectedSentenceCase: "Expected \"{{actual}}\" to be \"{{expected}}\" (Sentence case).",
+			expectedPreserveWord: "Expected \"{{actual}}\" to be \"{{expected}}\" (preserved word)."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const caseStyle = context.options[0]?.style || "Title Case";
+		const preserveWordsOption = parsePreserveWordsOption(context.options[0]?.preserveWords || defaultPreserveWords);
+		const minorWords = context.options[0]?.minorWords || defaultMinorWords;
+		const ignorePatterns = (context.options[0]?.ignorePatterns || [
+			"/^v\\d+/u",
+			"/\\w+\\.[a-z\\d]+$/u",
+			"/\\w+(?:API|Api)$/u",
+			"/\\w+(?:SDK|Sdk)$/u",
+			"/\\w+(?:CLI|Cli)$/u"
+		]).map((pattern) => {
+			if (isRegExp(pattern)) return toRegExp(pattern);
+			try {
+				return new RegExp(pattern, "v");
+			} catch {}
+			try {
+				return new RegExp(pattern, "u");
+			} catch {}
+			return new RegExp(pattern);
+		});
+		/**
+		* Check text node and report word-level errors
+		*/
+		function checkTextNode(node, firstNode, lastNode) {
+			const text = sourceCode.getText(node);
+			const wordAndOffsets = parseWordsFromText(text, firstNode, lastNode);
+			const processed = /* @__PURE__ */ new Set();
+			for (let index = 0; index < wordAndOffsets.length; index++) {
+				if (processed.has(index)) continue;
+				processed.add(index);
+				const wordAndOffset = wordAndOffsets[index];
+				if (wordAndOffset.punctuation) continue;
+				if (ignorePatterns.some((pattern) => pattern.test(wordAndOffset.word))) continue;
+				const preservePhrase = preserveWordsOption.findPreservePhrase((function* () {
+					const firstWord = wordAndOffsets[index];
+					if (firstWord.punctuation) return;
+					yield firstWord.word;
+					for (let next = index + 1; next < wordAndOffsets.length; next++) yield wordAndOffsets[next].word;
+				})());
+				if (preservePhrase) {
+					for (let wordIndex = 0; wordIndex < preservePhrase.length; wordIndex++) {
+						processed.add(index + wordIndex);
+						verifyWord(wordAndOffsets[index + wordIndex], preservePhrase[wordIndex], "preserved");
+					}
+					continue;
+				}
+				const preserveWordList = preserveWordsOption.findPreserveWord(wordAndOffset.word);
+				if (preserveWordList) {
+					if (!preserveWordList.some((w) => w === wordAndOffset.word)) verifyWord(wordAndOffset, preserveWordList[0], "preserved");
+					continue;
+				}
+				const expectedWordResult = convertWordCasing(wordAndOffset, {
+					caseStyle,
+					minorWords
+				});
+				verifyWord(wordAndOffset, expectedWordResult.word, expectedWordResult.isMinorWord ? "minor" : "normal");
+			}
+			/**
+			* Verify a single word against the expected casing
+			*/
+			function verifyWord(wordAndOffset, expectedWord, wordType = "normal") {
+				const { word, offset } = wordAndOffset;
+				if (word === expectedWord) return;
+				const [nodeStart] = sourceCode.getRange(node);
+				const range = [nodeStart + offset, nodeStart + offset + word.length];
+				context.report({
+					node,
+					messageId: wordType === "preserved" ? "expectedPreserveWord" : caseStyle === "Title Case" ? wordType === "minor" ? "expectedTitleCaseMinorWord" : "expectedTitleCase" : "expectedSentenceCase",
+					data: {
+						actual: word,
+						expected: expectedWord
+					},
+					loc: getSourceLocationFromRange(sourceCode, node, range),
+					fix(fixer) {
+						return fixer.replaceTextRange(range, expectedWord);
+					}
+				});
+			}
+		}
+		return { table(node) {
+			if (!node.children.length) return;
+			const headerRow = node.children[0];
+			if (headerRow.type !== "tableRow") return;
+			for (const cell of headerRow.children) {
+				const children = cell.children.filter((child) => child.type !== "text" || child.value.trim());
+				children.forEach((child, i) => {
+					if (child.type === "text") checkTextNode(child, i === 0, i === children.length - 1);
+				});
+			}
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/table-leading-trailing-pipes.ts
+var table_leading_trailing_pipes_default = createRule("table-leading-trailing-pipes", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent use of leading and trailing pipes in tables.",
+			categories: ["standard"],
+			listCategory: "Decorative"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{ anyOf: [{ enum: ["always", "never"] }, {
+			type: "object",
+			properties: {
+				leading: { enum: ["always", "never"] },
+				trailing: { enum: ["always", "never"] }
+			},
+			additionalProperties: false
+		}] }],
+		messages: {
+			missingLeadingPipe: "Table line should start with a leading pipe.",
+			unexpectedLeadingPipe: "Table line should not start with a leading pipe.",
+			missingTrailingPipe: "Table line should end with a trailing pipe.",
+			unexpectedTrailingPipe: "Table line should not end with a trailing pipe."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const preferOption = context.options[0] ?? "always";
+		const leadingOption = typeof preferOption === "string" ? preferOption : preferOption.leading ?? "always";
+		const trailingOption = typeof preferOption === "string" ? preferOption : preferOption.trailing ?? "always";
+		/**
+		* Verify the table pipes
+		*/
+		function verifyTablePipes(node) {
+			for (const row of node.children) verifyTableRowPipes(row);
+			const parsedDelimiterRow = parseTableDelimiterRow(sourceCode, node);
+			if (parsedDelimiterRow) verifyTableLinePipes(parsedDelimiterRow.range, parsedDelimiterRow.loc, parsedDelimiterRow.delimiters.length);
+		}
+		/**
+		* Verify the table row pipes
+		*/
+		function verifyTableRowPipes(node) {
+			const loc = sourceCode.getLoc(node);
+			const range = sourceCode.getRange(node);
+			verifyTableLinePipes(range, loc, node.children.length);
+		}
+		/**
+		* Verify the table line pipes
+		*/
+		function verifyTableLinePipes(lineContentRange, lineLocation, columnCount) {
+			verifyTableLeadingPipe(lineContentRange, lineLocation, columnCount);
+			verifyTableTrailingPipe(lineContentRange, lineLocation, columnCount);
+		}
+		/**
+		* Verify the table leading pipe
+		*/
+		function verifyTableLeadingPipe(lineContentRange, lineLocation, columnCount) {
+			if (leadingOption === "always") {
+				if (sourceCode.text.startsWith("|", lineContentRange[0])) return;
+				context.report({
+					messageId: "missingLeadingPipe",
+					loc: lineLocation.start,
+					fix(fixer) {
+						return fixer.insertTextBeforeRange(lineContentRange, "| ");
+					}
+				});
+			} else if (leadingOption === "never") {
+				if (columnCount < 2) {
+					if (!(trailingOption === "always" && sourceCode.text.endsWith("|", lineContentRange[1]))) return;
+				}
+				if (!sourceCode.text.startsWith("|", lineContentRange[0])) return;
+				let endIndex = lineContentRange[0] + 1;
+				while (endIndex < lineContentRange[1] && isSpaceOrTab(sourceCode.text[endIndex])) endIndex++;
+				context.report({
+					messageId: "unexpectedLeadingPipe",
+					loc: {
+						start: lineLocation.start,
+						end: {
+							line: lineLocation.start.line,
+							column: lineLocation.start.column + (endIndex - lineContentRange[0])
+						}
+					},
+					fix(fixer) {
+						return fixer.removeRange([lineContentRange[0], endIndex]);
+					}
+				});
+			}
+		}
+		/**
+		* Verify the table trailing pipe
+		*/
+		function verifyTableTrailingPipe(lineContentRange, lineLocation, columnCount) {
+			if (trailingOption === "always") {
+				if (sourceCode.text.endsWith("|", lineContentRange[1])) return;
+				context.report({
+					messageId: "missingTrailingPipe",
+					loc: lineLocation.end,
+					fix(fixer) {
+						return fixer.insertTextAfterRange(lineContentRange, " |");
+					}
+				});
+			} else if (trailingOption === "never") {
+				if (columnCount < 2) {
+					if (!(leadingOption === "always" && sourceCode.text.startsWith("|", lineContentRange[0]))) return;
+				}
+				if (!sourceCode.text.endsWith("|", lineContentRange[1])) return;
+				let startIndex = lineContentRange[1] - 1;
+				while (startIndex - 1 > lineContentRange[0] && isSpaceOrTab(sourceCode.text[startIndex - 1])) startIndex--;
+				context.report({
+					messageId: "unexpectedTrailingPipe",
+					loc: {
+						start: {
+							line: lineLocation.end.line,
+							column: lineLocation.end.column - (lineContentRange[1] - startIndex)
+						},
+						end: lineLocation.end
+					},
+					fix(fixer) {
+						return fixer.removeRange([startIndex, lineContentRange[1]]);
+					}
+				});
+			}
+		}
+		return { table(node) {
+			verifyTablePipes(node);
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/table-pipe-alignment.ts
+var table_pipe_alignment_default = createRule("table-pipe-alignment", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent alignment of table pipes",
+			categories: ["standard"],
+			listCategory: "Decorative"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { column: { enum: ["minimum", "consistent"] } },
+			additionalProperties: false
+		}],
+		messages: {
+			addSpaces: "Table pipe should be aligned at column {{expected}} (add {{count}} character{{plural}}).",
+			removeSpaces: "Table pipe should be aligned at column {{expected}} (remove {{count}} character{{plural}})."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const columnOption = (context.options[0] || {}).column || "minimum";
+		/**
+		* Verify the table pipes
+		*/
+		function verifyTablePipes(rows) {
+			let columnCount = 0;
+			for (const row of rows) columnCount = Math.max(columnCount, row.cells.length);
+			let targetRows = [...rows];
+			for (let pipeIndex = 0; pipeIndex <= columnCount; pipeIndex++) {
+				const expected = getExpectedPipePosition(rows, pipeIndex);
+				if (expected == null) continue;
+				const unreportedRows = [];
+				for (const row of targetRows) if (verifyRowPipe(row, pipeIndex, expected)) unreportedRows.push(row);
+				targetRows = unreportedRows;
+				if (targetRows.length === 0) break;
+			}
+		}
+		/**
+		* Verify the pipe in the row
+		*/
+		function verifyRowPipe(row, pipeIndex, expected) {
+			let cellIndex;
+			let pipe;
+			if (pipeIndex === 0) {
+				cellIndex = 0;
+				pipe = "leadingPipe";
+			} else {
+				cellIndex = pipeIndex - 1;
+				pipe = "trailingPipe";
+			}
+			if (row.cells.length <= cellIndex) return true;
+			const cell = row.cells[cellIndex];
+			const pipeToken = cell[pipe];
+			if (!pipeToken) return true;
+			return verifyPipe(pipeToken, expected, {
+				cell,
+				pipeIndex
+			});
+		}
+		/**
+		* Verify the pipe position
+		*/
+		function verifyPipe(pipe, expected, ctx) {
+			const actual = getTextWidth(sourceCode.lines[pipe.loc.start.line - 1].slice(0, pipe.loc.start.column - 1));
+			const diff = expected - actual;
+			if (diff === 0) return true;
+			context.report({
+				loc: pipe.loc,
+				messageId: diff > 0 ? "addSpaces" : "removeSpaces",
 				data: {
-					expected: delimiter,
-					actual: actualDelimiter
+					expected: String(expected),
+					count: String(Math.abs(diff)),
+					plural: Math.abs(diff) === 1 ? "" : "s"
 				},
 				fix(fixer) {
-					return [fixer.replaceTextRange([range[0], range[0] + actualDelimiter.length], delimiter), fixer.replaceTextRange([range[1] - actualDelimiter.length, range[1]], delimiter)];
+					if (diff > 0) {
+						if (ctx.pipeIndex === 0 || ctx.cell.type === "cell") return fixer.insertTextBeforeRange(pipe.range, " ".repeat(diff));
+						return fixer.insertTextAfterRange([ctx.cell.delimiter.range[0], ctx.cell.delimiter.range[0] + 1], "-".repeat(diff));
+					}
+					const baseEdit = fixRemoveSpaces();
+					if (baseEdit) return baseEdit;
+					if (ctx.pipeIndex === 0 || ctx.cell.type === "cell") return null;
+					const beforeDelimiter = sourceCode.lines[ctx.cell.delimiter.loc.start.line - 1].slice(0, ctx.cell.delimiter.loc.start.column - 1);
+					const widthBeforeDelimiter = getTextWidth(beforeDelimiter);
+					const newLength = expected - widthBeforeDelimiter;
+					const minimumDelimiterLength = getMinimumDelimiterLength(ctx.cell.align);
+					const spaceAfter = isNeedSpaceAfterContent(ctx.cell) ? " " : "";
+					if (newLength < minimumDelimiterLength + spaceAfter.length) return null;
+					const delimiterPrefix = ctx.cell.align === "left" || ctx.cell.align === "center" ? ":" : "";
+					const delimiterSuffix = (ctx.cell.align === "right" || ctx.cell.align === "center" ? ":" : "") + spaceAfter;
+					const newDelimiter = "-".repeat(newLength - delimiterPrefix.length - delimiterSuffix.length);
+					return fixer.replaceTextRange([ctx.cell.delimiter.range[0], pipe.range[0]], delimiterPrefix + newDelimiter + delimiterSuffix);
+					/**
+					* Fixer to remove spaces before the pipe
+					*/
+					function fixRemoveSpaces() {
+						const beforePipe = sourceCode.lines[pipe.loc.start.line - 1].slice(0, pipe.loc.start.column - 1);
+						const trimmedBeforePipe = beforePipe.trimEnd();
+						const spacesBeforePipeLength = beforePipe.length - trimmedBeforePipe.length;
+						const widthBeforePipe = getTextWidth(trimmedBeforePipe);
+						const newSpacesLength = expected - widthBeforePipe;
+						if (newSpacesLength < (ctx.pipeIndex > 0 && isNeedSpaceAfterContent(ctx.cell) ? 1 : 0)) return null;
+						return fixer.replaceTextRange([pipe.range[0] - spacesBeforePipeLength, pipe.range[0]], " ".repeat(newSpacesLength));
+					}
 				}
 			});
+			return false;
+		}
+		/**
+		* Get the expected pipe position for the index
+		*/
+		function getExpectedPipePosition(rows, pipeIndex) {
+			if (pipeIndex === 0) {
+				const firstCell = rows[0].cells[0];
+				const firstToken = firstCell.leadingPipe ?? firstCell.content;
+				if (!firstToken) return null;
+				return getTextWidth(sourceCode.lines[firstToken.loc.start.line - 1].slice(0, firstToken.loc.start.column - 1));
+			}
+			if (columnOption === "minimum") return getMinimumPipePosition(rows, pipeIndex);
+			else if (columnOption === "consistent") {
+				const columnIndex = pipeIndex - 1;
+				for (const row of rows) {
+					if (row.cells.length <= columnIndex) continue;
+					const cell = row.cells[columnIndex];
+					if (cell.type === "delimiter" || !cell.trailingPipe) continue;
+					const width = getTextWidth(sourceCode.lines[cell.trailingPipe.loc.start.line - 1].slice(0, cell.trailingPipe.loc.start.column - 1));
+					return Math.max(width, getMinimumPipePosition(rows, pipeIndex) || 0);
+				}
+			}
+			return null;
+		}
+		/**
+		* Get the minimum pipe position for the index
+		*/
+		function getMinimumPipePosition(rows, pipeIndex) {
+			let maxWidth = 0;
+			const columnIndex = pipeIndex - 1;
+			for (const row of rows) {
+				if (row.cells.length <= columnIndex) continue;
+				const cell = row.cells[columnIndex];
+				let width;
+				if (cell.type === "delimiter") {
+					const minimumDelimiterLength = getMinimumDelimiterLength(cell.align);
+					width = getTextWidth(sourceCode.lines[cell.delimiter.loc.start.line - 1].slice(0, cell.delimiter.loc.start.column - 1)) + minimumDelimiterLength;
+				} else {
+					if (!cell.content) continue;
+					width = getTextWidth(sourceCode.lines[cell.content.loc.end.line - 1].slice(0, cell.content.loc.end.column - 1));
+				}
+				if (isNeedSpaceAfterContent(cell)) width += 1;
+				maxWidth = Math.max(maxWidth, width);
+			}
+			return maxWidth;
+		}
+		/**
+		* Get the minimum delimiter length based on alignment
+		*/
+		function getMinimumDelimiterLength(align) {
+			return align === "none" ? 1 : align === "center" ? 3 : 2;
+		}
+		/**
+		* Check if a cell needs a space after its content
+		*/
+		function isNeedSpaceAfterContent(cell) {
+			let content;
+			if (cell.type === "delimiter") content = cell.delimiter;
+			else {
+				if (!cell.content) return false;
+				content = cell.content;
+			}
+			return cell.trailingPipe && content.range[1] < cell.trailingPipe.range[0];
+		}
+		/**
+		* Convert a parsed table row to row data
+		*/
+		function parsedTableRowToRowData(parsedRow) {
+			return { cells: parsedRow.cells.map((cell, index) => {
+				const nextCell = index + 1 < parsedRow.cells.length ? parsedRow.cells[index + 1] : null;
+				return {
+					type: "cell",
+					leadingPipe: cell.leadingPipe,
+					content: cell.cell,
+					trailingPipe: nextCell ? nextCell.leadingPipe : parsedRow.trailingPipe
+				};
+			}) };
+		}
+		/**
+		* Convert a parsed table delimiter row to row data
+		*/
+		function parsedTableDelimiterRowToRowData(parsedDelimiterRow) {
+			return { cells: parsedDelimiterRow.delimiters.map((cell, index) => {
+				const nextCell = index + 1 < parsedDelimiterRow.delimiters.length ? parsedDelimiterRow.delimiters[index + 1] : null;
+				return {
+					type: "delimiter",
+					leadingPipe: cell.leadingPipe,
+					delimiter: cell.delimiter,
+					align: cell.delimiter.align,
+					trailingPipe: nextCell ? nextCell.leadingPipe : parsedDelimiterRow.trailingPipe
+				};
+			}) };
+		}
+		return { table(node) {
+			const parsed = parseTable(sourceCode, node);
+			if (!parsed) return;
+			const rows = [parsedTableRowToRowData(parsed.headerRow), parsedTableDelimiterRowToRowData(parsed.delimiterRow)];
+			for (const bodyRow of parsed.bodyRows) rows.push(parsedTableRowToRowData(bodyRow));
+			verifyTablePipes(rows);
 		} };
 	}
 });
 
 //#endregion
-//#region src/rules/table-header-casing.ts
-var table_header_casing_default = createRule("table-header-casing", {
+//#region src/rules/table-pipe-spacing.ts
+/**
+* Parsed options
+*/
+function parseOptions(options) {
+	const spaceOption = options?.space;
+	const leadingSpace = (typeof spaceOption === "object" ? spaceOption.leading : spaceOption) || "always";
+	const trailingSpace = (typeof spaceOption === "object" ? spaceOption.trailing : spaceOption) || "always";
+	const cellAlignOption = options?.cellAlign;
+	const defaultDelimiterCellAlign = (typeof cellAlignOption === "object" ? cellAlignOption.defaultDelimiter : cellAlignOption) || "left";
+	const leftAlignmentDelimiterCellAlign = (typeof cellAlignOption === "object" ? cellAlignOption.leftAlignmentDelimiter : cellAlignOption) || "left";
+	const centerAlignmentDelimiterCellAlign = (typeof cellAlignOption === "object" ? cellAlignOption.centerAlignmentDelimiter : cellAlignOption) || "center";
+	const rightAlignmentDelimiterCellAlign = (typeof cellAlignOption === "object" ? cellAlignOption.rightAlignmentDelimiter : cellAlignOption) || "right";
+	return {
+		leadingSpace,
+		trailingSpace,
+		cellAlignByDelimiter: {
+			none: adjustAlign(defaultDelimiterCellAlign),
+			left: adjustAlign(leftAlignmentDelimiterCellAlign),
+			center: adjustAlign(centerAlignmentDelimiterCellAlign),
+			right: adjustAlign(rightAlignmentDelimiterCellAlign)
+		}
+	};
+	/**
+	* Adjust the alignment option based on the spacing options.
+	*/
+	function adjustAlign(align) {
+		if (align === "left") {
+			if (trailingSpace === "always") return "left";
+			return "ignore";
+		}
+		if (align === "center") {
+			if (leadingSpace === "always" && trailingSpace === "always") return "center";
+			return "ignore";
+		}
+		if (align === "right") {
+			if (leadingSpace === "always") return "right";
+			return "ignore";
+		}
+		return align;
+	}
+}
+var table_pipe_spacing_default = createRule("table-pipe-spacing", {
 	meta: {
-		type: "suggestion",
-		fixable: "code",
+		type: "layout",
 		docs: {
-			description: "enforce consistent casing in table header cells.",
-			categories: [],
-			listCategory: "Preference"
+			description: "enforce consistent spacing around table pipes",
+			categories: ["standard"],
+			listCategory: "Whitespace"
 		},
+		fixable: "whitespace",
+		hasSuggestions: false,
 		schema: [{
 			type: "object",
 			properties: {
-				style: { enum: ["Title Case", "Sentence case"] },
-				preserveWords: {
-					type: "array",
-					items: { type: "string" },
-					description: "Words that should be preserved as-is (case-insensitive matching)"
-				},
-				ignorePatterns: {
-					type: "array",
-					items: { type: "string" },
-					description: "Regular expression patterns for words to ignore during casing checks"
-				},
-				minorWords: {
-					type: "array",
-					items: { type: "string" },
-					description: "Words that should not be capitalized in Title Case (unless they're the first or last word)"
-				}
+				space: { anyOf: [{ enum: ["always", "never"] }, {
+					type: "object",
+					properties: {
+						leading: { enum: ["always", "never"] },
+						trailing: { enum: ["always", "never"] }
+					},
+					additionalProperties: false
+				}] },
+				cellAlign: { anyOf: [{ enum: [
+					"left",
+					"center",
+					"right"
+				] }, {
+					type: "object",
+					properties: {
+						defaultDelimiter: { enum: [
+							"left",
+							"center",
+							"right",
+							"ignore"
+						] },
+						leftAlignmentDelimiter: { enum: [
+							"left",
+							"center",
+							"right",
+							"ignore"
+						] },
+						centerAlignmentDelimiter: { enum: [
+							"left",
+							"center",
+							"right",
+							"ignore"
+						] },
+						rightAlignmentDelimiter: { enum: [
+							"left",
+							"center",
+							"right",
+							"ignore"
+						] }
+					},
+					additionalProperties: false
+				}] }
 			},
 			additionalProperties: false
 		}],
 		messages: {
-			expectedTitleCase: "Expected \"{{actual}}\" to be \"{{expected}}\" (Title Case).",
-			expectedTitleCaseMinorWord: "Expected \"{{actual}}\" to be \"{{expected}}\" (Title Case - minor word).",
-			expectedSentenceCase: "Expected \"{{actual}}\" to be \"{{expected}}\" (Sentence case).",
-			expectedPreserveWord: "Expected \"{{actual}}\" to be \"{{expected}}\" (preserved word)."
+			expectedSpaceBefore: "Expected 1 space before \"|\".",
+			expectedNoSpaceBefore: "Expected no space before \"|\".",
+			expectedSpaceAfter: "Expected 1 space after \"|\".",
+			expectedNoSpaceAfter: "Expected no space after \"|\".",
+			expectedAlignLeft: "Expected 1 space after \"|\" for left-aligned column.",
+			expectedNoSpaceAlignLeft: "Expected no space after \"|\" for left-aligned column.",
+			expectedAlignRight: "Expected 1 space before \"|\" for right-aligned column.",
+			expectedNoSpaceAlignRight: "Expected no space before \"|\" for right-aligned column.",
+			expectedAlignCenter: "Expected the number of spaces before and after the content to be the same or differ by 1 at most for center-aligned column."
 		}
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const caseStyle = context.options[0]?.style || "Title Case";
-		const preserveWordsOption = parsePreserveWordsOption(context.options[0]?.preserveWords || defaultPreserveWords);
-		const minorWords = context.options[0]?.minorWords || defaultMinorWords;
-		const ignorePatterns = (context.options[0]?.ignorePatterns || [
-			"/^v\\d+/u",
-			"/\\w+\\.[a-z\\d]+$/u",
-			"/\\w+(?:API|Api)$/u",
-			"/\\w+(?:SDK|Sdk)$/u",
-			"/\\w+(?:CLI|Cli)$/u"
-		]).map((pattern) => {
-			if (isRegExp(pattern)) return toRegExp(pattern);
-			try {
-				return new RegExp(pattern, "v");
-			} catch {}
-			try {
-				return new RegExp(pattern, "u");
-			} catch {}
-			return new RegExp(pattern);
-		});
+		const options = parseOptions(context.options[0]);
 		/**
-		* Check text node and report word-level errors
+		* Verify for the leading pipe.
 		*/
-		function checkTextNode(node, firstNode, lastNode) {
-			const text = sourceCode.getText(node);
-			const wordAndOffsets = parseWordsFromText(text, firstNode, lastNode);
-			const processed = /* @__PURE__ */ new Set();
-			for (let index = 0; index < wordAndOffsets.length; index++) {
-				if (processed.has(index)) continue;
-				processed.add(index);
-				const wordAndOffset = wordAndOffsets[index];
-				if (wordAndOffset.punctuation) continue;
-				if (ignorePatterns.some((pattern) => pattern.test(wordAndOffset.word))) continue;
-				const preservePhrase = preserveWordsOption.findPreservePhrase((function* () {
-					const firstWord = wordAndOffsets[index];
-					if (firstWord.punctuation) return;
-					yield firstWord.word;
-					for (let next = index + 1; next < wordAndOffsets.length; next++) yield wordAndOffsets[next].word;
-				})());
-				if (preservePhrase) {
-					for (let wordIndex = 0; wordIndex < preservePhrase.length; wordIndex++) {
-						processed.add(index + wordIndex);
-						verifyWord(wordAndOffsets[index + wordIndex], preservePhrase[wordIndex], "preserved");
+		function verifyLeadingPipe(pipe, nextToken) {
+			if (options.leadingSpace === "always") {
+				if (pipe.range[1] < nextToken.range[0]) return true;
+				context.report({
+					loc: pipe.loc,
+					messageId: "expectedSpaceAfter",
+					fix(fixer) {
+						return fixer.insertTextAfterRange(pipe.range, " ");
 					}
-					continue;
-				}
-				const preserveWordList = preserveWordsOption.findPreserveWord(wordAndOffset.word);
-				if (preserveWordList) {
-					if (!preserveWordList.some((w) => w === wordAndOffset.word)) verifyWord(wordAndOffset, preserveWordList[0], "preserved");
-					continue;
-				}
-				const expectedWordResult = convertWordCasing(wordAndOffset, {
-					caseStyle,
-					minorWords
 				});
-				verifyWord(wordAndOffset, expectedWordResult.word, expectedWordResult.isMinorWord ? "minor" : "normal");
+				return false;
+			} else if (options.leadingSpace === "never") {
+				if (pipe.range[1] === nextToken.range[0]) return true;
+				context.report({
+					loc: {
+						start: pipe.loc.end,
+						end: nextToken.loc.start
+					},
+					messageId: "expectedNoSpaceAfter",
+					fix(fixer) {
+						return fixer.removeRange([pipe.range[1], nextToken.range[0]]);
+					}
+				});
+				return false;
 			}
-			/**
-			* Verify a single word against the expected casing
-			*/
-			function verifyWord(wordAndOffset, expectedWord, wordType = "normal") {
-				const { word, offset } = wordAndOffset;
-				if (word === expectedWord) return;
-				const [nodeStart] = sourceCode.getRange(node);
-				const range = [nodeStart + offset, nodeStart + offset + word.length];
+			return true;
+		}
+		/**
+		* Verify for the trailing pipe.
+		*/
+		function verifyTrailingPipe(prevToken, pipe) {
+			if (options.trailingSpace === "always") {
+				if (prevToken.range[1] < pipe.range[0]) return true;
 				context.report({
-					node,
-					messageId: wordType === "preserved" ? "expectedPreserveWord" : caseStyle === "Title Case" ? wordType === "minor" ? "expectedTitleCaseMinorWord" : "expectedTitleCase" : "expectedSentenceCase",
-					data: {
-						actual: word,
-						expected: expectedWord
+					loc: pipe.loc,
+					messageId: "expectedSpaceBefore",
+					fix(fixer) {
+						return fixer.insertTextBeforeRange(pipe.range, " ");
+					}
+				});
+				return false;
+			} else if (options.trailingSpace === "never") {
+				if (prevToken.range[1] === pipe.range[0]) return true;
+				context.report({
+					loc: {
+						start: prevToken.loc.end,
+						end: pipe.loc.start
 					},
-					loc: getSourceLocationFromRange(sourceCode, node, range),
+					messageId: "expectedNoSpaceBefore",
 					fix(fixer) {
-						return fixer.replaceTextRange(range, expectedWord);
+						return fixer.removeRange([prevToken.range[1], pipe.range[0]]);
 					}
 				});
+				return false;
 			}
+			return true;
 		}
-		return { table(node) {
-			if (!node.children.length) return;
-			const headerRow = node.children[0];
-			if (headerRow.type !== "tableRow") return;
-			for (const cell of headerRow.children) {
-				const children = cell.children.filter((child) => child.type !== "text" || child.value.trim());
-				children.forEach((child, i) => {
-					if (child.type === "text") checkTextNode(child, i === 0, i === children.length - 1);
+		/**
+		* Verify for the alignment of the pipe according to the delimiter alignment.
+		* Return "leading" if the leading pipe is reported, "trailing" if the trailing pipe is reported, "both" if both are reported, or null if nothing is reported.
+		*/
+		function verifyAlignPipe({ leadingPipe, content, trailingPipe }, cellAlign) {
+			if (!leadingPipe || !trailingPipe || !content) return null;
+			const lineText = sourceCode.lines[leadingPipe.loc.start.line - 1];
+			if (cellAlign === "left") {
+				const expectedWidth = options.leadingSpace === "always" ? 1 : 0;
+				if (getLeadingSpacesWidth() === expectedWidth) return null;
+				context.report({
+					loc: leadingPipe.range[1] < content.range[0] ? {
+						start: leadingPipe.loc.end,
+						end: content.loc.start
+					} : leadingPipe.loc,
+					messageId: expectedWidth >= 1 ? "expectedAlignLeft" : "expectedNoSpaceAlignLeft",
+					*fix(fixer) {
+						const cellWidth = getCellWidth();
+						const contentTextWidth = getContentTextWidth();
+						const newLeadingSpaces = " ".repeat(expectedWidth);
+						const newTrailingSpaces = " ".repeat(Math.max(cellWidth - contentTextWidth - expectedWidth, 0));
+						const contentText = getNormalizedContentText();
+						yield fixer.replaceTextRange([leadingPipe.range[1], trailingPipe.range[0]], `${newLeadingSpaces}${contentText}${newTrailingSpaces}`);
+					}
+				});
+				return "leading";
+			} else if (cellAlign === "right") {
+				const expectedWidth = options.trailingSpace === "always" ? 1 : 0;
+				if (getTrailingSpacesWidth() === expectedWidth) return null;
+				context.report({
+					loc: content.range[1] < trailingPipe.range[0] ? {
+						start: content.loc.end,
+						end: trailingPipe.loc.start
+					} : trailingPipe.loc,
+					messageId: expectedWidth >= 1 ? "expectedAlignRight" : "expectedNoSpaceAlignRight",
+					*fix(fixer) {
+						const cellWidth = getCellWidth();
+						const contentTextWidth = getContentTextWidth();
+						const newLeadingSpaces = " ".repeat(Math.max(cellWidth - contentTextWidth - expectedWidth, 0));
+						const newTrailingSpaces = " ".repeat(expectedWidth);
+						const contentText = getNormalizedContentText();
+						yield fixer.replaceTextRange([leadingPipe.range[1], trailingPipe.range[0]], `${newLeadingSpaces}${contentText}${newTrailingSpaces}`);
+					}
+				});
+				return "trailing";
+			} else if (cellAlign === "center") {
+				const leadingSpacesWidth = getLeadingSpacesWidth();
+				const trailingSpacesWidth = getTrailingSpacesWidth();
+				if (leadingSpacesWidth === trailingSpacesWidth || leadingSpacesWidth + 1 === trailingSpacesWidth) return null;
+				const leadingReportLoc = leadingPipe.range[1] < content.range[0] ? {
+					start: leadingPipe.loc.end,
+					end: content.loc.start
+				} : leadingPipe.loc;
+				const trailingReportLoc = content.range[1] < trailingPipe.range[0] ? {
+					start: content.loc.end,
+					end: trailingPipe.loc.start
+				} : trailingPipe.loc;
+				for (const reportLoc of [leadingReportLoc, trailingReportLoc]) context.report({
+					loc: reportLoc,
+					messageId: "expectedAlignCenter",
+					*fix(fixer) {
+						const cellWidth = getCellWidth();
+						const contentTextWidth = getContentTextWidth();
+						const spacesLength = cellWidth - contentTextWidth;
+						const leadingSpacesLength = Math.floor(spacesLength / 2);
+						const trailingSpacesLength = spacesLength - leadingSpacesLength;
+						const newLeadingSpaces = " ".repeat(leadingSpacesLength);
+						const newTrailingSpaces = " ".repeat(trailingSpacesLength);
+						const contentText = getNormalizedContentText();
+						yield fixer.replaceTextRange([leadingPipe.range[1], trailingPipe.range[0]], `${newLeadingSpaces}${contentText}${newTrailingSpaces}`);
+					}
 				});
+				return "both";
+			}
+			return null;
+			/**
+			* Get the width of the leading spaces in the cell.
+			*/
+			function getLeadingSpacesWidth() {
+				return getTextWidth(lineText, leadingPipe.loc.end.column - 1, content.loc.start.column - 1);
+			}
+			/**
+			* Get the width of the trailing spaces in the cell.
+			*/
+			function getTrailingSpacesWidth() {
+				return getTextWidth(lineText, content.loc.end.column - 1, trailingPipe.loc.start.column - 1);
+			}
+			/**
+			* Get the width of the whole cell (including leading and trailing spaces)
+			*/
+			function getCellWidth() {
+				return getTextWidth(lineText, leadingPipe.loc.end.column - 1, trailingPipe.loc.start.column - 1);
+			}
+			/**
+			* Get the width of the content text (excluding leading and trailing spaces)
+			*/
+			function getContentTextWidth() {
+				return getTextWidth(lineText, content.loc.start.column - 1, content.loc.end.column - 1);
+			}
+			/**
+			* Get the normalized content text (with normalized spaces)
+			*/
+			function getNormalizedContentText() {
+				const prefixWidth = getWidth(lineText.slice(0, content.loc.start.column - 1));
+				let result = "";
+				for (const c of lineText.slice(content.loc.start.column - 1, content.loc.end.column - 1)) if (c === "	") result += " ".repeat(4 - (prefixWidth + result.length) % 4);
+				else result += c;
+				return result;
+			}
+		}
+		/**
+		* Convert a parsed table row to cell data list
+		*/
+		function parsedTableRowToCellDataList(parsedRow) {
+			return parsedRow.cells.map((cell, index) => {
+				const nextCell = index + 1 < parsedRow.cells.length ? parsedRow.cells[index + 1] : null;
+				return {
+					type: "cell",
+					leadingPipe: cell.leadingPipe,
+					content: cell.cell,
+					trailingPipe: nextCell ? nextCell.leadingPipe : parsedRow.trailingPipe
+				};
+			});
+		}
+		/**
+		* Convert a parsed table delimiter row to delimiter data list
+		*/
+		function parsedTableDelimiterRowToDelimiterDataList(parsedDelimiterRow) {
+			return parsedDelimiterRow.delimiters.map((cell, index) => {
+				const nextCell = index + 1 < parsedDelimiterRow.delimiters.length ? parsedDelimiterRow.delimiters[index + 1] : null;
+				return {
+					type: "delimiter",
+					leadingPipe: cell.leadingPipe,
+					content: cell.delimiter,
+					align: cell.delimiter.align,
+					trailingPipe: nextCell ? nextCell.leadingPipe : parsedDelimiterRow.trailingPipe
+				};
+			});
+		}
+		return { table(node) {
+			const parsedDelimiterRow = parseTableDelimiterRow(sourceCode, node);
+			const delimiters = parsedDelimiterRow && parsedTableDelimiterRowToDelimiterDataList(parsedDelimiterRow);
+			for (const row of node.children) {
+				const parsedRow = parseTableRow(sourceCode, row);
+				if (!parsedRow) continue;
+				const cells = parsedTableRowToCellDataList(parsedRow);
+				for (let columnIndex = 0; columnIndex < cells.length; columnIndex++) {
+					const cell = cells[columnIndex];
+					const delimiter = delimiters && columnIndex < delimiters.length ? delimiters[columnIndex] : null;
+					const alignReportedPoint = delimiter ? verifyAlignPipe(cell, options.cellAlignByDelimiter[delimiter.align]) : null;
+					if (alignReportedPoint === "both") continue;
+					if (cell.leadingPipe && alignReportedPoint !== "leading") {
+						if (options.leadingSpace !== "never" || cell.content) {
+							const nextToken = getNextToken(cells, columnIndex);
+							if (nextToken) verifyLeadingPipe(cell.leadingPipe, nextToken);
+						}
+					}
+					if (cell.trailingPipe && options.trailingSpace !== "never" && alignReportedPoint !== "trailing") {
+						const prevToken = getPrevToken(cells, columnIndex);
+						if (prevToken) verifyTrailingPipe(prevToken, cell.trailingPipe);
+					}
+				}
+			}
+			if (!delimiters) return;
+			for (let columnIndex = 0; columnIndex < delimiters.length; columnIndex++) {
+				const delimiter = delimiters[columnIndex];
+				const alignReportedPoint = verifyAlignPipe(delimiter, options.cellAlignByDelimiter[delimiter.align]);
+				if (alignReportedPoint === "both") continue;
+				if (delimiter.leadingPipe && alignReportedPoint !== "leading") verifyLeadingPipe(delimiter.leadingPipe, delimiter.content);
+				if (delimiter.trailingPipe && alignReportedPoint !== "trailing") verifyTrailingPipe(delimiter.content, delimiter.trailingPipe);
 			}
 		} };
+		/**
+		* Get the next token (pipe or cell) after the given column index.
+		*/
+		function getNextToken(cells, columnIndex) {
+			for (let i = columnIndex; i < cells.length; i++) {
+				const cell = cells[i];
+				const token = cell.content ?? cell.trailingPipe;
+				if (token) return token;
+			}
+			return null;
+		}
+		/**
+		* Get the prev token (pipe or cell) after the given column index.
+		*/
+		function getPrevToken(cells, columnIndex) {
+			for (let i = columnIndex; i >= 0; i--) {
+				const cell = cells[i];
+				const token = cell.content ?? cell.leadingPipe;
+				if (token) return token;
+			}
+			return null;
+		}
 	}
 });
 
@@ -8600,7 +10592,7 @@ var thematic_break_character_style_default = createRule("thematic-break-characte
 		docs: {
 			description: "enforce consistent character style for thematic breaks (horizontal rules) in Markdown.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Notation"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -8679,7 +10671,7 @@ var thematic_break_length_default = createRule("thematic-break-length", {
 		docs: {
 			description: "enforce consistent length for thematic breaks (horizontal rules) in Markdown.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -8745,7 +10737,7 @@ var thematic_break_sequence_pattern_default = createRule("thematic-break-sequenc
 		docs: {
 			description: "enforce consistent repeating patterns for thematic breaks (horizontal rules) in Markdown.",
 			categories: ["standard"],
-			listCategory: "Stylistic"
+			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -8814,6 +10806,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,
@@ -8841,6 +10834,9 @@ const rules$1 = [
 	sort_definitions_default,
 	strikethrough_delimiters_style_default,
 	table_header_casing_default,
+	table_leading_trailing_pipes_default,
+	table_pipe_alignment_default,
+	table_pipe_spacing_default,
 	thematic_break_character_style_default,
 	thematic_break_length_default,
 	thematic_break_sequence_pattern_default
@@ -8848,8 +10844,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 +10874,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 +10901,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",
@@ -8930,6 +10925,9 @@ const rules$2 = {
 	"markdown-preferences/setext-heading-underline-length": "error",
 	"markdown-preferences/sort-definitions": "error",
 	"markdown-preferences/strikethrough-delimiters-style": "error",
+	"markdown-preferences/table-leading-trailing-pipes": "error",
+	"markdown-preferences/table-pipe-alignment": "error",
+	"markdown-preferences/table-pipe-spacing": "error",
 	"markdown-preferences/thematic-break-character-style": "error",
 	"markdown-preferences/thematic-break-length": "error",
 	"markdown-preferences/thematic-break-sequence-pattern": "error"
@@ -8937,13 +10935,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.25.0";
 
 //#endregion
 //#region src/index.ts