eslint-plugin-markdown-preferences 0.16.0 → 0.17.0

package/README.md

@@ -129,7 +129,11 @@ The rules with the following star ⭐ are included in the configs.
 | [markdown-preferences/prefer-autolinks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html) | enforce the use of autolinks for URLs | 🔧 | ⭐ |
 | [markdown-preferences/prefer-fenced-code-blocks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-fenced-code-blocks.html) | enforce the use of fenced code blocks over indented code blocks | 🔧 | ⭐ |
 | [markdown-preferences/prefer-link-reference-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-link-reference-definitions.html) | enforce using link reference definitions instead of inline links | 🔧 |  |
+| [markdown-preferences/setext-heading-underline-length](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/setext-heading-underline-length.html) | enforce setext heading underline length | 🔧 |  |
 | [markdown-preferences/sort-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/sort-definitions.html) | enforce a specific order for link definitions and footnote definitions | 🔧 |  |
+| [markdown-preferences/thematic-break-character-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-character-style.html) | enforce consistent character style for thematic breaks (horizontal rules) in Markdown. | 🔧 |  |
+| [markdown-preferences/thematic-break-length](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-length.html) | enforce consistent length for thematic breaks (horizontal rules) in Markdown. | 🔧 |  |
+| [markdown-preferences/thematic-break-sequence-pattern](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-sequence-pattern.html) | enforce consistent repeating patterns for thematic breaks (horizontal rules) in Markdown. | 🔧 |  |
 
 <!-- prettier-ignore-end -->
 

package/lib/index.d.ts

@@ -115,6 +115,11 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-linked-words.html
    */
   'markdown-preferences/prefer-linked-words'?: Linter.RuleEntry<MarkdownPreferencesPreferLinkedWords>;
+  /**
+   * enforce setext heading underline length
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/setext-heading-underline-length.html
+   */
+  'markdown-preferences/setext-heading-underline-length'?: Linter.RuleEntry<MarkdownPreferencesSetextHeadingUnderlineLength>;
   /**
    * enforce a specific order for link definitions and footnote definitions
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/sort-definitions.html
@@ -125,6 +130,21 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/table-header-casing.html
    */
   'markdown-preferences/table-header-casing'?: Linter.RuleEntry<MarkdownPreferencesTableHeaderCasing>;
+  /**
+   * enforce consistent character style for thematic breaks (horizontal rules) in Markdown.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-character-style.html
+   */
+  'markdown-preferences/thematic-break-character-style'?: Linter.RuleEntry<MarkdownPreferencesThematicBreakCharacterStyle>;
+  /**
+   * enforce consistent length for thematic breaks (horizontal rules) in Markdown.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-length.html
+   */
+  'markdown-preferences/thematic-break-length'?: Linter.RuleEntry<MarkdownPreferencesThematicBreakLength>;
+  /**
+   * enforce consistent repeating patterns for thematic breaks (horizontal rules) in Markdown.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-sequence-pattern.html
+   */
+  'markdown-preferences/thematic-break-sequence-pattern'?: Linter.RuleEntry<MarkdownPreferencesThematicBreakSequencePattern>;
 }
 type MarkdownPreferencesAtxHeadingsClosingSequence = [] | [{
   closingSequence?: ("always" | "never");
@@ -205,6 +225,11 @@ type MarkdownPreferencesPreferLinkedWords = [] | [{
   }[];
   [k: string]: unknown | undefined;
 }];
+type MarkdownPreferencesSetextHeadingUnderlineLength = [] | [{
+  mode?: ("exact" | "minimum" | "consistent" | "consistent-line-length");
+  align?: ("any" | "exact" | "minimum" | "length");
+  length?: number;
+}];
 type MarkdownPreferencesSortDefinitions = [] | [{
   order?: (string | [string, ...(string)[]] | {
     match: (string | [string, ...(string)[]]);
@@ -218,6 +243,15 @@ type MarkdownPreferencesTableHeaderCasing = [] | [{
   ignorePatterns?: string[];
   minorWords?: string[];
 }];
+type MarkdownPreferencesThematicBreakCharacterStyle = [] | [{
+  style?: ("-" | "*" | "_");
+}];
+type MarkdownPreferencesThematicBreakLength = [] | [{
+  length?: number;
+}];
+type MarkdownPreferencesThematicBreakSequencePattern = [] | [{
+  pattern: (string | string | string);
+}];
 declare namespace recommended_d_exports {
   export { files, language, languageOptions, name$1 as name, plugins, rules$1 as rules };
 }
@@ -236,7 +270,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.16.0";
+declare const version: "0.17.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -86,10 +86,11 @@ function getListItemMarker(sourceCode, node) {
 * 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
 	};
 }
 /**
@@ -255,8 +256,22 @@ function getParsedLines(sourceCode) {
 }
 
 //#endregion
-//#region src/rules/atx-headings-closing-sequence-length.ts
+//#region src/utils/get-text-width.ts
 let segmenter;
+/**
+* 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-length.ts
 var atx_headings_closing_sequence_length_default = createRule("atx-headings-closing-sequence-length", {
 	meta: {
 		type: "layout",
@@ -397,17 +412,6 @@ 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
@@ -5119,6 +5123,360 @@ var prefer_linked_words_default = createRule("prefer-linked-words", {
 	}
 });
 
+//#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/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,6 +5894,217 @@ 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 = [
@@ -5560,8 +6129,12 @@ const rules$1 = [
 	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 +6177,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.16.0";
+const version = "0.17.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {
@@ -34,7 +34,7 @@
     "ts": "node --import=tsx",
     "mocha": "npm run ts -- ./node_modules/mocha/bin/mocha.js",
     "generate:version": "env-cmd -e version -- npm run update && npm run lint -- --fix",
-    "changeset:version": "changeset version && npm run generate:version && git add --all",
+    "changeset:version": "env-cmd -e version -- changeset version && npm run generate:version && git add --all",
     "changeset:publish": "npm run build && changeset publish"
   },
   "repository": {