eslint-plugin-markdown-preferences 0.13.0 → 0.14.0

package/README.md

@@ -29,7 +29,7 @@ For detailed usage instructions, rule configurations, and examples, visit our co
 ## 💿 Installation
 
 ```sh
-npm install --save-dev eslint eslint-plugin-markdown-preferences
+npm install --save-dev eslint @eslint/markdown eslint-plugin-markdown-preferences
 ```
 
 <!--DOCS_IGNORE_END-->
@@ -90,18 +90,22 @@ The rules with the following star ⭐ are included in the configs.
 
 ### Preference Rules
 
+- Rules to unify the expression and description style of documents.
+
 | Rule ID | Description | Fixable | RECOMMENDED |
 |:--------|:------------|:-------:|:-----------:|
 | [markdown-preferences/canonical-code-block-language](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/canonical-code-block-language.html) | enforce canonical language names in code blocks | 🔧 |  |
-| [markdown-preferences/emoji-notation](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emoji-notation.html) | Enforce consistent emoji notation style in Markdown files. | 🔧 |  |
+| [markdown-preferences/emoji-notation](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emoji-notation.html) | enforce consistent emoji notation style in Markdown files. | 🔧 |  |
 | [markdown-preferences/heading-casing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/heading-casing.html) | enforce consistent casing in headings. | 🔧 |  |
-| [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/ordered-list-marker-start](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-start.html) | enforce that ordered list markers start with 1 or 0 | 🔧 |  |
 | [markdown-preferences/prefer-inline-code-words](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-inline-code-words.html) | enforce the use of inline code for specific words. | 🔧 |  |
 | [markdown-preferences/prefer-linked-words](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-linked-words.html) | enforce the specified word to be a link. | 🔧 |  |
+| [markdown-preferences/table-header-casing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/table-header-casing.html) | enforce consistent casing in table header cells. | 🔧 |  |
 
 ### Stylistic Rules
 
+- Rules related to the formatting and visual style of Markdown.
+
 | 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. | 🔧 |  |
@@ -110,6 +114,7 @@ The rules with the following star ⭐ are included in the configs.
 | [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/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/prefer-autolinks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html) | enforce the use of autolinks for URLs | 🔧 | ⭐ |

package/lib/index.d.ts

@@ -31,7 +31,7 @@ interface RuleOptions {
    */
   'markdown-preferences/definitions-last'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce consistent emoji notation style in Markdown files.
+   * enforce consistent emoji notation style in Markdown files.
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emoji-notation.html
    */
   'markdown-preferences/emoji-notation'?: Linter.RuleEntry<MarkdownPreferencesEmojiNotation>;
@@ -105,6 +105,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 consistent casing in table header cells.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/table-header-casing.html
+   */
+  'markdown-preferences/table-header-casing'?: Linter.RuleEntry<MarkdownPreferencesTableHeaderCasing>;
 }
 type MarkdownPreferencesAtxHeadingsClosingSequence = [] | [{
   closingSequence?: ("always" | "never");
@@ -178,6 +183,12 @@ type MarkdownPreferencesSortDefinitions = [] | [{
   })[];
   alphabetical?: boolean;
 }];
+type MarkdownPreferencesTableHeaderCasing = [] | [{
+  style?: ("Title Case" | "Sentence case");
+  preserveWords?: string[];
+  ignorePatterns?: string[];
+  minorWords?: string[];
+}];
 declare namespace recommended_d_exports {
   export { files, language, languageOptions, name$1 as name, plugins, rules$1 as rules };
 }
@@ -196,7 +207,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.13.0";
+declare const version: "0.14.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -2546,7 +2546,7 @@ var emoji_notation_default = createRule("emoji-notation", {
 	meta: {
 		type: "suggestion",
 		docs: {
-			description: "Enforce consistent emoji notation style in Markdown files.",
+			description: "enforce consistent emoji notation style in Markdown files.",
 			categories: [],
 			listCategory: "Preference"
 		},
@@ -2813,6 +2813,7 @@ const defaultPreserveWords = [
 	"Biome",
 	"oxc",
 	"swc",
+	"markdownlint",
 	"Webpack",
 	"Vite",
 	"Babel",
@@ -3148,7 +3149,8 @@ const defaultPreserveWords = [
 	"Insomnia",
 	"Redoc",
 	"Stoplight",
-	"FAQ"
+	"FAQ",
+	"YouTube"
 ];
 
 //#endregion
@@ -3187,44 +3189,113 @@ const defaultMinorWords = [
 ];
 
 //#endregion
-//#region src/rules/heading-casing.ts
+//#region src/utils/word-casing.ts
 /**
-* Parse preserve words and phrases from the options
-* - Single words are added to preserveWords
-* - Multi-word phrases are added to preservePhrases and added to preserveWords with no spaces
+* Converts the casing of a word based on the specified case style and whether it is the first or last word in a phrase.
 */
-function parsePreserveWords(preserveWordsOption) {
-	const preserveWords = /* @__PURE__ */ new Map();
-	/**
-	* Add a single word to the preserveWords map
-	*/
-	function addPreserveWord(word) {
-		const lowerWord = word.toLowerCase();
-		let list = preserveWords.get(lowerWord);
-		if (!list) {
-			list = [];
-			preserveWords.set(lowerWord, list);
+function convertWordCasing({ word, first, last }, { caseStyle, minorWords }) {
+	if (caseStyle === "Title Case") {
+		if (first || last) return {
+			word: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
+			isMinorWord: false
+		};
+		if (minorWords.some((minorWord) => minorWord.toLowerCase() === word.toLowerCase())) return {
+			word: word.toLowerCase(),
+			isMinorWord: true
+		};
+		return {
+			word: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
+			isMinorWord: false
+		};
+	}
+	if (first) return {
+		word: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
+		isMinorWord: false
+	};
+	return {
+		word: word.toLowerCase(),
+		isMinorWord: false
+	};
+}
+
+//#endregion
+//#region src/utils/preserve-words.ts
+var PreserveWordsContext = class {
+	preserveWords;
+	preservePhrases;
+	constructor(preserveWordsOption) {
+		const preserveWords = /* @__PURE__ */ new Map();
+		/**
+		* Add a single word to the preserveWords map
+		*/
+		function addPreserveWord(word) {
+			const lowerWord = word.toLowerCase();
+			let list = preserveWords.get(lowerWord);
+			if (!list) {
+				list = [];
+				preserveWords.set(lowerWord, list);
+			}
+			list.push(word);
+		}
+		const preservePhrases = /* @__PURE__ */ new Map();
+		for (const word of preserveWordsOption) {
+			const splitted = word.split(/\s+/);
+			if (splitted.length <= 1) addPreserveWord(word);
+			else {
+				preservePhrases.set(word, splitted);
+				addPreserveWord(splitted.join(""));
+			}
 		}
-		list.push(word);
+		this.preserveWords = preserveWords;
+		this.preservePhrases = [...preservePhrases.values()].sort((a, b) => b.length - a.length);
+	}
+	findPreserveWord(word) {
+		return this.preserveWords.get(word.toLowerCase()) ?? null;
 	}
-	const preservePhrases = /* @__PURE__ */ new Map();
-	for (const word of preserveWordsOption) {
-		const splitted = word.split(/\s+/);
-		if (splitted.length <= 1) addPreserveWord(word);
-		else {
-			preservePhrases.set(word, splitted);
-			addPreserveWord(splitted.join(""));
+	findPreservePhrase(words) {
+		const firstWord = words.next();
+		if (firstWord.done) return null;
+		const firstLowerWord = firstWord.value.toLowerCase();
+		let returnCandidate = null;
+		const subWords = [firstWord.value];
+		for (const phrase of this.preservePhrases) {
+			if (returnCandidate && returnCandidate.preservePhrase.length !== phrase.length) break;
+			if (firstLowerWord !== phrase[0].toLowerCase()) continue;
+			while (subWords.length < phrase.length) {
+				const word = words.next();
+				if (word.done) return null;
+				subWords.push(word.value);
+			}
+			if (subWords.every((word, i) => word.toLowerCase() === phrase[i].toLowerCase())) {
+				let matchCount = 0;
+				for (let i = 0; i < subWords.length; i++) {
+					const word = subWords[i];
+					if (word === phrase[i]) matchCount++;
+				}
+				if (!returnCandidate || matchCount > returnCandidate.matchCount) returnCandidate = {
+					preservePhrase: phrase,
+					matchCount
+				};
+			}
 		}
+		return returnCandidate?.preservePhrase ?? null;
 	}
-	return {
-		preserveWords,
-		preservePhrases: [...preservePhrases.values()].sort((a, b) => b.length - a.length)
-	};
+};
+/**
+* Parse preserve words and phrases from the options
+* - Single words are added to preserveWords
+* - Multi-word phrases are added to preservePhrases and added to preserveWords with no spaces
+*/
+function parsePreserveWordsOption(preserveWordsOption) {
+	return new PreserveWordsContext(preserveWordsOption);
 }
+
+//#endregion
+//#region src/utils/words.ts
 /**
 * Parse text into words with offsets
 */
-function parseText(text, firstNode, lastNode) {
+function parseWordsFromText(text, firstNode, lastNode) {
 	const words = [];
 	const pattern = /(\w+(?:[^\s\w]\w+)*|:\w+:|[^\s\w]+|\s+)/gu;
 	let match;
@@ -3255,33 +3326,9 @@ function parseText(text, firstNode, lastNode) {
 	}
 	return words;
 }
-/**
-* Convert a single word based on case style and context
-*/
-function convertWord({ word, first, last }, caseStyle, minorWords) {
-	if (caseStyle === "Title Case") {
-		if (first || last) return {
-			word: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
-			isMinorWord: false
-		};
-		if (minorWords.some((minorWord) => minorWord.toLowerCase() === word.toLowerCase())) return {
-			word: word.toLowerCase(),
-			isMinorWord: true
-		};
-		return {
-			word: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
-			isMinorWord: false
-		};
-	}
-	if (first) return {
-		word: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(),
-		isMinorWord: false
-	};
-	return {
-		word: word.toLowerCase(),
-		isMinorWord: false
-	};
-}
+
+//#endregion
+//#region src/rules/heading-casing.ts
 var heading_casing_default = createRule("heading-casing", {
 	meta: {
 		type: "suggestion",
@@ -3324,14 +3371,14 @@ var heading_casing_default = createRule("heading-casing", {
 	create(context) {
 		const sourceCode = context.sourceCode;
 		const caseStyle = context.options[0]?.style || "Title Case";
-		const { preserveWords, preservePhrases } = parsePreserveWords(context.options[0]?.preserveWords || defaultPreserveWords);
+		const preserveWordsOption = parsePreserveWordsOption(context.options[0]?.preserveWords || defaultPreserveWords);
 		const minorWords = context.options[0]?.minorWords || defaultMinorWords;
 		const ignorePatterns = (context.options[0]?.ignorePatterns || [
 			"/^v\\d+/u",
 			"/\\w+\\.[a-z\\d]+$/u",
-			"/\\w*(?:API|Api)$/u",
-			"/\\w*(?:SDK|Sdk)$/u",
-			"/\\w*(?:CLI|Cli)$/u"
+			"/\\w+(?:API|Api)$/u",
+			"/\\w+(?:SDK|Sdk)$/u",
+			"/\\w+(?:CLI|Cli)$/u"
 		]).map((pattern) => {
 			if (isRegExp(pattern)) return toRegExp(pattern);
 			try {
@@ -3347,7 +3394,7 @@ var heading_casing_default = createRule("heading-casing", {
 		*/
 		function checkTextNode(node, firstNode, lastNode) {
 			const text = sourceCode.getText(node);
-			const wordAndOffsets = parseText(text, firstNode, lastNode);
+			const wordAndOffsets = parseWordsFromText(text, firstNode, lastNode);
 			const processed = /* @__PURE__ */ new Set();
 			for (let index = 0; index < wordAndOffsets.length; index++) {
 				if (processed.has(index)) continue;
@@ -3355,7 +3402,12 @@ var heading_casing_default = createRule("heading-casing", {
 				const wordAndOffset = wordAndOffsets[index];
 				if (wordAndOffset.punctuation) continue;
 				if (ignorePatterns.some((pattern) => pattern.test(wordAndOffset.word))) continue;
-				const preservePhrase = findPreservePhrase(wordAndOffsets, index);
+				const preservePhrase = preserveWordsOption.findPreservePhrase((function* () {
+					const firstWord = wordAndOffsets[index];
+					if (firstWord.punctuation) return;
+					yield firstWord.word;
+					for (let next = index + 1; next < wordAndOffsets.length; next++) yield wordAndOffsets[next].word;
+				})());
 				if (preservePhrase) {
 					for (let wordIndex = 0; wordIndex < preservePhrase.length; wordIndex++) {
 						processed.add(index + wordIndex);
@@ -3363,12 +3415,15 @@ var heading_casing_default = createRule("heading-casing", {
 					}
 					continue;
 				}
-				const preserveWordList = preserveWords.get(wordAndOffset.word.toLowerCase());
+				const preserveWordList = preserveWordsOption.findPreserveWord(wordAndOffset.word);
 				if (preserveWordList) {
 					if (!preserveWordList.some((w) => w === wordAndOffset.word)) verifyWord(wordAndOffset, preserveWordList[0], "preserved");
 					continue;
 				}
-				const expectedWordResult = convertWord(wordAndOffset, caseStyle, minorWords);
+				const expectedWordResult = convertWordCasing(wordAndOffset, {
+					caseStyle,
+					minorWords
+				});
 				verifyWord(wordAndOffset, expectedWordResult.word, expectedWordResult.isMinorWord ? "minor" : "normal");
 			}
 			/**
@@ -3393,39 +3448,11 @@ var heading_casing_default = createRule("heading-casing", {
 				});
 			}
 		}
-		/**
-		* Find a preserve phrase starting from the given index
-		* Returns the longest matching phrase or null if no match is found
-		*/
-		function findPreservePhrase(wordAndOffsets, index) {
-			const firstWord = wordAndOffsets[index];
-			if (firstWord.punctuation) return null;
-			const firstLowerWord = firstWord.word.toLowerCase();
-			let returnCandidate = null;
-			let subWords = null;
-			for (const phrase of preservePhrases) {
-				if (returnCandidate && returnCandidate.preservePhrase.length !== phrase.length) break;
-				if (firstLowerWord !== phrase[0].toLowerCase()) continue;
-				if (!subWords || subWords.length !== phrase.length) subWords = wordAndOffsets.slice(index, index + phrase.length).map((wo) => wo.word);
-				if (subWords.length === phrase.length && subWords.every((word, i) => word.toLowerCase() === phrase[i].toLowerCase())) {
-					let matchCount = 0;
-					for (let i = 0; i < subWords.length; i++) {
-						const word = subWords[i];
-						if (word === phrase[i]) matchCount++;
-					}
-					if (!returnCandidate || matchCount > returnCandidate.matchCount) returnCandidate = {
-						preservePhrase: phrase,
-						matchCount
-					};
-				}
-			}
-			return returnCandidate?.preservePhrase ?? null;
-		}
 		return { heading(node) {
 			if (!node.children.length) return;
 			const children = node.children.filter((child) => child.type !== "text" || child.value.trim());
 			children.forEach((child, i) => {
-				if (child.type === "text") checkTextNode(child, i === 0, i === node.children.length - 1);
+				if (child.type === "text") checkTextNode(child, i === 0, i === children.length - 1);
 			});
 		} };
 	}
@@ -3710,11 +3737,11 @@ var no_multiple_empty_lines_default = createRule("no-multiple-empty-lines", {
 //#region src/rules/no-text-backslash-linebreak.ts
 var no_text_backslash_linebreak_default = createRule("no-text-backslash-linebreak", {
 	meta: {
-		type: "suggestion",
+		type: "layout",
 		docs: {
 			description: "disallow text backslash at the end of a line.",
 			categories: ["recommended"],
-			listCategory: "Preference"
+			listCategory: "Stylistic"
 		},
 		fixable: void 0,
 		hasSuggestions: true,
@@ -4891,6 +4918,140 @@ function normalizedURL(url) {
 	return urlObj.href.endsWith("/") ? urlObj.href : `${urlObj.href}/`;
 }
 
+//#endregion
+//#region src/rules/table-header-casing.ts
+var table_header_casing_default = createRule("table-header-casing", {
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			description: "enforce consistent casing in table header cells.",
+			categories: [],
+			listCategory: "Preference"
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				style: { enum: ["Title Case", "Sentence case"] },
+				preserveWords: {
+					type: "array",
+					items: { type: "string" },
+					description: "Words that should be preserved as-is (case-insensitive matching)"
+				},
+				ignorePatterns: {
+					type: "array",
+					items: { type: "string" },
+					description: "Regular expression patterns for words to ignore during casing checks"
+				},
+				minorWords: {
+					type: "array",
+					items: { type: "string" },
+					description: "Words that should not be capitalized in Title Case (unless they're the first or last word)"
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			expectedTitleCase: "Expected \"{{actual}}\" to be \"{{expected}}\" (Title Case).",
+			expectedTitleCaseMinorWord: "Expected \"{{actual}}\" to be \"{{expected}}\" (Title Case - minor word).",
+			expectedSentenceCase: "Expected \"{{actual}}\" to be \"{{expected}}\" (Sentence case).",
+			expectedPreserveWord: "Expected \"{{actual}}\" to be \"{{expected}}\" (preserved word)."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const caseStyle = context.options[0]?.style || "Title Case";
+		const preserveWordsOption = parsePreserveWordsOption(context.options[0]?.preserveWords || defaultPreserveWords);
+		const minorWords = context.options[0]?.minorWords || defaultMinorWords;
+		const ignorePatterns = (context.options[0]?.ignorePatterns || [
+			"/^v\\d+/u",
+			"/\\w+\\.[a-z\\d]+$/u",
+			"/\\w+(?:API|Api)$/u",
+			"/\\w+(?:SDK|Sdk)$/u",
+			"/\\w+(?:CLI|Cli)$/u"
+		]).map((pattern) => {
+			if (isRegExp(pattern)) return toRegExp(pattern);
+			try {
+				return new RegExp(pattern, "v");
+			} catch {}
+			try {
+				return new RegExp(pattern, "u");
+			} catch {}
+			return new RegExp(pattern);
+		});
+		/**
+		* Check text node and report word-level errors
+		*/
+		function checkTextNode(node, firstNode, lastNode) {
+			const text = sourceCode.getText(node);
+			const wordAndOffsets = parseWordsFromText(text, firstNode, lastNode);
+			const processed = /* @__PURE__ */ new Set();
+			for (let index = 0; index < wordAndOffsets.length; index++) {
+				if (processed.has(index)) continue;
+				processed.add(index);
+				const wordAndOffset = wordAndOffsets[index];
+				if (wordAndOffset.punctuation) continue;
+				if (ignorePatterns.some((pattern) => pattern.test(wordAndOffset.word))) continue;
+				const preservePhrase = preserveWordsOption.findPreservePhrase((function* () {
+					const firstWord = wordAndOffsets[index];
+					if (firstWord.punctuation) return;
+					yield firstWord.word;
+					for (let next = index + 1; next < wordAndOffsets.length; next++) yield wordAndOffsets[next].word;
+				})());
+				if (preservePhrase) {
+					for (let wordIndex = 0; wordIndex < preservePhrase.length; wordIndex++) {
+						processed.add(index + wordIndex);
+						verifyWord(wordAndOffsets[index + wordIndex], preservePhrase[wordIndex], "preserved");
+					}
+					continue;
+				}
+				const preserveWordList = preserveWordsOption.findPreserveWord(wordAndOffset.word);
+				if (preserveWordList) {
+					if (!preserveWordList.some((w) => w === wordAndOffset.word)) verifyWord(wordAndOffset, preserveWordList[0], "preserved");
+					continue;
+				}
+				const expectedWordResult = convertWordCasing(wordAndOffset, {
+					caseStyle,
+					minorWords
+				});
+				verifyWord(wordAndOffset, expectedWordResult.word, expectedWordResult.isMinorWord ? "minor" : "normal");
+			}
+			/**
+			* Verify a single word against the expected casing
+			*/
+			function verifyWord(wordAndOffset, expectedWord, wordType = "normal") {
+				const { word, offset } = wordAndOffset;
+				if (word === expectedWord) return;
+				const [nodeStart] = sourceCode.getRange(node);
+				const range = [nodeStart + offset, nodeStart + offset + word.length];
+				context.report({
+					node,
+					messageId: wordType === "preserved" ? "expectedPreserveWord" : caseStyle === "Title Case" ? wordType === "minor" ? "expectedTitleCaseMinorWord" : "expectedTitleCase" : "expectedSentenceCase",
+					data: {
+						actual: word,
+						expected: expectedWord
+					},
+					loc: getSourceLocationFromRange(sourceCode, node, range),
+					fix(fixer) {
+						return fixer.replaceTextRange(range, expectedWord);
+					}
+				});
+			}
+		}
+		return { table(node) {
+			if (!node.children.length) return;
+			const headerRow = node.children[0];
+			if (headerRow.type !== "tableRow") return;
+			for (const cell of headerRow.children) {
+				const children = cell.children.filter((child) => child.type !== "text" || child.value.trim());
+				children.forEach((child, i) => {
+					if (child.type === "text") checkTextNode(child, i === 0, i === children.length - 1);
+				});
+			}
+		} };
+	}
+});
+
 //#endregion
 //#region src/utils/rules.ts
 const rules$1 = [
@@ -4912,7 +5073,8 @@ const rules$1 = [
 	prefer_inline_code_words_default,
 	prefer_link_reference_definitions_default,
 	prefer_linked_words_default,
-	sort_definitions_default
+	sort_definitions_default,
+	table_header_casing_default
 ];
 
 //#endregion
@@ -4952,7 +5114,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.13.0";
+const version = "0.14.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {
@@ -22,6 +22,7 @@
     "lint": "eslint .",
     "tsc": "tsc --project tsconfig.build.json",
     "eslint-fix": "eslint . --fix",
+    "markdownlint": "npx -y markdownlint-cli2 .",
     "test": "npm run mocha -- \"tests/src/**/*.ts\" --reporter=dot --timeout=60000",
     "cover": "c8 --reporter=lcov npm run test",
     "test:update": "npm run mocha -- \"tests/src/**/*.ts\" --reporter=dot --update",
@@ -59,6 +60,10 @@
     "@eslint/markdown": "^7.1.0",
     "eslint": ">=9.0.0"
   },
+  "dependencies": {
+    "emoji-regex-xs": "^2.0.1",
+    "string-width": "^7.2.0"
+  },
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.1",
     "@changesets/cli": "^2.28.1",
@@ -121,9 +126,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "dependencies": {
-    "emoji-regex-xs": "^2.0.1",
-    "string-width": "^7.2.0"
   }
 }