eslint-plugin-markdown-preferences 0.17.0 → 0.19.0

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]
+		}
 	};
 }
 /**
@@ -124,58 +130,162 @@ function getSourceLocationFromRange(sourceCode, node, range) {
 	};
 }
 
+//#endregion
+//#region src/utils/unicode.ts
+/**
+* Check if the string is whitespace
+*/
+function isWhitespace(string) {
+	return /^[\p{Zs}\t\n\f\r]+$/u.test(string);
+}
+/**
+* Check if the string is a space or tab
+*/
+function isSpaceOrTab(string) {
+	return /^[\t ]+$/u.test(string);
+}
+/**
+* Check if the character is a punctuation character
+*/
+function isPunctuation(char) {
+	return /^[\p{P}\p{S}]+$/u.test(char);
+}
+
 //#endregion
 //#region src/utils/atx-heading.ts
 /**
-* Parse the closing sequence of an ATX heading.
+* Parse the ATX heading.
 */
-function parseATXHeadingClosingSequence(sourceCode, node) {
+function parseATXHeading(sourceCode, node) {
 	if (getHeadingKind(sourceCode, node) !== "atx") return null;
 	const loc = sourceCode.getLoc(node);
 	const range = sourceCode.getRange(node);
-	const parsed = parseATXHeadingClosingSequenceFromText(sourceCode.text.slice(...range));
-	if (parsed == null) return { closingSequence: null };
-	const rawAfter = {
-		text: parsed.rawAfter,
-		range: [range[1] - parsed.rawAfter.length, range[1]],
+	const text = sourceCode.text.slice(...range);
+	const parsedOpening = parseATXHeadingOpeningSequenceFromText(text);
+	if (parsedOpening === null) return null;
+	const openingSequence = {
+		text: parsedOpening.openingSequence,
+		range: [range[0], range[0] + parsedOpening.openingSequence.length],
+		loc: {
+			start: loc.start,
+			end: {
+				line: loc.start.line,
+				column: loc.start.column + parsedOpening.openingSequence.length
+			}
+		}
+	};
+	const spaceAfterOpening = {
+		text: parsedOpening.rawAfter,
+		range: [openingSequence.range[1], openingSequence.range[1] + parsedOpening.rawAfter.length],
+		loc: {
+			start: openingSequence.loc.end,
+			end: {
+				line: openingSequence.loc.end.line,
+				column: openingSequence.loc.end.column + parsedOpening.rawAfter.length
+			}
+		}
+	};
+	const parsedClosing = parseATXHeadingClosingSequenceFromText(text);
+	if (parsedClosing == null) {
+		const textAfterOpening = sourceCode.text.slice(spaceAfterOpening.range[1], range[1]);
+		const contentText$1 = textAfterOpening.trimEnd();
+		return {
+			openingSequence: {
+				...openingSequence,
+				raws: { spaceAfter: spaceAfterOpening }
+			},
+			content: {
+				text: contentText$1,
+				range: [spaceAfterOpening.range[1], spaceAfterOpening.range[1] + contentText$1.length],
+				loc: {
+					start: spaceAfterOpening.loc.end,
+					end: {
+						line: loc.end.line,
+						column: loc.end.column - (textAfterOpening.length - contentText$1.length)
+					}
+				}
+			},
+			closingSequence: null
+		};
+	}
+	const spaceAfterClosing = {
+		text: parsedClosing.rawAfter,
+		range: [range[1] - parsedClosing.rawAfter.length, range[1]],
 		loc: {
 			start: {
 				line: loc.end.line,
-				column: loc.end.column - parsed.rawAfter.length
+				column: loc.end.column - parsedClosing.rawAfter.length
 			},
-			end: {
-				line: loc.end.line,
-				column: loc.end.column
-			}
+			end: loc.end
 		}
 	};
 	const closingSequence = {
-		text: parsed.closingSequence,
-		range: [rawAfter.range[0] - parsed.closingSequence.length, rawAfter.range[0]],
+		text: parsedClosing.closingSequence,
+		range: [spaceAfterClosing.range[0] - parsedClosing.closingSequence.length, spaceAfterClosing.range[0]],
 		loc: {
 			start: {
-				line: rawAfter.loc.start.line,
-				column: rawAfter.loc.start.column - parsed.closingSequence.length
+				line: spaceAfterClosing.loc.start.line,
+				column: spaceAfterClosing.loc.start.column - parsedClosing.closingSequence.length
 			},
-			end: rawAfter.loc.start
+			end: spaceAfterClosing.loc.start
 		}
 	};
-	const rawBefore = {
-		text: parsed.rawBefore,
-		range: [closingSequence.range[0] - parsed.rawBefore.length, closingSequence.range[0]],
+	const spaceBeforeClosing = {
+		text: parsedClosing.rawBefore,
+		range: [closingSequence.range[0] - parsedClosing.rawBefore.length, closingSequence.range[0]],
 		loc: {
 			start: {
 				line: closingSequence.loc.start.line,
-				column: closingSequence.loc.start.column - parsed.rawBefore.length
+				column: closingSequence.loc.start.column - parsedClosing.rawBefore.length
 			},
 			end: closingSequence.loc.start
 		}
 	};
+	const contentText = sourceCode.text.slice(spaceAfterOpening.range[1], spaceBeforeClosing.range[0]);
+	return {
+		openingSequence: {
+			...openingSequence,
+			raws: { spaceAfter: spaceAfterOpening }
+		},
+		content: {
+			text: contentText,
+			range: [spaceAfterOpening.range[1], spaceBeforeClosing.range[0]],
+			loc: {
+				start: spaceAfterOpening.loc.end,
+				end: spaceBeforeClosing.loc.start
+			}
+		},
+		closingSequence: {
+			...closingSequence,
+			raws: {
+				spaceBefore: spaceBeforeClosing,
+				spaceAfter: spaceAfterClosing
+			}
+		}
+	};
+}
+/**
+* Parse the opening sequence from a text string.
+*/
+function parseATXHeadingOpeningSequenceFromText(text) {
+	if (!text.startsWith("#")) return null;
+	let openingSequenceAfterOffset = 1;
+	while (openingSequenceAfterOffset < text.length && text[openingSequenceAfterOffset] === "#") openingSequenceAfterOffset++;
+	const afterOffset = skipWhitespace(openingSequenceAfterOffset);
+	if (afterOffset === openingSequenceAfterOffset || afterOffset >= text.length) return null;
 	return {
-		rawBefore,
-		closingSequence,
-		rawAfter
+		openingSequence: text.slice(0, openingSequenceAfterOffset),
+		rawAfter: text.slice(openingSequenceAfterOffset, afterOffset)
 	};
+	/**
+	* Skip whitespace characters at the start of the text.
+	*/
+	function skipWhitespace(index) {
+		let result = index;
+		let c;
+		while (result < text.length && (c = text[result]) && isSpaceOrTab(c)) result++;
+		return result;
+	}
 }
 /**
 * Parse the closing sequence from a text string.
@@ -198,7 +308,7 @@ function parseATXHeadingClosingSequenceFromText(text) {
 	function skipEndWhitespace(index) {
 		let result = index;
 		let c;
-		while (result >= 0 && (c = text[result]) && (c === " " || c === "	")) result--;
+		while (result >= 0 && (c = text[result]) && isSpaceOrTab(c)) result--;
 		return result;
 	}
 }
@@ -271,8 +381,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 +417,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 +433,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 +493,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 +520,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 +549,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 +566,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 +703,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 = {
@@ -2788,6 +3064,199 @@ var emoji_notation_default = createRule("emoji-notation", {
 	}
 });
 
+//#endregion
+//#region src/rules/emphasis-delimiters-style.ts
+/**
+* Check if the emphasis/strong node is intraword (inside a word)
+* CommonMark: Intraword emphasis with _ is not allowed
+*/
+function isIntrawordForUnderline(text, range) {
+	const before = text[range[0] - 1];
+	if (!isWhitespace(before) && !isPunctuation(before)) return true;
+	const after = text[range[1]];
+	if (!isWhitespace(after) && !isPunctuation(after)) return true;
+	return false;
+}
+var emphasis_delimiters_style_default = createRule("emphasis-delimiters-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce a consistent delimiter style for emphasis and strong emphasis",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				emphasis: { enum: ["*", "_"] },
+				strong: { enum: ["**", "__"] },
+				strongEmphasis: { anyOf: [
+					{ enum: ["***", "___"] },
+					{
+						type: "object",
+						properties: {
+							outer: { const: "*" },
+							inner: { const: "__" }
+						},
+						required: ["outer", "inner"],
+						additionalProperties: false
+					},
+					{
+						type: "object",
+						properties: {
+							outer: { const: "**" },
+							inner: { const: "_" }
+						},
+						required: ["outer", "inner"],
+						additionalProperties: false
+					},
+					{
+						type: "object",
+						properties: {
+							outer: { const: "_" },
+							inner: { const: "**" }
+						},
+						required: ["outer", "inner"],
+						additionalProperties: false
+					},
+					{
+						type: "object",
+						properties: {
+							outer: { const: "__" },
+							inner: { const: "*" }
+						},
+						required: ["outer", "inner"],
+						additionalProperties: false
+					}
+				] }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			wrongEmphasis: "Emphasis delimiter should be '{{expectedOpening}}' (was '{{actualOpening}}').",
+			wrongStrong: "Strong emphasis delimiter should be '{{expectedOpening}}' (was '{{actualOpening}}').",
+			wrongStrongEmphasis: "Delimiter for strong+emphasis should be '{{expectedOpening}}' (was '{{actualOpening}}').",
+			wrongStrongEmphasisDelimiterPair: "Delimiters for strong+emphasis should be '{{expectedOpening}}' ... '{{expectedClosing}}' (was '{{actualOpening}}' ... '{{actualClosing}}')."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const option = context.options[0] ?? {};
+		const emphasisDelimiter = option.emphasis ?? "_";
+		const emphasis = {
+			opening: emphasisDelimiter,
+			closing: emphasisDelimiter
+		};
+		const strongDelimiter = option.strong ?? "**";
+		const strong = {
+			opening: strongDelimiter,
+			closing: strongDelimiter
+		};
+		const strongEmphasis = parseStrongEmphasis(emphasisDelimiter, strongDelimiter, option.strongEmphasis);
+		const processed = /* @__PURE__ */ new Set();
+		/**
+		* Verify the delimiter of the node
+		*/
+		function verifyDelimiter(node, expected, messageId) {
+			const range = sourceCode.getRange(node);
+			if (sourceCode.text.startsWith(expected.opening, range[0]) && sourceCode.text.endsWith(expected.closing, range[1])) return;
+			if (sourceCode.text[range[0] - 1] === expected.opening[0] || sourceCode.text[range[1]] === expected.closing.at(-1) || sourceCode.text[range[0] + expected.opening.length] === expected.opening.at(-1) || sourceCode.text[range[1] - expected.closing.length - 1] === expected.closing[0]) return;
+			if ((expected.opening.startsWith("_") || expected.closing.at(-1) === "_") && isIntrawordForUnderline(sourceCode.text, range)) return;
+			const actual = {
+				opening: sourceCode.text.slice(range[0], range[0] + expected.opening.length),
+				closing: sourceCode.text.slice(range[1] - expected.closing.length, range[1])
+			};
+			context.report({
+				node,
+				messageId: expected.opening === expected.closing && actual.opening === actual.closing ? messageId : "wrongStrongEmphasisDelimiterPair",
+				data: {
+					expectedOpening: expected.opening,
+					actualOpening: actual.opening,
+					expectedClosing: expected.closing,
+					actualClosing: actual.closing
+				},
+				fix(fixer) {
+					return [fixer.replaceTextRange([range[0], range[0] + expected.opening.length], expected.opening), fixer.replaceTextRange([range[1] - expected.closing.length, range[1]], expected.closing)];
+				}
+			});
+		}
+		/**
+		* Verify the emphasis node has the correct delimiter
+		*/
+		function verifyEmphasis(node) {
+			verifyDelimiter(node, emphasis, "wrongEmphasis");
+		}
+		/**
+		* Verify the emphasis node has the correct delimiter
+		*/
+		function verifyStrong(node) {
+			verifyDelimiter(node, strong, "wrongStrong");
+		}
+		/**
+		* Verify the strong emphasis node has the correct delimiter
+		*/
+		function verifyStrongEmphasis(node) {
+			verifyDelimiter(node, strongEmphasis, "wrongStrongEmphasis");
+		}
+		return {
+			emphasis(node) {
+				if (processed.has(node)) return;
+				processed.add(node);
+				if (node.children.length === 1 && node.children[0].type === "strong") {
+					processed.add(node.children[0]);
+					verifyStrongEmphasis(node);
+					return;
+				}
+				verifyEmphasis(node);
+			},
+			strong(node) {
+				if (processed.has(node)) return;
+				processed.add(node);
+				if (node.children.length === 1 && node.children[0].type === "emphasis") {
+					processed.add(node.children[0]);
+					verifyStrongEmphasis(node);
+					return;
+				}
+				verifyStrong(node);
+			}
+		};
+	}
+});
+/**
+* Parse strongEmphasis option to normalized object form
+*/
+function parseStrongEmphasis(emphasis, strong, strongEmphasisOpt) {
+	if (strongEmphasisOpt != null) {
+		if (typeof strongEmphasisOpt === "string") return {
+			opening: strongEmphasisOpt,
+			closing: strongEmphasisOpt
+		};
+		return {
+			opening: strongEmphasisOpt.outer + strongEmphasisOpt.inner,
+			closing: strongEmphasisOpt.inner + strongEmphasisOpt.outer
+		};
+	}
+	if (emphasis === "*") {
+		if (strong === "**") return {
+			opening: "***",
+			closing: "***"
+		};
+		return {
+			opening: "*__",
+			closing: "__*"
+		};
+	} else if (strong === "**") return {
+		opening: "**_",
+		closing: "_**"
+	};
+	return {
+		opening: "___",
+		closing: "___"
+	};
+}
+
 //#endregion
 //#region src/rules/hard-linebreak-style.ts
 var hard_linebreak_style_default = createRule("hard-linebreak-style", {
@@ -3598,57 +4067,331 @@ var heading_casing_default = createRule("heading-casing", {
 });
 
 //#endregion
-//#region src/rules/list-marker-alignment.ts
-const ALIGN_TO_POSITION_NAME = {
-	left: "start",
-	right: "end"
-};
-var list_marker_alignment_default = createRule("list-marker-alignment", {
-	meta: {
-		type: "layout",
-		docs: {
-			description: "enforce consistent alignment of list markers",
-			categories: ["recommended"],
-			listCategory: "Stylistic"
-		},
-		fixable: "whitespace",
-		hasSuggestions: false,
-		schema: [{
-			type: "object",
-			properties: { align: { enum: ["left", "right"] } },
-			additionalProperties: false
-		}],
-		messages: { incorrectAlignment: "List marker alignment is inconsistent. Expected {{expected}} characters of indentation, but got {{actual}}." }
-	},
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const alignPositionName = ALIGN_TO_POSITION_NAME[context.options[0]?.align ?? "left"];
-		/**
-		* Get the marker location of a list item
-		*/
-		function getMarkerLocation(node) {
-			const start = sourceCode.getLoc(node).start;
-			const startColumnIndex = start.column - 1;
-			const marker = getListItemMarker(sourceCode, node);
-			return {
-				line: start.line,
-				start: startColumnIndex,
-				end: startColumnIndex + marker.raw.length
-			};
-		}
-		/**
-		* Check if list items have consistent alignment
-		*/
-		function checkListAlignment(listNode) {
-			const items = listNode.children;
-			if (items.length <= 1) return;
-			const referenceMarkerLocation = getMarkerLocation(items[0]);
-			for (const item of items.slice(1)) {
-				const markerLocation = getMarkerLocation(item);
-				const diff = markerLocation[alignPositionName] - referenceMarkerLocation[alignPositionName];
-				if (diff === 0) continue;
-				context.report({
-					node: item,
+//#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 = {
+	left: "start",
+	right: "end"
+};
+var list_marker_alignment_default = createRule("list-marker-alignment", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent alignment of list markers",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { align: { enum: ["left", "right"] } },
+			additionalProperties: false
+		}],
+		messages: { incorrectAlignment: "List marker alignment is inconsistent. Expected {{expected}} characters of indentation, but got {{actual}}." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const alignPositionName = ALIGN_TO_POSITION_NAME[context.options[0]?.align ?? "left"];
+		/**
+		* Get the marker location of a list item
+		*/
+		function getMarkerLocation(node) {
+			const start = sourceCode.getLoc(node).start;
+			const startColumnIndex = start.column - 1;
+			const marker = getListItemMarker(sourceCode, node);
+			return {
+				line: start.line,
+				start: startColumnIndex,
+				end: startColumnIndex + marker.raw.length
+			};
+		}
+		/**
+		* Check if list items have consistent alignment
+		*/
+		function checkListAlignment(listNode) {
+			const items = listNode.children;
+			if (items.length <= 1) return;
+			const referenceMarkerLocation = getMarkerLocation(items[0]);
+			for (const item of items.slice(1)) {
+				const markerLocation = getMarkerLocation(item);
+				const diff = markerLocation[alignPositionName] - referenceMarkerLocation[alignPositionName];
+				if (diff === 0) continue;
+				context.report({
+					node: item,
 					loc: {
 						start: {
 							line: markerLocation.line,
@@ -4150,7 +4893,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 +4914,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 +5049,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 +6034,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", {
@@ -5602,7 +6397,7 @@ var sort_definitions_default = createRule("sort-definitions", {
 				const last = group.at(-1);
 				if (last && (node.type !== "definition" && node.type !== "footnoteDefinition" || sourceCode.getParent(node) !== sourceCode.getParent(last))) {
 					const range = sourceCode.getRange(node);
-					const lastDefinitionRange = sourceCode.getRange(node);
+					const lastDefinitionRange = sourceCode.getRange(last);
 					if (lastDefinitionRange[1] <= range[0]) {
 						verify(group);
 						group.length = 0;
@@ -5760,6 +6555,48 @@ function normalizedURL(url) {
 	return urlObj.href.endsWith("/") ? urlObj.href : `${urlObj.href}/`;
 }
 
+//#endregion
+//#region src/rules/strikethrough-delimiters-style.ts
+var strikethrough_delimiters_style_default = createRule("strikethrough-delimiters-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce a consistent delimiter style for strikethrough",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { delimiter: { enum: ["~", "~~"] } },
+			additionalProperties: false
+		}],
+		messages: { wrongDelimiter: "Strikethrough delimiter should be '{{expected}}' (was '{{actual}}')." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const option = context.options[0] ?? {};
+		const delimiter = option.delimiter ?? "~~";
+		return { delete(node) {
+			const range = sourceCode.getRange(node);
+			const actualDelimiter = ["~~", "~"].find((d) => sourceCode.text.startsWith(d, range[0]) && sourceCode.text.endsWith(d, range[1]));
+			if (!actualDelimiter || actualDelimiter === delimiter) return;
+			context.report({
+				node,
+				messageId: "wrongDelimiter",
+				data: {
+					expected: delimiter,
+					actual: actualDelimiter
+				},
+				fix(fixer) {
+					return [fixer.replaceTextRange([range[0], range[0] + actualDelimiter.length], delimiter), fixer.replaceTextRange([range[1] - actualDelimiter.length, range[1]], delimiter)];
+				}
+			});
+		} };
+	}
+});
+
 //#endregion
 //#region src/rules/table-header-casing.ts
 var table_header_casing_default = createRule("table-header-casing", {
@@ -6108,14 +6945,18 @@ 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,
+	emphasis_delimiters_style_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 +6964,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,
@@ -6131,6 +6973,7 @@ const rules$1 = [
 	prefer_linked_words_default,
 	setext_heading_underline_length_default,
 	sort_definitions_default,
+	strikethrough_delimiters_style_default,
 	table_header_casing_default,
 	thematic_break_character_style_default,
 	thematic_break_length_default,
@@ -6177,7 +7020,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.17.0";
+const version = "0.19.0";
 
 //#endregion
 //#region src/index.ts