eslint-plugin-markdown-preferences 0.14.0 → 0.16.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!
 
@@ -37,6 +37,7 @@ npm install --save-dev eslint @eslint/markdown eslint-plugin-markdown-preference
 ## 📖 Usage
 
 <!--USAGE_SECTION_START-->
+
 <!--USAGE_GUIDE_START-->
 
 ### Configuration
@@ -75,6 +76,7 @@ See [the rule list](https://ota-meshi.github.io/eslint-plugin-markdown-preferenc
 Is not supported.
 
 <!--USAGE_GUIDE_END-->
+
 <!--USAGE_SECTION_END-->
 
 ## ✅ Rules
@@ -86,12 +88,12 @@ The rules with the following star ⭐ are included in the configs.
 
 <!--RULES_TABLE_START-->
 
-<!-- prettier-ignore-start -->
-
 ### Preference Rules
 
 - Rules to unify the expression and description style of documents.
 
+<!-- prettier-ignore-start -->
+
 | 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 | 🔧 |  |
@@ -102,21 +104,28 @@ The rules with the following star ⭐ are included in the configs.
 | [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. | 🔧 |  |
 
+<!-- prettier-ignore-end -->
+
 ### Stylistic Rules
 
 - Rules related to the formatting and visual style of Markdown.
 
+<!-- prettier-ignore-start -->
+
 | 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/padding-line-between-blocks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/padding-line-between-blocks.html) | require or disallow padding lines between blocks | 🔧 | ⭐ |
 | [markdown-preferences/prefer-autolinks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html) | enforce the use of autolinks for URLs | 🔧 | ⭐ |
 | [markdown-preferences/prefer-fenced-code-blocks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-fenced-code-blocks.html) | enforce the use of fenced code blocks over indented code blocks | 🔧 | ⭐ |
 | [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 | 🔧 |  |
@@ -125,7 +134,13 @@ The rules with the following star ⭐ are included in the configs.
 <!-- prettier-ignore-end -->
 
 <!--RULES_TABLE_END-->
+
 <!--RULES_SECTION_END-->
+
+## 👫 Related Packages
+
+- [eslint-plugin-markdown-links](https://github.com/ota-meshi/eslint-plugin-markdown-links) ... ESLint plugin with powerful checking rules related to Markdown links.
+
 <!--DOCS_IGNORE_START-->
 
 ## 🍻 Contributing

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
@@ -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
@@ -75,6 +85,11 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-start.html
    */
   'markdown-preferences/ordered-list-marker-start'?: Linter.RuleEntry<MarkdownPreferencesOrderedListMarkerStart>;
+  /**
+   * require or disallow padding lines between blocks
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/padding-line-between-blocks.html
+   */
+  'markdown-preferences/padding-line-between-blocks'?: Linter.RuleEntry<MarkdownPreferencesPaddingLineBetweenBlocks>;
   /**
    * enforce the use of autolinks for URLs
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html
@@ -137,6 +152,9 @@ type MarkdownPreferencesHeadingCasing = [] | [{
   ignorePatterns?: string[];
   minorWords?: string[];
 }];
+type MarkdownPreferencesListMarkerAlignment = [] | [{
+  align?: ("left" | "right");
+}];
 type MarkdownPreferencesNoMultipleEmptyLines = [] | [{
   max?: number;
   maxEOF?: number;
@@ -149,6 +167,17 @@ type MarkdownPreferencesNoTrailingSpaces = [] | [{
 type MarkdownPreferencesOrderedListMarkerStart = [] | [{
   start?: (1 | 0);
 }];
+type MarkdownPreferencesPaddingLineBetweenBlocks = {
+  prev: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]] | {
+    type: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]]);
+    in?: ("list" | "blockquote" | "footnote-definition");
+  });
+  next: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]] | {
+    type: (("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*") | [("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"), ...(("blockquote" | "code" | "heading" | "html" | "list" | "paragraph" | "thematic-break" | "table" | "link-definition" | "footnote-definition" | "frontmatter" | "*"))[]]);
+    in?: ("list" | "blockquote" | "footnote-definition");
+  });
+  blankLine: ("any" | "never" | "always");
+}[];
 type MarkdownPreferencesPreferInlineCodeWords = [] | [{
   words: string[];
   ignores?: {
@@ -207,7 +236,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.14.0";
+declare const version: "0.16.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -27,14 +27,110 @@ function createRule(ruleName, rule) {
 	};
 }
 
+//#endregion
+//#region src/utils/ast.ts
+/**
+* Get the kind of heading.
+*/
+function getHeadingKind(sourceCode, node) {
+	const loc = sourceCode.getLoc(node);
+	if (loc.start.line !== loc.end.line) return "setext";
+	return "atx";
+}
+/**
+* Get the kind of code block.
+*/
+function getCodeBlockKind(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	return text.startsWith("```") ? "backtick-fenced" : text.startsWith("~~~") ? "tilde-fenced" : "indented";
+}
+/**
+* Get the kind of link.
+*/
+function getLinkKind(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	return text.startsWith("[") ? "inline" : text.startsWith("<") && text.endsWith(">") ? "autolink" : "gfm-autolink";
+}
+/**
+* Get the marker of a list item.
+*/
+function getListItemMarker(sourceCode, node) {
+	const item = node.type === "list" ? node.children[0] || node : node;
+	const text = sourceCode.getText(item);
+	if (text.startsWith("-")) return {
+		kind: "-",
+		raw: "-"
+	};
+	if (text.startsWith("*")) return {
+		kind: "*",
+		raw: "*"
+	};
+	if (text.startsWith("+")) return {
+		kind: "+",
+		raw: "+"
+	};
+	const matchDot = /^(\d+)\./.exec(text);
+	if (matchDot) return {
+		kind: ".",
+		raw: matchDot[0],
+		sequence: Number(matchDot[1])
+	};
+	const matchParen = /^(\d+)\)/.exec(text);
+	return {
+		kind: ")",
+		raw: matchParen[0],
+		sequence: Number(matchParen[1])
+	};
+}
+/**
+* Get the marker for a thematic break.
+*/
+function getThematicBreakMarker(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	return {
+		kind: text.startsWith("-") ? "-" : "*",
+		hasSpaces: /\s/u.test(text)
+	};
+}
+/**
+* Get the source location from a range in a node.
+*/
+function getSourceLocationFromRange(sourceCode, node, range) {
+	const [nodeStart] = sourceCode.getRange(node);
+	let startLine, startColumn;
+	if (nodeStart <= range[0]) {
+		const loc = sourceCode.getLoc(node);
+		const beforeLines = sourceCode.text.slice(nodeStart, range[0]).split(/\n/u);
+		startLine = loc.start.line + beforeLines.length - 1;
+		startColumn = (beforeLines.length === 1 ? loc.start.column : 1) + (beforeLines.at(-1) || "").length;
+	} else {
+		const beforeLines = sourceCode.text.slice(0, range[0]).split(/\n/u);
+		startLine = beforeLines.length;
+		startColumn = 1 + (beforeLines.at(-1) || "").length;
+	}
+	const contentLines = sourceCode.text.slice(range[0], range[1]).split(/\n/u);
+	const endLine = startLine + contentLines.length - 1;
+	const endColumn = (contentLines.length === 1 ? startColumn : 1) + (contentLines.at(-1) || "").length;
+	return {
+		start: {
+			line: startLine,
+			column: startColumn
+		},
+		end: {
+			line: endLine,
+			column: endColumn
+		}
+	};
+}
+
 //#endregion
 //#region src/utils/atx-heading.ts
 /**
 * Parse the closing sequence of an ATX heading.
 */
 function parseATXHeadingClosingSequence(sourceCode, node) {
+	if (getHeadingKind(sourceCode, node) !== "atx") return null;
 	const loc = sourceCode.getLoc(node);
-	if (loc.start.line !== loc.end.line) return null;
 	const range = sourceCode.getRange(node);
 	const parsed = parseATXHeadingClosingSequenceFromText(sourceCode.text.slice(...range));
 	if (parsed == null) return { closingSequence: null };
@@ -108,7 +204,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 +246,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 +324,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 +341,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 +354,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 +367,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 +380,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 +389,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);
@@ -381,83 +477,122 @@ var atx_headings_closing_sequence_default = createRule("atx-headings-closing-seq
 });
 
 //#endregion
-//#region src/utils/ast.ts
-/**
-* Get the kind of code block.
-*/
-function getCodeBlockKind(sourceCode, node) {
-	const text = sourceCode.getText(node);
-	return text.startsWith("```") ? "backtick-fenced" : text.startsWith("~~~") ? "tilde-fenced" : "indented";
-}
-/**
-* Get the kind of link.
-*/
-function getLinkKind(sourceCode, node) {
-	const text = sourceCode.getText(node);
-	return text.startsWith("[") ? "inline" : text.startsWith("<") && text.endsWith(">") ? "autolink" : "gfm-autolink";
-}
-/**
-* Get the marker of a list item.
-*/
-function getListItemMarker(sourceCode, node) {
-	const item = node.type === "list" ? node.children[0] || node : node;
-	const text = sourceCode.getText(item);
-	if (text.startsWith("-")) return {
-		kind: "-",
-		raw: "-"
-	};
-	if (text.startsWith("*")) return {
-		kind: "*",
-		raw: "*"
-	};
-	if (text.startsWith("+")) return {
-		kind: "+",
-		raw: "+"
-	};
-	const matchDot = /^(\d+)\./.exec(text);
-	if (matchDot) return {
-		kind: ".",
-		raw: matchDot[0],
-		sequence: Number(matchDot[1])
-	};
-	const matchParen = /^(\d+)\)/.exec(text);
-	return {
-		kind: ")",
-		raw: matchParen[0],
-		sequence: Number(matchParen[1])
-	};
-}
+//#region src/utils/blockquotes.ts
+const cache = /* @__PURE__ */ new WeakMap();
 /**
-* Get the source location from a range in a node.
+* Helper function to get blockquote level information.
 */
-function getSourceLocationFromRange(sourceCode, node, range) {
-	const [nodeStart] = sourceCode.getRange(node);
-	let startLine, startColumn;
-	if (nodeStart <= range[0]) {
-		const loc = sourceCode.getLoc(node);
-		const beforeLines = sourceCode.text.slice(nodeStart, range[0]).split(/\n/u);
-		startLine = loc.start.line + beforeLines.length - 1;
-		startColumn = (beforeLines.length === 1 ? loc.start.column : 1) + (beforeLines.at(-1) || "").length;
-	} else {
-		const beforeLines = sourceCode.text.slice(0, range[0]).split(/\n/u);
-		startLine = beforeLines.length;
-		startColumn = 1 + (beforeLines.at(-1) || "").length;
+function getBlockquoteLevelFromLine(sourceCode, lineNumber) {
+	let map = cache.get(sourceCode);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		cache.set(sourceCode, map);
 	}
-	const contentLines = sourceCode.text.slice(range[0], range[1]).split(/\n/u);
-	const endLine = startLine + contentLines.length - 1;
-	const endColumn = (contentLines.length === 1 ? startColumn : 1) + (contentLines.at(-1) || "").length;
-	return {
-		start: {
-			line: startLine,
-			column: startColumn
-		},
-		end: {
-			line: endLine,
-			column: endColumn
-		}
+	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/rules/canonical-code-block-language.ts
 const DEFAULT_LANGUAGES = {
@@ -3458,20 +3593,99 @@ var heading_casing_default = createRule("heading-casing", {
 	}
 });
 
+//#endregion
+//#region src/rules/list-marker-alignment.ts
+const ALIGN_TO_POSITION_NAME = {
+	left: "start",
+	right: "end"
+};
+var list_marker_alignment_default = createRule("list-marker-alignment", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent alignment of list markers",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { align: { enum: ["left", "right"] } },
+			additionalProperties: false
+		}],
+		messages: { incorrectAlignment: "List marker alignment is inconsistent. Expected {{expected}} characters of indentation, but got {{actual}}." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const alignPositionName = ALIGN_TO_POSITION_NAME[context.options[0]?.align ?? "left"];
+		/**
+		* Get the marker location of a list item
+		*/
+		function getMarkerLocation(node) {
+			const start = sourceCode.getLoc(node).start;
+			const startColumnIndex = start.column - 1;
+			const marker = getListItemMarker(sourceCode, node);
+			return {
+				line: start.line,
+				start: startColumnIndex,
+				end: startColumnIndex + marker.raw.length
+			};
+		}
+		/**
+		* Check if list items have consistent alignment
+		*/
+		function checkListAlignment(listNode) {
+			const items = listNode.children;
+			if (items.length <= 1) return;
+			const referenceMarkerLocation = getMarkerLocation(items[0]);
+			for (const item of items.slice(1)) {
+				const markerLocation = getMarkerLocation(item);
+				const diff = markerLocation[alignPositionName] - referenceMarkerLocation[alignPositionName];
+				if (diff === 0) continue;
+				context.report({
+					node: item,
+					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",
@@ -3492,7 +3706,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.
 		*/
@@ -3516,15 +3729,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",
@@ -3536,12 +3750,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`);
 						}
 					}]
 				});
@@ -3551,7 +3769,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)) {
@@ -3560,8 +3778,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;
@@ -3638,7 +3855,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;
@@ -3852,7 +4069,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);
@@ -4085,6 +4302,272 @@ var ordered_list_marker_start_default = createRule("ordered-list-marker-start",
 	}
 });
 
+//#endregion
+//#region src/rules/padding-line-between-blocks.ts
+/**
+* Determines whether a blank line must be preserved between two nodes
+* due to Markdown syntax constraints (e.g., setext headings).
+*/
+function requiresBlankLineBetween(prev, next, sourceCode) {
+	if (prev.type === "paragraph") {
+		if (next.type === "paragraph" || next.type === "definition") return true;
+		else if (next.type === "heading") return getHeadingKind(sourceCode, next) === "setext";
+		else if (next.type === "thematicBreak") {
+			const marker = getThematicBreakMarker(sourceCode, next);
+			return marker.kind === "-" && !marker.hasSpaces;
+		}
+	} else if (prev.type === "list") {
+		if (next.type === "paragraph" || next.type === "table" || next.type === "definition") return true;
+		else if (next.type === "heading") return getHeadingKind(sourceCode, next) === "setext";
+	} else if (prev.type === "blockquote") {
+		if (next.type === "paragraph" || next.type === "blockquote" || next.type === "table" || next.type === "definition") return true;
+		else if (next.type === "heading") return getHeadingKind(sourceCode, next) === "setext";
+	} else if (prev.type === "table") {
+		if (next.type === "paragraph" || next.type === "table" || next.type === "definition") return true;
+		else if (next.type === "heading") return getHeadingKind(sourceCode, next) === "setext";
+	} else if (prev.type === "footnoteDefinition") {
+		if (next.type === "paragraph" || next.type === "table" || next.type === "definition") return true;
+		else if (next.type === "heading") return getHeadingKind(sourceCode, next) === "setext";
+	} else if (prev.type === "html") return true;
+	return false;
+}
+const BLOCK_TYPES = [
+	"blockquote",
+	"code",
+	"heading",
+	"html",
+	"list",
+	"paragraph",
+	"thematic-break",
+	"table",
+	"link-definition",
+	"footnote-definition",
+	"frontmatter",
+	"*"
+];
+const BLOCK_TYPE_SCHEMAS = [{
+	type: "string",
+	enum: BLOCK_TYPES
+}, {
+	type: "array",
+	items: {
+		type: "string",
+		enum: BLOCK_TYPES
+	},
+	minItems: 1
+}];
+const SELECTOR_SCHEMA = { oneOf: [...BLOCK_TYPE_SCHEMAS, {
+	type: "object",
+	properties: {
+		type: { oneOf: BLOCK_TYPE_SCHEMAS },
+		in: { enum: [
+			"list",
+			"blockquote",
+			"footnote-definition"
+		] }
+	},
+	required: ["type"],
+	additionalProperties: false
+}] };
+const BLOCK_TYPE_MAP0 = {
+	heading: "heading",
+	paragraph: "paragraph",
+	list: "list",
+	blockquote: "blockquote",
+	code: "code",
+	html: "html",
+	table: "table",
+	thematicBreak: "thematic-break",
+	definition: "link-definition",
+	footnoteDefinition: "footnote-definition",
+	json: "frontmatter",
+	toml: "frontmatter",
+	yaml: "frontmatter"
+};
+const BLOCK_TYPE_MAP = BLOCK_TYPE_MAP0;
+/**
+* Get the block type of a node
+*/
+function getBlockType(node) {
+	const nodeType = node.type;
+	const blockType = BLOCK_TYPE_MAP[nodeType];
+	if (blockType) return blockType;
+	return null;
+}
+var padding_line_between_blocks_default = createRule("padding-line-between-blocks", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "require or disallow padding lines between blocks",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					prev: SELECTOR_SCHEMA,
+					next: SELECTOR_SCHEMA,
+					blankLine: {
+						type: "string",
+						enum: [
+							"any",
+							"never",
+							"always"
+						]
+					}
+				},
+				required: [
+					"prev",
+					"next",
+					"blankLine"
+				],
+				additionalProperties: false
+			}
+		},
+		messages: {
+			expectedBlankLine: "Expected a blank line between {{prevType}} and {{nextType}}.",
+			unexpectedBlankLine: "Unexpected blank line between {{prevType}} and {{nextType}}."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = [...context.options || []].reverse();
+		const containerStack = [];
+		/**
+		* Check if the actual type matches the expected type pattern
+		*/
+		function matchesType(actualType, block, expected) {
+			if (Array.isArray(expected)) {
+				for (const e of expected) {
+					const matched$1 = matchesType(actualType, block, e);
+					if (matched$1) return matched$1;
+				}
+				return null;
+			}
+			if (typeof expected === "string") return expected === actualType || expected === "*" ? actualType : null;
+			let matched = null;
+			if (Array.isArray(expected.type)) for (const e of expected.type) {
+				matched = matchesType(actualType, block, e);
+				if (matched) break;
+			}
+			else matched = matchesType(actualType, block, expected.type);
+			if (!matched) return null;
+			if (expected.in === "list") {
+				if (containerStack[0]?.type !== "listItem") return null;
+			} else if (expected.in === "blockquote") {
+				if (containerStack[0]?.type !== "blockquote") return null;
+			} else if (expected.in === "footnote-definition") {
+				if (containerStack[0]?.type !== "footnoteDefinition") return null;
+			}
+			return matched;
+		}
+		/**
+		* Get the expected padding between two blocks
+		*/
+		function getExpectedPadding(prevBlock, nextBlock) {
+			const prevType = getBlockType(prevBlock);
+			const nextType = getBlockType(nextBlock);
+			if (!prevType || !nextType) return null;
+			for (const rule of options) {
+				const prev = matchesType(prevType, prevBlock, rule.prev);
+				if (!prev) continue;
+				const next = matchesType(nextType, nextBlock, rule.next);
+				if (!next) continue;
+				return {
+					prev,
+					next,
+					blankLine: rule.blankLine
+				};
+			}
+			return null;
+		}
+		/**
+		* Check padding between blocks in a container node
+		*/
+		function checkBlockPadding(containerNode) {
+			for (let i = 0; i < containerNode.children.length - 1; i++) {
+				const prevBlock = containerNode.children[i];
+				const nextBlock = containerNode.children[i + 1];
+				const expected = getExpectedPadding(prevBlock, nextBlock);
+				if (expected === null) continue;
+				const prevLoc = sourceCode.getLoc(prevBlock);
+				const nextLoc = sourceCode.getLoc(nextBlock);
+				const actualBlankLine = nextLoc.start.line - prevLoc.end.line - 1;
+				const hasBlankLine = actualBlankLine > 0;
+				let messageId = "expectedBlankLine";
+				if (expected.blankLine === "always") {
+					if (hasBlankLine) continue;
+					let list = null;
+					const stack$1 = [...containerStack];
+					let target$1;
+					while (target$1 = stack$1.shift()) if (target$1.type === "listItem") {
+						list = target$1;
+						break;
+					}
+					if (list && !list.spread) continue;
+					messageId = "expectedBlankLine";
+				} else if (expected.blankLine === "never") {
+					if (!hasBlankLine) continue;
+					if (requiresBlankLineBetween(prevBlock, nextBlock, sourceCode)) continue;
+					messageId = "unexpectedBlankLine";
+				} else continue;
+				const lineLength = sourceCode.lines[nextLoc.start.line - 1].length;
+				let blockquote = null;
+				const stack = [...containerStack];
+				let target;
+				while (target = stack.shift()) if (target.type === "blockquote") {
+					blockquote = target;
+					break;
+				}
+				context.report({
+					node: nextBlock,
+					loc: {
+						start: nextLoc.start,
+						end: {
+							line: nextLoc.start.line,
+							column: lineLength + 1
+						}
+					},
+					messageId,
+					data: {
+						prevType: expected.prev,
+						nextType: expected.next
+					},
+					fix(fixer) {
+						if (expected.blankLine === "always") {
+							let text = "\n";
+							if (blockquote) {
+								const blockquoteLoc = sourceCode.getLoc(blockquote);
+								text += getBlockquoteLevelFromLine(sourceCode, blockquoteLoc.start.line).prefix.trimEnd();
+							}
+							const nextRange = sourceCode.getRange(nextBlock);
+							const startNext = nextRange[0] - nextLoc.start.column;
+							return fixer.insertTextBeforeRange([startNext, startNext], text);
+						}
+						const lines = getParsedLines(sourceCode);
+						const linesToRemove = [];
+						for (let line = prevLoc.end.line + 1; line < nextLoc.start.line; line++) linesToRemove.push(lines.get(line));
+						return linesToRemove.map((line) => fixer.removeRange(line.range));
+					}
+				});
+			}
+		}
+		return {
+			"root, blockquote, listItem, footnoteDefinition"(node) {
+				containerStack.unshift(node);
+			},
+			"root, blockquote, listItem, footnoteDefinition:exit"(node) {
+				checkBlockPadding(node);
+				containerStack.shift();
+			}
+		};
+	}
+});
+
 //#endregion
 //#region src/rules/prefer-autolinks.ts
 var prefer_autolinks_default = createRule("prefer-autolinks", {
@@ -4140,7 +4623,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;
@@ -4150,6 +4632,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;
@@ -4185,6 +4668,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]);
@@ -4808,14 +5292,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
@@ -5057,17 +5541,20 @@ var table_header_casing_default = createRule("table-header-casing", {
 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,
 	no_trailing_spaces_default,
 	ordered_list_marker_sequence_default,
 	ordered_list_marker_start_default,
+	padding_line_between_blocks_default,
 	prefer_autolinks_default,
 	prefer_fenced_code_blocks_default,
 	prefer_inline_code_words_default,
@@ -5099,9 +5586,12 @@ 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/padding-line-between-blocks": "error",
 	"markdown-preferences/prefer-autolinks": "error",
 	"markdown-preferences/prefer-fenced-code-blocks": "error"
 };
@@ -5114,7 +5604,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.14.0";
+const version = "0.16.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {
@@ -33,7 +33,7 @@
     "docs:build": "vitepress build docs",
     "ts": "node --import=tsx",
     "mocha": "npm run ts -- ./node_modules/mocha/bin/mocha.js",
-    "generate:version": "env-cmd -e version npm run update && npm run lint -- --fix",
+    "generate:version": "env-cmd -e version -- npm run update && npm run lint -- --fix",
     "changeset:version": "changeset version && npm run generate:version && git add --all",
     "changeset:publish": "npm run build && changeset publish"
   },
@@ -62,14 +62,14 @@
   },
   "dependencies": {
     "emoji-regex-xs": "^2.0.1",
-    "string-width": "^7.2.0"
+    "string-width": "^8.0.0"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.1",
     "@changesets/cli": "^2.28.1",
     "@changesets/get-release-plan": "^4.0.8",
     "@eslint/core": "^0.15.0",
-    "@eslint/markdown": "^7.1.0",
+    "@eslint/markdown": "^7.2.0",
     "@ota-meshi/eslint-plugin": "^0.18.0",
     "@shikijs/vitepress-twoslash": "^3.0.0",
     "@types/eslint": "^9.6.1",
@@ -83,8 +83,8 @@
     "@types/semver": "^7.5.8",
     "assert": "^2.1.0",
     "c8": "^10.1.3",
-    "env-cmd": "^10.1.0",
-    "eslint": "^9.22.0",
+    "env-cmd": "^11.0.0",
+    "eslint": "^9.34.0",
     "eslint-compat-utils": "^0.6.4",
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-eslint-comments": "^3.2.0",
@@ -93,6 +93,7 @@
     "eslint-plugin-json-schema-validator": "^5.3.1",
     "eslint-plugin-jsonc": "^2.19.1",
     "eslint-plugin-markdown": "^5.1.0",
+    "eslint-plugin-markdown-links": "^0.4.0",
     "eslint-plugin-n": "^17.16.2",
     "eslint-plugin-node-dependencies": "^1.0.0",
     "eslint-plugin-prettier": "^5.2.3",