eslint-plugin-markdown-preferences 0.15.0 → 0.17.0

package/README.md

@@ -37,6 +37,7 @@ npm install --save-dev eslint @eslint/markdown eslint-plugin-markdown-preference
 ## 📖 Usage
 
 <!--USAGE_SECTION_START-->
+
 <!--USAGE_GUIDE_START-->
 
 ### Configuration
@@ -75,6 +76,7 @@ See [the rule list](https://ota-meshi.github.io/eslint-plugin-markdown-preferenc
 Is not supported.
 
 <!--USAGE_GUIDE_END-->
+
 <!--USAGE_SECTION_END-->
 
 ## ✅ Rules
@@ -86,12 +88,12 @@ The rules with the following star ⭐ are included in the configs.
 
 <!--RULES_TABLE_START-->
 
-<!-- prettier-ignore-start -->
-
 ### Preference Rules
 
 - Rules to unify the expression and description style of documents.
 
+<!-- prettier-ignore-start -->
+
 | Rule ID | Description | Fixable | RECOMMENDED |
 |:--------|:------------|:-------:|:-----------:|
 | [markdown-preferences/canonical-code-block-language](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/canonical-code-block-language.html) | enforce canonical language names in code blocks | 🔧 |  |
@@ -102,10 +104,14 @@ The rules with the following star ⭐ are included in the configs.
 | [markdown-preferences/prefer-linked-words](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-linked-words.html) | enforce the specified word to be a link. | 🔧 |  |
 | [markdown-preferences/table-header-casing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/table-header-casing.html) | enforce consistent casing in table header cells. | 🔧 |  |
 
+<!-- prettier-ignore-end -->
+
 ### Stylistic Rules
 
 - Rules related to the formatting and visual style of Markdown.
 
+<!-- prettier-ignore-start -->
+
 | Rule ID | Description | Fixable | RECOMMENDED |
 |:--------|:------------|:-------:|:-----------:|
 | [markdown-preferences/atx-headings-closing-sequence-length](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-headings-closing-sequence-length.html) | enforce consistent length for the closing sequence (trailing #s) in ATX headings. | 🔧 |  |
@@ -119,15 +125,26 @@ The rules with the following star ⭐ are included in the configs.
 | [markdown-preferences/no-text-backslash-linebreak](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-text-backslash-linebreak.html) | disallow text backslash at the end of a line. |  | ⭐ |
 | [markdown-preferences/no-trailing-spaces](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-trailing-spaces.html) | disallow trailing whitespace at the end of lines in Markdown files. | 🔧 |  |
 | [markdown-preferences/ordered-list-marker-sequence](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-sequence.html) | enforce that ordered list markers use sequential numbers | 🔧 |  |
+| [markdown-preferences/padding-line-between-blocks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/padding-line-between-blocks.html) | require or disallow padding lines between blocks | 🔧 | ⭐ |
 | [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 -->
 
 <!--RULES_TABLE_END-->
+
 <!--RULES_SECTION_END-->
+
+## 👫 Related Packages
+
+- [eslint-plugin-markdown-links](https://github.com/ota-meshi/eslint-plugin-markdown-links) ... ESLint plugin with powerful checking rules related to Markdown links.
+
 <!--DOCS_IGNORE_START-->
 
 ## 🍻 Contributing

package/lib/index.d.ts

@@ -85,6 +85,11 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-start.html
    */
   'markdown-preferences/ordered-list-marker-start'?: Linter.RuleEntry<MarkdownPreferencesOrderedListMarkerStart>;
+  /**
+   * require or disallow padding lines between blocks
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/padding-line-between-blocks.html
+   */
+  'markdown-preferences/padding-line-between-blocks'?: Linter.RuleEntry<MarkdownPreferencesPaddingLineBetweenBlocks>;
   /**
    * enforce the use of autolinks for URLs
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html
@@ -110,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
@@ -120,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");
@@ -162,6 +187,17 @@ type MarkdownPreferencesNoTrailingSpaces = [] | [{
 type MarkdownPreferencesOrderedListMarkerStart = [] | [{
   start?: (1 | 0);
 }];
+type MarkdownPreferencesPaddingLineBetweenBlocks = {
+  prev: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]] | {
+    type: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]]);
+    in?: ("list" | "blockquote" | "footnote-definition");
+  });
+  next: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]] | {
+    type: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]]);
+    in?: ("list" | "blockquote" | "footnote-definition");
+  });
+  blankLine: ("any" | "never" | "always");
+}[];
 type MarkdownPreferencesPreferInlineCodeWords = [] | [{
   words: string[];
   ignores?: {
@@ -189,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)[]]);
@@ -202,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 };
 }
@@ -220,7 +270,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.15.0";
+declare const version: "0.17.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -27,14 +27,111 @@ function createRule(ruleName, rule) {
 	};
 }
 
+//#endregion
+//#region src/utils/ast.ts
+/**
+* Get the kind of heading.
+*/
+function getHeadingKind(sourceCode, node) {
+	const loc = sourceCode.getLoc(node);
+	if (loc.start.line !== loc.end.line) return "setext";
+	return "atx";
+}
+/**
+* Get the kind of code block.
+*/
+function getCodeBlockKind(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	return text.startsWith("```") ? "backtick-fenced" : text.startsWith("~~~") ? "tilde-fenced" : "indented";
+}
+/**
+* Get the kind of link.
+*/
+function getLinkKind(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	return text.startsWith("[") ? "inline" : text.startsWith("<") && text.endsWith(">") ? "autolink" : "gfm-autolink";
+}
+/**
+* Get the marker of a list item.
+*/
+function getListItemMarker(sourceCode, node) {
+	const item = node.type === "list" ? node.children[0] || node : node;
+	const text = sourceCode.getText(item);
+	if (text.startsWith("-")) return {
+		kind: "-",
+		raw: "-"
+	};
+	if (text.startsWith("*")) return {
+		kind: "*",
+		raw: "*"
+	};
+	if (text.startsWith("+")) return {
+		kind: "+",
+		raw: "+"
+	};
+	const matchDot = /^(\d+)\./.exec(text);
+	if (matchDot) return {
+		kind: ".",
+		raw: matchDot[0],
+		sequence: Number(matchDot[1])
+	};
+	const matchParen = /^(\d+)\)/.exec(text);
+	return {
+		kind: ")",
+		raw: matchParen[0],
+		sequence: Number(matchParen[1])
+	};
+}
+/**
+* Get the marker for a thematic break.
+*/
+function getThematicBreakMarker(sourceCode, node) {
+	const text = sourceCode.getText(node).trimEnd();
+	return {
+		kind: text.startsWith("-") ? "-" : text.startsWith("*") ? "*" : "_",
+		hasSpaces: /\s/u.test(text),
+		text
+	};
+}
+/**
+* Get the source location from a range in a node.
+*/
+function getSourceLocationFromRange(sourceCode, node, range) {
+	const [nodeStart] = sourceCode.getRange(node);
+	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;
+	} else {
+		const beforeLines = sourceCode.text.slice(0, range[0]).split(/\n/u);
+		startLine = beforeLines.length;
+		startColumn = 1 + (beforeLines.at(-1) || "").length;
+	}
+	const contentLines = sourceCode.text.slice(range[0], range[1]).split(/\n/u);
+	const endLine = startLine + contentLines.length - 1;
+	const endColumn = (contentLines.length === 1 ? startColumn : 1) + (contentLines.at(-1) || "").length;
+	return {
+		start: {
+			line: startLine,
+			column: startColumn
+		},
+		end: {
+			line: endLine,
+			column: endColumn
+		}
+	};
+}
+
 //#endregion
 //#region src/utils/atx-heading.ts
 /**
 * Parse the closing sequence of an ATX heading.
 */
 function parseATXHeadingClosingSequence(sourceCode, node) {
+	if (getHeadingKind(sourceCode, node) !== "atx") return null;
 	const loc = sourceCode.getLoc(node);
-	if (loc.start.line !== loc.end.line) return null;
 	const range = sourceCode.getRange(node);
 	const parsed = parseATXHeadingClosingSequenceFromText(sourceCode.text.slice(...range));
 	if (parsed == null) return { closingSequence: null };
@@ -159,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",
@@ -301,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
@@ -497,84 +597,6 @@ var blockquote_marker_alignment_default = createRule("blockquote-marker-alignmen
 	}
 });
 
-//#endregion
-//#region src/utils/ast.ts
-/**
-* Get the kind of code block.
-*/
-function getCodeBlockKind(sourceCode, node) {
-	const text = sourceCode.getText(node);
-	return text.startsWith("```") ? "backtick-fenced" : text.startsWith("~~~") ? "tilde-fenced" : "indented";
-}
-/**
-* Get the kind of link.
-*/
-function getLinkKind(sourceCode, node) {
-	const text = sourceCode.getText(node);
-	return text.startsWith("[") ? "inline" : text.startsWith("<") && text.endsWith(">") ? "autolink" : "gfm-autolink";
-}
-/**
-* Get the marker of a list item.
-*/
-function getListItemMarker(sourceCode, node) {
-	const item = node.type === "list" ? node.children[0] || node : node;
-	const text = sourceCode.getText(item);
-	if (text.startsWith("-")) return {
-		kind: "-",
-		raw: "-"
-	};
-	if (text.startsWith("*")) return {
-		kind: "*",
-		raw: "*"
-	};
-	if (text.startsWith("+")) return {
-		kind: "+",
-		raw: "+"
-	};
-	const matchDot = /^(\d+)\./.exec(text);
-	if (matchDot) return {
-		kind: ".",
-		raw: matchDot[0],
-		sequence: Number(matchDot[1])
-	};
-	const matchParen = /^(\d+)\)/.exec(text);
-	return {
-		kind: ")",
-		raw: matchParen[0],
-		sequence: Number(matchParen[1])
-	};
-}
-/**
-* Get the source location from a range in a node.
-*/
-function getSourceLocationFromRange(sourceCode, node, range) {
-	const [nodeStart] = sourceCode.getRange(node);
-	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;
-	} else {
-		const beforeLines = sourceCode.text.slice(0, range[0]).split(/\n/u);
-		startLine = beforeLines.length;
-		startColumn = 1 + (beforeLines.at(-1) || "").length;
-	}
-	const contentLines = sourceCode.text.slice(range[0], range[1]).split(/\n/u);
-	const endLine = startLine + contentLines.length - 1;
-	const endColumn = (contentLines.length === 1 ? startColumn : 1) + (contentLines.at(-1) || "").length;
-	return {
-		start: {
-			line: startLine,
-			column: startColumn
-		},
-		end: {
-			line: endLine,
-			column: endColumn
-		}
-	};
-}
-
 //#endregion
 //#region src/rules/canonical-code-block-language.ts
 const DEFAULT_LANGUAGES = {
@@ -4284,6 +4306,272 @@ var ordered_list_marker_start_default = createRule("ordered-list-marker-start",
 	}
 });
 
+//#endregion
+//#region src/rules/padding-line-between-blocks.ts
+/**
+* Determines whether a blank line must be preserved between two nodes
+* due to Markdown syntax constraints (e.g., setext headings).
+*/
+function requiresBlankLineBetween(prev, next, sourceCode) {
+	if (prev.type === "paragraph") {
+		if (next.type === "paragraph" || next.type === "definition") return true;
+		else if (next.type === "heading") return getHeadingKind(sourceCode, next) === "setext";
+		else if (next.type === "thematicBreak") {
+			const marker = getThematicBreakMarker(sourceCode, next);
+			return marker.kind === "-" && !marker.hasSpaces;
+		}
+	} else if (prev.type === "list") {
+		if (next.type === "paragraph" || next.type === "table" || next.type === "definition") return true;
+		else if (next.type === "heading") return getHeadingKind(sourceCode, next) === "setext";
+	} else if (prev.type === "blockquote") {
+		if (next.type === "paragraph" || next.type === "blockquote" || next.type === "table" || next.type === "definition") return true;
+		else if (next.type === "heading") return getHeadingKind(sourceCode, next) === "setext";
+	} else if (prev.type === "table") {
+		if (next.type === "paragraph" || next.type === "table" || next.type === "definition") return true;
+		else if (next.type === "heading") return getHeadingKind(sourceCode, next) === "setext";
+	} else if (prev.type === "footnoteDefinition") {
+		if (next.type === "paragraph" || next.type === "table" || next.type === "definition") return true;
+		else if (next.type === "heading") return getHeadingKind(sourceCode, next) === "setext";
+	} else if (prev.type === "html") return true;
+	return false;
+}
+const BLOCK_TYPES = [
+	"blockquote",
+	"code",
+	"heading",
+	"html",
+	"list",
+	"paragraph",
+	"thematic-break",
+	"table",
+	"link-definition",
+	"footnote-definition",
+	"frontmatter",
+	"*"
+];
+const BLOCK_TYPE_SCHEMAS = [{
+	type: "string",
+	enum: BLOCK_TYPES
+}, {
+	type: "array",
+	items: {
+		type: "string",
+		enum: BLOCK_TYPES
+	},
+	minItems: 1
+}];
+const SELECTOR_SCHEMA = { oneOf: [...BLOCK_TYPE_SCHEMAS, {
+	type: "object",
+	properties: {
+		type: { oneOf: BLOCK_TYPE_SCHEMAS },
+		in: { enum: [
+			"list",
+			"blockquote",
+			"footnote-definition"
+		] }
+	},
+	required: ["type"],
+	additionalProperties: false
+}] };
+const BLOCK_TYPE_MAP0 = {
+	heading: "heading",
+	paragraph: "paragraph",
+	list: "list",
+	blockquote: "blockquote",
+	code: "code",
+	html: "html",
+	table: "table",
+	thematicBreak: "thematic-break",
+	definition: "link-definition",
+	footnoteDefinition: "footnote-definition",
+	json: "frontmatter",
+	toml: "frontmatter",
+	yaml: "frontmatter"
+};
+const BLOCK_TYPE_MAP = BLOCK_TYPE_MAP0;
+/**
+* Get the block type of a node
+*/
+function getBlockType(node) {
+	const nodeType = node.type;
+	const blockType = BLOCK_TYPE_MAP[nodeType];
+	if (blockType) return blockType;
+	return null;
+}
+var padding_line_between_blocks_default = createRule("padding-line-between-blocks", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "require or disallow padding lines between blocks",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					prev: SELECTOR_SCHEMA,
+					next: SELECTOR_SCHEMA,
+					blankLine: {
+						type: "string",
+						enum: [
+							"any",
+							"never",
+							"always"
+						]
+					}
+				},
+				required: [
+					"prev",
+					"next",
+					"blankLine"
+				],
+				additionalProperties: false
+			}
+		},
+		messages: {
+			expectedBlankLine: "Expected a blank line between {{prevType}} and {{nextType}}.",
+			unexpectedBlankLine: "Unexpected blank line between {{prevType}} and {{nextType}}."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = [...context.options || []].reverse();
+		const containerStack = [];
+		/**
+		* Check if the actual type matches the expected type pattern
+		*/
+		function matchesType(actualType, block, expected) {
+			if (Array.isArray(expected)) {
+				for (const e of expected) {
+					const matched$1 = matchesType(actualType, block, e);
+					if (matched$1) return matched$1;
+				}
+				return null;
+			}
+			if (typeof expected === "string") return expected === actualType || expected === "*" ? actualType : null;
+			let matched = null;
+			if (Array.isArray(expected.type)) for (const e of expected.type) {
+				matched = matchesType(actualType, block, e);
+				if (matched) break;
+			}
+			else matched = matchesType(actualType, block, expected.type);
+			if (!matched) return null;
+			if (expected.in === "list") {
+				if (containerStack[0]?.type !== "listItem") return null;
+			} else if (expected.in === "blockquote") {
+				if (containerStack[0]?.type !== "blockquote") return null;
+			} else if (expected.in === "footnote-definition") {
+				if (containerStack[0]?.type !== "footnoteDefinition") return null;
+			}
+			return matched;
+		}
+		/**
+		* Get the expected padding between two blocks
+		*/
+		function getExpectedPadding(prevBlock, nextBlock) {
+			const prevType = getBlockType(prevBlock);
+			const nextType = getBlockType(nextBlock);
+			if (!prevType || !nextType) return null;
+			for (const rule of options) {
+				const prev = matchesType(prevType, prevBlock, rule.prev);
+				if (!prev) continue;
+				const next = matchesType(nextType, nextBlock, rule.next);
+				if (!next) continue;
+				return {
+					prev,
+					next,
+					blankLine: rule.blankLine
+				};
+			}
+			return null;
+		}
+		/**
+		* Check padding between blocks in a container node
+		*/
+		function checkBlockPadding(containerNode) {
+			for (let i = 0; i < containerNode.children.length - 1; i++) {
+				const prevBlock = containerNode.children[i];
+				const nextBlock = containerNode.children[i + 1];
+				const expected = getExpectedPadding(prevBlock, nextBlock);
+				if (expected === null) continue;
+				const prevLoc = sourceCode.getLoc(prevBlock);
+				const nextLoc = sourceCode.getLoc(nextBlock);
+				const actualBlankLine = nextLoc.start.line - prevLoc.end.line - 1;
+				const hasBlankLine = actualBlankLine > 0;
+				let messageId = "expectedBlankLine";
+				if (expected.blankLine === "always") {
+					if (hasBlankLine) continue;
+					let list = null;
+					const stack$1 = [...containerStack];
+					let target$1;
+					while (target$1 = stack$1.shift()) if (target$1.type === "listItem") {
+						list = target$1;
+						break;
+					}
+					if (list && !list.spread) continue;
+					messageId = "expectedBlankLine";
+				} else if (expected.blankLine === "never") {
+					if (!hasBlankLine) continue;
+					if (requiresBlankLineBetween(prevBlock, nextBlock, sourceCode)) continue;
+					messageId = "unexpectedBlankLine";
+				} else continue;
+				const lineLength = sourceCode.lines[nextLoc.start.line - 1].length;
+				let blockquote = null;
+				const stack = [...containerStack];
+				let target;
+				while (target = stack.shift()) if (target.type === "blockquote") {
+					blockquote = target;
+					break;
+				}
+				context.report({
+					node: nextBlock,
+					loc: {
+						start: nextLoc.start,
+						end: {
+							line: nextLoc.start.line,
+							column: lineLength + 1
+						}
+					},
+					messageId,
+					data: {
+						prevType: expected.prev,
+						nextType: expected.next
+					},
+					fix(fixer) {
+						if (expected.blankLine === "always") {
+							let text = "\n";
+							if (blockquote) {
+								const blockquoteLoc = sourceCode.getLoc(blockquote);
+								text += getBlockquoteLevelFromLine(sourceCode, blockquoteLoc.start.line).prefix.trimEnd();
+							}
+							const nextRange = sourceCode.getRange(nextBlock);
+							const startNext = nextRange[0] - nextLoc.start.column;
+							return fixer.insertTextBeforeRange([startNext, startNext], text);
+						}
+						const lines = getParsedLines(sourceCode);
+						const linesToRemove = [];
+						for (let line = prevLoc.end.line + 1; line < nextLoc.start.line; line++) linesToRemove.push(lines.get(line));
+						return linesToRemove.map((line) => fixer.removeRange(line.range));
+					}
+				});
+			}
+		}
+		return {
+			"root, blockquote, listItem, footnoteDefinition"(node) {
+				containerStack.unshift(node);
+			},
+			"root, blockquote, listItem, footnoteDefinition:exit"(node) {
+				checkBlockPadding(node);
+				containerStack.shift();
+			}
+		};
+	}
+});
+
 //#endregion
 //#region src/rules/prefer-autolinks.ts
 var prefer_autolinks_default = createRule("prefer-autolinks", {
@@ -4835,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", {
@@ -5252,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 = [
@@ -5270,13 +6123,18 @@ const rules$1 = [
 	no_trailing_spaces_default,
 	ordered_list_marker_sequence_default,
 	ordered_list_marker_start_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
@@ -5306,6 +6164,7 @@ const rules$2 = {
 	"markdown-preferences/list-marker-alignment": "error",
 	"markdown-preferences/no-laziness-blockquotes": "error",
 	"markdown-preferences/no-text-backslash-linebreak": "error",
+	"markdown-preferences/padding-line-between-blocks": "error",
 	"markdown-preferences/prefer-autolinks": "error",
 	"markdown-preferences/prefer-fenced-code-blocks": "error"
 };
@@ -5318,7 +6177,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.15.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.15.0",
+  "version": "0.17.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {
@@ -33,8 +33,8 @@
     "docs:build": "vitepress build docs",
     "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",
+    "generate:version": "env-cmd -e version -- npm run update && npm run lint -- --fix",
+    "changeset:version": "env-cmd -e version -- changeset version && npm run generate:version && git add --all",
     "changeset:publish": "npm run build && changeset publish"
   },
   "repository": {
@@ -62,14 +62,14 @@
   },
   "dependencies": {
     "emoji-regex-xs": "^2.0.1",
-    "string-width": "^7.2.0"
+    "string-width": "^8.0.0"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.1",
     "@changesets/cli": "^2.28.1",
     "@changesets/get-release-plan": "^4.0.8",
     "@eslint/core": "^0.15.0",
-    "@eslint/markdown": "^7.1.0",
+    "@eslint/markdown": "^7.2.0",
     "@ota-meshi/eslint-plugin": "^0.18.0",
     "@shikijs/vitepress-twoslash": "^3.0.0",
     "@types/eslint": "^9.6.1",
@@ -83,8 +83,8 @@
     "@types/semver": "^7.5.8",
     "assert": "^2.1.0",
     "c8": "^10.1.3",
-    "env-cmd": "^10.1.0",
-    "eslint": "^9.22.0",
+    "env-cmd": "^11.0.0",
+    "eslint": "^9.34.0",
     "eslint-compat-utils": "^0.6.4",
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-eslint-comments": "^3.2.0",
@@ -93,6 +93,7 @@
     "eslint-plugin-json-schema-validator": "^5.3.1",
     "eslint-plugin-jsonc": "^2.19.1",
     "eslint-plugin-markdown": "^5.1.0",
+    "eslint-plugin-markdown-links": "^0.4.0",
     "eslint-plugin-n": "^17.16.2",
     "eslint-plugin-node-dependencies": "^1.0.0",
     "eslint-plugin-prettier": "^5.2.3",