eslint-plugin-markdown-preferences 0.16.0 → 0.18.0

package/lib/index.js

@@ -73,23 +73,30 @@ function getListItemMarker(sourceCode, node) {
 	if (matchDot) return {
 		kind: ".",
 		raw: matchDot[0],
-		sequence: Number(matchDot[1])
+		sequence: {
+			value: Number(matchDot[1]),
+			raw: matchDot[1]
+		}
 	};
 	const matchParen = /^(\d+)\)/.exec(text);
 	return {
 		kind: ")",
 		raw: matchParen[0],
-		sequence: Number(matchParen[1])
+		sequence: {
+			value: Number(matchParen[1]),
+			raw: matchParen[1]
+		}
 	};
 }
 /**
 * Get the marker for a thematic break.
 */
 function getThematicBreakMarker(sourceCode, node) {
-	const text = sourceCode.getText(node);
+	const text = sourceCode.getText(node).trimEnd();
 	return {
-		kind: text.startsWith("-") ? "-" : "*",
-		hasSpaces: /\s/u.test(text)
+		kind: text.startsWith("-") ? "-" : text.startsWith("*") ? "*" : "_",
+		hasSpaces: /\s/u.test(text),
+		text
 	};
 }
 /**
@@ -126,55 +133,138 @@ function getSourceLocationFromRange(sourceCode, node, range) {
 //#endregion
 //#region src/utils/atx-heading.ts
 /**
-* Parse the closing sequence of an ATX heading.
+* Parse the ATX heading.
 */
-function parseATXHeadingClosingSequence(sourceCode, node) {
+function parseATXHeading(sourceCode, node) {
 	if (getHeadingKind(sourceCode, node) !== "atx") return null;
 	const loc = sourceCode.getLoc(node);
 	const range = sourceCode.getRange(node);
-	const parsed = parseATXHeadingClosingSequenceFromText(sourceCode.text.slice(...range));
-	if (parsed == null) return { closingSequence: null };
-	const rawAfter = {
-		text: parsed.rawAfter,
-		range: [range[1] - parsed.rawAfter.length, range[1]],
+	const text = sourceCode.text.slice(...range);
+	const parsedOpening = parseATXHeadingOpeningSequenceFromText(text);
+	if (parsedOpening === null) return null;
+	const openingSequence = {
+		text: parsedOpening.openingSequence,
+		range: [range[0], range[0] + parsedOpening.openingSequence.length],
+		loc: {
+			start: loc.start,
+			end: {
+				line: loc.start.line,
+				column: loc.start.column + parsedOpening.openingSequence.length
+			}
+		}
+	};
+	const spaceAfterOpening = {
+		text: parsedOpening.rawAfter,
+		range: [openingSequence.range[1], openingSequence.range[1] + parsedOpening.rawAfter.length],
+		loc: {
+			start: openingSequence.loc.end,
+			end: {
+				line: openingSequence.loc.end.line,
+				column: openingSequence.loc.end.column + parsedOpening.rawAfter.length
+			}
+		}
+	};
+	const parsedClosing = parseATXHeadingClosingSequenceFromText(text);
+	if (parsedClosing == null) {
+		const textAfterOpening = sourceCode.text.slice(spaceAfterOpening.range[1], range[1]);
+		const contentText$1 = textAfterOpening.trimEnd();
+		return {
+			openingSequence: {
+				...openingSequence,
+				raws: { spaceAfter: spaceAfterOpening }
+			},
+			content: {
+				text: contentText$1,
+				range: [spaceAfterOpening.range[1], spaceAfterOpening.range[1] + contentText$1.length],
+				loc: {
+					start: spaceAfterOpening.loc.end,
+					end: {
+						line: loc.end.line,
+						column: loc.end.column - (textAfterOpening.length - contentText$1.length)
+					}
+				}
+			},
+			closingSequence: null
+		};
+	}
+	const spaceAfterClosing = {
+		text: parsedClosing.rawAfter,
+		range: [range[1] - parsedClosing.rawAfter.length, range[1]],
 		loc: {
 			start: {
 				line: loc.end.line,
-				column: loc.end.column - parsed.rawAfter.length
+				column: loc.end.column - parsedClosing.rawAfter.length
 			},
-			end: {
-				line: loc.end.line,
-				column: loc.end.column
-			}
+			end: loc.end
 		}
 	};
 	const closingSequence = {
-		text: parsed.closingSequence,
-		range: [rawAfter.range[0] - parsed.closingSequence.length, rawAfter.range[0]],
+		text: parsedClosing.closingSequence,
+		range: [spaceAfterClosing.range[0] - parsedClosing.closingSequence.length, spaceAfterClosing.range[0]],
 		loc: {
 			start: {
-				line: rawAfter.loc.start.line,
-				column: rawAfter.loc.start.column - parsed.closingSequence.length
+				line: spaceAfterClosing.loc.start.line,
+				column: spaceAfterClosing.loc.start.column - parsedClosing.closingSequence.length
 			},
-			end: rawAfter.loc.start
+			end: spaceAfterClosing.loc.start
 		}
 	};
-	const rawBefore = {
-		text: parsed.rawBefore,
-		range: [closingSequence.range[0] - parsed.rawBefore.length, closingSequence.range[0]],
+	const spaceBeforeClosing = {
+		text: parsedClosing.rawBefore,
+		range: [closingSequence.range[0] - parsedClosing.rawBefore.length, closingSequence.range[0]],
 		loc: {
 			start: {
 				line: closingSequence.loc.start.line,
-				column: closingSequence.loc.start.column - parsed.rawBefore.length
+				column: closingSequence.loc.start.column - parsedClosing.rawBefore.length
 			},
 			end: closingSequence.loc.start
 		}
 	};
+	const contentText = sourceCode.text.slice(spaceAfterOpening.range[1], spaceBeforeClosing.range[0]);
+	return {
+		openingSequence: {
+			...openingSequence,
+			raws: { spaceAfter: spaceAfterOpening }
+		},
+		content: {
+			text: contentText,
+			range: [spaceAfterOpening.range[1], spaceBeforeClosing.range[0]],
+			loc: {
+				start: spaceAfterOpening.loc.end,
+				end: spaceBeforeClosing.loc.start
+			}
+		},
+		closingSequence: {
+			...closingSequence,
+			raws: {
+				spaceBefore: spaceBeforeClosing,
+				spaceAfter: spaceAfterClosing
+			}
+		}
+	};
+}
+/**
+* Parse the opening sequence from a text string.
+*/
+function parseATXHeadingOpeningSequenceFromText(text) {
+	if (!text.startsWith("#")) return null;
+	let openingSequenceAfterOffset = 1;
+	while (openingSequenceAfterOffset < text.length && text[openingSequenceAfterOffset] === "#") openingSequenceAfterOffset++;
+	const afterOffset = skipWhitespace(openingSequenceAfterOffset);
+	if (afterOffset === openingSequenceAfterOffset || afterOffset >= text.length) return null;
 	return {
-		rawBefore,
-		closingSequence,
-		rawAfter
+		openingSequence: text.slice(0, openingSequenceAfterOffset),
+		rawAfter: text.slice(openingSequenceAfterOffset, afterOffset)
 	};
+	/**
+	* Skip whitespace characters at the start of the text.
+	*/
+	function skipWhitespace(index) {
+		let result = index;
+		let c;
+		while (result < text.length && (c = text[result]) && (c === " " || c === "	")) result++;
+		return result;
+	}
 }
 /**
 * Parse the closing sequence from a text string.
@@ -255,9 +345,23 @@ function getParsedLines(sourceCode) {
 }
 
 //#endregion
-//#region src/rules/atx-headings-closing-sequence-length.ts
+//#region src/utils/get-text-width.ts
 let segmenter;
-var atx_headings_closing_sequence_length_default = createRule("atx-headings-closing-sequence-length", {
+/**
+* Get the width of a text string.
+*/
+function getTextWidth(text) {
+	if (!text.includes("	")) return stringWidth(text);
+	if (!segmenter) segmenter = new Intl.Segmenter("en");
+	let width = 0;
+	for (const { segment: c } of segmenter.segment(text)) if (c === "	") width += 4 - width % 4;
+	else width += stringWidth(c);
+	return width;
+}
+
+//#endregion
+//#region src/rules/atx-heading-closing-sequence-length.ts
+var atx_heading_closing_sequence_length_default = createRule("atx-heading-closing-sequence-length", {
 	meta: {
 		type: "layout",
 		docs: {
@@ -292,14 +396,11 @@ var atx_headings_closing_sequence_length_default = createRule("atx-headings-clos
 		/**
 		* Verify the closing sequence length of an ATX heading.
 		*/
-		function verifyATXHeadingClosingSequenceLength(node, getExpected) {
-			const parsed = parseATXHeadingClosingSequence(sourceCode, node);
-			if (!parsed || parsed.closingSequence == null) return;
+		function verifyATXHeadingClosingSequenceLength(parsed, reportNode, expectedLength) {
 			const actualLength = parsed.closingSequence.text.length;
-			const expectedLength = getExpected(node, parsed);
 			if (expectedLength === actualLength) return;
 			context.report({
-				node,
+				node: reportNode,
 				loc: parsed.closingSequence.loc,
 				messageId: "wrongClosingLength",
 				data: {
@@ -311,40 +412,41 @@ var atx_headings_closing_sequence_length_default = createRule("atx-headings-clos
 				}
 			});
 		}
-		return option.mode === "match-opening" ? (() => {
-			const getExpected = (node) => node.depth;
-			return { heading(node) {
-				verifyATXHeadingClosingSequenceLength(node, getExpected);
-			} };
-		})() : option.mode === "length" ? (() => {
+		if (option.mode === "match-opening") return { heading(node) {
+			const parsed = parseATXHeading(sourceCode, node);
+			if (!parsed || parsed.closingSequence == null) return;
+			verifyATXHeadingClosingSequenceLength(parsed, node, node.depth);
+		} };
+		if (option.mode === "length") {
 			const expected = option.length || 2;
-			const getExpected = () => expected;
 			return { heading(node) {
-				verifyATXHeadingClosingSequenceLength(node, getExpected);
+				const parsed = parseATXHeading(sourceCode, node);
+				if (!parsed || parsed.closingSequence == null) return;
+				verifyATXHeadingClosingSequenceLength(parsed, node, expected);
 			} };
-		})() : option.mode === "fixed-line-length" ? (() => {
+		}
+		if (option.mode === "fixed-line-length") {
 			const totalLength = option.length || 80;
-			const getExpected = (_node, parsed) => {
-				return totalLength - getContentLength(parsed);
-			};
 			return { heading(node) {
-				verifyATXHeadingClosingSequenceLength(node, getExpected);
+				const parsed = parseATXHeading(sourceCode, node);
+				if (!parsed || parsed.closingSequence == null) return;
+				verifyATXHeadingClosingSequenceLength(parsed, node, totalLength - getContentLength(parsed));
 			} };
-		})() : option.mode === "consistent" ? (() => {
-			let getExpected = null;
+		}
+		if (option.mode === "consistent") {
+			let expectedLength = null;
 			return { heading(node) {
-				if (getExpected == null) {
-					const parsed = parseATXHeadingClosingSequence(sourceCode, node);
-					if (!parsed || parsed.closingSequence == null) return;
-					const expected = parsed.closingSequence.text.length;
-					getExpected = () => expected;
-				} else verifyATXHeadingClosingSequenceLength(node, getExpected);
+				const parsed = parseATXHeading(sourceCode, node);
+				if (!parsed || parsed.closingSequence == null) return;
+				if (expectedLength == null) expectedLength = parsed.closingSequence.text.length;
+				else verifyATXHeadingClosingSequenceLength(parsed, node, expectedLength);
 			} };
-		})() : option.mode === "consistent-line-length" ? (() => {
+		}
+		if (option.mode === "consistent-line-length") {
 			const headings = [];
 			return {
 				heading(node) {
-					const parsed = parseATXHeadingClosingSequence(sourceCode, node);
+					const parsed = parseATXHeading(sourceCode, node);
 					if (!parsed || !parsed.closingSequence) return;
 					headings.push({
 						node,
@@ -370,13 +472,11 @@ var atx_headings_closing_sequence_length_default = createRule("atx-headings-clos
 						const lineLength = getLineLength(heading.parsed);
 						if (mostLongContentHeading.contentLength < lineLength && lineLength < minLineLength) minLineLength = Math.min(minLineLength, lineLength);
 					}
-					const getExpected = (_node, parsed) => {
-						return minLineLength - getContentLength(parsed);
-					};
-					for (const { node } of headings) verifyATXHeadingClosingSequenceLength(node, getExpected);
+					for (const heading of headings) verifyATXHeadingClosingSequenceLength(heading.parsed, heading.node, minLineLength - getContentLength(heading.parsed));
 				}
 			};
-		})() : {};
+		}
+		return {};
 		/**
 		* Get the content length of the heading.
 		*/
@@ -397,21 +497,10 @@ var atx_headings_closing_sequence_length_default = createRule("atx-headings-clos
 		}
 	}
 });
-/**
-* Get the width of a text string.
-*/
-function getTextWidth(text) {
-	if (!text.includes("	")) return stringWidth(text);
-	if (!segmenter) segmenter = new Intl.Segmenter("en");
-	let width = 0;
-	for (const { segment: c } of segmenter.segment(text)) if (c === "	") width += 4 - width % 4;
-	else width += stringWidth(c);
-	return width;
-}
 
 //#endregion
-//#region src/rules/atx-headings-closing-sequence.ts
-var atx_headings_closing_sequence_default = createRule("atx-headings-closing-sequence", {
+//#region src/rules/atx-heading-closing-sequence.ts
+var atx_heading_closing_sequence_default = createRule("atx-heading-closing-sequence", {
 	meta: {
 		type: "layout",
 		docs: {
@@ -439,7 +528,7 @@ var atx_headings_closing_sequence_default = createRule("atx-headings-closing-seq
 			if (opt.closingSequence === "always" || opt.closingSequence === "never") closingSequence = opt.closingSequence;
 		}
 		return { heading(node) {
-			const parsed = parseATXHeadingClosingSequence(sourceCode, node);
+			const parsed = parseATXHeading(sourceCode, node);
 			if (!parsed) return;
 			if (closingSequence === "always") {
 				if (parsed.closingSequence) return;
@@ -456,12 +545,12 @@ var atx_headings_closing_sequence_default = createRule("atx-headings-closing-seq
 				context.report({
 					node,
 					loc: {
-						start: parsed.rawBefore.loc.start,
+						start: parsed.closingSequence.raws.spaceBefore.loc.start,
 						end: parsed.closingSequence.loc.end
 					},
 					messageId: "forbidClosing",
 					*fix(fixer) {
-						const removeRange = [parsed.rawBefore.range[0], parsed.closingSequence.range[1]];
+						const removeRange = [parsed.closingSequence.raws.spaceBefore.range[0], parsed.closingSequence.range[1]];
 						const newHeadingText = sourceCode.text.slice(sourceCode.getRange(node)[0], removeRange[0]);
 						const newHeadingParsed = parseATXHeadingClosingSequenceFromText(newHeadingText);
 						if (newHeadingParsed) {
@@ -593,6 +682,176 @@ var blockquote_marker_alignment_default = createRule("blockquote-marker-alignmen
 	}
 });
 
+//#endregion
+//#region src/rules/bullet-list-marker-style.ts
+const MARKERS$1 = [
+	"-",
+	"*",
+	"+"
+];
+/**
+* Get the other marker.
+*/
+function getOtherMarker(unavailableMarker) {
+	return MARKERS$1.find((mark) => unavailableMarker !== mark);
+}
+/**
+* Parse rule options.
+*/
+function parseOptions$1(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}").`);
+	const overrides = (options.overrides ?? []).map((override, index) => {
+		const primaryForOverride = override.primary || "-";
+		const secondaryForOverride = override.secondary || getOtherMarker(primaryForOverride);
+		if (primaryForOverride === secondaryForOverride) throw new Error(`overrides[${index}]: \`primary\` and \`secondary\` cannot be the same (primary: "${primaryForOverride}", secondary: "${secondaryForOverride}").`);
+		return {
+			level: override.level,
+			parentMarker: override.parentMarker ?? "any",
+			primary: primaryForOverride,
+			secondary: secondaryForOverride
+		};
+	}).reverse();
+	return { get(level, parentMarker) {
+		for (const o of overrides) if ((o.level == null || o.level === level) && (o.parentMarker === "any" || o.parentMarker === parentMarker)) return {
+			primary: o.primary,
+			secondary: o.secondary
+		};
+		return {
+			primary,
+			secondary
+		};
+	} };
+}
+var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent bullet list (unordered list) marker style",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				primary: { enum: MARKERS$1 },
+				secondary: { enum: [...MARKERS$1, "any"] },
+				overrides: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							level: {
+								type: "integer",
+								minimum: 1
+							},
+							parentMarker: { enum: [
+								...MARKERS$1,
+								"any",
+								"ordered"
+							] },
+							primary: { enum: MARKERS$1 },
+							secondary: { enum: [...MARKERS$1, "any"] }
+						},
+						additionalProperties: false
+					}
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: { unexpected: "Bullet list marker should be '{{marker}}'." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = parseOptions$1(context.options[0] || {});
+		let containerStack = {
+			node: sourceCode.ast,
+			level: 1,
+			upper: null
+		};
+		/**
+		* Check bullet list marker style
+		*/
+		function checkBulletList(node) {
+			let parentMarker;
+			if (containerStack.node.type === "listItem") {
+				const parentMarkerKind = getListItemMarker(sourceCode, containerStack.node).kind;
+				parentMarker = parentMarkerKind === "." || parentMarkerKind === ")" ? "ordered" : parentMarkerKind;
+			} else parentMarker = "top";
+			const { primary, secondary } = options.get(containerStack.level, parentMarker);
+			const nodeIndex = containerStack.node.children.indexOf(node);
+			if (nodeIndex === -1) return;
+			const prevNode = nodeIndex > 0 ? containerStack.node.children[nodeIndex - 1] : null;
+			const prevBulletList = prevNode && (prevNode.type === "list" ? prevNode : null);
+			const prevBulletListMarker = prevBulletList && getListItemMarker(sourceCode, prevBulletList);
+			const expectedMarker = prevBulletListMarker?.kind !== primary ? primary : secondary;
+			if (expectedMarker === "any") return;
+			const marker = getListItemMarker(sourceCode, node);
+			if (marker.kind === expectedMarker) return;
+			const loc = sourceCode.getLoc(node);
+			context.report({
+				node,
+				loc: {
+					start: loc.start,
+					end: {
+						line: loc.start.line,
+						column: loc.start.column + marker.raw.length
+					}
+				},
+				messageId: "unexpected",
+				data: { marker: expectedMarker },
+				*fix(fixer) {
+					if (prevNode?.type === "list" && prevBulletListMarker && (prevBulletListMarker.kind === "-" || prevBulletListMarker.kind === "*" || prevBulletListMarker.kind === "+")) yield fixMarker(prevNode.children[0], prevBulletListMarker.kind);
+					yield* fixMarkers(node, expectedMarker);
+					let prevMarker = expectedMarker;
+					for (let index = nodeIndex + 1; index < containerStack.node.children.length; index++) {
+						const nextNode = containerStack.node.children[index];
+						if (nextNode.type !== "list") break;
+						const nextMarker = getListItemMarker(sourceCode, nextNode);
+						if (nextMarker.kind !== prevMarker) break;
+						let expectedNextMarker = prevMarker === primary ? secondary : primary;
+						if (expectedNextMarker === "any") expectedNextMarker = getOtherMarker(prevMarker);
+						yield* fixMarkers(nextNode, expectedNextMarker);
+						prevMarker = expectedNextMarker;
+					}
+					/**
+					* Fix bullet list markers
+					*/
+					function* fixMarkers(list, replacementMarker) {
+						for (const item of list.children) yield fixMarker(item, replacementMarker);
+					}
+					/**
+					* Fix bullet list item marker
+					*/
+					function fixMarker(item, replacementMarker) {
+						const range = sourceCode.getRange(item);
+						return fixer.replaceTextRange([range[0], range[0] + 1], replacementMarker);
+					}
+				}
+			});
+		}
+		return {
+			list(node) {
+				if (node.ordered) return;
+				checkBulletList(node);
+			},
+			"root, blockquote, listItem, footnoteDefinition"(node) {
+				containerStack = {
+					node,
+					level: node.type === "listItem" ? containerStack.level + 1 : 1,
+					upper: containerStack
+				};
+			},
+			"root, blockquote, listItem, footnoteDefinition:exit"() {
+				containerStack = containerStack.upper;
+			}
+		};
+	}
+});
+
 //#endregion
 //#region src/rules/canonical-code-block-language.ts
 const DEFAULT_LANGUAGES = {
@@ -3594,84 +3853,358 @@ var heading_casing_default = createRule("heading-casing", {
 });
 
 //#endregion
-//#region src/rules/list-marker-alignment.ts
-const ALIGN_TO_POSITION_NAME = {
-	left: "start",
-	right: "end"
-};
-var list_marker_alignment_default = createRule("list-marker-alignment", {
+//#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 alignment of list markers",
-			categories: ["recommended"],
+			description: "enforce consistent style for level 1 headings",
+			categories: [],
 			listCategory: "Stylistic"
 		},
-		fixable: "whitespace",
+		fixable: "code",
 		hasSuggestions: false,
 		schema: [{
 			type: "object",
-			properties: { align: { enum: ["left", "right"] } },
+			properties: {
+				style: { enum: ["atx", "setext"] },
+				allowMultilineSetext: { type: "boolean" }
+			},
 			additionalProperties: false
 		}],
-		messages: { incorrectAlignment: "List marker alignment is inconsistent. Expected {{expected}} characters of indentation, but got {{actual}}." }
+		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 alignPositionName = ALIGN_TO_POSITION_NAME[context.options[0]?.align ?? "left"];
-		/**
-		* Get the marker location of a list item
-		*/
-		function getMarkerLocation(node) {
-			const start = sourceCode.getLoc(node).start;
-			const startColumnIndex = start.column - 1;
-			const marker = getListItemMarker(sourceCode, node);
-			return {
-				line: start.line,
-				start: startColumnIndex,
-				end: startColumnIndex + marker.raw.length
-			};
-		}
-		/**
-		* Check if list items have consistent alignment
-		*/
-		function checkListAlignment(listNode) {
-			const items = listNode.children;
-			if (items.length <= 1) return;
-			const referenceMarkerLocation = getMarkerLocation(items[0]);
-			for (const item of items.slice(1)) {
-				const markerLocation = getMarkerLocation(item);
-				const diff = markerLocation[alignPositionName] - referenceMarkerLocation[alignPositionName];
-				if (diff === 0) continue;
+		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;
+				const isMultiline = parsed.contentLines.length > 1;
+				if (isMultiline) {
+					if (allowMultilineSetext) return;
+					context.report({
+						node,
+						messageId: "multilineSetextNotAllowed"
+					});
+					return;
+				}
 				context.report({
-					node: item,
-					loc: {
-						start: {
-							line: markerLocation.line,
-							column: markerLocation.start + 1
-						},
-						end: {
-							line: markerLocation.line,
-							column: markerLocation.end + 1
-						}
-					},
-					messageId: "incorrectAlignment",
-					data: {
-						expected: String(markerLocation.start - diff),
-						actual: String(markerLocation.start)
-					},
-					fix(fixer) {
+					node,
+					messageId: "expectedAtx",
+					*fix(fixer) {
+						const heading = parsed.contentLines[0];
+						yield fixer.insertTextBeforeRange(heading.range, "# ");
 						const lines = getParsedLines(sourceCode);
-						const line = lines.get(markerLocation.line);
-						if (diff < 0) {
-							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;
-						const referenceMarkerBefore = lines.get(referenceMarkerLocation.line).text.slice(0, referenceMarkerLocation.start);
-						if (referenceMarkerBefore === itemBefore) {
-							const removeEndIndex = line.range[0] + markerLocation.start;
+						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.openingSequence.raws.spaceAfter.range[1]]);
+						if (parsed.closingSequence) yield fixer.removeRange([parsed.closingSequence.raws.spaceBefore.range[0], parsed.closingSequence.raws.spaceAfter.range[1]]);
+						const lines = getParsedLines(sourceCode);
+						const underline = "=".repeat(Math.max(getTextWidth(parsed.content.text), 3));
+						const prefix = lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1);
+						const appendingText = `\n${prefix}${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: [],
+			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;
+				const isMultiline = parsed.contentLines.length > 1;
+				if (isMultiline) {
+					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.openingSequence.raws.spaceAfter.range[1]]);
+						if (parsed.closingSequence) yield fixer.removeRange([parsed.closingSequence.raws.spaceBefore.range[0], parsed.closingSequence.raws.spaceAfter.range[1]]);
+						const lines = getParsedLines(sourceCode);
+						const underline = "-".repeat(Math.max(getTextWidth(parsed.content.text), 3));
+						const prefix = lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1);
+						const appendingText = `\n${prefix}${underline}`;
+						yield fixer.insertTextAfter(node, appendingText);
+					}
+				});
+			}
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/list-marker-alignment.ts
+const ALIGN_TO_POSITION_NAME = {
+	left: "start",
+	right: "end"
+};
+var list_marker_alignment_default = createRule("list-marker-alignment", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent alignment of list markers",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { align: { enum: ["left", "right"] } },
+			additionalProperties: false
+		}],
+		messages: { incorrectAlignment: "List marker alignment is inconsistent. Expected {{expected}} characters of indentation, but got {{actual}}." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const alignPositionName = ALIGN_TO_POSITION_NAME[context.options[0]?.align ?? "left"];
+		/**
+		* Get the marker location of a list item
+		*/
+		function getMarkerLocation(node) {
+			const start = sourceCode.getLoc(node).start;
+			const startColumnIndex = start.column - 1;
+			const marker = getListItemMarker(sourceCode, node);
+			return {
+				line: start.line,
+				start: startColumnIndex,
+				end: startColumnIndex + marker.raw.length
+			};
+		}
+		/**
+		* Check if list items have consistent alignment
+		*/
+		function checkListAlignment(listNode) {
+			const items = listNode.children;
+			if (items.length <= 1) return;
+			const referenceMarkerLocation = getMarkerLocation(items[0]);
+			for (const item of items.slice(1)) {
+				const markerLocation = getMarkerLocation(item);
+				const diff = markerLocation[alignPositionName] - referenceMarkerLocation[alignPositionName];
+				if (diff === 0) continue;
+				context.report({
+					node: item,
+					loc: {
+						start: {
+							line: markerLocation.line,
+							column: markerLocation.start + 1
+						},
+						end: {
+							line: markerLocation.line,
+							column: markerLocation.end + 1
+						}
+					},
+					messageId: "incorrectAlignment",
+					data: {
+						expected: String(markerLocation.start - diff),
+						actual: String(markerLocation.start)
+					},
+					fix(fixer) {
+						const lines = getParsedLines(sourceCode);
+						const line = lines.get(markerLocation.line);
+						if (diff < 0) {
+							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;
+						const referenceMarkerBefore = lines.get(referenceMarkerLocation.line).text.slice(0, referenceMarkerLocation.start);
+						if (referenceMarkerBefore === itemBefore) {
+							const removeEndIndex = line.range[0] + markerLocation.start;
 							const removeStartIndex = removeEndIndex - diff;
 							return fixer.removeRange([removeStartIndex, removeEndIndex]);
 						}
@@ -4146,7 +4679,7 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 				messageId: "inconsistentStart",
 				data: {
 					expected: new Intl.ListFormat("en-US", { type: "disjunction" }).format(expected.map((n) => `'${n}'`)),
-					actual: String(marker.sequence)
+					actual: marker.sequence.raw
 				},
 				fix: scope.last == null ? (fixer) => {
 					const expectedMarker = `1${marker.kind}`;
@@ -4167,7 +4700,7 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 				const marker = getListItemMarker(sourceCode, item);
 				if (marker.kind !== "." && marker.kind !== ")") continue;
 				const expectedSequence = node.start + i;
-				if (marker.sequence !== expectedSequence) {
+				if (marker.sequence.value !== expectedSequence) {
 					const expectedMarker = `${expectedSequence}${marker.kind}`;
 					context.report({
 						node: item,
@@ -4302,6 +4835,174 @@ var ordered_list_marker_start_default = createRule("ordered-list-marker-start",
 	}
 });
 
+//#endregion
+//#region src/rules/ordered-list-marker-style.ts
+const MARKER_KINDS = [".", ")"];
+const MARKERS = MARKER_KINDS.map((kind) => `n${kind}`);
+/**
+* Get the other marker kind.
+*/
+function getOtherMarkerKind(unavailableMarker) {
+	return MARKER_KINDS.find((mark) => unavailableMarker !== mark);
+}
+function markerToKind(marker) {
+	if (marker === "n.") return ".";
+	if (marker === "n)") return ")";
+	return marker;
+}
+/**
+* Parse rule options.
+*/
+function parseOptions(options) {
+	const prefer = markerToKind(options.prefer) || ".";
+	const overrides = (options.overrides ?? []).map((override) => {
+		const preferForOverride = markerToKind(override.prefer) || ".";
+		return {
+			level: override.level,
+			parentMarker: markerToKind(override.parentMarker) ?? "any",
+			prefer: preferForOverride
+		};
+	}).reverse();
+	return { get(level, parentMarker) {
+		for (const o of overrides) if ((o.level == null || o.level === level) && (o.parentMarker === "any" || o.parentMarker === parentMarker)) return { prefer: o.prefer };
+		return { prefer };
+	} };
+}
+/**
+* Check if a item marker is an ordered list marker.
+*/
+function isOrderedListItemMarker(itemMarker) {
+	return itemMarker.kind === "." || itemMarker.kind === ")";
+}
+var ordered_list_marker_style_default = createRule("ordered-list-marker-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent ordered list marker style",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				prefer: { enum: MARKERS },
+				overrides: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							level: {
+								type: "integer",
+								minimum: 1
+							},
+							parentMarker: { enum: [
+								...MARKERS,
+								"any",
+								"bullet"
+							] },
+							prefer: { enum: MARKERS }
+						},
+						additionalProperties: false
+					}
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: { unexpected: "Ordered list marker should be '{{sequence}}{{markerKind}}'." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = parseOptions(context.options[0] || {});
+		let containerStack = {
+			node: sourceCode.ast,
+			level: 1,
+			upper: null
+		};
+		/**
+		* Check ordered list marker style
+		*/
+		function checkOrderedList(node) {
+			let parentMarker;
+			if (containerStack.node.type === "listItem") {
+				const parentMarkerKind = getListItemMarker(sourceCode, containerStack.node).kind;
+				parentMarker = parentMarkerKind === "-" || parentMarkerKind === "*" || parentMarkerKind === "+" ? "bullet" : parentMarkerKind;
+			} else parentMarker = "top";
+			const { prefer } = options.get(containerStack.level, parentMarker);
+			const nodeIndex = containerStack.node.children.indexOf(node);
+			if (nodeIndex === -1) return;
+			const prevNode = nodeIndex > 0 ? containerStack.node.children[nodeIndex - 1] : null;
+			const prevBulletList = prevNode && (prevNode.type === "list" ? prevNode : null);
+			const prevBulletListMarker = prevBulletList && getListItemMarker(sourceCode, prevBulletList);
+			const expectedMarker = prevBulletListMarker?.kind !== prefer ? prefer : getOtherMarkerKind(prefer);
+			const marker = getListItemMarker(sourceCode, node);
+			if (marker.kind === expectedMarker || !isOrderedListItemMarker(marker)) return;
+			const loc = sourceCode.getLoc(node);
+			context.report({
+				node,
+				loc: {
+					start: loc.start,
+					end: {
+						line: loc.start.line,
+						column: loc.start.column + marker.raw.length
+					}
+				},
+				messageId: "unexpected",
+				data: {
+					sequence: marker.sequence.raw,
+					markerKind: expectedMarker
+				},
+				*fix(fixer) {
+					if (prevNode?.type === "list" && prevBulletListMarker && isOrderedListItemMarker(prevBulletListMarker)) yield* fixMarker(prevNode.children[0], prevBulletListMarker.kind);
+					yield* fixMarkers(node, expectedMarker);
+					let prevMarker = expectedMarker;
+					for (let index = nodeIndex + 1; index < containerStack.node.children.length; index++) {
+						const nextNode = containerStack.node.children[index];
+						if (nextNode.type !== "list") break;
+						const nextMarker = getListItemMarker(sourceCode, nextNode);
+						if (nextMarker.kind !== prevMarker) break;
+						const expectedNextMarker = prevMarker === prefer ? getOtherMarkerKind(prefer) : prefer;
+						yield* fixMarkers(nextNode, expectedNextMarker);
+						prevMarker = expectedNextMarker;
+					}
+					/**
+					* Fix ordered list markers
+					*/
+					function* fixMarkers(list, replacementMarker) {
+						for (const item of list.children) yield* fixMarker(item, replacementMarker);
+					}
+					/**
+					* Fix ordered list item marker
+					*/
+					function* fixMarker(item, replacementMarker) {
+						const range = sourceCode.getRange(item);
+						const itemMarker = getListItemMarker(sourceCode, item);
+						if (!isOrderedListItemMarker(itemMarker)) return;
+						yield fixer.replaceTextRange([range[0] + itemMarker.raw.length - 1, range[0] + itemMarker.raw.length], replacementMarker);
+					}
+				}
+			});
+		}
+		return {
+			list(node) {
+				if (!node.ordered) return;
+				checkOrderedList(node);
+			},
+			"root, blockquote, listItem, footnoteDefinition"(node) {
+				containerStack = {
+					node,
+					level: node.type === "listItem" ? containerStack.level + 1 : 1,
+					upper: containerStack
+				};
+			},
+			"root, blockquote, listItem, footnoteDefinition:exit"() {
+				containerStack = containerStack.upper;
+			}
+		};
+	}
+});
+
 //#endregion
 //#region src/rules/padding-line-between-blocks.ts
 /**
@@ -5119,6 +5820,244 @@ var prefer_linked_words_default = createRule("prefer-linked-words", {
 	}
 });
 
+//#endregion
+//#region src/rules/setext-heading-underline-length.ts
+var setext_heading_underline_length_default = createRule("setext-heading-underline-length", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce setext heading underline length",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		schema: [{
+			type: "object",
+			properties: {
+				mode: {
+					type: "string",
+					enum: [
+						"exact",
+						"minimum",
+						"consistent",
+						"consistent-line-length"
+					]
+				},
+				align: {
+					type: "string",
+					enum: [
+						"any",
+						"exact",
+						"minimum",
+						"length"
+					]
+				},
+				length: {
+					type: "integer",
+					minimum: 1
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			exactLength: "Setext heading underline should be exactly the same length as the heading text.",
+			minimumLength: "Setext heading underline should be at least as long as the heading text.",
+			consistentAny: "Setext heading underline should be consistent with other underlines in the document.",
+			consistentExact: "Setext heading underline should be exactly the same length as the longest heading text in the document.",
+			consistentMinimum: "Setext heading underline should be at least as long as the longest heading text in the document.",
+			consistentLength: "Setext heading underline should be {{expectedLength}} characters long for consistency.",
+			consistentLineLengthAny: "Setext heading underline should be consistent in line length with other underlines in the document.",
+			consistentLineLengthExact: "Setext heading underline should be exactly the same line length as the longest heading line in the document.",
+			consistentLineLengthMinimum: "Setext heading underline should be at least as long as the longest heading line in the document.",
+			consistentLineLengthLength: "Setext heading underline should be {{expectedLength}} characters long for line length consistency."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = context.options[0] || {};
+		const mode = options.mode || "exact";
+		const parsedSetextHeadings = /* @__PURE__ */ new Map();
+		/**
+		* Get the parsed setext heading for a specific heading.
+		*/
+		function getParsedSetextHeading(heading) {
+			const cached = parsedSetextHeadings.get(heading);
+			if (cached) return cached;
+			const underline = parseSetextHeading(sourceCode, heading);
+			if (!underline) return null;
+			parsedSetextHeadings.set(heading, underline);
+			return underline;
+		}
+		/**
+		* Helper function to report errors for both regular and blockquote headings
+		*/
+		function reportError(node, messageId, expectedLength) {
+			const parsed = getParsedSetextHeading(node);
+			if (!parsed) return;
+			context.report({
+				node,
+				messageId,
+				loc: parsed.underline.loc,
+				data: { expectedLength: String(expectedLength) },
+				fix(fixer) {
+					const newUnderline = parsed.underline.marker.repeat(expectedLength);
+					return fixer.replaceTextRange(parsed.underline.range, newUnderline);
+				}
+			});
+		}
+		if (mode === "exact" || mode === "minimum") return { heading(node) {
+			const parsed = getParsedSetextHeading(node);
+			if (!parsed) return;
+			const expectedLength = getMaxHeaderTextWidth(parsed);
+			if (expectedLength < 1) return;
+			if (mode === "exact") {
+				if (parsed.underline.text.length !== expectedLength) reportError(node, "exactLength", expectedLength);
+			} else if (mode === "minimum") {
+				if (parsed.underline.text.length < expectedLength) reportError(node, "minimumLength", expectedLength);
+			}
+		} };
+		if (mode === "consistent") {
+			const align = options.align || "exact";
+			const fixedLength = options.length || 0;
+			const setextHeadings = [];
+			return {
+				heading(node) {
+					if (getHeadingKind(sourceCode, node) !== "setext") return;
+					setextHeadings.push(node);
+				},
+				"root:exit"() {
+					if (setextHeadings.length === 0) return;
+					let expectedLength = 0;
+					if (align === "any") {
+						if (setextHeadings.length < 2) return;
+						for (const node of setextHeadings) {
+							const parsed = getParsedSetextHeading(node);
+							if (!parsed) continue;
+							expectedLength = parsed.underline.text.length;
+							break;
+						}
+					} else if (align === "exact") for (const node of setextHeadings) {
+						const parsed = getParsedSetextHeading(node);
+						if (!parsed) continue;
+						expectedLength = Math.max(expectedLength, getMaxHeaderTextWidth(parsed));
+					}
+					else if (align === "minimum") {
+						let maxTextWidth = 0;
+						for (const node of setextHeadings) {
+							const parsed = getParsedSetextHeading(node);
+							if (!parsed) continue;
+							maxTextWidth = Math.max(maxTextWidth, getMaxHeaderTextWidth(parsed));
+							expectedLength = Math.max(expectedLength, parsed.underline.text.length);
+						}
+						if (expectedLength < maxTextWidth) expectedLength = maxTextWidth;
+						else for (const node of setextHeadings) {
+							const parsed = getParsedSetextHeading(node);
+							if (!parsed) continue;
+							if (maxTextWidth <= parsed.underline.text.length) expectedLength = Math.min(expectedLength, parsed.underline.text.length);
+						}
+					} else if (align === "length") expectedLength = fixedLength;
+					else return;
+					if (!expectedLength || expectedLength < 1) return;
+					for (const node of setextHeadings) {
+						const parsed = getParsedSetextHeading(node);
+						if (!parsed) continue;
+						if (parsed.underline.text.length === expectedLength) continue;
+						if (align === "any") reportError(node, "consistentAny", expectedLength);
+						else if (align === "exact") reportError(node, "consistentExact", expectedLength);
+						else if (align === "minimum") reportError(node, "consistentMinimum", expectedLength);
+						else if (align === "length") reportError(node, "consistentLength", expectedLength);
+					}
+				}
+			};
+		}
+		if (mode === "consistent-line-length") {
+			const align = options.align || "exact";
+			const fixedLength = options.length || 0;
+			const setextHeadings = [];
+			return {
+				heading(node) {
+					if (getHeadingKind(sourceCode, node) !== "setext") return;
+					setextHeadings.push(node);
+				},
+				"root:exit"() {
+					if (setextHeadings.length === 0) return;
+					let minimumRequiredLineLength = 1;
+					for (const node of setextHeadings) {
+						const parsed = getParsedSetextHeading(node);
+						if (!parsed) continue;
+						minimumRequiredLineLength = Math.max(minimumRequiredLineLength, parsed.underline.raws.prefix.length + parsed.underline.raws.spaceBefore.length + 1);
+					}
+					let expectedLineLength = minimumRequiredLineLength;
+					if (align === "any") {
+						if (setextHeadings.length < 2) return;
+						for (const node of setextHeadings) {
+							const parsed = getParsedSetextHeading(node);
+							if (!parsed) continue;
+							expectedLineLength = Math.max(parsed.underline.loc.end.column - 1, minimumRequiredLineLength);
+							break;
+						}
+					} else if (align === "exact") for (const node of setextHeadings) {
+						const parsed = getParsedSetextHeading(node);
+						if (!parsed) continue;
+						expectedLineLength = Math.max(expectedLineLength, getMaxHeaderLineWidth(parsed));
+					}
+					else if (align === "minimum") {
+						let maxLineWidth = 0;
+						for (const node of setextHeadings) {
+							const parsed = getParsedSetextHeading(node);
+							if (!parsed) continue;
+							maxLineWidth = Math.max(maxLineWidth, getMaxHeaderLineWidth(parsed));
+							expectedLineLength = Math.max(expectedLineLength, parsed.underline.loc.end.column - 1);
+						}
+						if (expectedLineLength < maxLineWidth) expectedLineLength = maxLineWidth;
+						else for (const node of setextHeadings) {
+							const parsed = getParsedSetextHeading(node);
+							if (!parsed) continue;
+							if (maxLineWidth <= parsed.underline.loc.end.column - 1) expectedLineLength = Math.min(expectedLineLength, parsed.underline.loc.end.column - 1);
+						}
+					} else if (align === "length") expectedLineLength = Math.max(fixedLength, minimumRequiredLineLength);
+					else return;
+					if (!expectedLineLength || expectedLineLength < 1) return;
+					for (const node of setextHeadings) {
+						const parsed = getParsedSetextHeading(node);
+						if (!parsed) continue;
+						const expectedLength = expectedLineLength - parsed.underline.raws.prefix.length - parsed.underline.raws.spaceBefore.length;
+						if (parsed.underline.text.length === expectedLength) continue;
+						if (align === "any") reportError(node, "consistentLineLengthAny", expectedLength);
+						else if (align === "exact") reportError(node, "consistentLineLengthExact", expectedLength);
+						else if (align === "minimum") reportError(node, "consistentLineLengthMinimum", expectedLength);
+						else if (align === "length") reportError(node, "consistentLineLengthLength", expectedLength);
+					}
+				}
+			};
+		}
+		return {};
+		/**
+		* Get the maximum width of header lines.
+		*/
+		function getMaxHeaderTextWidth(parsed) {
+			let maxWidth = 0;
+			for (const contentLine of parsed.contentLines) {
+				const lineWidth = getTextWidth(contentLine.raws.prefix + contentLine.raws.spaceBefore + contentLine.text);
+				const prefixWidth = getTextWidth(contentLine.raws.prefix + contentLine.raws.spaceBefore);
+				maxWidth = Math.max(maxWidth, lineWidth - prefixWidth);
+			}
+			return maxWidth;
+		}
+		/**
+		* Get the maximum width of header lines.
+		*/
+		function getMaxHeaderLineWidth(parsed) {
+			let maxLineWidth = 0;
+			for (const contentLine of parsed.contentLines) {
+				const lineWidth = getTextWidth(contentLine.raws.prefix + contentLine.raws.spaceBefore + contentLine.text);
+				maxLineWidth = Math.max(maxLineWidth, lineWidth);
+			}
+			return maxLineWidth;
+		}
+	}
+});
+
 //#endregion
 //#region src/rules/sort-definitions.ts
 var sort_definitions_default = createRule("sort-definitions", {
@@ -5536,17 +6475,231 @@ var table_header_casing_default = createRule("table-header-casing", {
 	}
 });
 
+//#endregion
+//#region src/rules/thematic-break-character-style.ts
+var thematic_break_character_style_default = createRule("thematic-break-character-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent character style for thematic breaks (horizontal rules) in Markdown.",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { style: {
+				type: "string",
+				enum: [
+					"-",
+					"*",
+					"_"
+				]
+			} },
+			additionalProperties: false
+		}],
+		messages: { unexpected: "Thematic break should use '{{expected}}' but found '{{actual}}'." }
+	},
+	create(context) {
+		const option = context.options[0];
+		const style = option?.style || "-";
+		return { thematicBreak(node) {
+			const marker = getThematicBreakMarker(context.sourceCode, node);
+			if (marker.kind !== style) context.report({
+				node,
+				messageId: "unexpected",
+				data: {
+					expected: style,
+					actual: marker.kind
+				},
+				fix(fixer) {
+					const range = context.sourceCode.getRange(node);
+					const text = context.sourceCode.getText(node);
+					const rep = text.replaceAll(marker.kind, style);
+					return fixer.replaceTextRange(range, rep);
+				}
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/utils/thematic-break.ts
+/**
+* Check if the pattern is valid within the thematic break string.
+*/
+function isValidThematicBreakPattern(pattern, text) {
+	for (let i = 0; i < text.length; i += pattern.length) {
+		const subSequence = text.slice(i, i + pattern.length);
+		if (subSequence === pattern) continue;
+		if (subSequence.length < pattern.length && pattern.startsWith(subSequence)) continue;
+		return false;
+	}
+	return true;
+}
+/**
+* Create a thematic break string from a pattern and length.
+*/
+function createThematicBreakFromPattern(pattern, length) {
+	const mark = pattern[0];
+	let candidate = pattern.repeat(Math.floor(length / pattern.length));
+	if (candidate.length < length) candidate += pattern.slice(0, length - candidate.length);
+	candidate = candidate.trim();
+	if (candidate.length !== length) return null;
+	let markCount = 0;
+	for (const c of candidate) {
+		if (c !== mark) continue;
+		markCount++;
+		if (markCount >= 3) return candidate;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/rules/thematic-break-length.ts
+var thematic_break_length_default = createRule("thematic-break-length", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent length for thematic breaks (horizontal rules) in Markdown.",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { length: {
+				type: "integer",
+				minimum: 3
+			} },
+			additionalProperties: false
+		}],
+		messages: { unexpected: "Thematic break should be {{expected}} characters, but found {{actual}}." }
+	},
+	create(context) {
+		const option = context.options[0] || {};
+		const expectedLength = option.length ?? 3;
+		const sourceCode = context.sourceCode;
+		return { thematicBreak(node) {
+			const marker = getThematicBreakMarker(sourceCode, node);
+			if (marker.text.length === expectedLength) return;
+			context.report({
+				node,
+				messageId: "unexpected",
+				data: {
+					expected: String(expectedLength),
+					actual: String(marker.text.length)
+				},
+				fix(fixer) {
+					const sequence = replacementSequence(marker);
+					if (!sequence) return null;
+					return fixer.replaceText(node, sequence);
+				}
+			});
+		} };
+		/**
+		* Replace the sequence in the thematic break marker with the expected length.
+		*/
+		function replacementSequence(marker) {
+			if (marker.hasSpaces) {
+				const pattern = inferSequencePattern(marker.text);
+				if (pattern) return createThematicBreakFromPattern(pattern, expectedLength);
+				return null;
+			}
+			return marker.kind.repeat(expectedLength);
+		}
+		/**
+		* Infer sequence pattern from the original string.
+		*/
+		function inferSequencePattern(original) {
+			for (let length = 2; length < original.length; length++) {
+				const pattern = original.slice(0, length);
+				if (isValidThematicBreakPattern(pattern, original)) return pattern;
+			}
+			return null;
+		}
+	}
+});
+
+//#endregion
+//#region src/rules/thematic-break-sequence-pattern.ts
+var thematic_break_sequence_pattern_default = createRule("thematic-break-sequence-pattern", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent repeating patterns for thematic breaks (horizontal rules) in Markdown.",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { pattern: { anyOf: [
+				{
+					type: "string",
+					minLength: 1,
+					pattern: "^\\-[	 \\-]*$"
+				},
+				{
+					type: "string",
+					minLength: 1,
+					pattern: "^\\*[	 *]*$"
+				},
+				{
+					type: "string",
+					minLength: 1,
+					pattern: "^_[	 _]*$"
+				}
+			] } },
+			required: ["pattern"],
+			additionalProperties: false
+		}],
+		messages: { inconsistentPattern: "Thematic break does not match the preferred repeating pattern '{{pattern}}'." }
+	},
+	create(context) {
+		const option = context.options[0] || {};
+		const pattern = option.pattern ?? "-";
+		const sourceCode = context.sourceCode;
+		const patterns = {
+			"-": pattern.replaceAll(/[*_]/gu, "-"),
+			"*": pattern.replaceAll(/[-_]/gu, "*"),
+			_: pattern.replaceAll(/[*-]/gu, "_")
+		};
+		return { thematicBreak(node) {
+			const marker = getThematicBreakMarker(sourceCode, node);
+			const patternForKind = patterns[marker.kind];
+			if (isValidThematicBreakPattern(patternForKind, marker.text)) return;
+			context.report({
+				node,
+				messageId: "inconsistentPattern",
+				data: { pattern },
+				fix(fixer) {
+					const replacement = createThematicBreakFromPattern(patternForKind, marker.text.length);
+					if (!replacement) return null;
+					return fixer.replaceText(node, replacement);
+				}
+			});
+		} };
+	}
+});
+
 //#endregion
 //#region src/utils/rules.ts
 const rules$1 = [
-	atx_headings_closing_sequence_length_default,
-	atx_headings_closing_sequence_default,
+	atx_heading_closing_sequence_length_default,
+	atx_heading_closing_sequence_default,
 	blockquote_marker_alignment_default,
+	bullet_list_marker_style_default,
 	canonical_code_block_language_default,
 	definitions_last_default,
 	emoji_notation_default,
 	hard_linebreak_style_default,
 	heading_casing_default,
+	level1_heading_style_default,
+	level2_heading_style_default,
 	list_marker_alignment_default,
 	no_laziness_blockquotes_default,
 	no_multiple_empty_lines_default,
@@ -5554,14 +6707,19 @@ const rules$1 = [
 	no_trailing_spaces_default,
 	ordered_list_marker_sequence_default,
 	ordered_list_marker_start_default,
+	ordered_list_marker_style_default,
 	padding_line_between_blocks_default,
 	prefer_autolinks_default,
 	prefer_fenced_code_blocks_default,
 	prefer_inline_code_words_default,
 	prefer_link_reference_definitions_default,
 	prefer_linked_words_default,
+	setext_heading_underline_length_default,
 	sort_definitions_default,
-	table_header_casing_default
+	table_header_casing_default,
+	thematic_break_character_style_default,
+	thematic_break_length_default,
+	thematic_break_sequence_pattern_default
 ];
 
 //#endregion
@@ -5604,7 +6762,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.16.0";
+const version = "0.18.0";
 
 //#endregion
 //#region src/index.ts