eslint-plugin-markdown-preferences 0.17.0 → 0.18.0

package/README.md

@@ -114,17 +114,21 @@ The rules with the following star ⭐ are included in the configs.
 
 | 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. | 🔧 |  |
-| [markdown-preferences/atx-headings-closing-sequence](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-headings-closing-sequence.html) | enforce consistent use of closing sequence in ATX headings. | 🔧 |  |
+| [markdown-preferences/atx-heading-closing-sequence-length](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-heading-closing-sequence-length.html) | enforce consistent length for the closing sequence (trailing #s) in ATX headings. | 🔧 |  |
+| [markdown-preferences/atx-heading-closing-sequence](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-heading-closing-sequence.html) | enforce consistent use of closing sequence in ATX headings. | 🔧 |  |
 | [markdown-preferences/blockquote-marker-alignment](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/blockquote-marker-alignment.html) | enforce consistent alignment of blockquote markers | 🔧 | ⭐ |
+| [markdown-preferences/bullet-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/bullet-list-marker-style.html) | enforce consistent bullet list (unordered list) marker style | 🔧 |  |
 | [markdown-preferences/definitions-last](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html) | require link definitions and footnote definitions to be placed at the end of the document | 🔧 |  |
 | [markdown-preferences/hard-linebreak-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html) | enforce consistent hard linebreak style. | 🔧 | ⭐ |
+| [markdown-preferences/level1-heading-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level1-heading-style.html) | enforce consistent style for level 1 headings | 🔧 |  |
+| [markdown-preferences/level2-heading-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level2-heading-style.html) | enforce consistent style for level 2 headings | 🔧 |  |
 | [markdown-preferences/list-marker-alignment](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/list-marker-alignment.html) | enforce consistent alignment of list markers | 🔧 | ⭐ |
 | [markdown-preferences/no-laziness-blockquotes](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-laziness-blockquotes.html) | disallow laziness in blockquotes |  | ⭐ |
 | [markdown-preferences/no-multiple-empty-lines](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-multiple-empty-lines.html) | disallow multiple empty lines in Markdown files. | 🔧 |  |
 | [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/ordered-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-style.html) | enforce consistent ordered list marker style | 🔧 |  |
 | [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 | 🔧 | ⭐ |

package/lib/index.d.ts

@@ -12,19 +12,24 @@ declare module 'eslint' {
 interface RuleOptions {
   /**
    * enforce consistent use of closing sequence in ATX headings.
-   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-headings-closing-sequence.html
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-heading-closing-sequence.html
    */
-  'markdown-preferences/atx-headings-closing-sequence'?: Linter.RuleEntry<MarkdownPreferencesAtxHeadingsClosingSequence>;
+  'markdown-preferences/atx-heading-closing-sequence'?: Linter.RuleEntry<MarkdownPreferencesAtxHeadingClosingSequence>;
   /**
    * enforce consistent length for the closing sequence (trailing #s) in ATX headings.
-   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-headings-closing-sequence-length.html
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-heading-closing-sequence-length.html
    */
-  'markdown-preferences/atx-headings-closing-sequence-length'?: Linter.RuleEntry<MarkdownPreferencesAtxHeadingsClosingSequenceLength>;
+  'markdown-preferences/atx-heading-closing-sequence-length'?: Linter.RuleEntry<MarkdownPreferencesAtxHeadingClosingSequenceLength>;
   /**
    * enforce consistent alignment of blockquote markers
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/blockquote-marker-alignment.html
    */
   'markdown-preferences/blockquote-marker-alignment'?: Linter.RuleEntry<[]>;
+  /**
+   * enforce consistent bullet list (unordered list) marker style
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/bullet-list-marker-style.html
+   */
+  'markdown-preferences/bullet-list-marker-style'?: Linter.RuleEntry<MarkdownPreferencesBulletListMarkerStyle>;
   /**
    * enforce canonical language names in code blocks
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/canonical-code-block-language.html
@@ -50,6 +55,16 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/heading-casing.html
    */
   'markdown-preferences/heading-casing'?: Linter.RuleEntry<MarkdownPreferencesHeadingCasing>;
+  /**
+   * enforce consistent style for level 1 headings
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level1-heading-style.html
+   */
+  'markdown-preferences/level1-heading-style'?: Linter.RuleEntry<MarkdownPreferencesLevel1HeadingStyle>;
+  /**
+   * enforce consistent style for level 2 headings
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/level2-heading-style.html
+   */
+  'markdown-preferences/level2-heading-style'?: Linter.RuleEntry<MarkdownPreferencesLevel2HeadingStyle>;
   /**
    * enforce consistent alignment of list markers
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/list-marker-alignment.html
@@ -85,6 +100,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>;
+  /**
+   * enforce consistent ordered list marker style
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-style.html
+   */
+  'markdown-preferences/ordered-list-marker-style'?: Linter.RuleEntry<MarkdownPreferencesOrderedListMarkerStyle>;
   /**
    * require or disallow padding lines between blocks
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/padding-line-between-blocks.html
@@ -146,13 +166,23 @@ interface RuleOptions {
    */
   'markdown-preferences/thematic-break-sequence-pattern'?: Linter.RuleEntry<MarkdownPreferencesThematicBreakSequencePattern>;
 }
-type MarkdownPreferencesAtxHeadingsClosingSequence = [] | [{
+type MarkdownPreferencesAtxHeadingClosingSequence = [] | [{
   closingSequence?: ("always" | "never");
 }];
-type MarkdownPreferencesAtxHeadingsClosingSequenceLength = [] | [{
+type MarkdownPreferencesAtxHeadingClosingSequenceLength = [] | [{
   mode?: ("match-opening" | "length" | "consistent" | "consistent-line-length" | "fixed-line-length");
   length?: number;
 }];
+type MarkdownPreferencesBulletListMarkerStyle = [] | [{
+  primary?: ("-" | "*" | "+");
+  secondary?: ("-" | "*" | "+" | "any");
+  overrides?: {
+    level?: number;
+    parentMarker?: ("-" | "*" | "+" | "any" | "ordered");
+    primary?: ("-" | "*" | "+");
+    secondary?: ("-" | "*" | "+" | "any");
+  }[];
+}];
 type MarkdownPreferencesCanonicalCodeBlockLanguage = [] | [{
   languages?: {
     [k: string]: string;
@@ -172,6 +202,14 @@ type MarkdownPreferencesHeadingCasing = [] | [{
   ignorePatterns?: string[];
   minorWords?: string[];
 }];
+type MarkdownPreferencesLevel1HeadingStyle = [] | [{
+  style?: ("atx" | "setext");
+  allowMultilineSetext?: boolean;
+}];
+type MarkdownPreferencesLevel2HeadingStyle = [] | [{
+  style?: ("atx" | "setext");
+  allowMultilineSetext?: boolean;
+}];
 type MarkdownPreferencesListMarkerAlignment = [] | [{
   align?: ("left" | "right");
 }];
@@ -187,6 +225,14 @@ type MarkdownPreferencesNoTrailingSpaces = [] | [{
 type MarkdownPreferencesOrderedListMarkerStart = [] | [{
   start?: (1 | 0);
 }];
+type MarkdownPreferencesOrderedListMarkerStyle = [] | [{
+  prefer?: ("n." | "n)");
+  overrides?: {
+    level?: number;
+    parentMarker?: ("n." | "n)" | "any" | "bullet");
+    prefer?: ("n." | "n)");
+  }[];
+}];
 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" | "*"))[]]);
@@ -270,7 +316,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.17.0";
+declare const version: "0.18.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -73,13 +73,19 @@ 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]
+		}
 	};
 }
 /**
@@ -127,57 +133,140 @@ 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 {
-		rawBefore,
-		closingSequence,
-		rawAfter
+		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 {
+		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.
 */
 function parseATXHeadingClosingSequenceFromText(text) {
@@ -271,8 +360,8 @@ function getTextWidth(text) {
 }
 
 //#endregion
-//#region src/rules/atx-headings-closing-sequence-length.ts
-var atx_headings_closing_sequence_length_default = createRule("atx-headings-closing-sequence-length", {
+//#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: {
@@ -307,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: {
@@ -326,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,
@@ -385,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.
 		*/
@@ -414,8 +499,8 @@ var atx_headings_closing_sequence_length_default = createRule("atx-headings-clos
 });
 
 //#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: {
@@ -443,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;
@@ -460,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) {
@@ -597,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 = {
@@ -3597,6 +3852,280 @@ var heading_casing_default = createRule("heading-casing", {
 	}
 });
 
+//#endregion
+//#region src/utils/setext-heading.ts
+/**
+* Parse the setext heading.
+*/
+function parseSetextHeading(sourceCode, node) {
+	if (getHeadingKind(sourceCode, node) !== "setext") return null;
+	const lines = getParsedLines(sourceCode);
+	const contentLines = [];
+	const nodeLoc = sourceCode.getLoc(node);
+	for (let lineNumber = nodeLoc.start.line; lineNumber < nodeLoc.end.line; lineNumber++) {
+		const content = parseContent(lines.get(lineNumber));
+		contentLines.push(content);
+	}
+	const underline = parseUnderline(lines.get(nodeLoc.end.line));
+	if (!underline) return null;
+	return {
+		contentLines,
+		underline
+	};
+}
+/**
+* Parse the content line of a setext heading.
+*/
+function parseContent(line) {
+	let prefix = "";
+	let spaceBefore = "";
+	let suffix = "";
+	for (let index = 0; index < line.text.length; index++) {
+		const c = line.text[index];
+		if (!c.trim()) {
+			spaceBefore += c;
+			continue;
+		}
+		if (c === ">" && spaceBefore.length < 4) {
+			prefix += spaceBefore + c;
+			spaceBefore = "";
+			continue;
+		}
+		suffix = line.text.slice(index);
+		break;
+	}
+	const content = suffix.trimEnd();
+	const spaceAfter = suffix.slice(content.length);
+	return {
+		text: content,
+		range: [line.range[0] + prefix.length + spaceBefore.length, line.range[1] - line.linebreak.length - spaceAfter.length],
+		loc: {
+			start: {
+				line: line.line,
+				column: prefix.length + spaceBefore.length + 1
+			},
+			end: {
+				line: line.line,
+				column: prefix.length + spaceBefore.length + content.length + 1
+			}
+		},
+		raws: {
+			prefix,
+			spaceBefore,
+			spaceAfter
+		}
+	};
+}
+/**
+* Parse the underline of a setext heading.
+*/
+function parseUnderline(line) {
+	let marker = null;
+	let underlineText = "";
+	let prefix = "";
+	let spaceBefore = "";
+	let spaceAfter = "";
+	for (let index = line.text.length - 1; index >= 0; index--) {
+		const c = line.text[index];
+		if (!marker) {
+			if (c === "=" || c === "-") {
+				underlineText = c + underlineText;
+				marker = c;
+			} else if (!c.trim()) spaceAfter = c + spaceAfter;
+			else return null;
+			continue;
+		}
+		if (c === marker) {
+			underlineText = c + spaceBefore + underlineText;
+			spaceBefore = "";
+		} else if (!c.trim()) spaceBefore = c + spaceBefore;
+		else {
+			prefix = line.text.slice(0, index + 1);
+			break;
+		}
+	}
+	if (!marker) return null;
+	const underlineLoc = {
+		start: {
+			line: line.line,
+			column: prefix.length + spaceBefore.length + 1
+		},
+		end: {
+			line: line.line,
+			column: prefix.length + spaceBefore.length + underlineText.length + 1
+		}
+	};
+	return {
+		text: underlineText,
+		range: [line.range[0] + prefix.length + spaceBefore.length, line.range[1] - line.linebreak.length - spaceAfter.length],
+		loc: underlineLoc,
+		marker,
+		raws: {
+			prefix,
+			spaceBefore,
+			spaceAfter
+		}
+	};
+}
+
+//#endregion
+//#region src/rules/level1-heading-style.ts
+var level1_heading_style_default = createRule("level1-heading-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent style for level 1 headings",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				style: { enum: ["atx", "setext"] },
+				allowMultilineSetext: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			expectedAtx: "Expected ATX style heading (# Heading).",
+			expectedSetext: "Expected Setext style heading (Heading\\n======).",
+			multilineSetextNotAllowed: "Multiline Setext headings are not allowed."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const opt = context.options[0] || {};
+		const style = opt.style ?? "atx";
+		const allowMultilineSetext = opt.allowMultilineSetext;
+		return { heading(node) {
+			if (node.depth !== 1) return;
+			const headingKind = getHeadingKind(sourceCode, node);
+			if (style === "atx") {
+				if (headingKind !== "setext") return;
+				const parsed = parseSetextHeading(sourceCode, node);
+				if (!parsed) return;
+				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/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 = {
@@ -4150,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}`;
@@ -4171,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,
@@ -4306,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
 /**
@@ -5123,122 +5820,6 @@ 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", {
@@ -6108,14 +6689,17 @@ var thematic_break_sequence_pattern_default = createRule("thematic-break-sequenc
 //#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,
@@ -6123,6 +6707,7 @@ 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,
@@ -6177,7 +6762,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.17.0";
+const version = "0.18.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {