eslint-plugin-markdown-preferences 0.13.0 → 0.15.0

package/README.md

@@ -13,10 +13,10 @@ A specialized ESLint plugin that helps enforce consistent writing style and form
 
 ## 📛 Features
 
-- **⚡ Effortless automation** - Transform your Markdown with auto-fixing that handles formatting, linking, and style consistency automatically
-- **📖 Professional documentation** - Enforce consistent line breaks, clean up trailing spaces, and organize link definitions for enterprise-ready documentation
-- **🎯 Smart terminology management** - Automatically convert specified words into inline code or clickable links based on your configuration
-- **⚙️ Highly customizable configuration** - Fine-tune every aspect with granular rule options, word lists, ignore patterns, and flexible thresholds to match your exact requirements
+- **⚡ Effortless automation** - Transform your Markdown with auto-fixing that handles formatting, casing, and style consistency automatically
+- **📖 Professional documentation** - Enforce consistent headings, table headers, and organize link definitions for enterprise-ready documentation
+- **🎨 Clean formatting** - Remove trailing spaces, control line breaks, standardize code blocks, and ensure consistent list numbering for polished output
+- **⚙️ Flexible customization** - Configure casing styles (Title Case, Sentence case), code block languages, emoji notation, and more with extensive options
 
 **Try it live:** Check out the [Online Demo](https://eslint-online-playground.netlify.app/#eslint-plugin-markdown-preferences) to see the plugin in action!
 
@@ -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,26 +90,33 @@ 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. | 🔧 |  |
 | [markdown-preferences/atx-headings-closing-sequence](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-headings-closing-sequence.html) | enforce consistent use of closing sequence in ATX headings. | 🔧 |  |
+| [markdown-preferences/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/definitions-last](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html) | require link definitions and footnote definitions to be placed at the end of the document | 🔧 |  |
 | [markdown-preferences/hard-linebreak-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html) | enforce consistent hard linebreak style. | 🔧 | ⭐ |
+| [markdown-preferences/list-marker-alignment](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/list-marker-alignment.html) | enforce consistent alignment of list markers | 🔧 | ⭐ |
 | [markdown-preferences/no-laziness-blockquotes](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-laziness-blockquotes.html) | disallow laziness in blockquotes |  | ⭐ |
 | [markdown-preferences/no-multiple-empty-lines](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-multiple-empty-lines.html) | disallow multiple empty lines in Markdown files. | 🔧 |  |
+| [markdown-preferences/no-text-backslash-linebreak](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-text-backslash-linebreak.html) | disallow text backslash at the end of a line. |  | ⭐ |
 | [markdown-preferences/no-trailing-spaces](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-trailing-spaces.html) | disallow trailing whitespace at the end of lines in Markdown files. | 🔧 |  |
 | [markdown-preferences/ordered-list-marker-sequence](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-sequence.html) | enforce that ordered list markers use sequential numbers | 🔧 |  |
 | [markdown-preferences/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

@@ -20,6 +20,11 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-headings-closing-sequence-length.html
    */
   'markdown-preferences/atx-headings-closing-sequence-length'?: Linter.RuleEntry<MarkdownPreferencesAtxHeadingsClosingSequenceLength>;
+  /**
+   * enforce consistent alignment of blockquote markers
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/blockquote-marker-alignment.html
+   */
+  'markdown-preferences/blockquote-marker-alignment'?: Linter.RuleEntry<[]>;
   /**
    * enforce canonical language names in code blocks
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/canonical-code-block-language.html
@@ -31,7 +36,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>;
@@ -45,6 +50,11 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/heading-casing.html
    */
   'markdown-preferences/heading-casing'?: Linter.RuleEntry<MarkdownPreferencesHeadingCasing>;
+  /**
+   * enforce consistent alignment of list markers
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/list-marker-alignment.html
+   */
+  'markdown-preferences/list-marker-alignment'?: Linter.RuleEntry<MarkdownPreferencesListMarkerAlignment>;
   /**
    * disallow laziness in blockquotes
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-laziness-blockquotes.html
@@ -105,6 +115,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");
@@ -132,6 +147,9 @@ type MarkdownPreferencesHeadingCasing = [] | [{
   ignorePatterns?: string[];
   minorWords?: string[];
 }];
+type MarkdownPreferencesListMarkerAlignment = [] | [{
+  align?: ("left" | "right");
+}];
 type MarkdownPreferencesNoMultipleEmptyLines = [] | [{
   max?: number;
   maxEOF?: number;
@@ -178,6 +196,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 +220,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.15.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -108,7 +108,7 @@ function parseATXHeadingClosingSequenceFromText(text) {
 
 //#endregion
 //#region src/utils/lines.ts
-const cache = /* @__PURE__ */ new WeakMap();
+const cache$1 = /* @__PURE__ */ new WeakMap();
 var ParsedLines = class {
 	lines;
 	constructor(codeText) {
@@ -150,11 +150,11 @@ var ParsedLines = class {
 * @param sourceCode source code to parse
 * @returns parsed lines
 */
-function parseLines(sourceCode) {
-	const cached = cache.get(sourceCode);
+function getParsedLines(sourceCode) {
+	const cached = cache$1.get(sourceCode);
 	if (cached) return cached;
 	const parsedLines = new ParsedLines(sourceCode.text);
-	cache.set(sourceCode, parsedLines);
+	cache$1.set(sourceCode, parsedLines);
 	return parsedLines;
 }
 
@@ -228,9 +228,8 @@ var atx_headings_closing_sequence_length_default = createRule("atx-headings-clos
 			} };
 		})() : option.mode === "fixed-line-length" ? (() => {
 			const totalLength = option.length || 80;
-			const lines = parseLines(sourceCode);
 			const getExpected = (_node, parsed) => {
-				return totalLength - getContentLength(lines, parsed);
+				return totalLength - getContentLength(parsed);
 			};
 			return { heading(node) {
 				verifyATXHeadingClosingSequenceLength(node, getExpected);
@@ -246,7 +245,6 @@ var atx_headings_closing_sequence_length_default = createRule("atx-headings-clos
 				} else verifyATXHeadingClosingSequenceLength(node, getExpected);
 			} };
 		})() : option.mode === "consistent-line-length" ? (() => {
-			const lines = parseLines(sourceCode);
 			const headings = [];
 			return {
 				heading(node) {
@@ -260,9 +258,9 @@ var atx_headings_closing_sequence_length_default = createRule("atx-headings-clos
 				"root:exit"() {
 					let mostLongContentHeading = null;
 					for (const heading of headings) {
-						const contentLength = getContentLength(lines, heading.parsed);
+						const contentLength = getContentLength(heading.parsed);
 						if (mostLongContentHeading == null || contentLength > mostLongContentHeading.contentLength) {
-							const lineLength = getLineLength(lines, heading.parsed);
+							const lineLength = getLineLength(heading.parsed);
 							mostLongContentHeading = {
 								...heading,
 								contentLength,
@@ -273,11 +271,11 @@ var atx_headings_closing_sequence_length_default = createRule("atx-headings-clos
 					if (!mostLongContentHeading) return;
 					let minLineLength = mostLongContentHeading.lineLength;
 					for (const heading of headings) {
-						const lineLength = getLineLength(lines, heading.parsed);
+						const lineLength = getLineLength(heading.parsed);
 						if (mostLongContentHeading.contentLength < lineLength && lineLength < minLineLength) minLineLength = Math.min(minLineLength, lineLength);
 					}
 					const getExpected = (_node, parsed) => {
-						return minLineLength - getContentLength(lines, parsed);
+						return minLineLength - getContentLength(parsed);
 					};
 					for (const { node } of headings) verifyATXHeadingClosingSequenceLength(node, getExpected);
 				}
@@ -286,7 +284,8 @@ var atx_headings_closing_sequence_length_default = createRule("atx-headings-clos
 		/**
 		* Get the content length of the heading.
 		*/
-		function getContentLength(lines, parsed) {
+		function getContentLength(parsed) {
+			const lines = getParsedLines(sourceCode);
 			const line = lines.get(parsed.closingSequence.loc.start.line);
 			const beforeClosing = sourceCode.text.slice(line.range[0], parsed.closingSequence.range[0]);
 			return getTextWidth(beforeClosing);
@@ -294,7 +293,8 @@ var atx_headings_closing_sequence_length_default = createRule("atx-headings-clos
 		/**
 		* Get the line length of the heading.
 		*/
-		function getLineLength(lines, parsed) {
+		function getLineLength(parsed) {
+			const lines = getParsedLines(sourceCode);
 			const line = lines.get(parsed.closingSequence.loc.start.line);
 			const lineText = sourceCode.text.slice(line.range[0], parsed.closingSequence.range[1]);
 			return getTextWidth(lineText);
@@ -380,6 +380,123 @@ var atx_headings_closing_sequence_default = createRule("atx-headings-closing-seq
 	}
 });
 
+//#endregion
+//#region src/utils/blockquotes.ts
+const cache = /* @__PURE__ */ new WeakMap();
+/**
+* Helper function to get blockquote level information.
+*/
+function getBlockquoteLevelFromLine(sourceCode, lineNumber) {
+	let map = cache.get(sourceCode);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		cache.set(sourceCode, map);
+	}
+	const cached = map.get(lineNumber);
+	if (cached) return cached;
+	const lineText = sourceCode.lines[lineNumber - 1];
+	let prefix = "";
+	let level = 0;
+	const blockquoteMarkers = /* @__PURE__ */ new Map();
+	for (const c of lineText) {
+		if (c === ">") {
+			level++;
+			blockquoteMarkers.set(level, { index: prefix.length });
+		} else if (c.trim()) break;
+		prefix += c;
+	}
+	const result = {
+		line: lineNumber,
+		prefix,
+		level,
+		blockquoteMarkers
+	};
+	map.set(lineNumber, result);
+	return result;
+}
+
+//#endregion
+//#region src/rules/blockquote-marker-alignment.ts
+var blockquote_marker_alignment_default = createRule("blockquote-marker-alignment", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent alignment of blockquote markers",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [],
+		messages: { inconsistentAlignment: "Blockquote markers should be consistently aligned at the same nesting level." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		let blockquoteStack = {
+			node: sourceCode.ast,
+			level: 0,
+			upper: null
+		};
+		return {
+			blockquote(node) {
+				blockquoteStack = {
+					node,
+					level: blockquoteStack.level + 1,
+					upper: blockquoteStack,
+					reported: blockquoteStack.reported
+				};
+				if (blockquoteStack.reported) return;
+				const blockquoteLevel = blockquoteStack.level;
+				const loc = sourceCode.getLoc(node);
+				const startLine = loc.start.line;
+				const endLine = loc.end.line;
+				const base = getBlockquoteLevelFromLine(sourceCode, startLine).blockquoteMarkers.get(blockquoteLevel);
+				if (!base) return;
+				for (let lineNumber = startLine + 1; lineNumber <= endLine; lineNumber++) {
+					const marker = getBlockquoteLevelFromLine(sourceCode, lineNumber).blockquoteMarkers.get(blockquoteLevel);
+					if (!marker) continue;
+					if (base.index === marker.index) continue;
+					blockquoteStack.reported = true;
+					context.report({
+						node,
+						loc: {
+							start: {
+								line: lineNumber,
+								column: marker.index + 1
+							},
+							end: {
+								line: lineNumber,
+								column: marker.index + 2
+							}
+						},
+						messageId: "inconsistentAlignment",
+						fix(fixer) {
+							const lines = getParsedLines(sourceCode);
+							const line = lines.get(lineNumber);
+							if (marker.index < base.index) {
+								const addSpaces = " ".repeat(base.index - marker.index);
+								return fixer.insertTextBeforeRange([line.range[0] + marker.index, line.range[0] + marker.index], addSpaces);
+							}
+							if (blockquoteLevel === 1) {
+								const expectedSpaces = " ".repeat(base.index);
+								return fixer.replaceTextRange([line.range[0], line.range[0] + marker.index], expectedSpaces);
+							}
+							const itemBefore = line.text.slice(0, line.range[0] + marker.index);
+							if (itemBefore.includes("	")) return null;
+							let removeStartIndex = marker.index;
+							for (; removeStartIndex > base.index; removeStartIndex--) if (line.text[removeStartIndex - 1] !== " ") break;
+							return fixer.removeRange([line.range[0] + removeStartIndex, line.range[0] + marker.index]);
+						}
+					});
+				}
+			},
+			"blockquote:exit"() {
+				blockquoteStack = blockquoteStack.upper;
+			}
+		};
+	}
+});
+
 //#endregion
 //#region src/utils/ast.ts
 /**
@@ -2546,7 +2663,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 +2930,7 @@ const defaultPreserveWords = [
 	"Biome",
 	"oxc",
 	"swc",
+	"markdownlint",
 	"Webpack",
 	"Vite",
 	"Babel",
@@ -3148,7 +3266,8 @@ const defaultPreserveWords = [
 	"Insomnia",
 	"Redoc",
 	"Stoplight",
-	"FAQ"
+	"FAQ",
+	"YouTube"
 ];
 
 //#endregion
@@ -3187,44 +3306,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);
 		}
-		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(""));
+			}
+		}
+		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 +3443,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 +3488,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 +3511,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 +3519,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 +3532,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,58 +3565,109 @@ 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);
 			});
 		} };
 	}
 });
 
+//#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,
+							column: markerLocation.start + 1
+						},
+						end: {
+							line: markerLocation.line,
+							column: markerLocation.end + 1
+						}
+					},
+					messageId: "incorrectAlignment",
+					data: {
+						expected: String(markerLocation.start - diff),
+						actual: String(markerLocation.start)
+					},
+					fix(fixer) {
+						const lines = getParsedLines(sourceCode);
+						const line = lines.get(markerLocation.line);
+						if (diff < 0) {
+							const addSpaces = " ".repeat(-diff);
+							return fixer.insertTextBeforeRange([line.range[0] + markerLocation.start, line.range[0] + markerLocation.start], addSpaces);
+						}
+						const itemBefore = line.text.slice(0, markerLocation.start - diff);
+						if (itemBefore.includes("	")) return null;
+						const referenceMarkerBefore = lines.get(referenceMarkerLocation.line).text.slice(0, referenceMarkerLocation.start);
+						if (referenceMarkerBefore === itemBefore) {
+							const removeEndIndex = line.range[0] + markerLocation.start;
+							const removeStartIndex = removeEndIndex - diff;
+							return fixer.removeRange([removeStartIndex, removeEndIndex]);
+						}
+						return null;
+					}
+				});
+			}
+		}
+		return { list: checkListAlignment };
+	}
+});
+
 //#endregion
 //#region src/rules/no-laziness-blockquotes.ts
-/**
-* Helper function to get blockquote line information.
-*/
-function getBlockquoteLineInfo(line) {
-	const regex = /^\s*(?:>\s*)*/u;
-	const match = regex.exec(line.text);
-	return {
-		line,
-		prefix: match[0],
-		level: (match[0].match(/>/gu) || []).length
-	};
-}
 var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 	meta: {
 		type: "problem",
@@ -3465,7 +3688,6 @@ var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 	create(context) {
 		const sourceCode = context.sourceCode;
 		const checkedLines = /* @__PURE__ */ new Set();
-		const lines = parseLines(sourceCode);
 		/**
 		* Report invalid blockquote lines.
 		*/
@@ -3489,15 +3711,16 @@ var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 			for (const group of invalidGroups) {
 				const first = group.lines[0];
 				const last = group.lines.at(-1);
+				const lines = getParsedLines(sourceCode);
 				context.report({
 					loc: {
 						start: {
-							line: first.line.line,
+							line: first.line,
 							column: 1
 						},
 						end: {
-							line: last.line.line,
-							column: last.line.text.length + 1
+							line: last.line,
+							column: lines.get(last.line).text.length + 1
 						}
 					},
 					messageId: "lazyBlockquoteLine",
@@ -3509,12 +3732,16 @@ var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 						messageId: "addMarker",
 						data: { missingMarkers: `${base.level - group.level}` },
 						*fix(fixer) {
-							for (const invalidLine of group.lines) yield fixer.replaceTextRange([invalidLine.line.range[0], invalidLine.line.range[0] + invalidLine.prefix.length], base.prefix);
+							for (const invalidLine of group.lines) {
+								const parsedLine = lines.get(invalidLine.line);
+								yield fixer.replaceTextRange([parsedLine.range[0], parsedLine.range[0] + invalidLine.prefix.length], base.prefix);
+							}
 						}
 					}, {
 						messageId: "addLineBreak",
 						fix: (fixer) => {
-							return fixer.insertTextBeforeRange([first.line.range[0], first.line.range[0]], `${first.prefix.trimEnd()}\n`);
+							const parsedLine = lines.get(first.line);
+							return fixer.insertTextBeforeRange([parsedLine.range[0], parsedLine.range[0]], `${first.prefix.trimEnd()}\n`);
 						}
 					}]
 				});
@@ -3524,7 +3751,7 @@ var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 			const loc = sourceCode.getLoc(node);
 			const startLine = loc.start.line;
 			const endLine = loc.end.line;
-			const base = getBlockquoteLineInfo(lines.get(startLine));
+			const base = getBlockquoteLevelFromLine(sourceCode, startLine);
 			const invalidLines = [];
 			for (let lineNumber = startLine + 1; lineNumber <= endLine; lineNumber++) {
 				if (checkedLines.has(lineNumber)) {
@@ -3533,8 +3760,7 @@ var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 					continue;
 				}
 				checkedLines.add(lineNumber);
-				const line = lines.get(lineNumber);
-				const current = getBlockquoteLineInfo(line);
+				const current = getBlockquoteLevelFromLine(sourceCode, lineNumber);
 				if (base.level <= current.level) {
 					reportInvalidLines(invalidLines, base);
 					invalidLines.length = 0;
@@ -3611,7 +3837,7 @@ var no_multiple_empty_lines_default = createRule("no-multiple-empty-lines", {
 			toml: addIgnoreLoc,
 			json: addIgnoreLoc,
 			"root:exit"() {
-				const lines = [...parseLines(sourceCode)];
+				const lines = [...getParsedLines(sourceCode)];
 				const bofEmptyLines = [];
 				while (lines.length) {
 					if (lines[0].text.trim()) break;
@@ -3710,11 +3936,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,
@@ -3825,7 +4051,7 @@ var no_trailing_spaces_default = createRule("no-trailing-spaces", {
 			"root:exit"() {
 				const re = /[^\S\n\r]+$/u;
 				const skipMatch = /^[^\S\n\r]*$/u;
-				const lines = parseLines(sourceCode);
+				const lines = getParsedLines(sourceCode);
 				const commentLineNumbers = getCommentLineNumbers();
 				for (const lineInfo of lines) {
 					const matches = re.exec(lineInfo.text);
@@ -4113,7 +4339,6 @@ var prefer_fenced_code_blocks_default = createRule("prefer-fenced-code-blocks",
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const lines = parseLines(sourceCode);
 		return { code(node) {
 			const kind = getCodeBlockKind(sourceCode, node);
 			if (kind === "backtick-fenced" || kind === "tilde-fenced") return;
@@ -4123,6 +4348,7 @@ var prefer_fenced_code_blocks_default = createRule("prefer-fenced-code-blocks",
 				messageId: "useFencedCodeBlock",
 				fix(fixer) {
 					if (!isFixableIndentedCodeBlock(node)) return null;
+					const lines = getParsedLines(sourceCode);
 					const startColumnOffset = loc.start.column - 1;
 					const removeRanges = [];
 					let prefixText = null;
@@ -4158,6 +4384,7 @@ var prefer_fenced_code_blocks_default = createRule("prefer-fenced-code-blocks",
 		*/
 		function isFixableIndentedCodeBlock(node) {
 			if (!node.value.startsWith(" ")) return true;
+			const lines = getParsedLines(sourceCode);
 			const loc = sourceCode.getLoc(node);
 			const firstLine = lines.get(loc.start.line);
 			const codeBlockFirstLine = normalizePrefix(node.value.split(/\r?\n/u)[0]);
@@ -4781,14 +5008,14 @@ var sort_definitions_default = createRule("sort-definitions", {
 		}
 		/** Compile order option */
 		function compileOption(orderOption) {
-			const cache$1 = /* @__PURE__ */ new Map();
+			const cache$2 = /* @__PURE__ */ new Map();
 			const compiled = compileOptionWithoutCache(orderOption);
 			return {
 				match: (node) => {
-					const cached = cache$1.get(node);
+					const cached = cache$2.get(node);
 					if (cached != null) return cached;
 					const result = compiled.match(node);
-					cache$1.set(node, result);
+					cache$2.set(node, result);
 					return result;
 				},
 				sort: compiled.sort
@@ -4891,16 +5118,152 @@ 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 = [
 	atx_headings_closing_sequence_length_default,
 	atx_headings_closing_sequence_default,
+	blockquote_marker_alignment_default,
 	canonical_code_block_language_default,
 	definitions_last_default,
 	emoji_notation_default,
 	hard_linebreak_style_default,
 	heading_casing_default,
+	list_marker_alignment_default,
 	no_laziness_blockquotes_default,
 	no_multiple_empty_lines_default,
 	no_text_backslash_linebreak_default,
@@ -4912,7 +5275,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
@@ -4937,7 +5301,9 @@ const plugins = {
 	}
 };
 const rules$2 = {
+	"markdown-preferences/blockquote-marker-alignment": "error",
 	"markdown-preferences/hard-linebreak-style": "error",
+	"markdown-preferences/list-marker-alignment": "error",
 	"markdown-preferences/no-laziness-blockquotes": "error",
 	"markdown-preferences/no-text-backslash-linebreak": "error",
 	"markdown-preferences/prefer-autolinks": "error",
@@ -4952,7 +5318,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.13.0";
+const version = "0.15.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.13.0",
+  "version": "0.15.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"
   }
 }