eslint-plugin-markdown-preferences 0.14.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!
 
@@ -110,8 +110,10 @@ The rules with the following star ⭐ are included in the configs.
 |:--------|:------------|:-------:|:-----------:|
 | [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. |  | ⭐ |

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
@@ -137,6 +147,9 @@ type MarkdownPreferencesHeadingCasing = [] | [{
   ignorePatterns?: string[];
   minorWords?: string[];
 }];
+type MarkdownPreferencesListMarkerAlignment = [] | [{
+  align?: ("left" | "right");
+}];
 type MarkdownPreferencesNoMultipleEmptyLines = [] | [{
   max?: number;
   maxEOF?: number;
@@ -207,7 +220,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.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
 /**
@@ -3458,20 +3575,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 +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.
 		*/
@@ -3516,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",
@@ -3536,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`);
 						}
 					}]
 				});
@@ -3551,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)) {
@@ -3560,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;
@@ -3638,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;
@@ -3852,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);
@@ -4140,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;
@@ -4150,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;
@@ -4185,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]);
@@ -4808,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
@@ -5057,11 +5257,13 @@ 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,
@@ -5099,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",
@@ -5114,7 +5318,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.14.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.14.0",
+  "version": "0.15.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {