eslint-plugin-markdown-preferences 0.18.0 → 0.20.0

package/README.md

@@ -118,7 +118,10 @@ The rules with the following star ⭐ are included in the configs.
 | [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/code-fence-length](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-length.html) | enforce consistent code fence length in fenced code blocks. | 🔧 |  |
+| [markdown-preferences/code-fence-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-style.html) | enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks. | 🔧 |  |
 | [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/emphasis-delimiters-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emphasis-delimiters-style.html) | enforce a consistent delimiter style for emphasis and strong emphasis | 🔧 |  |
 | [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 | 🔧 |  |
@@ -135,6 +138,7 @@ The rules with the following star ⭐ are included in the configs.
 | [markdown-preferences/prefer-link-reference-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-link-reference-definitions.html) | enforce using link reference definitions instead of inline links | 🔧 |  |
 | [markdown-preferences/setext-heading-underline-length](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/setext-heading-underline-length.html) | enforce setext heading underline length | 🔧 |  |
 | [markdown-preferences/sort-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/sort-definitions.html) | enforce a specific order for link definitions and footnote definitions | 🔧 |  |
+| [markdown-preferences/strikethrough-delimiters-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/strikethrough-delimiters-style.html) | enforce a consistent delimiter style for strikethrough | 🔧 |  |
 | [markdown-preferences/thematic-break-character-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-character-style.html) | enforce consistent character style for thematic breaks (horizontal rules) in Markdown. | 🔧 |  |
 | [markdown-preferences/thematic-break-length](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-length.html) | enforce consistent length for thematic breaks (horizontal rules) in Markdown. | 🔧 |  |
 | [markdown-preferences/thematic-break-sequence-pattern](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/thematic-break-sequence-pattern.html) | enforce consistent repeating patterns for thematic breaks (horizontal rules) in Markdown. | 🔧 |  |

package/lib/index.d.ts

@@ -35,6 +35,16 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/canonical-code-block-language.html
    */
   'markdown-preferences/canonical-code-block-language'?: Linter.RuleEntry<MarkdownPreferencesCanonicalCodeBlockLanguage>;
+  /**
+   * enforce consistent code fence length in fenced code blocks.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-length.html
+   */
+  'markdown-preferences/code-fence-length'?: Linter.RuleEntry<MarkdownPreferencesCodeFenceLength>;
+  /**
+   * enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-style.html
+   */
+  'markdown-preferences/code-fence-style'?: Linter.RuleEntry<MarkdownPreferencesCodeFenceStyle>;
   /**
    * require link definitions and footnote definitions to be placed at the end of the document
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html
@@ -45,6 +55,11 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emoji-notation.html
    */
   'markdown-preferences/emoji-notation'?: Linter.RuleEntry<MarkdownPreferencesEmojiNotation>;
+  /**
+   * enforce a consistent delimiter style for emphasis and strong emphasis
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emphasis-delimiters-style.html
+   */
+  'markdown-preferences/emphasis-delimiters-style'?: Linter.RuleEntry<MarkdownPreferencesEmphasisDelimitersStyle>;
   /**
    * enforce consistent hard linebreak style.
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html
@@ -145,6 +160,11 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/sort-definitions.html
    */
   'markdown-preferences/sort-definitions'?: Linter.RuleEntry<MarkdownPreferencesSortDefinitions>;
+  /**
+   * enforce a consistent delimiter style for strikethrough
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/strikethrough-delimiters-style.html
+   */
+  'markdown-preferences/strikethrough-delimiters-style'?: Linter.RuleEntry<MarkdownPreferencesStrikethroughDelimitersStyle>;
   /**
    * enforce consistent casing in table header cells.
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/table-header-casing.html
@@ -188,11 +208,40 @@ type MarkdownPreferencesCanonicalCodeBlockLanguage = [] | [{
     [k: string]: string;
   };
 }];
+type MarkdownPreferencesCodeFenceLength = [] | [{
+  length?: number;
+  fallbackLength?: (number | ("minimum" | "as-is"));
+  overrides?: {
+    lang: string;
+    length?: number;
+    fallbackLength?: (number | ("minimum" | "as-is"));
+  }[];
+}];
+type MarkdownPreferencesCodeFenceStyle = [] | [{
+  style?: ("backtick" | "tilde");
+}];
 type MarkdownPreferencesEmojiNotation = [] | [{
   prefer?: ("unicode" | "colon");
   ignoreUnknown?: boolean;
   ignoreList?: string[];
 }];
+type MarkdownPreferencesEmphasisDelimitersStyle = [] | [{
+  emphasis?: ("*" | "_");
+  strong?: ("**" | "__");
+  strongEmphasis?: (("***" | "___") | {
+    outer: "*";
+    inner: "__";
+  } | {
+    outer: "**";
+    inner: "_";
+  } | {
+    outer: "_";
+    inner: "**";
+  } | {
+    outer: "__";
+    inner: "*";
+  });
+}];
 type MarkdownPreferencesHardLinebreakStyle = [] | [{
   style?: ("backslash" | "spaces");
 }];
@@ -283,6 +332,9 @@ type MarkdownPreferencesSortDefinitions = [] | [{
   })[];
   alphabetical?: boolean;
 }];
+type MarkdownPreferencesStrikethroughDelimitersStyle = [] | [{
+  delimiter?: ("~" | "~~");
+}];
 type MarkdownPreferencesTableHeaderCasing = [] | [{
   style?: ("Title Case" | "Sentence case");
   preserveWords?: string[];
@@ -316,7 +368,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.18.0";
+declare const version: "0.20.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -130,6 +130,27 @@ 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
 /**
@@ -262,7 +283,7 @@ function parseATXHeadingOpeningSequenceFromText(text) {
 	function skipWhitespace(index) {
 		let result = index;
 		let c;
-		while (result < text.length && (c = text[result]) && (c === " " || c === "	")) result++;
+		while (result < text.length && (c = text[result]) && isSpaceOrTab(c)) result++;
 		return result;
 	}
 }
@@ -287,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;
 	}
 }
@@ -852,6 +873,108 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 	}
 });
 
+//#endregion
+//#region src/utils/fenced-code-block.ts
+const RE_OPENING_FENCE = /^(`{3,}|~{3,})/u;
+const RE_LANGUAGE = /^(\w*)/u;
+/**
+* Parse the fenced code block.
+*/
+function parseFencedCodeBlock(sourceCode, node) {
+	const loc = sourceCode.getLoc(node);
+	const range = sourceCode.getRange(node);
+	const text = sourceCode.text.slice(...range);
+	const match = RE_OPENING_FENCE.exec(text);
+	if (!match) return null;
+	const [, fenceText] = match;
+	const fenceChar = fenceText[0];
+	let closingFenceText = "";
+	const trimmed = text.trimEnd();
+	const trailingSpacesLength = text.length - trimmed.length;
+	for (let index = trimmed.length - 1; index >= 0; index--) {
+		const c = trimmed[index];
+		if (c === fenceChar || isSpaceOrTab(c)) {
+			closingFenceText = c + closingFenceText;
+			continue;
+		}
+		if (c === "\n") break;
+		return null;
+	}
+	closingFenceText = closingFenceText.trimStart();
+	if (!closingFenceText || !closingFenceText.startsWith(fenceText)) return null;
+	const lines = getParsedLines(sourceCode);
+	const afterOpeningFence = lines.get(loc.start.line).text.slice(fenceText.length);
+	const trimmedAfterOpeningFence = afterOpeningFence.trimStart();
+	const spaceAfterOpeningFenceLength = afterOpeningFence.length - trimmedAfterOpeningFence.length;
+	let languageText = "";
+	if (trimmedAfterOpeningFence) {
+		const langMatch = RE_LANGUAGE.exec(trimmedAfterOpeningFence);
+		languageText = langMatch[1];
+	}
+	const afterLanguage = trimmedAfterOpeningFence.slice(languageText.length);
+	const trimmedAfterLanguage = afterLanguage.trimStart();
+	const spaceAfterLanguageLength = afterLanguage.length - trimmedAfterLanguage.length;
+	const metaText = trimmedAfterLanguage.trimEnd();
+	const openingFence = {
+		text: fenceText,
+		range: [range[0], range[0] + fenceText.length],
+		loc: {
+			start: loc.start,
+			end: {
+				line: loc.start.line,
+				column: loc.start.column + fenceText.length
+			}
+		}
+	};
+	const language$1 = languageText ? {
+		text: languageText,
+		range: [openingFence.range[1] + spaceAfterOpeningFenceLength, openingFence.range[1] + spaceAfterOpeningFenceLength + languageText.length],
+		loc: {
+			start: {
+				line: openingFence.loc.end.line,
+				column: openingFence.loc.end.column + spaceAfterOpeningFenceLength
+			},
+			end: {
+				line: openingFence.loc.end.line,
+				column: openingFence.loc.end.column + spaceAfterOpeningFenceLength + languageText.length
+			}
+		}
+	} : null;
+	const meta = language$1 && metaText ? {
+		text: metaText,
+		range: [language$1.range[1] + spaceAfterLanguageLength, language$1.range[1] + spaceAfterLanguageLength + metaText.length],
+		loc: {
+			start: {
+				line: language$1.loc.end.line,
+				column: language$1.loc.end.column + spaceAfterLanguageLength
+			},
+			end: {
+				line: language$1.loc.end.line,
+				column: language$1.loc.end.column + spaceAfterLanguageLength + metaText.length
+			}
+		}
+	} : null;
+	return {
+		openingFence,
+		language: language$1,
+		meta,
+		closingFence: {
+			text: closingFenceText,
+			range: [range[1] - trailingSpacesLength - closingFenceText.length, range[1] - trailingSpacesLength],
+			loc: {
+				start: {
+					line: loc.end.line,
+					column: loc.end.column - trailingSpacesLength - closingFenceText.length
+				},
+				end: {
+					line: loc.end.line,
+					column: loc.end.column - trailingSpacesLength
+				}
+			}
+		}
+	};
+}
+
 //#endregion
 //#region src/rules/canonical-code-block-language.ts
 const DEFAULT_LANGUAGES = {
@@ -906,23 +1029,204 @@ var canonical_code_block_language_default = createRule("canonical-code-block-lan
 			const canonical = languages[node.lang];
 			const current = node.lang;
 			if (current === canonical) return;
-			const nodeRange = sourceCode.getRange(node);
-			const nodeText = sourceCode.text.slice(nodeRange[0], nodeRange[1]);
-			const fenceRegex = /^(`{3,}|~{3,})(\w*)(?:\s.*)?$/mu;
-			const fenceMatch = fenceRegex.exec(nodeText.split("\n")[0]);
-			if (!fenceMatch) return;
-			const [, fence, langInfo] = fenceMatch;
-			const range = [nodeRange[0] + fence.length, nodeRange[0] + fence.length + langInfo.length];
+			const parsed = parseFencedCodeBlock(sourceCode, node);
+			if (!parsed || !parsed.language) return;
 			context.report({
 				node,
-				loc: getSourceLocationFromRange(sourceCode, node, range),
+				loc: parsed.language.loc,
 				messageId: "useCanonical",
 				data: {
 					canonical,
 					current
 				},
 				fix(fixer) {
-					return fixer.replaceTextRange(range, canonical);
+					return fixer.replaceTextRange(parsed.language.range, canonical);
+				}
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/code-fence-length.ts
+var code_fence_length_default = createRule("code-fence-length", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent code fence length in fenced code blocks.",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				length: {
+					type: "integer",
+					minimum: 3
+				},
+				fallbackLength: { anyOf: [{
+					type: "integer",
+					minimum: 3
+				}, { enum: ["minimum", "as-is"] }] },
+				overrides: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							lang: { type: "string" },
+							length: {
+								type: "integer",
+								minimum: 3
+							},
+							fallbackLength: { anyOf: [{
+								type: "integer",
+								minimum: 3
+							}, { enum: ["minimum", "as-is"] }] }
+						},
+						required: ["lang"],
+						additionalProperties: false
+					}
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			notMatch: "The opening and closing code fence lengths must match.",
+			notPreferred: "Code fence length should be {{expected}} (was {{actual}})."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = context.options[0] ?? {};
+		/**
+		* Get the effective options for the given code block node.
+		*/
+		function getOptionForCode(node) {
+			const override = options.overrides?.find((o) => o.lang === node.lang);
+			return {
+				length: override?.length ?? options.length ?? 3,
+				fallbackLength: override?.fallbackLength ?? options.fallbackLength ?? "minimum"
+			};
+		}
+		/**
+		* Report the given code block node for not preferred length.
+		*/
+		function reportNotPreferred(node, parsed, length) {
+			const expectedFence = getExpectedFence(parsed, length);
+			context.report({
+				node,
+				loc: parsed.openingFence.loc,
+				data: {
+					expected: expectedFence,
+					actual: parsed.openingFence.text
+				},
+				messageId: "notPreferred",
+				fix(fixer) {
+					return [fixer.replaceTextRange(parsed.openingFence.range, expectedFence), fixer.replaceTextRange(parsed.closingFence.range, expectedFence)];
+				}
+			});
+		}
+		/**
+		* Verify the length of the given code block node.
+		*/
+		function verifyFenceLength(node, parsed) {
+			const { length, fallbackLength } = getOptionForCode(node);
+			if (parsed.openingFence.text.length === length) return true;
+			const expectedFence = getExpectedFence(parsed, length);
+			if (!node.value.includes(expectedFence)) {
+				reportNotPreferred(node, parsed, length);
+				return false;
+			}
+			if (fallbackLength === "as-is") return true;
+			if (fallbackLength === "minimum") {
+				let fallback = length + 1;
+				while (node.value.includes(getExpectedFence(parsed, fallback))) fallback++;
+				if (parsed.openingFence.text.length === fallback) return true;
+				reportNotPreferred(node, parsed, fallback);
+				return false;
+			}
+			if (fallbackLength <= length) return true;
+			if (parsed.openingFence.text.length === fallbackLength) return true;
+			const fallbackExpectedFence = getExpectedFence(parsed, fallbackLength);
+			if (node.value.includes(fallbackExpectedFence)) return true;
+			reportNotPreferred(node, parsed, fallbackLength);
+			return false;
+		}
+		/**
+		* Get the expected fence string for the given length.
+		*/
+		function getExpectedFence(parsed, length) {
+			const fenceChar = parsed.openingFence.text[0];
+			return fenceChar.repeat(Math.max(3, length));
+		}
+		/**
+		* Verify that the opening and closing fence lengths match.
+		*/
+		function verifyClosingFenceLength(node, parsed) {
+			if (parsed.openingFence.text.length === parsed.closingFence.text.length) return true;
+			context.report({
+				node,
+				loc: parsed.closingFence.loc,
+				messageId: "notMatch",
+				fix(fixer) {
+					return [fixer.replaceTextRange(parsed.closingFence.range, parsed.openingFence.text)];
+				}
+			});
+			return false;
+		}
+		return { code(node) {
+			const parsed = parseFencedCodeBlock(sourceCode, node);
+			if (!parsed) return;
+			if (!verifyFenceLength(node, parsed)) return;
+			verifyClosingFenceLength(node, parsed);
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/code-fence-style.ts
+var code_fence_style_default = createRule("code-fence-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks.",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { style: {
+				type: "string",
+				enum: ["backtick", "tilde"]
+			} },
+			additionalProperties: false
+		}],
+		messages: { useCodeFenceStyle: "Use {{expected}} code fence style instead of {{actual}}." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const styleOption = context.options[0]?.style ?? "backtick";
+		const expectedChar = styleOption === "tilde" ? "~" : "`";
+		return { code(node) {
+			const parsed = parseFencedCodeBlock(sourceCode, node);
+			if (!parsed) return;
+			if (parsed.openingFence.text.includes(expectedChar)) return;
+			const expectedOpeningFence = expectedChar.repeat(Math.max(3, parsed.openingFence.text.length));
+			if (node.value.includes(expectedOpeningFence)) return;
+			context.report({
+				node,
+				loc: parsed.openingFence.loc,
+				data: {
+					expected: expectedOpeningFence,
+					actual: parsed.openingFence.text
+				},
+				messageId: "useCodeFenceStyle",
+				fix(fixer) {
+					return [fixer.replaceTextRange(parsed.openingFence.range, expectedOpeningFence), fixer.replaceTextRange(parsed.closingFence.range, expectedChar.repeat(Math.max(3, parsed.closingFence.text.length)))];
 				}
 			});
 		} };
@@ -3043,6 +3347,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", {
@@ -6183,7 +6680,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;
@@ -6341,6 +6838,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", {
@@ -6694,8 +7233,11 @@ const rules$1 = [
 	blockquote_marker_alignment_default,
 	bullet_list_marker_style_default,
 	canonical_code_block_language_default,
+	code_fence_length_default,
+	code_fence_style_default,
 	definitions_last_default,
 	emoji_notation_default,
+	emphasis_delimiters_style_default,
 	hard_linebreak_style_default,
 	heading_casing_default,
 	level1_heading_style_default,
@@ -6716,6 +7258,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,
@@ -6762,7 +7305,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.18.0";
+const version = "0.20.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

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