eslint-plugin-markdown-preferences 0.22.0 → 0.23.0

package/README.md

@@ -130,6 +130,8 @@ The rules with the following 💄 are included in the `standard` config.
 | [markdown-preferences/link-bracket-newline](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-bracket-newline.html) | enforce linebreaks after opening and before closing link brackets | 🔧 | 💄 |
 | [markdown-preferences/link-bracket-spacing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-bracket-spacing.html) | enforce consistent spacing inside link brackets | 🔧 | 💄 |
 | [markdown-preferences/link-destination-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-destination-style.html) | enforce a consistent style for link destinations | 🔧 | 💄 |
+| [markdown-preferences/link-paren-newline](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-paren-newline.html) | enforce linebreaks after opening and before closing link parentheses | 🔧 | 💄 |
+| [markdown-preferences/link-paren-spacing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-paren-spacing.html) | enforce consistent spacing inside link parentheses | 🔧 | 💄 |
 | [markdown-preferences/link-title-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-title-style.html) | enforce a consistent style for link titles | 🔧 | 💄 |
 | [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 |  | ⭐💄 |

package/lib/index.d.ts

@@ -95,6 +95,16 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-destination-style.html
    */
   'markdown-preferences/link-destination-style'?: Linter.RuleEntry<MarkdownPreferencesLinkDestinationStyle>;
+  /**
+   * enforce linebreaks after opening and before closing link parentheses
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-paren-newline.html
+   */
+  'markdown-preferences/link-paren-newline'?: Linter.RuleEntry<MarkdownPreferencesLinkParenNewline>;
+  /**
+   * enforce consistent spacing inside link parentheses
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-paren-spacing.html
+   */
+  'markdown-preferences/link-paren-spacing'?: Linter.RuleEntry<MarkdownPreferencesLinkParenSpacing>;
   /**
    * enforce a consistent style for link titles
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/link-title-style.html
@@ -297,6 +307,13 @@ type MarkdownPreferencesLinkDestinationStyle = [] | [{
   avoidEscape?: boolean;
   [k: string]: unknown | undefined;
 }];
+type MarkdownPreferencesLinkParenNewline = [] | [{
+  newline?: ("always" | "never" | "consistent");
+  multiline?: boolean;
+}];
+type MarkdownPreferencesLinkParenSpacing = [] | [{
+  space?: ("always" | "never");
+}];
 type MarkdownPreferencesLinkTitleStyle = [] | [{
   style?: ("double" | "single" | "parentheses");
   avoidEscape?: boolean;
@@ -425,7 +442,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.22.0";
+declare const version: "0.23.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -186,47 +186,48 @@ function parseATXHeading(sourceCode, node) {
 			}
 		}
 	};
-	const spaceAfterOpening = {
-		text: parsedOpening.rawAfter,
-		range: [openingSequence.range[1], openingSequence.range[1] + parsedOpening.rawAfter.length],
-		loc: {
-			start: openingSequence.loc.end,
-			end: {
-				line: openingSequence.loc.end.line,
-				column: openingSequence.loc.end.column + parsedOpening.rawAfter.length
-			}
-		}
+	const contentLocStart = {
+		line: openingSequence.loc.end.line,
+		column: openingSequence.loc.end.column + parsedOpening.after.length
 	};
 	const parsedClosing = parseATXHeadingClosingSequenceFromText(text);
 	if (parsedClosing == null) {
-		const textAfterOpening = sourceCode.text.slice(spaceAfterOpening.range[1], range[1]);
+		const textAfterOpening = sourceCode.text.slice(openingSequence.range[1] + parsedOpening.after.length, range[1]);
 		const contentText$1 = textAfterOpening.trimEnd();
+		const contentRange$1 = [openingSequence.range[1] + parsedOpening.after.length, openingSequence.range[1] + parsedOpening.after.length + contentText$1.length];
+		const contentLocEnd = {
+			line: loc.end.line,
+			column: loc.end.column - (textAfterOpening.length - contentText$1.length)
+		};
+		const after = contentText$1 === textAfterOpening ? null : {
+			text: textAfterOpening.slice(contentText$1.length),
+			range: [contentRange$1[1], range[1]],
+			loc: {
+				start: contentLocEnd,
+				end: loc.end
+			}
+		};
 		return {
-			openingSequence: {
-				...openingSequence,
-				raws: { spaceAfter: spaceAfterOpening }
-			},
+			openingSequence,
 			content: {
 				text: contentText$1,
-				range: [spaceAfterOpening.range[1], spaceAfterOpening.range[1] + contentText$1.length],
+				range: contentRange$1,
 				loc: {
-					start: spaceAfterOpening.loc.end,
-					end: {
-						line: loc.end.line,
-						column: loc.end.column - (textAfterOpening.length - contentText$1.length)
-					}
+					start: contentLocStart,
+					end: contentLocEnd
 				}
 			},
-			closingSequence: null
+			closingSequence: null,
+			after
 		};
 	}
 	const spaceAfterClosing = {
-		text: parsedClosing.rawAfter,
-		range: [range[1] - parsedClosing.rawAfter.length, range[1]],
+		text: parsedClosing.after,
+		range: [range[1] - parsedClosing.after.length, range[1]],
 		loc: {
 			start: {
 				line: loc.end.line,
-				column: loc.end.column - parsedClosing.rawAfter.length
+				column: loc.end.column - parsedClosing.after.length
 			},
 			end: loc.end
 		}
@@ -242,38 +243,23 @@ function parseATXHeading(sourceCode, node) {
 			end: spaceAfterClosing.loc.start
 		}
 	};
-	const spaceBeforeClosing = {
-		text: parsedClosing.rawBefore,
-		range: [closingSequence.range[0] - parsedClosing.rawBefore.length, closingSequence.range[0]],
-		loc: {
-			start: {
-				line: closingSequence.loc.start.line,
-				column: closingSequence.loc.start.column - parsedClosing.rawBefore.length
-			},
-			end: closingSequence.loc.start
-		}
-	};
-	const contentText = sourceCode.text.slice(spaceAfterOpening.range[1], spaceBeforeClosing.range[0]);
+	const contentRange = [openingSequence.range[1] + parsedOpening.after.length, closingSequence.range[0] - parsedClosing.before.length];
+	const contentText = sourceCode.text.slice(...contentRange);
 	return {
-		openingSequence: {
-			...openingSequence,
-			raws: { spaceAfter: spaceAfterOpening }
-		},
+		openingSequence,
 		content: {
 			text: contentText,
-			range: [spaceAfterOpening.range[1], spaceBeforeClosing.range[0]],
+			range: contentRange,
 			loc: {
-				start: spaceAfterOpening.loc.end,
-				end: spaceBeforeClosing.loc.start
+				start: contentLocStart,
+				end: {
+					line: closingSequence.loc.start.line,
+					column: closingSequence.loc.start.column - parsedClosing.before.length
+				}
 			}
 		},
-		closingSequence: {
-			...closingSequence,
-			raws: {
-				spaceBefore: spaceBeforeClosing,
-				spaceAfter: spaceAfterClosing
-			}
-		}
+		closingSequence,
+		after: spaceAfterClosing.range[0] < spaceAfterClosing.range[1] ? spaceAfterClosing : null
 	};
 }
 /**
@@ -287,7 +273,7 @@ function parseATXHeadingOpeningSequenceFromText(text) {
 	if (afterOffset === openingSequenceAfterOffset || afterOffset >= text.length) return null;
 	return {
 		openingSequence: text.slice(0, openingSequenceAfterOffset),
-		rawAfter: text.slice(openingSequenceAfterOffset, afterOffset)
+		after: text.slice(openingSequenceAfterOffset, afterOffset)
 	};
 	/**
 	* Skip whitespace characters at the start of the text.
@@ -310,9 +296,9 @@ function parseATXHeadingClosingSequenceFromText(text) {
 	const beforeOffset = skipEndWhitespace(closingSequenceBeforeOffset);
 	if (beforeOffset === closingSequenceBeforeOffset || beforeOffset < 0) return null;
 	return {
-		rawBefore: text.slice(beforeOffset + 1, closingSequenceBeforeOffset + 1),
+		before: text.slice(beforeOffset + 1, closingSequenceBeforeOffset + 1),
 		closingSequence: text.slice(closingSequenceBeforeOffset + 1, trimmedEndOffset),
-		rawAfter: text.slice(trimmedEndOffset)
+		after: text.slice(trimmedEndOffset)
 	};
 	/**
 	* Skip whitespace characters at the end of the text.
@@ -577,16 +563,16 @@ var atx_heading_closing_sequence_default = createRule("atx-heading-closing-seque
 				context.report({
 					node,
 					loc: {
-						start: parsed.closingSequence.raws.spaceBefore.loc.start,
+						start: parsed.content.loc.end,
 						end: parsed.closingSequence.loc.end
 					},
 					messageId: "forbidClosing",
 					*fix(fixer) {
-						const removeRange = [parsed.closingSequence.raws.spaceBefore.range[0], parsed.closingSequence.range[1]];
+						const removeRange = [parsed.content.range[1], parsed.closingSequence.range[1]];
 						const newHeadingText = sourceCode.text.slice(sourceCode.getRange(node)[0], removeRange[0]);
 						const newHeadingParsed = parseATXHeadingClosingSequenceFromText(newHeadingText);
 						if (newHeadingParsed) {
-							const escapeIndex = removeRange[0] - newHeadingParsed.rawAfter.length - 1;
+							const escapeIndex = removeRange[0] - newHeadingParsed.after.length - 1;
 							yield fixer.insertTextBeforeRange([escapeIndex, escapeIndex], "\\");
 						}
 						yield fixer.removeRange(removeRange);
@@ -4527,8 +4513,8 @@ var level1_heading_style_default = createRule("level1-heading-style", {
 					*fix(fixer) {
 						const parsed = parseATXHeading(sourceCode, node);
 						if (!parsed) return;
-						yield fixer.removeRange([parsed.openingSequence.range[0], parsed.openingSequence.raws.spaceAfter.range[1]]);
-						if (parsed.closingSequence) yield fixer.removeRange([parsed.closingSequence.raws.spaceBefore.range[0], parsed.closingSequence.raws.spaceAfter.range[1]]);
+						yield fixer.removeRange([parsed.openingSequence.range[0], parsed.content.range[0]]);
+						if (parsed.closingSequence) yield fixer.removeRange([parsed.content.range[1], parsed.after?.range[1] ?? parsed.closingSequence.range[1]]);
 						const lines = getParsedLines(sourceCode);
 						const underline = "=".repeat(Math.max(getTextWidth(parsed.content.text), 3));
 						const appendingText = `\n${lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1)}${underline}`;
@@ -4604,8 +4590,8 @@ var level2_heading_style_default = createRule("level2-heading-style", {
 					*fix(fixer) {
 						const parsed = parseATXHeading(sourceCode, node);
 						if (!parsed) return;
-						yield fixer.removeRange([parsed.openingSequence.range[0], parsed.openingSequence.raws.spaceAfter.range[1]]);
-						if (parsed.closingSequence) yield fixer.removeRange([parsed.closingSequence.raws.spaceBefore.range[0], parsed.closingSequence.raws.spaceAfter.range[1]]);
+						yield fixer.removeRange([parsed.openingSequence.range[0], parsed.content.range[0]]);
+						if (parsed.closingSequence) yield fixer.removeRange([parsed.content.range[1], parsed.after?.range[1] ?? parsed.closingSequence.range[1]]);
 						const lines = getParsedLines(sourceCode);
 						const underline = "-".repeat(Math.max(getTextWidth(parsed.content.text), 3));
 						const appendingText = `\n${lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1)}${underline}`;
@@ -4633,12 +4619,18 @@ function parseInlineLink(sourceCode, node) {
 	}
 	const parsed = parseInlineLinkDestAndTitleFromText(sourceCode.text.slice(textRange[1], nodeRange[1]));
 	if (!parsed) return null;
+	const openingParenRange = [textRange[1] + parsed.openingParen.range[0], textRange[1] + parsed.openingParen.range[1]];
 	const destinationRange = [textRange[1] + parsed.destination.range[0], textRange[1] + parsed.destination.range[1]];
+	const closingParenRange = [textRange[1] + parsed.closingParen.range[0], textRange[1] + parsed.closingParen.range[1]];
 	return {
 		text: {
 			range: textRange,
 			loc: getSourceLocationFromRange(sourceCode, node, textRange)
 		},
+		openingParen: {
+			range: openingParenRange,
+			loc: getSourceLocationFromRange(sourceCode, node, openingParenRange)
+		},
 		destination: {
 			type: parsed.destination.type,
 			text: parsed.destination.text,
@@ -4650,7 +4642,11 @@ function parseInlineLink(sourceCode, node) {
 			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
+		} : null,
+		closingParen: {
+			range: closingParenRange,
+			loc: getSourceLocationFromRange(sourceCode, node, closingParenRange)
+		}
 	};
 }
 /**
@@ -4685,12 +4681,15 @@ function parseInlineLinkDestAndTitleFromText(text) {
 	}
 	skipSpaces();
 	if (text[index] === ")") {
+		const closingParenStartIndex$1 = index;
 		index++;
 		skipSpaces();
 		if (index < text.length) return null;
 		return {
+			openingParen: { range: [0, 1] },
 			destination,
-			title: null
+			title: null,
+			closingParen: { range: [closingParenStartIndex$1, index] }
 		};
 	}
 	if (text.length <= index) return null;
@@ -4711,12 +4710,15 @@ function parseInlineLinkDestAndTitleFromText(text) {
 	} else return null;
 	skipSpaces();
 	if (text[index] !== ")") return null;
+	const closingParenStartIndex = index;
 	index++;
 	skipSpaces();
 	if (index < text.length) return null;
 	return {
+		openingParen: { range: [0, 1] },
 		destination,
-		title
+		title,
+		closingParen: { range: [closingParenStartIndex, index] }
 	};
 	/**
 	* Skip spaces
@@ -4808,12 +4810,18 @@ function parseImage(sourceCode, node) {
 	if (!parsed) return null;
 	const nodeRange = sourceCode.getRange(node);
 	const textRange = [nodeRange[0] + parsed.text.range[0], nodeRange[0] + parsed.text.range[1]];
+	const openingParenRange = [nodeRange[0] + parsed.openingParen.range[0], nodeRange[0] + parsed.openingParen.range[1]];
 	const destinationRange = [nodeRange[0] + parsed.destination.range[0], nodeRange[0] + parsed.destination.range[1]];
+	const closingParenRange = [nodeRange[0] + parsed.closingParen.range[0], nodeRange[0] + parsed.closingParen.range[1]];
 	return {
 		text: {
 			range: textRange,
 			loc: getSourceLocationFromRange(sourceCode, node, textRange)
 		},
+		openingParen: {
+			range: openingParenRange,
+			loc: getSourceLocationFromRange(sourceCode, node, openingParenRange)
+		},
 		destination: {
 			type: parsed.destination.type,
 			text: parsed.destination.text,
@@ -4825,7 +4833,11 @@ function parseImage(sourceCode, node) {
 			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
+		} : null,
+		closingParen: {
+			range: closingParenRange,
+			loc: getSourceLocationFromRange(sourceCode, node, closingParenRange)
+		}
 	};
 }
 /**
@@ -4836,6 +4848,7 @@ function parseImageFromText(text) {
 	let index = text.length - 1;
 	skipSpaces();
 	if (text[index] !== ")") return null;
+	const closingParenStartIndex = index;
 	index--;
 	skipSpaces();
 	let title = null;
@@ -4880,12 +4893,16 @@ function parseImageFromText(text) {
 	}
 	skipSpaces();
 	if (text[index] !== "(") return null;
+	const openingParenStartIndex = index;
 	index--;
 	if (text[index] !== "]") return null;
+	const textRange = [1, index + 1];
 	return {
-		text: { range: [1, index + 1] },
+		openingParen: { range: [openingParenStartIndex, openingParenStartIndex + 1] },
+		text: { range: textRange },
 		destination,
-		title
+		title,
+		closingParen: { range: [closingParenStartIndex, closingParenStartIndex + 1] }
 	};
 	/**
 	* Skip spaces
@@ -5624,6 +5641,265 @@ function hasLoneLastBackslash(text) {
 	return escapeText.length % 2 === 1;
 }
 
+//#endregion
+//#region src/rules/link-paren-newline.ts
+var link_paren_newline_default = createRule("link-paren-newline", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce linebreaks after opening and before closing link parentheses",
+			categories: ["standard"],
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				newline: { enum: [
+					"always",
+					"never",
+					"consistent"
+				] },
+				multiline: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			expectedNewlineAfterOpeningParen: "Expected a linebreak after this opening parenthesis.",
+			unexpectedNewlineAfterOpeningParen: "Unexpected linebreak after this opening parenthesis.",
+			expectedNewlineBeforeClosingParen: "Expected a linebreak before this closing parenthesis.",
+			unexpectedNewlineBeforeClosingParen: "Unexpected linebreak before this closing parenthesis."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const optionProvider = parseOptions$3(context.options[0]);
+		/**
+		* Parse the options.
+		*/
+		function parseOptions$3(option) {
+			const newline = option?.newline ?? "never";
+			const multiline = option?.multiline ?? false;
+			return (openingParenIndex, closingParenIndex) => {
+				if (multiline) {
+					if (sourceCode.text.slice(openingParenIndex + 1, closingParenIndex).trim().includes("\n")) return "always";
+				}
+				return newline;
+			};
+		}
+		/**
+		* Verify the newline around the parentheses.
+		*/
+		function verifyNewlineAroundParens(node, openingParenIndex, closingParenIndex) {
+			const newline = optionProvider(openingParenIndex, closingParenIndex);
+			const spaceAfterOpeningParen = getSpaceAfterOpeningParen(openingParenIndex);
+			verifyNewlineAfterOpeningParen(node, spaceAfterOpeningParen, openingParenIndex, newline);
+			const newlineOptionBeforeClosingParen = newline === "consistent" ? getSpaceAfterOpeningParen(openingParenIndex).includes("\n") ? "always" : "never" : newline;
+			verifyNewlineBeforeClosingParen(node, getSpaceBeforeClosingParen(closingParenIndex), openingParenIndex, closingParenIndex, newlineOptionBeforeClosingParen);
+		}
+		/**
+		* Verify the newline after the opening parenthesis and before the closing parenthesis.
+		*/
+		function verifyNewlineAfterOpeningParen(node, spaceAfterOpeningParen, openingParenIndex, newline) {
+			if (newline === "always") {
+				if (spaceAfterOpeningParen.includes("\n")) return;
+				const loc = getSourceLocationFromRange(sourceCode, node, [openingParenIndex, openingParenIndex + 1]);
+				context.report({
+					node,
+					loc,
+					messageId: "expectedNewlineAfterOpeningParen",
+					fix: (fixer) => fixer.insertTextAfterRange([openingParenIndex, openingParenIndex + 1], `\n${" ".repeat(loc.start.column)}${spaceAfterOpeningParen}`)
+				});
+			} else if (newline === "never") {
+				if (!spaceAfterOpeningParen.includes("\n")) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [openingParenIndex + 1, openingParenIndex + 1 + spaceAfterOpeningParen.length]),
+					messageId: "unexpectedNewlineAfterOpeningParen",
+					fix: (fixer) => fixer.replaceTextRange([openingParenIndex + 1, openingParenIndex + 1 + spaceAfterOpeningParen.length], " ")
+				});
+			}
+		}
+		/**
+		* Verify the newline before the closing parenthesis.
+		*/
+		function verifyNewlineBeforeClosingParen(node, spaceBeforeClosingParen, openingParenIndex, closingParenIndex, newline) {
+			if (openingParenIndex + 1 === closingParenIndex - spaceBeforeClosingParen.length) return;
+			if (newline === "always") {
+				if (spaceBeforeClosingParen.includes("\n")) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [closingParenIndex, closingParenIndex + 1]),
+					messageId: "expectedNewlineBeforeClosingParen",
+					fix: (fixer) => {
+						const openingParenLoc = getSourceLocationFromRange(sourceCode, node, [openingParenIndex, openingParenIndex + 1]);
+						return fixer.insertTextBeforeRange([closingParenIndex, closingParenIndex + 1], `\n${" ".repeat(openingParenLoc.start.column)}`);
+					}
+				});
+			} else if (newline === "never") {
+				if (!spaceBeforeClosingParen.includes("\n")) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [closingParenIndex - spaceBeforeClosingParen.length, closingParenIndex]),
+					messageId: "unexpectedNewlineBeforeClosingParen",
+					fix: (fixer) => fixer.replaceTextRange([closingParenIndex - spaceBeforeClosingParen.length, closingParenIndex], " ")
+				});
+			}
+		}
+		return {
+			link(node) {
+				if (getLinkKind(sourceCode, node) !== "inline") return;
+				const parsed = parseInlineLink(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundParens(node, parsed.openingParen.range[0], parsed.closingParen.range[0]);
+			},
+			image(node) {
+				const parsed = parseImage(sourceCode, node);
+				if (!parsed) return;
+				verifyNewlineAroundParens(node, parsed.openingParen.range[0], parsed.closingParen.range[0]);
+			}
+		};
+		/**
+		* Get the spaces after the opening parenthesis.
+		*/
+		function getSpaceAfterOpeningParen(openingParenIndex) {
+			for (let i = openingParenIndex + 1; i < sourceCode.text.length; i++) {
+				const char = sourceCode.text[i];
+				if (isWhitespace(char)) continue;
+				return sourceCode.text.slice(openingParenIndex + 1, i);
+			}
+			return sourceCode.text.slice(openingParenIndex + 1);
+		}
+		/**
+		* Get the spaces before the closing parenthesis.
+		*/
+		function getSpaceBeforeClosingParen(closingParenIndex) {
+			for (let i = closingParenIndex - 1; i >= 0; i--) {
+				const char = sourceCode.text[i];
+				if (isWhitespace(char)) continue;
+				return sourceCode.text.slice(i + 1, closingParenIndex);
+			}
+			return sourceCode.text.slice(0, closingParenIndex);
+		}
+	}
+});
+
+//#endregion
+//#region src/rules/link-paren-spacing.ts
+var link_paren_spacing_default = createRule("link-paren-spacing", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent spacing inside link parentheses",
+			categories: ["standard"],
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { space: { enum: ["always", "never"] } },
+			additionalProperties: false
+		}],
+		messages: {
+			unexpectedSpaceAfterOpeningParen: "Unexpected space after opening parenthesis.",
+			expectedSpaceAfterOpeningParen: "Expected space after opening parenthesis.",
+			unexpectedSpaceBeforeClosingParen: "Unexpected space before closing parenthesis.",
+			expectedSpaceBeforeClosingParen: "Expected space before closing parenthesis."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const spaceOption = context.options[0]?.space || "never";
+		/**
+		* Verify the space after the opening paren and before the closing paren.
+		*/
+		function verifySpaceAfterOpeningParen(node, openingParen) {
+			const space = getSpaceAfterOpeningParen(openingParen);
+			if (space.includes("\n")) return;
+			if (spaceOption === "always") {
+				if (space.length > 0) return;
+				context.report({
+					node,
+					loc: openingParen.loc,
+					messageId: "expectedSpaceAfterOpeningParen",
+					fix: (fixer) => fixer.insertTextAfterRange(openingParen.range, " ")
+				});
+			} else if (spaceOption === "never") {
+				if (space.length === 0) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [openingParen.range[1], openingParen.range[1] + space.length]),
+					messageId: "unexpectedSpaceAfterOpeningParen",
+					fix: (fixer) => fixer.removeRange([openingParen.range[1], openingParen.range[1] + space.length])
+				});
+			}
+		}
+		/**
+		* Verify the space before the closing paren.
+		*/
+		function verifySpaceBeforeClosingParen(node, closingParen) {
+			const space = getSpaceBeforeClosingParen(closingParen);
+			if (space.includes("\n")) return;
+			if (spaceOption === "always") {
+				if (space.length > 0) return;
+				context.report({
+					node,
+					loc: closingParen.loc,
+					messageId: "expectedSpaceBeforeClosingParen",
+					fix: (fixer) => fixer.insertTextBeforeRange(closingParen.range, " ")
+				});
+			} else if (spaceOption === "never") {
+				if (space.length === 0) return;
+				context.report({
+					node,
+					loc: getSourceLocationFromRange(sourceCode, node, [closingParen.range[0] - space.length, closingParen.range[0]]),
+					messageId: "unexpectedSpaceBeforeClosingParen",
+					fix: (fixer) => fixer.removeRange([closingParen.range[0] - space.length, closingParen.range[0]])
+				});
+			}
+		}
+		return {
+			link(node) {
+				if (getLinkKind(sourceCode, node) !== "inline") return;
+				const parsed = parseInlineLink(sourceCode, node);
+				if (!parsed) return;
+				verifySpaceAfterOpeningParen(node, parsed.openingParen);
+				verifySpaceBeforeClosingParen(node, parsed.closingParen);
+			},
+			image(node) {
+				const parsed = parseImage(sourceCode, node);
+				if (!parsed) return;
+				verifySpaceAfterOpeningParen(node, parsed.openingParen);
+				verifySpaceBeforeClosingParen(node, parsed.closingParen);
+			}
+		};
+		/**
+		* Get the spaces after the opening paren.
+		*/
+		function getSpaceAfterOpeningParen(openingParen) {
+			for (let i = openingParen.range[1]; i < sourceCode.text.length; i++) {
+				const char = sourceCode.text[i];
+				if (isWhitespace(char)) continue;
+				return sourceCode.text.slice(openingParen.range[1], i);
+			}
+			return sourceCode.text.slice(openingParen.range[1]);
+		}
+		/**
+		* Get the spaces before the closing paren.
+		*/
+		function getSpaceBeforeClosingParen(closingParen) {
+			for (let i = closingParen.range[0] - 1; i >= 0; i--) {
+				const char = sourceCode.text[i];
+				if (isWhitespace(char)) continue;
+				return sourceCode.text.slice(i + 1, closingParen.range[0]);
+			}
+			return sourceCode.text.slice(0, closingParen.range[0]);
+		}
+	}
+});
+
 //#endregion
 //#region src/rules/link-title-style.ts
 const STYLES = {
@@ -8543,6 +8819,8 @@ const rules$1 = [
 	link_bracket_newline_default,
 	link_bracket_spacing_default,
 	link_destination_style_default,
+	link_paren_newline_default,
+	link_paren_spacing_default,
 	link_title_style_default,
 	list_marker_alignment_default,
 	no_laziness_blockquotes_default,
@@ -8634,6 +8912,8 @@ const rules$2 = {
 	"markdown-preferences/link-bracket-newline": "error",
 	"markdown-preferences/link-bracket-spacing": "error",
 	"markdown-preferences/link-destination-style": "error",
+	"markdown-preferences/link-paren-newline": "error",
+	"markdown-preferences/link-paren-spacing": "error",
 	"markdown-preferences/link-title-style": "error",
 	"markdown-preferences/list-marker-alignment": "error",
 	"markdown-preferences/no-laziness-blockquotes": "error",
@@ -8663,7 +8943,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.22.0";
+const version = "0.23.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {
@@ -94,7 +94,7 @@
     "eslint-plugin-json-schema-validator": "^5.3.1",
     "eslint-plugin-jsonc": "^2.19.1",
     "eslint-plugin-markdown": "^5.1.0",
-    "eslint-plugin-markdown-links": "^0.4.0",
+    "eslint-plugin-markdown-links": "^0.5.0",
     "eslint-plugin-n": "^17.16.2",
     "eslint-plugin-node-dependencies": "^1.0.0",
     "eslint-plugin-prettier": "^5.2.3",
@@ -115,7 +115,7 @@
     "stylelint-config-recommended-vue": "^1.6.0",
     "stylelint-config-standard": "^39.0.0",
     "stylelint-config-standard-vue": "^1.0.0",
-    "tsdown": "^0.14.0",
+    "tsdown": "^0.15.0",
     "tsx": "^4.19.3",
     "twoslash-eslint": "^0.3.1",
     "type-fest": "^4.37.0",