eslint-plugin-markdown-preferences 0.20.0 → 0.22.0

package/lib/index.js

@@ -30,6 +30,12 @@ function createRule(ruleName, rule) {
 //#endregion
 //#region src/utils/ast.ts
 /**
+* Get the parent of a node.
+*/
+function getParent(sourceCode, node) {
+	return sourceCode.getParent(node);
+}
+/**
 * Get the kind of heading.
 */
 function getHeadingKind(sourceCode, node) {
@@ -150,6 +156,12 @@ function isSpaceOrTab(string) {
 function isPunctuation(char) {
 	return /^[\p{P}\p{S}]+$/u.test(char);
 }
+/**
+* Check if the character is an ASCII control character
+*/
+function isAsciiControlCharacter(char) {
+	return /^[\x00-\x1f\x7f]+$/u.test(char);
+}
 
 //#endregion
 //#region src/utils/atx-heading.ts
@@ -387,7 +399,7 @@ var atx_heading_closing_sequence_length_default = createRule("atx-heading-closin
 		type: "layout",
 		docs: {
 			description: "enforce consistent length for the closing sequence (trailing #s) in ATX headings.",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -413,7 +425,8 @@ var atx_heading_closing_sequence_length_default = createRule("atx-heading-closin
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const option = Object.assign({ mode: "match-opening" }, context.options[0] || {});
+		const option = context.options[0] || {};
+		const mode = option.mode || "match-opening";
 		/**
 		* Verify the closing sequence length of an ATX heading.
 		*/
@@ -433,12 +446,12 @@ var atx_heading_closing_sequence_length_default = createRule("atx-heading-closin
 				}
 			});
 		}
-		if (option.mode === "match-opening") return { heading(node) {
+		if (mode === "match-opening") return { heading(node) {
 			const parsed = parseATXHeading(sourceCode, node);
 			if (!parsed || parsed.closingSequence == null) return;
 			verifyATXHeadingClosingSequenceLength(parsed, node, node.depth);
 		} };
-		if (option.mode === "length") {
+		if (mode === "length") {
 			const expected = option.length || 2;
 			return { heading(node) {
 				const parsed = parseATXHeading(sourceCode, node);
@@ -446,7 +459,7 @@ var atx_heading_closing_sequence_length_default = createRule("atx-heading-closin
 				verifyATXHeadingClosingSequenceLength(parsed, node, expected);
 			} };
 		}
-		if (option.mode === "fixed-line-length") {
+		if (mode === "fixed-line-length") {
 			const totalLength = option.length || 80;
 			return { heading(node) {
 				const parsed = parseATXHeading(sourceCode, node);
@@ -454,7 +467,7 @@ var atx_heading_closing_sequence_length_default = createRule("atx-heading-closin
 				verifyATXHeadingClosingSequenceLength(parsed, node, totalLength - getContentLength(parsed));
 			} };
 		}
-		if (option.mode === "consistent") {
+		if (mode === "consistent") {
 			let expectedLength = null;
 			return { heading(node) {
 				const parsed = parseATXHeading(sourceCode, node);
@@ -463,7 +476,7 @@ var atx_heading_closing_sequence_length_default = createRule("atx-heading-closin
 				else verifyATXHeadingClosingSequenceLength(parsed, node, expectedLength);
 			} };
 		}
-		if (option.mode === "consistent-line-length") {
+		if (mode === "consistent-line-length") {
 			const headings = [];
 			return {
 				heading(node) {
@@ -502,8 +515,7 @@ var atx_heading_closing_sequence_length_default = createRule("atx-heading-closin
 		* Get the content length of the heading.
 		*/
 		function getContentLength(parsed) {
-			const lines = getParsedLines(sourceCode);
-			const line = lines.get(parsed.closingSequence.loc.start.line);
+			const line = getParsedLines(sourceCode).get(parsed.closingSequence.loc.start.line);
 			const beforeClosing = sourceCode.text.slice(line.range[0], parsed.closingSequence.range[0]);
 			return getTextWidth(beforeClosing);
 		}
@@ -511,8 +523,7 @@ var atx_heading_closing_sequence_length_default = createRule("atx-heading-closin
 		* Get the line length of the heading.
 		*/
 		function getLineLength(parsed) {
-			const lines = getParsedLines(sourceCode);
-			const line = lines.get(parsed.closingSequence.loc.start.line);
+			const line = getParsedLines(sourceCode).get(parsed.closingSequence.loc.start.line);
 			const lineText = sourceCode.text.slice(line.range[0], parsed.closingSequence.range[1]);
 			return getTextWidth(lineText);
 		}
@@ -526,7 +537,7 @@ var atx_heading_closing_sequence_default = createRule("atx-heading-closing-seque
 		type: "layout",
 		docs: {
 			description: "enforce consistent use of closing sequence in ATX headings.",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -628,7 +639,7 @@ var blockquote_marker_alignment_default = createRule("blockquote-marker-alignmen
 		type: "layout",
 		docs: {
 			description: "enforce consistent alignment of blockquote markers",
-			categories: ["recommended"],
+			categories: ["recommended", "standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "whitespace",
@@ -677,8 +688,7 @@ var blockquote_marker_alignment_default = createRule("blockquote-marker-alignmen
 						},
 						messageId: "inconsistentAlignment",
 						fix(fixer) {
-							const lines = getParsedLines(sourceCode);
-							const line = lines.get(lineNumber);
+							const line = getParsedLines(sourceCode).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);
@@ -687,8 +697,7 @@ var blockquote_marker_alignment_default = createRule("blockquote-marker-alignmen
 								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;
+							if (line.text.slice(0, line.range[0] + marker.index).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]);
@@ -719,7 +728,7 @@ function getOtherMarker(unavailableMarker) {
 /**
 * Parse rule options.
 */
-function parseOptions$1(options) {
+function parseOptions$2(options) {
 	const primary = options.primary || "-";
 	const secondary = options.secondary || getOtherMarker(primary);
 	if (primary === secondary) throw new Error(`\`primary\` and \`secondary\` cannot be the same (primary: "${primary}", secondary: "${secondary}").`);
@@ -750,7 +759,7 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 		type: "layout",
 		docs: {
 			description: "enforce consistent bullet list (unordered list) marker style",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -787,7 +796,7 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions$1(context.options[0] || {});
+		const options = parseOptions$2(context.options[0] || {});
 		let containerStack = {
 			node: sourceCode.ast,
 			level: 1,
@@ -831,8 +840,7 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 					for (let index = nodeIndex + 1; index < containerStack.node.children.length; index++) {
 						const nextNode = containerStack.node.children[index];
 						if (nextNode.type !== "list") break;
-						const nextMarker = getListItemMarker(sourceCode, nextNode);
-						if (nextMarker.kind !== prevMarker) break;
+						if (getListItemMarker(sourceCode, nextNode).kind !== prevMarker) break;
 						let expectedNextMarker = prevMarker === primary ? secondary : primary;
 						if (expectedNextMarker === "any") expectedNextMarker = getOtherMarker(prevMarker);
 						yield* fixMarkers(nextNode, expectedNextMarker);
@@ -902,15 +910,11 @@ function parseFencedCodeBlock(sourceCode, node) {
 	}
 	closingFenceText = closingFenceText.trimStart();
 	if (!closingFenceText || !closingFenceText.startsWith(fenceText)) return null;
-	const lines = getParsedLines(sourceCode);
-	const afterOpeningFence = lines.get(loc.start.line).text.slice(fenceText.length);
+	const afterOpeningFence = getParsedLines(sourceCode).get(loc.start.line).text.slice(fenceText.length);
 	const trimmedAfterOpeningFence = afterOpeningFence.trimStart();
 	const spaceAfterOpeningFenceLength = afterOpeningFence.length - trimmedAfterOpeningFence.length;
 	let languageText = "";
-	if (trimmedAfterOpeningFence) {
-		const langMatch = RE_LANGUAGE.exec(trimmedAfterOpeningFence);
-		languageText = langMatch[1];
-	}
+	if (trimmedAfterOpeningFence) languageText = RE_LANGUAGE.exec(trimmedAfterOpeningFence)[1];
 	const afterLanguage = trimmedAfterOpeningFence.slice(languageText.length);
 	const trimmedAfterLanguage = afterLanguage.trimStart();
 	const spaceAfterLanguageLength = afterLanguage.length - trimmedAfterLanguage.length;
@@ -926,7 +930,7 @@ function parseFencedCodeBlock(sourceCode, node) {
 			}
 		}
 	};
-	const language$1 = languageText ? {
+	const language$2 = languageText ? {
 		text: languageText,
 		range: [openingFence.range[1] + spaceAfterOpeningFenceLength, openingFence.range[1] + spaceAfterOpeningFenceLength + languageText.length],
 		loc: {
@@ -940,23 +944,23 @@ function parseFencedCodeBlock(sourceCode, node) {
 			}
 		}
 	} : null;
-	const meta = language$1 && metaText ? {
+	const meta = language$2 && metaText ? {
 		text: metaText,
-		range: [language$1.range[1] + spaceAfterLanguageLength, language$1.range[1] + spaceAfterLanguageLength + metaText.length],
+		range: [language$2.range[1] + spaceAfterLanguageLength, language$2.range[1] + spaceAfterLanguageLength + metaText.length],
 		loc: {
 			start: {
-				line: language$1.loc.end.line,
-				column: language$1.loc.end.column + spaceAfterLanguageLength
+				line: language$2.loc.end.line,
+				column: language$2.loc.end.column + spaceAfterLanguageLength
 			},
 			end: {
-				line: language$1.loc.end.line,
-				column: language$1.loc.end.column + spaceAfterLanguageLength + metaText.length
+				line: language$2.loc.end.line,
+				column: language$2.loc.end.column + spaceAfterLanguageLength + metaText.length
 			}
 		}
 	} : null;
 	return {
 		openingFence,
-		language: language$1,
+		language: language$2,
 		meta,
 		closingFence: {
 			text: closingFenceText,
@@ -1054,7 +1058,7 @@ var code_fence_length_default = createRule("code-fence-length", {
 		type: "layout",
 		docs: {
 			description: "enforce consistent code fence length in fenced code blocks.",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -1104,7 +1108,7 @@ var code_fence_length_default = createRule("code-fence-length", {
 		* Get the effective options for the given code block node.
 		*/
 		function getOptionForCode(node) {
-			const override = options.overrides?.find((o) => o.lang === node.lang);
+			const override = options.overrides ? [...options.overrides].reverse().find((o) => o.lang === node.lang) : null;
 			return {
 				length: override?.length ?? options.length ?? 3,
 				fallbackLength: override?.fallbackLength ?? options.fallbackLength ?? "minimum"
@@ -1158,8 +1162,7 @@ var code_fence_length_default = createRule("code-fence-length", {
 		* Get the expected fence string for the given length.
 		*/
 		function getExpectedFence(parsed, length) {
-			const fenceChar = parsed.openingFence.text[0];
-			return fenceChar.repeat(Math.max(3, length));
+			return parsed.openingFence.text[0].repeat(Math.max(3, length));
 		}
 		/**
 		* Verify that the opening and closing fence lengths match.
@@ -1192,7 +1195,7 @@ var code_fence_style_default = createRule("code-fence-style", {
 		type: "layout",
 		docs: {
 			description: "enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks.",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -1209,8 +1212,7 @@ var code_fence_style_default = createRule("code-fence-style", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const styleOption = context.options[0]?.style ?? "backtick";
-		const expectedChar = styleOption === "tilde" ? "~" : "`";
+		const expectedChar = (context.options[0]?.style ?? "backtick") === "tilde" ? "~" : "`";
 		return { code(node) {
 			const parsed = parseFencedCodeBlock(sourceCode, node);
 			if (!parsed) return;
@@ -1262,8 +1264,7 @@ var definitions_last_default = createRule("definitions-last", {
 				*fix(fixer) {
 					let rangeStart = range[0];
 					for (let index = range[0] - 1; index >= 0; index--) {
-						const c = sourceCode.text[index];
-						if (c.trim()) break;
+						if (sourceCode.text[index].trim()) break;
 						rangeStart = index;
 					}
 					yield fixer.removeRange([rangeStart, range[1]]);
@@ -3229,13 +3230,13 @@ var EmojiData = class {
 	get emojiToColon() {
 		if (this._emojiToColon) return this._emojiToColon;
 		const emojiToCode = this._emojiToColon = Object.create(null);
-		for (const [name$2, unicode] of this.entries) emojiToCode[unicode] = `:${name$2}:`;
+		for (const [name$3, unicode] of this.entries) emojiToCode[unicode] = `:${name$3}:`;
 		return emojiToCode;
 	}
 	get colonToEmoji() {
 		if (this._colonToEmoji) return this._colonToEmoji;
 		const colonToEmoji = this._colonToEmoji = Object.create(null);
-		for (const [name$2, unicode] of this.entries) colonToEmoji[`:${name$2}:`] = unicode;
+		for (const [name$3, unicode] of this.entries) colonToEmoji[`:${name$3}:`] = unicode;
 		return colonToEmoji;
 	}
 };
@@ -3284,7 +3285,7 @@ var emoji_notation_default = createRule("emoji-notation", {
 		const ignoreUnknown = options.ignoreUnknown ?? true;
 		const ignoreList = (options.ignoreList || []).map((s) => toRegExp(s)).flatMap((re) => {
 			const result = [re];
-			for (const [name$2, unicode] of emojiData.entries) if (re.test(`:${name$2}:`) || re.test(unicode)) result.push(toRegExp(`:${name$2}:`), toRegExp(unicode));
+			for (const [name$3, unicode] of emojiData.entries) if (re.test(`:${name$3}:`) || re.test(unicode)) result.push(toRegExp(`:${name$3}:`), toRegExp(unicode));
 			return result;
 		});
 		const isIgnoreBase = (s) => ignoreList.some((re) => re.test(s));
@@ -3365,7 +3366,7 @@ var emphasis_delimiters_style_default = createRule("emphasis-delimiters-style",
 		type: "layout",
 		docs: {
 			description: "enforce a consistent delimiter style for emphasis and strong emphasis",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -3547,7 +3548,7 @@ var hard_linebreak_style_default = createRule("hard-linebreak-style", {
 		type: "layout",
 		docs: {
 			description: "enforce consistent hard linebreak style.",
-			categories: ["recommended"],
+			categories: ["recommended", "standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -4159,10 +4160,7 @@ var PreserveWordsContext = class {
 			}
 			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++;
-				}
+				for (let i = 0; i < subWords.length; i++) if (subWords[i] === phrase[i]) matchCount++;
 				if (!returnCandidate || matchCount > returnCandidate.matchCount) returnCandidate = {
 					preservePhrase: phrase,
 					matchCount
@@ -4472,7 +4470,7 @@ var level1_heading_style_default = createRule("level1-heading-style", {
 		type: "layout",
 		docs: {
 			description: "enforce consistent style for level 1 headings",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -4503,8 +4501,7 @@ var level1_heading_style_default = createRule("level1-heading-style", {
 				if (headingKind !== "setext") return;
 				const parsed = parseSetextHeading(sourceCode, node);
 				if (!parsed) return;
-				const isMultiline = parsed.contentLines.length > 1;
-				if (isMultiline) {
+				if (parsed.contentLines.length > 1) {
 					if (allowMultilineSetext) return;
 					context.report({
 						node,
@@ -4534,8 +4531,7 @@ var level1_heading_style_default = createRule("level1-heading-style", {
 						if (parsed.closingSequence) yield fixer.removeRange([parsed.closingSequence.raws.spaceBefore.range[0], parsed.closingSequence.raws.spaceAfter.range[1]]);
 						const lines = getParsedLines(sourceCode);
 						const underline = "=".repeat(Math.max(getTextWidth(parsed.content.text), 3));
-						const prefix = lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1);
-						const appendingText = `\n${prefix}${underline}`;
+						const appendingText = `\n${lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1)}${underline}`;
 						yield fixer.insertTextAfter(node, appendingText);
 					}
 				});
@@ -4551,7 +4547,7 @@ var level2_heading_style_default = createRule("level2-heading-style", {
 		type: "layout",
 		docs: {
 			description: "enforce consistent style for level 2 headings",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -4582,8 +4578,7 @@ var level2_heading_style_default = createRule("level2-heading-style", {
 				if (headingKind !== "setext") return;
 				const parsed = parseSetextHeading(sourceCode, node);
 				if (!parsed) return;
-				const isMultiline = parsed.contentLines.length > 1;
-				if (isMultiline) {
+				if (parsed.contentLines.length > 1) {
 					if (allowMultilineSetext) return;
 					context.report({
 						node,
@@ -4613,8 +4608,7 @@ var level2_heading_style_default = createRule("level2-heading-style", {
 						if (parsed.closingSequence) yield fixer.removeRange([parsed.closingSequence.raws.spaceBefore.range[0], parsed.closingSequence.raws.spaceAfter.range[1]]);
 						const lines = getParsedLines(sourceCode);
 						const underline = "-".repeat(Math.max(getTextWidth(parsed.content.text), 3));
-						const prefix = lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1);
-						const appendingText = `\n${prefix}${underline}`;
+						const appendingText = `\n${lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1)}${underline}`;
 						yield fixer.insertTextAfter(node, appendingText);
 					}
 				});
@@ -4624,93 +4618,1197 @@ var level2_heading_style_default = createRule("level2-heading-style", {
 });
 
 //#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", {
+//#region src/utils/link.ts
+/**
+* Parse the inline link.
+*/
+function parseInlineLink(sourceCode, node) {
+	if (getLinkKind(sourceCode, node) !== "inline") return null;
+	const nodeRange = sourceCode.getRange(node);
+	let textRange;
+	if (node.children.length === 0) textRange = [nodeRange[0], sourceCode.text.indexOf("]", nodeRange[0]) + 1];
+	else {
+		const lastChildRange = sourceCode.getRange(node.children[node.children.length - 1]);
+		textRange = [nodeRange[0], sourceCode.text.indexOf("]", lastChildRange[1]) + 1];
+	}
+	const parsed = parseInlineLinkDestAndTitleFromText(sourceCode.text.slice(textRange[1], nodeRange[1]));
+	if (!parsed) return null;
+	const destinationRange = [textRange[1] + parsed.destination.range[0], textRange[1] + parsed.destination.range[1]];
+	return {
+		text: {
+			range: textRange,
+			loc: getSourceLocationFromRange(sourceCode, node, textRange)
+		},
+		destination: {
+			type: parsed.destination.type,
+			text: parsed.destination.text,
+			range: destinationRange,
+			loc: getSourceLocationFromRange(sourceCode, node, destinationRange)
+		},
+		title: parsed.title ? {
+			type: parsed.title.type,
+			text: parsed.title.text,
+			range: [textRange[1] + parsed.title.range[0], textRange[1] + parsed.title.range[1]],
+			loc: getSourceLocationFromRange(sourceCode, node, [textRange[1] + parsed.title.range[0], textRange[1] + parsed.title.range[1]])
+		} : null
+	};
+}
+/**
+* Parse the inline link destination and link title from the given text.
+*/
+function parseInlineLinkDestAndTitleFromText(text) {
+	let index = 0;
+	if (text[index] !== "(") return null;
+	index++;
+	skipSpaces();
+	let destination;
+	const destinationStartIndex = index;
+	if (text[index] === "<") {
+		index++;
+		if (!skipUntilEnd((c) => c === ">")) return null;
+		index++;
+		const destinationRange = [destinationStartIndex, index];
+		destination = {
+			type: "pointy-bracketed",
+			text: text.slice(...destinationRange),
+			range: destinationRange
+		};
+	} else {
+		if (text.length <= index) return null;
+		skipUntilEnd((c) => isWhitespace(c) || isAsciiControlCharacter(c) || c === ")");
+		const destinationRange = [destinationStartIndex, index];
+		destination = {
+			type: "bare",
+			text: text.slice(...destinationRange),
+			range: destinationRange
+		};
+	}
+	skipSpaces();
+	if (text[index] === ")") {
+		index++;
+		skipSpaces();
+		if (index < text.length) return null;
+		return {
+			destination,
+			title: null
+		};
+	}
+	if (text.length <= index) return null;
+	let title;
+	const titleStartIndex = index;
+	const startChar = text[index];
+	if (startChar === "'" || startChar === "\"" || startChar === "(") {
+		index++;
+		const endChar = startChar === "(" ? ")" : startChar;
+		if (!skipUntilEnd((c) => c === endChar)) return null;
+		index++;
+		const titleRange = [titleStartIndex, index];
+		title = {
+			type: startChar === "'" ? "single-quoted" : startChar === "\"" ? "double-quoted" : "parenthesized",
+			text: text.slice(...titleRange),
+			range: titleRange
+		};
+	} else return null;
+	skipSpaces();
+	if (text[index] !== ")") return null;
+	index++;
+	skipSpaces();
+	if (index < text.length) return null;
+	return {
+		destination,
+		title
+	};
+	/**
+	* Skip spaces
+	*/
+	function skipSpaces() {
+		while (index < text.length && isWhitespace(text[index])) index++;
+	}
+	/**
+	* Skip until the end by the given condition
+	*/
+	function skipUntilEnd(checkEnd) {
+		while (index < text.length) {
+			const c = text[index];
+			if (checkEnd(c)) return true;
+			index++;
+			if (c !== "\\") continue;
+			if (index < text.length && (text[index] === "\\" || checkEnd(text[index])) && !isWhitespace(text[index])) index++;
+		}
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/link-reference.ts
+/**
+* Parse the link reference.
+*/
+function parseLinkReference(sourceCode, node) {
+	const nodeRange = sourceCode.getRange(node);
+	let textRange;
+	if (node.children.length === 0) textRange = [nodeRange[0], sourceCode.text.indexOf("]", nodeRange[0]) + 1];
+	else {
+		const lastChildRange = sourceCode.getRange(node.children[node.children.length - 1]);
+		textRange = [nodeRange[0], sourceCode.text.indexOf("]", lastChildRange[1]) + 1];
+	}
+	if (node.referenceType === "shortcut") return {
+		text: {
+			range: textRange,
+			loc: getSourceLocationFromRange(sourceCode, node, textRange)
+		},
+		label: null
+	};
+	if (node.referenceType === "collapsed") {
+		const labelRange$1 = [textRange[1], textRange[1] + 1];
+		return {
+			text: {
+				range: textRange,
+				loc: getSourceLocationFromRange(sourceCode, node, textRange)
+			},
+			label: {
+				type: "collapsed",
+				range: labelRange$1,
+				loc: getSourceLocationFromRange(sourceCode, node, labelRange$1)
+			}
+		};
+	}
+	let index = textRange[1] + 1;
+	while (index < sourceCode.text.length) {
+		const c = sourceCode.text[index];
+		if (c === "]") break;
+		index++;
+		if (c !== "\\") continue;
+		if (index < sourceCode.text.length && (sourceCode.text[index] === "\\" || sourceCode.text[index] === "]")) index++;
+	}
+	if (sourceCode.text[index] !== "]") return null;
+	const labelRange = [textRange[1], index + 1];
+	return {
+		text: {
+			range: textRange,
+			loc: getSourceLocationFromRange(sourceCode, node, textRange)
+		},
+		label: {
+			type: "full",
+			text: sourceCode.text.slice(...labelRange),
+			range: labelRange,
+			loc: getSourceLocationFromRange(sourceCode, node, labelRange)
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/image.ts
+/**
+* Parse the image.
+*/
+function parseImage(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	const parsed = parseImageFromText(text);
+	if (!parsed) return null;
+	const nodeRange = sourceCode.getRange(node);
+	const textRange = [nodeRange[0] + parsed.text.range[0], nodeRange[0] + parsed.text.range[1]];
+	const destinationRange = [nodeRange[0] + parsed.destination.range[0], nodeRange[0] + parsed.destination.range[1]];
+	return {
+		text: {
+			range: textRange,
+			loc: getSourceLocationFromRange(sourceCode, node, textRange)
+		},
+		destination: {
+			type: parsed.destination.type,
+			text: parsed.destination.text,
+			range: destinationRange,
+			loc: getSourceLocationFromRange(sourceCode, node, destinationRange)
+		},
+		title: parsed.title ? {
+			type: parsed.title.type,
+			text: parsed.title.text,
+			range: [nodeRange[0] + parsed.title.range[0], nodeRange[0] + parsed.title.range[1]],
+			loc: getSourceLocationFromRange(sourceCode, node, [nodeRange[0] + parsed.title.range[0], nodeRange[0] + parsed.title.range[1]])
+		} : null
+	};
+}
+/**
+* Parse the image from the given text.
+*/
+function parseImageFromText(text) {
+	if (!text.startsWith("![")) return null;
+	let index = text.length - 1;
+	skipSpaces();
+	if (text[index] !== ")") return null;
+	index--;
+	skipSpaces();
+	let title = null;
+	const titleEndIndex = index + 1;
+	const endChar = text[index];
+	if (endChar === "'" || endChar === "\"" || endChar === ")") {
+		index--;
+		const startChar = endChar === ")" ? "(" : endChar;
+		if (skipUntilStart((c) => c === startChar)) {
+			const titleRange = [index, titleEndIndex];
+			index--;
+			title = {
+				type: startChar === "'" ? "single-quoted" : startChar === "\"" ? "double-quoted" : "parenthesized",
+				text: text.slice(...titleRange),
+				range: titleRange
+			};
+			skipSpaces();
+		}
+	}
+	if (title == null) index = titleEndIndex - 1;
+	let destination;
+	const destinationEndIndex = index + 1;
+	if (text[index] === ">") {
+		index--;
+		if (!skipUntilStart((c) => c === "<")) return null;
+		const destinationRange = [index, destinationEndIndex];
+		index--;
+		destination = {
+			type: "pointy-bracketed",
+			text: text.slice(...destinationRange),
+			range: destinationRange
+		};
+	} else {
+		if (text.length <= index) return null;
+		skipUntilStart((c) => isWhitespace(c) || isAsciiControlCharacter(c) || c === "(");
+		const destinationRange = [index + 1, destinationEndIndex];
+		destination = {
+			type: "bare",
+			text: text.slice(...destinationRange),
+			range: destinationRange
+		};
+	}
+	skipSpaces();
+	if (text[index] !== "(") return null;
+	index--;
+	if (text[index] !== "]") return null;
+	return {
+		text: { range: [1, index + 1] },
+		destination,
+		title
+	};
+	/**
+	* Skip spaces
+	*/
+	function skipSpaces() {
+		while (index >= 0 && isWhitespace(text[index])) index--;
+	}
+	/**
+	* Skip until the start by the given condition
+	*/
+	function skipUntilStart(checkStart) {
+		while (index >= 0) {
+			const c = text[index];
+			if (checkStart(c)) {
+				if (index > 1 && !isWhitespace(c)) {
+					let escapeText = "";
+					while (text.endsWith(`${escapeText}\\`, index)) escapeText += "\\";
+					if (escapeText.length % 2 === 1) {
+						index -= escapeText.length + 1;
+						continue;
+					}
+				}
+				return true;
+			}
+			index--;
+		}
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/image-reference.ts
+/**
+* Parse the image reference.
+*/
+function parseImageReference(sourceCode, node) {
+	const nodeRange = sourceCode.getRange(node);
+	if (node.referenceType === "shortcut") {
+		const textRange$1 = [nodeRange[0] + 1, nodeRange[1]];
+		return {
+			text: {
+				range: textRange$1,
+				text: sourceCode.text.slice(...textRange$1),
+				loc: getSourceLocationFromRange(sourceCode, node, textRange$1)
+			},
+			label: null
+		};
+	}
+	if (node.referenceType === "collapsed") {
+		const textRange$1 = [nodeRange[0] + 1, nodeRange[1] - 2];
+		const labelRange$1 = [textRange$1[1], nodeRange[1]];
+		return {
+			text: {
+				range: textRange$1,
+				text: sourceCode.text.slice(...textRange$1),
+				loc: getSourceLocationFromRange(sourceCode, node, textRange$1)
+			},
+			label: {
+				type: "collapsed",
+				range: labelRange$1,
+				loc: getSourceLocationFromRange(sourceCode, node, labelRange$1)
+			}
+		};
+	}
+	const parsed = parseFullImageReferenceFromText(sourceCode.getText(node));
+	if (!parsed) return null;
+	const textRange = [nodeRange[0] + parsed.text.range[0], nodeRange[0] + parsed.text.range[1]];
+	const labelRange = [nodeRange[0] + parsed.label.range[0], nodeRange[0] + parsed.label.range[1]];
+	return {
+		text: {
+			range: textRange,
+			text: parsed.text.text,
+			loc: getSourceLocationFromRange(sourceCode, node, textRange)
+		},
+		label: {
+			type: "full",
+			text: parsed.label.text,
+			range: labelRange,
+			loc: getSourceLocationFromRange(sourceCode, node, labelRange)
+		}
+	};
+}
+/**
+* Parse the full image reference from the given text.
+*/
+function parseFullImageReferenceFromText(text) {
+	if (!text.startsWith("![")) return null;
+	let index = text.length - 1;
+	skipSpaces();
+	if (text[index] !== "]") return null;
+	const labelEndIndex = index + 1;
+	index--;
+	skipSpaces();
+	if (!skipUntilStart((c) => c === "[")) return null;
+	const labelRange = [index, labelEndIndex];
+	index--;
+	const label = {
+		text: text.slice(...labelRange),
+		range: labelRange
+	};
+	if (text[index] !== "]") return null;
+	const textRange = [1, index + 1];
+	return {
+		text: {
+			text: text.slice(...textRange),
+			range: textRange
+		},
+		label
+	};
+	/**
+	* Skip spaces
+	*/
+	function skipSpaces() {
+		while (index >= 0 && isWhitespace(text[index])) index--;
+	}
+	/**
+	* Skip until the start by the given condition
+	*/
+	function skipUntilStart(checkStart) {
+		while (index >= 0) {
+			const c = text[index];
+			if (checkStart(c)) {
+				if (index > 1) {
+					let escapeText = "";
+					while (text.endsWith(`${escapeText}\\`, index)) escapeText += "\\";
+					if (escapeText.length % 2 === 1) {
+						index -= escapeText.length + 1;
+						continue;
+					}
+				}
+				return true;
+			}
+			index--;
+		}
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/link-definition.ts
+/**
+* Parse the link definition.
+*/
+function parseLinkDefinition(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	const parsed = parseLinkDefinitionFromText(text);
+	if (!parsed) return null;
+	const nodeRange = sourceCode.getRange(node);
+	const labelRange = [nodeRange[0] + parsed.label.range[0], nodeRange[0] + parsed.label.range[1]];
+	const destinationRange = [nodeRange[0] + parsed.destination.range[0], nodeRange[0] + parsed.destination.range[1]];
+	return {
+		label: {
+			text: parsed.label.text,
+			range: labelRange,
+			loc: getSourceLocationFromRange(sourceCode, node, labelRange)
+		},
+		destination: {
+			type: parsed.destination.type,
+			text: parsed.destination.text,
+			range: destinationRange,
+			loc: getSourceLocationFromRange(sourceCode, node, destinationRange)
+		},
+		title: parsed.title ? {
+			type: parsed.title.type,
+			text: parsed.title.text,
+			range: [nodeRange[0] + parsed.title.range[0], nodeRange[0] + parsed.title.range[1]],
+			loc: getSourceLocationFromRange(sourceCode, node, [nodeRange[0] + parsed.title.range[0], nodeRange[0] + parsed.title.range[1]])
+		} : null
+	};
+}
+/**
+* Parse the link definition from the given text.
+*/
+function parseLinkDefinitionFromText(text) {
+	let index = 0;
+	if (text[index] !== "[") return null;
+	const labelStartIndex = index;
+	index++;
+	if (!skipUntilEnd((c) => c === "]")) return null;
+	index++;
+	const labelRange = [labelStartIndex, index];
+	if (!text.slice(labelRange[0] + 1, labelRange[1] - 1).trim()) return null;
+	if (text[index] !== ":") return null;
+	const label = {
+		text: text.slice(...labelRange),
+		range: labelRange
+	};
+	index++;
+	skipSpaces();
+	let destination;
+	const destinationStartIndex = index;
+	if (text[index] === "<") {
+		index++;
+		if (!skipUntilEnd((c) => c === ">")) return null;
+		index++;
+		const destinationRange = [destinationStartIndex, index];
+		destination = {
+			type: "pointy-bracketed",
+			text: text.slice(...destinationRange),
+			range: destinationRange
+		};
+	} else {
+		if (text.length <= index) return null;
+		skipUntilEnd((c) => isWhitespace(c) || isAsciiControlCharacter(c));
+		const destinationRange = [destinationStartIndex, index];
+		destination = {
+			type: "bare",
+			text: text.slice(...destinationRange),
+			range: destinationRange
+		};
+	}
+	skipSpaces();
+	if (text.length <= index) return {
+		label,
+		destination,
+		title: null
+	};
+	let title;
+	const titleStartIndex = index;
+	const startChar = text[index];
+	if (startChar === "'" || startChar === "\"" || startChar === "(") {
+		index++;
+		const endChar = startChar === "(" ? ")" : startChar;
+		if (!skipUntilEnd((c) => c === endChar)) return null;
+		index++;
+		const titleRange = [titleStartIndex, index];
+		title = {
+			type: startChar === "'" ? "single-quoted" : startChar === "\"" ? "double-quoted" : "parenthesized",
+			text: text.slice(...titleRange),
+			range: titleRange
+		};
+	} else return null;
+	skipSpaces();
+	if (index < text.length) return null;
+	return {
+		label,
+		destination,
+		title
+	};
+	/**
+	* Skip spaces
+	*/
+	function skipSpaces() {
+		while (index < text.length && isWhitespace(text[index])) index++;
+	}
+	/**
+	* Skip until the end by the given condition
+	*/
+	function skipUntilEnd(checkEnd) {
+		while (index < text.length) {
+			const c = text[index];
+			if (checkEnd(c)) return true;
+			index++;
+			if (c !== "\\") continue;
+			if (index < text.length && (text[index] === "\\" || checkEnd(text[index])) && !isWhitespace(text[index])) index++;
+		}
+		return false;
+	}
+}
+
+//#endregion
+//#region src/rules/link-bracket-newline.ts
+var link_bracket_newline_default = createRule("link-bracket-newline", {
 	meta: {
 		type: "layout",
 		docs: {
-			description: "enforce consistent alignment of list markers",
-			categories: ["recommended"],
+			description: "enforce linebreaks after opening and before closing link brackets",
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "whitespace",
 		hasSuggestions: false,
 		schema: [{
 			type: "object",
-			properties: { align: { enum: ["left", "right"] } },
+			properties: {
+				newline: { enum: [
+					"always",
+					"never",
+					"consistent"
+				] },
+				multiline: { type: "boolean" }
+			},
 			additionalProperties: false
 		}],
-		messages: { incorrectAlignment: "List marker alignment is inconsistent. Expected {{expected}} characters of indentation, but got {{actual}}." }
+		messages: {
+			expectedNewlineAfterOpeningBracket: "Expected a linebreak after this opening bracket.",
+			unexpectedNewlineAfterOpeningBracket: "Unexpected linebreak after this opening bracket.",
+			expectedNewlineBeforeClosingBracket: "Expected a linebreak before this closing bracket.",
+			unexpectedNewlineBeforeClosingBracket: "Unexpected linebreak before this closing bracket."
+		}
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const alignPositionName = ALIGN_TO_POSITION_NAME[context.options[0]?.align ?? "left"];
+		const optionProvider = parseOptions$3(context.options[0]);
 		/**
-		* Get the marker location of a list item
+		* Parse the options.
 		*/
-		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
+		function parseOptions$3(option) {
+			const newline = option?.newline ?? "never";
+			const multiline = option?.multiline ?? false;
+			return (bracketsRange) => {
+				if (multiline) {
+					if (sourceCode.text.slice(bracketsRange[0] + 1, bracketsRange[1] - 1).trim().includes("\n")) return "always";
+				}
+				return newline;
 			};
 		}
 		/**
-		* Check if list items have consistent alignment
+		* Verify the newline around the brackets.
 		*/
-		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;
+		function verifyNewlineAroundBrackets(node, bracketsRange) {
+			const newline = optionProvider(bracketsRange);
+			const openingBracketIndex = bracketsRange[0];
+			const spaceAfterOpeningBracket = getSpaceAfterOpeningBracket(openingBracketIndex);
+			verifyNewlineAfterOpeningBracket(node, spaceAfterOpeningBracket, openingBracketIndex, newline);
+			const closingBracketIndex = bracketsRange[1] - 1;
+			const newlineOptionBeforeClosingBracket = newline === "consistent" ? getSpaceAfterOpeningBracket(bracketsRange[0]).includes("\n") ? "always" : "never" : newline;
+			verifyNewlineBeforeClosingBracket(node, getSpaceBeforeClosingBracket(closingBracketIndex), openingBracketIndex, closingBracketIndex, newlineOptionBeforeClosingBracket);
+		}
+		/**
+		* Verify the newline after the opening bracket and before the closing bracket.
+		*/
+		function verifyNewlineAfterOpeningBracket(node, spaceAfterOpeningBracket, openingBracketIndex, newline) {
+			if (newline === "always") {
+				if (spaceAfterOpeningBracket.includes("\n")) return;
+				const loc = getSourceLocationFromRange(sourceCode, node, [openingBracketIndex, openingBracketIndex + 1]);
 				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;
+					node,
+					loc,
+					messageId: "expectedNewlineAfterOpeningBracket",
+					fix: (fixer) => fixer.insertTextAfterRange([openingBracketIndex, openingBracketIndex + 1], `\n${" ".repeat(loc.start.column)}${spaceAfterOpeningBracket}`)
+				});
+			} else if (newline === "never") {
+				if (!spaceAfterOpeningBracket.includes("\n")) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [openingBracketIndex + 1, openingBracketIndex + 1 + spaceAfterOpeningBracket.length]),
+					messageId: "unexpectedNewlineAfterOpeningBracket",
+					fix: (fixer) => fixer.replaceTextRange([openingBracketIndex + 1, openingBracketIndex + 1 + spaceAfterOpeningBracket.length], " ")
+				});
+			}
+		}
+		/**
+		* Verify the newline before the closing bracket.
+		*/
+		function verifyNewlineBeforeClosingBracket(node, spaceBeforeClosingBracket, openingBracketIndex, closingBracketIndex, newline) {
+			if (openingBracketIndex + 1 === closingBracketIndex - spaceBeforeClosingBracket.length) return;
+			if (newline === "always") {
+				if (spaceBeforeClosingBracket.includes("\n")) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [closingBracketIndex, closingBracketIndex + 1]),
+					messageId: "expectedNewlineBeforeClosingBracket",
+					fix: (fixer) => {
+						const openingBracketLoc = getSourceLocationFromRange(sourceCode, node, [openingBracketIndex, openingBracketIndex + 1]);
+						return fixer.insertTextBeforeRange([closingBracketIndex, closingBracketIndex + 1], `\n${" ".repeat(openingBracketLoc.start.column)}`);
 					}
 				});
+			} else if (newline === "never") {
+				if (!spaceBeforeClosingBracket.includes("\n")) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [closingBracketIndex - spaceBeforeClosingBracket.length, closingBracketIndex]),
+					messageId: "unexpectedNewlineBeforeClosingBracket",
+					fix: (fixer) => fixer.replaceTextRange([closingBracketIndex - spaceBeforeClosingBracket.length, closingBracketIndex], " ")
+				});
 			}
 		}
-		return { list: checkListAlignment };
+		return {
+			link(node) {
+				if (getLinkKind(sourceCode, node) !== "inline") return;
+				const parsed = parseInlineLink(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundBrackets(node, parsed.text.range);
+			},
+			linkReference(node) {
+				const parsed = parseLinkReference(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundBrackets(node, parsed.text.range);
+				if (parsed.label?.type === "full") verifyNewlineAroundBrackets(node, parsed.label.range);
+			},
+			image(node) {
+				const parsed = parseImage(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundBrackets(node, parsed.text.range);
+			},
+			imageReference(node) {
+				const parsed = parseImageReference(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundBrackets(node, parsed.text.range);
+				if (parsed.label?.type === "full") verifyNewlineAroundBrackets(node, parsed.label.range);
+			},
+			definition(node) {
+				const parsed = parseLinkDefinition(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundBrackets(node, parsed.label.range);
+			}
+		};
+		/**
+		* Get the spaces after the opening bracket.
+		*/
+		function getSpaceAfterOpeningBracket(openingBracketIndex) {
+			for (let i = openingBracketIndex + 1; i < sourceCode.text.length; i++) {
+				const char = sourceCode.text[i];
+				if (isWhitespace(char)) continue;
+				return sourceCode.text.slice(openingBracketIndex + 1, i);
+			}
+			return sourceCode.text.slice(openingBracketIndex + 1);
+		}
+		/**
+		* Get the spaces before the closing bracket.
+		*/
+		function getSpaceBeforeClosingBracket(closingBracketIndex) {
+			for (let i = closingBracketIndex - 1; i >= 0; i--) {
+				const char = sourceCode.text[i];
+				if (isWhitespace(char)) continue;
+				return sourceCode.text.slice(i + 1, closingBracketIndex);
+			}
+			return sourceCode.text.slice(0, closingBracketIndex);
+		}
+	}
+});
+
+//#endregion
+//#region src/rules/link-bracket-spacing.ts
+/**
+* The basic option for links and images.
+*/
+function parseOptions$1(option) {
+	const space = option?.space ?? "never";
+	const imagesInLinks = option?.imagesInLinks;
+	return {
+		space,
+		spaceForText: getOptionForText
+	};
+	/**
+	* Get the spacing option for the given node.
+	*/
+	function getOptionForText(node) {
+		if (imagesInLinks != null) {
+			const children = [...node.children];
+			let child;
+			while (children.length && (child = children[0]) && child.type === "text" && isWhitespace(child.value)) children.shift();
+			while (children.length && (child = children[children.length - 1]) && child.type === "text" && isWhitespace(child.value)) children.pop();
+			const loneChild = children.length === 1 ? children[0] : null;
+			if (loneChild?.type === "image" || loneChild?.type === "imageReference") return imagesInLinks ? "always" : "never";
+		}
+		if (node.children.length === 0 || node.children.length === 1 && node.children[0]?.type === "text" && isWhitespace(node.children[0].value)) return "ignore";
+		return space;
+	}
+}
+var link_bracket_spacing_default = createRule("link-bracket-spacing", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent spacing inside link brackets",
+			categories: ["standard"],
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				space: { enum: ["always", "never"] },
+				imagesInLinks: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			unexpectedSpaceAfterOpeningBracket: "Unexpected space after opening bracket.",
+			expectedSpaceAfterOpeningBracket: "Expected space after opening bracket.",
+			unexpectedSpaceBeforeClosingBracket: "Unexpected space before closing bracket.",
+			expectedSpaceBeforeClosingBracket: "Expected space before closing bracket."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = parseOptions$1(context.options[0]);
+		/**
+		* Verify the space after the opening bracket and before the closing bracket.
+		*/
+		function verifySpaceAfterOpeningBracket(node, openingBracketIndex, spaceOption) {
+			const space = getSpaceAfterOpeningBracket(openingBracketIndex);
+			if (space.includes("\n")) return;
+			if (spaceOption === "always") {
+				if (space.length > 0) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [openingBracketIndex, openingBracketIndex + 1]),
+					messageId: "expectedSpaceAfterOpeningBracket",
+					fix: (fixer) => fixer.insertTextAfterRange([openingBracketIndex, openingBracketIndex + 1], " ")
+				});
+			} else if (spaceOption === "never") {
+				if (space.length === 0) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [openingBracketIndex + 1, openingBracketIndex + 1 + space.length]),
+					messageId: "unexpectedSpaceAfterOpeningBracket",
+					fix: (fixer) => fixer.removeRange([openingBracketIndex + 1, openingBracketIndex + 1 + space.length])
+				});
+			}
+		}
+		/**
+		* Verify the space before the closing bracket.
+		*/
+		function verifySpaceBeforeClosingBracket(node, openingBracketIndex, closingBracketIndex, spaceOption) {
+			const space = getSpaceBeforeClosingBracket(closingBracketIndex);
+			if (openingBracketIndex + 1 === closingBracketIndex - space.length) return;
+			if (space.includes("\n")) return;
+			if (spaceOption === "always") {
+				if (space.length > 0) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [closingBracketIndex, closingBracketIndex + 1]),
+					messageId: "expectedSpaceBeforeClosingBracket",
+					fix: (fixer) => fixer.insertTextBeforeRange([closingBracketIndex, closingBracketIndex + 1], " ")
+				});
+			} else if (spaceOption === "never") {
+				if (space.length === 0) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [closingBracketIndex - space.length, closingBracketIndex]),
+					messageId: "unexpectedSpaceBeforeClosingBracket",
+					fix: (fixer) => fixer.removeRange([closingBracketIndex - space.length, closingBracketIndex])
+				});
+			}
+		}
+		return {
+			link(node) {
+				if (getLinkKind(sourceCode, node) !== "inline") return;
+				const parsed = parseInlineLink(sourceCode, node);
+				if (!parsed) return;
+				const spaceForText = options.spaceForText(node);
+				if (spaceForText === "ignore") return;
+				verifySpaceAfterOpeningBracket(node, parsed.text.range[0], spaceForText);
+				verifySpaceBeforeClosingBracket(node, parsed.text.range[0], parsed.text.range[1] - 1, spaceForText);
+			},
+			linkReference(node) {
+				const parsed = parseLinkReference(sourceCode, node);
+				if (!parsed) return;
+				const spaceForText = options.spaceForText(node);
+				if (spaceForText !== "ignore") {
+					if (spaceForText !== "never" || !sourceCode.text.slice(parsed.text.range[0] + 1, parsed.text.range[1] - 1).trimStart().startsWith("^")) {
+						verifySpaceAfterOpeningBracket(node, parsed.text.range[0], spaceForText);
+						verifySpaceBeforeClosingBracket(node, parsed.text.range[0], parsed.text.range[1] - 1, spaceForText);
+					}
+				}
+				if (parsed.label?.type === "full") {
+					verifySpaceAfterOpeningBracket(node, parsed.label.range[0], options.space);
+					verifySpaceBeforeClosingBracket(node, parsed.label.range[0], parsed.label.range[1] - 1, options.space);
+				}
+			},
+			image(node) {
+				const parsed = parseImage(sourceCode, node);
+				if (!parsed) return;
+				verifySpaceAfterOpeningBracket(node, parsed.text.range[0], options.space);
+				verifySpaceBeforeClosingBracket(node, parsed.text.range[0], parsed.text.range[1] - 1, options.space);
+			},
+			imageReference(node) {
+				const parsed = parseImageReference(sourceCode, node);
+				if (!parsed) return;
+				verifySpaceAfterOpeningBracket(node, parsed.text.range[0], options.space);
+				verifySpaceBeforeClosingBracket(node, parsed.text.range[0], parsed.text.range[1] - 1, options.space);
+				if (parsed.label?.type === "full") {
+					verifySpaceAfterOpeningBracket(node, parsed.label.range[0], options.space);
+					verifySpaceBeforeClosingBracket(node, parsed.label.range[0], parsed.label.range[1] - 1, options.space);
+				}
+			},
+			definition(node) {
+				const parsed = parseLinkDefinition(sourceCode, node);
+				if (!parsed) return;
+				if (options.space !== "never" || !sourceCode.text.slice(parsed.label.range[0] + 1, parsed.label.range[1] - 1).trimStart().startsWith("^")) {
+					verifySpaceAfterOpeningBracket(node, parsed.label.range[0], options.space);
+					verifySpaceBeforeClosingBracket(node, parsed.label.range[0], parsed.label.range[1] - 1, options.space);
+				}
+			}
+		};
+		/**
+		* Get the spaces after the opening bracket.
+		*/
+		function getSpaceAfterOpeningBracket(openingBracketIndex) {
+			for (let i = openingBracketIndex + 1; i < sourceCode.text.length; i++) {
+				const char = sourceCode.text[i];
+				if (isWhitespace(char)) continue;
+				return sourceCode.text.slice(openingBracketIndex + 1, i);
+			}
+			return sourceCode.text.slice(openingBracketIndex + 1);
+		}
+		/**
+		* Get the spaces before the closing bracket.
+		*/
+		function getSpaceBeforeClosingBracket(closingBracketIndex) {
+			for (let i = closingBracketIndex - 1; i >= 0; i--) {
+				const char = sourceCode.text[i];
+				if (isWhitespace(char)) continue;
+				return sourceCode.text.slice(i + 1, closingBracketIndex);
+			}
+			return sourceCode.text.slice(0, closingBracketIndex);
+		}
+	}
+});
+
+//#endregion
+//#region src/rules/link-destination-style.ts
+const STYLES$1 = {
+	bare: {
+		messageId: "expectedBare",
+		typeName: "bare"
+	},
+	"pointy-brackets": {
+		messageId: "expectedPointyBrackets",
+		typeName: "pointy-bracketed"
+	}
+};
+var link_destination_style_default = createRule("link-destination-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce a consistent style for link destinations",
+			categories: ["standard"],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				style: { enum: ["bare", "pointy-brackets"] },
+				avoidEscape: { type: "boolean" }
+			}
+		}],
+		messages: {
+			expectedBare: "Link destination should not be enclosed in pointy brackets.",
+			expectedPointyBrackets: "Expected link destination to be pointy bracketed."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = context.options[0] || {};
+		const preferStyle = STYLES$1[options.style || "bare"];
+		const avoidEscape = options.avoidEscape ?? true;
+		/**
+		* Verify destination style.
+		*/
+		function verifyDestination(node, destination) {
+			if (preferStyle.typeName === destination.type) return;
+			if (avoidEscape) {
+				if (preferStyle.typeName === "bare") {
+					if (hasWhitespaceOrControlCharacter(destination.text) || !isBalancedDestinationParentheses(destination.text)) return;
+				} else if (preferStyle.typeName === "pointy-bracketed") {
+					if (hasLoneLastBackslash(destination.text)) return;
+				}
+			}
+			context.report({
+				node,
+				loc: destination.loc,
+				messageId: preferStyle.messageId,
+				*fix(fixer) {
+					if (destination.type === "bare" && preferStyle.typeName === "pointy-bracketed") {
+						yield fixer.insertTextBeforeRange([destination.range[0], destination.range[0]], "<");
+						if (hasLoneLastBackslash(destination.text)) yield fixer.insertTextBeforeRange([destination.range[1] - 1, destination.range[1]], "\\");
+						yield fixer.insertTextAfterRange([destination.range[1], destination.range[1]], ">");
+					} else if (destination.type === "pointy-bracketed" && preferStyle.typeName === "bare") {
+						yield fixer.removeRange([destination.range[0], destination.range[0] + 1]);
+						const balancedParentheses = isBalancedDestinationParentheses(destination.text);
+						const textStartIndex = destination.range[0] + 1;
+						const textEndIndex = destination.range[1] - 1;
+						for (let index = textStartIndex; index < textEndIndex; index++) {
+							const c = sourceCode.text[index];
+							if (c === "(" || c === ")") {
+								if (!balancedParentheses) yield fixer.insertTextBeforeRange([index, index], "\\");
+							} else if (isWhitespace(c) || isAsciiControlCharacter(c)) yield fixer.replaceTextRange([index, index + 1], encodeURI(c));
+							else if (c === "\\") index++;
+						}
+						yield fixer.removeRange([destination.range[1] - 1, destination.range[1]]);
+					}
+				}
+			});
+		}
+		return {
+			link(node) {
+				if (getLinkKind(sourceCode, node) !== "inline") return;
+				const parsed = parseInlineLink(sourceCode, node);
+				if (!parsed) return;
+				verifyDestination(node, parsed.destination);
+			},
+			image(node) {
+				const parsed = parseImage(sourceCode, node);
+				if (!parsed) return;
+				verifyDestination(node, parsed.destination);
+			},
+			definition(node) {
+				if (!node.url && preferStyle.typeName === "bare") return;
+				const parsed = parseLinkDefinition(sourceCode, node);
+				if (!parsed) return;
+				verifyDestination(node, parsed.destination);
+			}
+		};
+	}
+});
+/**
+* Checks if the text has whitespace or control characters.
+*/
+function hasWhitespaceOrControlCharacter(text) {
+	for (let index = 0; index < text.length; index++) {
+		const c = text[index];
+		if (isWhitespace(c) || isAsciiControlCharacter(c)) return true;
+		else if (c === "\\") index++;
+	}
+	return false;
+}
+/**
+* Checks if the destination text is balanced parentheses.
+*/
+function isBalancedDestinationParentheses(text) {
+	let parentheses = 0;
+	for (let index = 0; index < text.length; index++) {
+		const c = text[index];
+		if (c === "(") parentheses++;
+		else if (c === ")") {
+			parentheses--;
+			if (parentheses < 0) return false;
+		} else if (c === "\\") index++;
+	}
+	if (parentheses > 0) return false;
+	return true;
+}
+/**
+* Checks if the text has a lone last backslash.
+*/
+function hasLoneLastBackslash(text) {
+	if (!text.endsWith("\\")) return false;
+	let escapeText = "";
+	while (text.endsWith(`${escapeText}\\`)) escapeText += "\\";
+	return escapeText.length % 2 === 1;
+}
+
+//#endregion
+//#region src/rules/link-title-style.ts
+const STYLES = {
+	double: {
+		messageId: "expectedDouble",
+		open: "\"",
+		close: "\"",
+		typeName: "double-quoted"
+	},
+	single: {
+		messageId: "expectedSingle",
+		open: "'",
+		close: "'",
+		typeName: "single-quoted"
+	},
+	parentheses: {
+		messageId: "expectedParentheses",
+		open: "(",
+		close: ")",
+		typeName: "parenthesized"
+	}
+};
+var link_title_style_default = createRule("link-title-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce a consistent style for link titles",
+			categories: ["standard"],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				style: { enum: [
+					"double",
+					"single",
+					"parentheses"
+				] },
+				avoidEscape: { type: "boolean" }
+			}
+		}],
+		messages: {
+			expectedDouble: "Expected link title to be double quoted.",
+			expectedSingle: "Expected link title to be single quoted.",
+			expectedParentheses: "Expected link title to be parenthesized."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = context.options[0] || {};
+		const preferStyle = STYLES[options.style || "double"];
+		const avoidEscape = options.avoidEscape ?? true;
+		/**
+		* Verify title style.
+		*/
+		function verifyTitle(node, title) {
+			if (preferStyle.typeName === title.type) return;
+			if (avoidEscape) {
+				if (title.text.slice(1, -1).includes(preferStyle.close)) return;
+			}
+			context.report({
+				node,
+				loc: title.loc,
+				messageId: preferStyle.messageId,
+				*fix(fixer) {
+					yield fixer.replaceTextRange([title.range[0], title.range[0] + 1], preferStyle.open);
+					for (let index = title.range[0] + 1; index < title.range[1] - 1; index++) {
+						const c = sourceCode.text[index];
+						if (c === preferStyle.close) yield fixer.insertTextBeforeRange([index, index], "\\");
+						else if (c === "\\") index++;
+					}
+					yield fixer.replaceTextRange([title.range[1] - 1, title.range[1]], preferStyle.close);
+				}
+			});
+		}
+		return {
+			link(node) {
+				if (getLinkKind(sourceCode, node) !== "inline") return;
+				const parsed = parseInlineLink(sourceCode, node);
+				if (!parsed || !parsed.title) return;
+				verifyTitle(node, parsed.title);
+			},
+			image(node) {
+				const parsed = parseImage(sourceCode, node);
+				if (!parsed || !parsed.title) return;
+				verifyTitle(node, parsed.title);
+			},
+			definition(node) {
+				const parsed = parseLinkDefinition(sourceCode, node);
+				if (!parsed || !parsed.title) return;
+				verifyTitle(node, parsed.title);
+			}
+		};
+	}
+});
+
+//#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", "standard"],
+			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;
+						if (lines.get(referenceMarkerLocation.line).text.slice(0, referenceMarkerLocation.start) === itemBefore) {
+							const removeEndIndex = line.range[0] + markerLocation.start;
+							const removeStartIndex = removeEndIndex - diff;
+							return fixer.removeRange([removeStartIndex, removeEndIndex]);
+						}
+						return null;
+					}
+				});
+			}
+		}
+		return { list: checkListAlignment };
 	}
 });
 
@@ -4721,7 +5819,7 @@ var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 		type: "problem",
 		docs: {
 			description: "disallow laziness in blockquotes",
-			categories: ["recommended"],
+			categories: ["recommended", "standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: void 0,
@@ -4821,6 +5919,182 @@ var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
 	}
 });
 
+//#endregion
+//#region src/rules/no-multi-spaces.ts
+var no_multi_spaces_default = createRule("no-multi-spaces", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "disallow multiple spaces",
+			categories: ["standard"],
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [],
+		messages: { multipleSpaces: "Multiple spaces are not allowed." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		return {
+			definition: verifyLinkDefinition,
+			footnoteDefinition: verifyFootnoteDefinition,
+			heading: verifyHeading,
+			image: verifyImage,
+			imageReference: verifyImageReference,
+			link: verifyLink,
+			linkReference: verifyLinkReference,
+			listItem: verifyListItem,
+			text: verifyText
+		};
+		/**
+		* Verify a text node.
+		*/
+		function verifyText(node) {
+			verifyTextInNode(node);
+		}
+		/**
+		* Verify a definition node.
+		*/
+		function verifyLinkDefinition(node) {
+			const parsed = parseLinkDefinition(sourceCode, node);
+			if (!parsed) return;
+			const nodeRange = sourceCode.getRange(node);
+			verifyTextInRange(node, [nodeRange[0], parsed.destination.range[0]]);
+			verifyTextInRange(node, [parsed.destination.range[1], nodeRange[1]]);
+		}
+		/**
+		* Verify a footnote definition node
+		*/
+		function verifyFootnoteDefinition(node) {
+			verifyTextOutsideChildren(node);
+		}
+		/**
+		* Verify a heading node
+		*/
+		function verifyHeading(node) {
+			verifyTextOutsideChildren(node);
+		}
+		/**
+		* Verify an image node
+		*/
+		function verifyImage(node) {
+			const parsed = parseImage(sourceCode, node);
+			if (!parsed) return;
+			const nodeRange = sourceCode.getRange(node);
+			verifyTextInRange(node, [nodeRange[0], parsed.destination.range[0]]);
+			verifyTextInRange(node, [parsed.destination.range[1], nodeRange[1]]);
+		}
+		/**
+		* Verify an image reference node
+		*/
+		function verifyImageReference(node) {
+			verifyTextInNode(node);
+		}
+		/**
+		* Verify a link node
+		*/
+		function verifyLink(node) {
+			const parsed = parseInlineLink(sourceCode, node);
+			if (!parsed) return;
+			const nodeRange = sourceCode.getRange(node);
+			if (node.children.length > 0) {
+				const first = node.children[0];
+				const last = node.children[node.children.length - 1];
+				const firstRange = sourceCode.getRange(first);
+				const lastRange = sourceCode.getRange(last);
+				verifyTextInRange(node, [nodeRange[0], firstRange[0]]);
+				verifyTextInRange(node, [lastRange[1], parsed.destination.range[0]]);
+			} else verifyTextInRange(node, [nodeRange[0], parsed.destination.range[0]]);
+			verifyTextInRange(node, [parsed.destination.range[1], nodeRange[1]]);
+		}
+		/**
+		* Verify a link reference node
+		*/
+		function verifyLinkReference(node) {
+			verifyTextOutsideChildren(node);
+		}
+		/**
+		* Verify a list item node
+		*/
+		function verifyListItem(node) {
+			verifyTextOutsideChildren(node);
+		}
+		/**
+		* Verify spaces in a node
+		*/
+		function verifyTextInNode(node) {
+			const nodeRange = sourceCode.getRange(node);
+			verifyTextInRange(node, nodeRange);
+		}
+		/**
+		* Verify spaces in a node excluding children
+		*/
+		function verifyTextOutsideChildren(node) {
+			const nodeRange = sourceCode.getRange(node);
+			if (node.children.length > 0) {
+				const first = node.children[0];
+				const last = node.children[node.children.length - 1];
+				const firstRange = sourceCode.getRange(first);
+				const lastRange = sourceCode.getRange(last);
+				verifyTextInRange(node, [nodeRange[0], firstRange[0]]);
+				verifyTextInRange(node, [lastRange[1], nodeRange[1]]);
+			} else verifyTextInRange(node, nodeRange);
+		}
+		/**
+		* Verify spaces in a node
+		*/
+		function verifyTextInRange(node, textRange) {
+			const nodeRange = sourceCode.getRange(node);
+			const text = sourceCode.text.slice(...textRange);
+			const reSpaces = /\s{2,}|\n/gu;
+			let match;
+			while ((match = reSpaces.exec(text)) !== null) {
+				const spaces = match[0];
+				if (spaces.includes("\n")) {
+					let c = "";
+					while ((c = text[reSpaces.lastIndex]) && (c === ">" || !c.trim())) reSpaces.lastIndex++;
+					continue;
+				}
+				if (spaces.length < 2) continue;
+				const start = textRange[0] + match.index;
+				const end = start + spaces.length;
+				const range = [start, end];
+				if (nodeRange[0] === range[0]) {
+					let isIndentation = true;
+					for (let index = nodeRange[0] - 1; index >= 0; index--) {
+						const c = sourceCode.text[index];
+						if (c === "\n") break;
+						if (isWhitespace(c)) continue;
+						isIndentation = false;
+						break;
+					}
+					if (isIndentation) continue;
+				}
+				if (nodeRange[1] === range[1]) {
+					let isTrailingSpaces = true;
+					for (let index = nodeRange[1]; index < sourceCode.text.length; index++) {
+						const c = sourceCode.text[index];
+						if (c === "\n") break;
+						if (isWhitespace(c)) continue;
+						isTrailingSpaces = false;
+						break;
+					}
+					if (isTrailingSpaces) continue;
+				}
+				context.report({
+					node,
+					messageId: "multipleSpaces",
+					loc: getSourceLocationFromRange(sourceCode, node, range),
+					fix(fixer) {
+						return fixer.replaceTextRange(range, " ");
+					}
+				});
+			}
+		}
+	}
+});
+
 //#endregion
 //#region src/rules/no-multiple-empty-lines.ts
 var no_multiple_empty_lines_default = createRule("no-multiple-empty-lines", {
@@ -4828,7 +6102,7 @@ var no_multiple_empty_lines_default = createRule("no-multiple-empty-lines", {
 		type: "layout",
 		docs: {
 			description: "disallow multiple empty lines in Markdown files.",
-			categories: null,
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "whitespace",
@@ -4987,7 +6261,7 @@ var no_text_backslash_linebreak_default = createRule("no-text-backslash-linebrea
 		type: "layout",
 		docs: {
 			description: "disallow text backslash at the end of a line.",
-			categories: ["recommended"],
+			categories: ["recommended", "standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: void 0,
@@ -5032,7 +6306,7 @@ var no_trailing_spaces_default = createRule("no-trailing-spaces", {
 		type: "layout",
 		docs: {
 			description: "disallow trailing whitespace at the end of lines in Markdown files.",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "whitespace",
@@ -5093,7 +6367,31 @@ var no_trailing_spaces_default = createRule("no-trailing-spaces", {
 			html(node) {
 				if (htmlComment.test(node.value)) comments.push(node);
 			},
-			"break, code, inlineCode, text, yaml, toml, json"(node) {
+			break(node) {
+				ignoreNodes.push(node);
+				const range = sourceCode.getRange(node);
+				let trailingSpaceCount = 0;
+				for (let index = range[1] - 1; index >= range[0]; index--) {
+					const c = sourceCode.text[index];
+					if (c === "\n" || c === "\r") {
+						trailingSpaceCount = 0;
+						continue;
+					}
+					if (!isWhitespace(c)) return;
+					trailingSpaceCount++;
+				}
+				const extraSpaces = trailingSpaceCount - 2;
+				if (extraSpaces <= 0) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [range[0], range[0] + extraSpaces]),
+					messageId: "trailingSpace",
+					fix(fixer) {
+						return fixer.removeRange([range[0], range[0] + extraSpaces]);
+					}
+				});
+			},
+			"code, inlineCode, text, yaml, toml, json"(node) {
 				ignoreNodes.push(node);
 			},
 			"root:exit"() {
@@ -5134,7 +6432,7 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 		type: "layout",
 		docs: {
 			description: "enforce that ordered list markers use sequential numbers",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -5250,7 +6548,7 @@ var ordered_list_marker_start_default = createRule("ordered-list-marker-start",
 		type: "layout",
 		docs: {
 			description: "enforce that ordered list markers start with 1 or 0",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Preference"
 		},
 		fixable: "code",
@@ -5267,8 +6565,7 @@ var ordered_list_marker_start_default = createRule("ordered-list-marker-start",
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const option = context.options[0] || {};
-		const expectedStart = option.start ?? 1;
+		const expectedStart = (context.options[0] || {}).start ?? 1;
 		let scope = {
 			node: sourceCode.ast,
 			upper: null,
@@ -5376,7 +6673,7 @@ var ordered_list_marker_style_default = createRule("ordered-list-marker-style",
 		type: "layout",
 		docs: {
 			description: "enforce consistent ordered list marker style",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -5457,8 +6754,7 @@ var ordered_list_marker_style_default = createRule("ordered-list-marker-style",
 					for (let index = nodeIndex + 1; index < containerStack.node.children.length; index++) {
 						const nextNode = containerStack.node.children[index];
 						if (nextNode.type !== "list") break;
-						const nextMarker = getListItemMarker(sourceCode, nextNode);
-						if (nextMarker.kind !== prevMarker) break;
+						if (getListItemMarker(sourceCode, nextNode).kind !== prevMarker) break;
 						const expectedNextMarker = prevMarker === prefer ? getOtherMarkerKind(prefer) : prefer;
 						yield* fixMarkers(nextNode, expectedNextMarker);
 						prevMarker = expectedNextMarker;
@@ -5567,7 +6863,7 @@ const SELECTOR_SCHEMA = { oneOf: [...BLOCK_TYPE_SCHEMAS, {
 	required: ["type"],
 	additionalProperties: false
 }] };
-const BLOCK_TYPE_MAP0 = {
+const BLOCK_TYPE_MAP = {
 	heading: "heading",
 	paragraph: "paragraph",
 	list: "list",
@@ -5582,7 +6878,6 @@ const BLOCK_TYPE_MAP0 = {
 	toml: "frontmatter",
 	yaml: "frontmatter"
 };
-const BLOCK_TYPE_MAP = BLOCK_TYPE_MAP0;
 /**
 * Get the block type of a node
 */
@@ -5597,7 +6892,7 @@ var padding_line_between_blocks_default = createRule("padding-line-between-block
 		type: "layout",
 		docs: {
 			description: "require or disallow padding lines between blocks",
-			categories: ["recommended"],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "whitespace",
@@ -5633,7 +6928,31 @@ var padding_line_between_blocks_default = createRule("padding-line-between-block
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = [...context.options || []].reverse();
+		const options = [...context.options?.length ? context.options : [
+			{
+				prev: "*",
+				next: "*",
+				blankLine: "always"
+			},
+			{
+				prev: "link-definition",
+				next: "link-definition",
+				blankLine: "never"
+			},
+			{
+				prev: "footnote-definition",
+				next: "footnote-definition",
+				blankLine: "never"
+			},
+			{
+				prev: "paragraph",
+				next: {
+					type: "list",
+					in: "list"
+				},
+				blankLine: "never"
+			}
+		]].reverse();
 		const containerStack = [];
 		/**
 		* Check if the actual type matches the expected type pattern
@@ -5694,8 +7013,7 @@ var padding_line_between_blocks_default = createRule("padding-line-between-block
 				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;
+				const hasBlankLine = nextLoc.start.line - prevLoc.end.line - 1 > 0;
 				let messageId = "expectedBlankLine";
 				if (expected.blankLine === "always") {
 					if (hasBlankLine) continue;
@@ -5742,8 +7060,7 @@ var padding_line_between_blocks_default = createRule("padding-line-between-block
 								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;
+							const startNext = sourceCode.getRange(nextBlock)[0] - nextLoc.start.column;
 							return fixer.insertTextBeforeRange([startNext, startNext], text);
 						}
 						const lines = getParsedLines(sourceCode);
@@ -5773,7 +7090,7 @@ var prefer_autolinks_default = createRule("prefer-autolinks", {
 		type: "layout",
 		docs: {
 			description: "enforce the use of autolinks for URLs",
-			categories: ["recommended"],
+			categories: ["recommended", "standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -5811,7 +7128,7 @@ var prefer_fenced_code_blocks_default = createRule("prefer-fenced-code-blocks",
 		type: "layout",
 		docs: {
 			description: "enforce the use of fenced code blocks over indented code blocks",
-			categories: ["recommended"],
+			categories: ["recommended", "standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -5871,8 +7188,7 @@ var prefer_fenced_code_blocks_default = createRule("prefer-fenced-code-blocks",
 			const firstLine = lines.get(loc.start.line);
 			const codeBlockFirstLine = normalizePrefix(node.value.split(/\r?\n/u)[0]);
 			const startColumnOffset = loc.start.column - 1;
-			const normalizedFirstLine = normalizePrefix(firstLine.text.slice(startColumnOffset));
-			return normalizedFirstLine.startsWith(codeBlockFirstLine);
+			return normalizePrefix(firstLine.text.slice(startColumnOffset)).startsWith(codeBlockFirstLine);
 		}
 	}
 });
@@ -6061,8 +7377,7 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = context.options[0] || {};
-		const minLinks = options.minLinks ?? 2;
+		const minLinks = (context.options[0] || {}).minLinks ?? 2;
 		const definitions = [];
 		const links = [];
 		const references = [];
@@ -6165,8 +7480,7 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 			const range = sourceCode.getRange(link);
 			if (link.type === "link") {
 				const bracketsRange$1 = getLinkBracketsRange(link);
-				const linkBracketsText$1 = sourceCode.text.slice(...bracketsRange$1);
-				const linkLabelText$1 = linkBracketsText$1.slice(1, -1).trim();
+				const linkLabelText$1 = sourceCode.text.slice(...bracketsRange$1).slice(1, -1).trim();
 				const urlStartIndex$1 = sourceCode.text.indexOf("(", bracketsRange$1[1]);
 				return {
 					label: linkLabelText$1,
@@ -6175,8 +7489,7 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 				};
 			}
 			const bracketsRange = getImageBracketsRange(link);
-			const linkBracketsText = sourceCode.text.slice(...bracketsRange);
-			const linkLabelText = linkBracketsText.slice(1, -1).trim();
+			const linkLabelText = sourceCode.text.slice(...bracketsRange).slice(1, -1).trim();
 			const urlStartIndex = sourceCode.text.indexOf("(", bracketsRange[1]);
 			return {
 				label: linkLabelText,
@@ -6324,7 +7637,7 @@ var setext_heading_underline_length_default = createRule("setext-heading-underli
 		type: "layout",
 		docs: {
 			description: "enforce setext heading underline length",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "whitespace",
@@ -6562,7 +7875,7 @@ var sort_definitions_default = createRule("sort-definitions", {
 		type: "layout",
 		docs: {
 			description: "enforce a specific order for link definitions and footnote definitions",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -6650,8 +7963,7 @@ var sort_definitions_default = createRule("sort-definitions", {
 						if (moveNode.type === "definition" && index > 0) {
 							if (movedNodes[index - 1].type === "footnoteDefinition") {
 								const footnoteLoc = sourceCode.getLoc(definitions[index - 1]);
-								const linkLoc = sourceCode.getLoc(definitions[index]);
-								if (linkLoc.start.line - footnoteLoc.end.line <= 1) text = `\n${text}`;
+								if (sourceCode.getLoc(definitions[index]).start.line - footnoteLoc.end.line <= 1) text = `\n${text}`;
 							}
 						}
 						return fixer.replaceText(definitions[index], text);
@@ -6678,10 +7990,9 @@ var sort_definitions_default = createRule("sort-definitions", {
 		return {
 			"*"(node) {
 				const last = group.at(-1);
-				if (last && (node.type !== "definition" && node.type !== "footnoteDefinition" || sourceCode.getParent(node) !== sourceCode.getParent(last))) {
+				if (last && (node.type !== "definition" && node.type !== "footnoteDefinition" || getParent(sourceCode, node) !== getParent(sourceCode, last))) {
 					const range = sourceCode.getRange(node);
-					const lastDefinitionRange = sourceCode.getRange(last);
-					if (lastDefinitionRange[1] <= range[0]) {
+					if (sourceCode.getRange(last)[1] <= range[0]) {
 						verify(group);
 						group.length = 0;
 					}
@@ -6694,14 +8005,13 @@ var sort_definitions_default = createRule("sort-definitions", {
 		};
 		/** Parse options */
 		function parseOption(userOption) {
-			const order = userOption?.order ?? [{
+			const compiled = (userOption?.order ?? [{
 				match: String.raw`!/^\[\\^/u`,
 				sort: "alphabetical"
 			}, {
 				match: String.raw`/./u`,
 				sort: "alphabetical"
-			}];
-			const compiled = order.map(compileOption);
+			}]).map(compileOption);
 			return {
 				ignore: (node) => {
 					return !compiled.some((c) => c.match(node));
@@ -6743,20 +8053,14 @@ var sort_definitions_default = createRule("sort-definitions", {
 		}
 		/** Compile order option without cache */
 		function compileOptionWithoutCache(orderOption) {
-			if (typeof orderOption === "string") {
-				const match$1 = compileMatcher([orderOption]);
-				return {
-					match: match$1,
-					sort: "ignore"
-				};
-			}
-			if (Array.isArray(orderOption)) {
-				const match$1 = compileMatcher(orderOption);
-				return {
-					match: match$1,
-					sort: "ignore"
-				};
-			}
+			if (typeof orderOption === "string") return {
+				match: compileMatcher([orderOption]),
+				sort: "ignore"
+			};
+			if (Array.isArray(orderOption)) return {
+				match: compileMatcher(orderOption),
+				sort: "ignore"
+			};
 			const { match } = compileOptionWithoutCache(orderOption.match);
 			return {
 				match,
@@ -6765,7 +8069,7 @@ var sort_definitions_default = createRule("sort-definitions", {
 		}
 		/** Compile matcher */
 		function compileMatcher(pattern) {
-			const rules$3 = [];
+			const rules$4 = [];
 			for (const p of pattern) {
 				let negative, patternStr;
 				if (p.startsWith("!")) {
@@ -6776,11 +8080,11 @@ var sort_definitions_default = createRule("sort-definitions", {
 					patternStr = p;
 				}
 				const regex = toRegExp(patternStr);
-				if (isRegExp(patternStr)) rules$3.push({
+				if (isRegExp(patternStr)) rules$4.push({
 					negative,
 					match: (node) => regex.test(getDefinitionText(node))
 				});
-				else rules$3.push({
+				else rules$4.push({
 					negative,
 					match: (node) => {
 						if (node.label === patternStr || node.identifier === patternStr) return true;
@@ -6788,8 +8092,7 @@ var sort_definitions_default = createRule("sort-definitions", {
 							if (node.url === patternStr) return true;
 							if (URL.canParse(patternStr) && URL.canParse(node.url)) {
 								const normalizedPattern = normalizedURL(patternStr);
-								const normalizedUrl = normalizedURL(node.url);
-								if (normalizedUrl.startsWith(normalizedPattern)) return true;
+								if (normalizedURL(node.url).startsWith(normalizedPattern)) return true;
 							}
 						}
 						return regex.test(getDefinitionText(node));
@@ -6797,8 +8100,8 @@ var sort_definitions_default = createRule("sort-definitions", {
 				});
 			}
 			return (node) => {
-				let result = Boolean(rules$3[0]?.negative);
-				for (const { negative, match } of rules$3) {
+				let result = Boolean(rules$4[0]?.negative);
+				for (const { negative, match } of rules$4) {
 					if (result === !negative) continue;
 					if (match(node)) result = !negative;
 				}
@@ -6845,7 +8148,7 @@ var strikethrough_delimiters_style_default = createRule("strikethrough-delimiter
 		type: "layout",
 		docs: {
 			description: "enforce a consistent delimiter style for strikethrough",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -6859,8 +8162,7 @@ var strikethrough_delimiters_style_default = createRule("strikethrough-delimiter
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const option = context.options[0] ?? {};
-		const delimiter = option.delimiter ?? "~~";
+		const delimiter = (context.options[0] ?? {}).delimiter ?? "~~";
 		return { delete(node) {
 			const range = sourceCode.getRange(node);
 			const actualDelimiter = ["~~", "~"].find((d) => sourceCode.text.startsWith(d, range[0]) && sourceCode.text.endsWith(d, range[1]));
@@ -7021,7 +8323,7 @@ var thematic_break_character_style_default = createRule("thematic-break-characte
 		type: "layout",
 		docs: {
 			description: "enforce consistent character style for thematic breaks (horizontal rules) in Markdown.",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -7041,8 +8343,7 @@ var thematic_break_character_style_default = createRule("thematic-break-characte
 		messages: { unexpected: "Thematic break should use '{{expected}}' but found '{{actual}}'." }
 	},
 	create(context) {
-		const option = context.options[0];
-		const style = option?.style || "-";
+		const style = context.options[0]?.style || "-";
 		return { thematicBreak(node) {
 			const marker = getThematicBreakMarker(context.sourceCode, node);
 			if (marker.kind !== style) context.report({
@@ -7054,8 +8355,7 @@ var thematic_break_character_style_default = createRule("thematic-break-characte
 				},
 				fix(fixer) {
 					const range = context.sourceCode.getRange(node);
-					const text = context.sourceCode.getText(node);
-					const rep = text.replaceAll(marker.kind, style);
+					const rep = context.sourceCode.getText(node).replaceAll(marker.kind, style);
 					return fixer.replaceTextRange(range, rep);
 				}
 			});
@@ -7102,7 +8402,7 @@ var thematic_break_length_default = createRule("thematic-break-length", {
 		type: "layout",
 		docs: {
 			description: "enforce consistent length for thematic breaks (horizontal rules) in Markdown.",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -7118,8 +8418,7 @@ var thematic_break_length_default = createRule("thematic-break-length", {
 		messages: { unexpected: "Thematic break should be {{expected}} characters, but found {{actual}}." }
 	},
 	create(context) {
-		const option = context.options[0] || {};
-		const expectedLength = option.length ?? 3;
+		const expectedLength = (context.options[0] || {}).length ?? 3;
 		const sourceCode = context.sourceCode;
 		return { thematicBreak(node) {
 			const marker = getThematicBreakMarker(sourceCode, node);
@@ -7169,7 +8468,7 @@ var thematic_break_sequence_pattern_default = createRule("thematic-break-sequenc
 		type: "layout",
 		docs: {
 			description: "enforce consistent repeating patterns for thematic breaks (horizontal rules) in Markdown.",
-			categories: [],
+			categories: ["standard"],
 			listCategory: "Stylistic"
 		},
 		fixable: "code",
@@ -7199,8 +8498,7 @@ var thematic_break_sequence_pattern_default = createRule("thematic-break-sequenc
 		messages: { inconsistentPattern: "Thematic break does not match the preferred repeating pattern '{{pattern}}'." }
 	},
 	create(context) {
-		const option = context.options[0] || {};
-		const pattern = option.pattern ?? "-";
+		const pattern = (context.options[0] || {}).pattern ?? "-";
 		const sourceCode = context.sourceCode;
 		const patterns = {
 			"-": pattern.replaceAll(/[*_]/gu, "-"),
@@ -7242,8 +8540,13 @@ const rules$1 = [
 	heading_casing_default,
 	level1_heading_style_default,
 	level2_heading_style_default,
+	link_bracket_newline_default,
+	link_bracket_spacing_default,
+	link_destination_style_default,
+	link_title_style_default,
 	list_marker_alignment_default,
 	no_laziness_blockquotes_default,
+	no_multi_spaces_default,
 	no_multiple_empty_lines_default,
 	no_text_backslash_linebreak_default,
 	no_trailing_spaces_default,
@@ -7269,6 +8572,37 @@ const rules$1 = [
 //#region src/configs/recommended.ts
 var recommended_exports = {};
 __export(recommended_exports, {
+	files: () => files$1,
+	language: () => language$1,
+	languageOptions: () => languageOptions$1,
+	name: () => name$2,
+	plugins: () => plugins$1,
+	rules: () => rules$3
+});
+const name$2 = "markdown-preferences/recommended";
+const files$1 = ["*.md", "**/*.md"];
+const language$1 = "markdown/gfm";
+const languageOptions$1 = { frontmatter: "yaml" };
+const plugins$1 = {
+	markdown,
+	get "markdown-preferences"() {
+		return src_default;
+	}
+};
+const rules$3 = {
+	"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",
+	"markdown-preferences/prefer-fenced-code-blocks": "error"
+};
+
+//#endregion
+//#region src/configs/standard.ts
+var standard_exports = {};
+__export(standard_exports, {
 	files: () => files,
 	language: () => language,
 	languageOptions: () => languageOptions,
@@ -7287,14 +8621,38 @@ const plugins = {
 	}
 };
 const rules$2 = {
+	"markdown-preferences/atx-heading-closing-sequence-length": "error",
+	"markdown-preferences/atx-heading-closing-sequence": "error",
 	"markdown-preferences/blockquote-marker-alignment": "error",
+	"markdown-preferences/bullet-list-marker-style": "error",
+	"markdown-preferences/code-fence-length": "error",
+	"markdown-preferences/code-fence-style": "error",
+	"markdown-preferences/emphasis-delimiters-style": "error",
 	"markdown-preferences/hard-linebreak-style": "error",
+	"markdown-preferences/level1-heading-style": "error",
+	"markdown-preferences/level2-heading-style": "error",
+	"markdown-preferences/link-bracket-newline": "error",
+	"markdown-preferences/link-bracket-spacing": "error",
+	"markdown-preferences/link-destination-style": "error",
+	"markdown-preferences/link-title-style": "error",
 	"markdown-preferences/list-marker-alignment": "error",
 	"markdown-preferences/no-laziness-blockquotes": "error",
+	"markdown-preferences/no-multi-spaces": "error",
+	"markdown-preferences/no-multiple-empty-lines": "error",
 	"markdown-preferences/no-text-backslash-linebreak": "error",
+	"markdown-preferences/no-trailing-spaces": "error",
+	"markdown-preferences/ordered-list-marker-sequence": "error",
+	"markdown-preferences/ordered-list-marker-start": "error",
+	"markdown-preferences/ordered-list-marker-style": "error",
 	"markdown-preferences/padding-line-between-blocks": "error",
 	"markdown-preferences/prefer-autolinks": "error",
-	"markdown-preferences/prefer-fenced-code-blocks": "error"
+	"markdown-preferences/prefer-fenced-code-blocks": "error",
+	"markdown-preferences/setext-heading-underline-length": "error",
+	"markdown-preferences/sort-definitions": "error",
+	"markdown-preferences/strikethrough-delimiters-style": "error",
+	"markdown-preferences/thematic-break-character-style": "error",
+	"markdown-preferences/thematic-break-length": "error",
+	"markdown-preferences/thematic-break-sequence-pattern": "error"
 };
 
 //#endregion
@@ -7305,11 +8663,14 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.20.0";
+const version = "0.22.0";
 
 //#endregion
 //#region src/index.ts
-const configs = { recommended: recommended_exports };
+const configs = {
+	recommended: recommended_exports,
+	standard: standard_exports
+};
 const rules = rules$1.reduce((obj, r) => {
 	obj[r.meta.docs.ruleName] = r;
 	return obj;