eslint-plugin-md-style 0.1.0-beta.2 → 0.1.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm version](https://img.shields.io/npm/v/eslint-plugin-md-style)](https://www.npmjs.com/package/eslint-plugin-md-style)
 [![npm downloads](https://img.shields.io/npm/dm/eslint-plugin-md-style)](https://www.npmjs.com/package/eslint-plugin-md-style)
-[![codecov](https://codecov.io/gh/NoiseFan/eslint-plugin-md-style/graph/badge.svg)](https://codecov.io/gh/NoiseFan/eslint-plugin-md-style)
+[![codecov](https://codecov.io/gh/NoiseFan/eslint-plugin-md-style/graph/badge.svg?branch=main)](https://codecov.io/gh/NoiseFan/eslint-plugin-md-style?branch=main)
 
 ESLint plugin for enforcing style rules in Markdown-based documentation.
 
@@ -18,6 +18,13 @@ It currently ships:
 
 ## Quick Start
 
+### Version Requirements
+
+- `eslint`: `^9.30.0` or `^10.0.0`
+- `@antfu/eslint-config`: `^7.5.0` when used
+
+This plugin is designed for ESLint flat config. If you use `@antfu/eslint-config`, make sure its version satisfies the requirement above.
+
 Install the required packages:
 
 ```bash
@@ -61,9 +68,9 @@ export default [
     plugins: {
       'md-style': mdStyle,
     },
-    language: 'md-style/commonmark',
+    language: 'md-style/gfm',
     rules: {
-      'md-style/space-between-link': 'error',
+      'md-style/space-between-inline-element': 'error',
       'md-style/valid-heading-anchor': 'error',
     },
   },
@@ -113,14 +120,19 @@ export default antfu(
 
 | Rule | Included in `recommended` | Autofix |
 | --- | --- | --- |
-| `md-style/space-between-link` | ✅ | 🔧 |
+| `md-style/space-between-inline-element` | ✅ | 🔧 |
 | `md-style/valid-heading-anchor` | ✅ | 🔧 |
 
 ## Why `@eslint/markdown` Is Required
 
 This plugin builds on top of `@eslint/markdown` rather than replacing it.
 
-`@eslint/markdown` provides the Markdown processor and language support. This plugin re-exports those capabilities through its own plugin entry and adds documentation style rules on top, including the `md-style/commonmark` language used by the bundled configs.
+`@eslint/markdown` provides the Markdown processor and language support. This plugin re-exports those capabilities through its own plugin entry and adds documentation style rules on top, including the `md-style/gfm` language used by the bundled configs.
+
+## References
+
+- [W3C Manual of Style](https://www.w3.org/guide/manual-of-style/)
+- [中文排版要求](https://w3c.github.io/clreq/)
 
 ## License
 

package/dist/index.mjs

@@ -10,12 +10,57 @@ function createRule({ create, defaultOptions, meta }) {
 		}
 	};
 }
+
+//#endregion
+//#region src/utils/ast.ts
+/**
+* Checks whether an unknown value behaves like an mdast parent node.
+*
+* This intentionally accepts unknown values because ESLint's ancestor API does
+* not expose mdast-specific types.
+*/
+function hasChildren(node) {
+	return !!node && typeof node === "object" && "children" in node && Array.isArray(node.children);
+}
+function isTableCell(node) {
+	return node.type === "tableCell";
+}
+const INLINE_ELEMENT_TYPES = new Set([
+	"link",
+	"image",
+	"inlineCode",
+	"emphasis",
+	"strong"
+]);
+/**
+* Checks whether a phrasing node is one of the selected inline element targets.
+*/
+function isInlineElement(node) {
+	return !!node && INLINE_ELEMENT_TYPES.has(node.type);
+}
+/**
+* Checks whether the current inline element is nested inside another selected inline element.
+*/
+function isNestedInlineElement(nodeContext) {
+	const { parent } = nodeContext;
+	return isInlineElement(parent);
+}
+/**
+* Extracts the plain-text value of a phrasing node.
+* If the node does not expose `value`, recursively concatenates the text from its children.
+*/
+function getNodeValue(node) {
+	if (!node) return;
+	if ("value" in node) return node.value;
+	if (hasChildren(node)) return node.children.map(getNodeValue).join("") || void 0;
+}
 /**
 * Gets the start and end offsets for a node.
 */
 function getNodePosition(node) {
 	const start = node.position?.start.offset;
 	const end = node.position?.end.offset;
+	/* v8 ignore if -- @preserve */
 	if (start == null || end == null) return {
 		position: false,
 		start: 0,
@@ -27,18 +72,6 @@ function getNodePosition(node) {
 		end
 	};
 }
-
-//#endregion
-//#region src/utils/ast.ts
-/**
-* Checks whether an unknown value behaves like an mdast parent node.
-*
-* This intentionally accepts unknown values because ESLint's ancestor API does
-* not expose mdast-specific types.
-*/
-function hasChildren(node) {
-	return !!node && typeof node === "object" && "children" in node && Array.isArray(node.children);
-}
 function getNodeContext(context, node) {
 	const parent = context.sourceCode.getAncestors(node).at(-1);
 	if (!hasChildren(parent)) return {
@@ -47,6 +80,7 @@ function getNodeContext(context, node) {
 		current: node
 	};
 	const currentIndex = parent.children.findIndex((child) => child === node);
+	/* v8 ignore if -- @preserve */
 	if (currentIndex === -1) return {
 		parent,
 		prev: void 0,
@@ -60,9 +94,17 @@ function getNodeContext(context, node) {
 		current: node
 	};
 }
+/**
+* Gets the character adjacent to the start or end of a string.
+*/
+function getAdjacentChar(str, position) {
+	if (!str) return void 0;
+	str = str.trim();
+	return position === "head" ? str[0] : str[str.length - 1];
+}
 
 //#endregion
-//#region src/utils/rules/anchor.ts
+//#region src/utils/anchor.ts
 /**
 * Match the trailing anchor-like fragment from a heading string.
 * @example `中文标题 {#Chinese-Title}` -> `{#Chinese-Title}`
@@ -128,16 +170,7 @@ function calcAnchorPositionCompensate(content) {
 }
 
 //#endregion
-//#region src/utils/rules/link.ts
-const LINK_SPACE_MESSAGE_IDS = {
-	missingSpaceBeforeLink: "missingSpaceBeforeLink",
-	missingSpaceAfterLink: "missingSpaceAfterLink",
-	multipleSpacesBeforeLink: "multipleSpacesBeforeLink",
-	multipleSpacesAfterLink: "multipleSpacesAfterLink",
-	multipleSpacesAfterPunctuation: "multipleSpacesAfterPunctuation",
-	unexpectedSpaceBeforeLink: "unexpectedSpaceBeforeLink",
-	unexpectedSpaceAfterLink: "unexpectedSpaceAfterLink"
-};
+//#region src/utils/punctuation.ts
 const OPENING_PAIRED_PUNCTUATION = new Set([
 	"(",
 	"[",
@@ -149,6 +182,23 @@ const OPENING_PAIRED_PUNCTUATION = new Set([
 	"“",
 	"‘"
 ]);
+const CLOSING_PAIRED_PUNCTUATION = new Set([
+	")",
+	"]",
+	"}",
+	">",
+	"）",
+	"】",
+	"》",
+	"”",
+	"’"
+]);
+/**
+* Checks whether the character is a slash used as a path-like separator.
+*/
+function isSlashPunctuation(str) {
+	return str === "/";
+}
 /**
 * Checks whether the character is fullwidth punctuation.
 * @example `。` -> true
@@ -168,20 +218,6 @@ function isDashPunctuation(str) {
 	if (!str || str.length !== 1) return false;
 	return DASH_PUNCTUATION_RE.test(str);
 }
-/**
-* Checks whether adjacent text is a custom container marker on the next line.
-*
-* @deprecated Temporary workaround to prevent space-between-link from reporting
-* false positives on custom containers. Remove this and handle the case in a
-* dedicated custom container rule when one exists.
-* @see https://vitepress.dev/guide/markdown#custom-containers
-* @example `\n:::` -> true
-* @example `\n::::` -> true
-* @example `:::` -> false
-*/
-function isCustomContainerMarker(str) {
-	return /^[ \t]*\n[ \t]*:{3,}[ \t]*$/u.test(str || "");
-}
 const PUNCTUATION_RE = /^\p{P}$/u;
 /**
 * Checks whether the character is punctuation.
@@ -194,6 +230,20 @@ function isPunctuation(str) {
 	return PUNCTUATION_RE.test(str);
 }
 /**
+* Checks whether the start or end of a string is adjacent to punctuation.
+* @example `。 hello`, `head` -> true
+* @example `hello .`, `tail` -> true
+*/
+function hasPunctuation(str, position = "head") {
+	if (!str) return false;
+	str = str.trim();
+	if (position === "head") return isPunctuation(str[0]);
+	else return isPunctuation(str[str.length - 1]);
+}
+
+//#endregion
+//#region src/utils/space.ts
+/**
 * Gets the count and range of consecutive whitespace at the start or end of a string.
 * @example `  text`, `head` -> { count: 2, start: 0, end: 2 }
 * @example `text  `, `tail` -> { count: 2, start: 4, end: 6 }
@@ -224,34 +274,6 @@ function getWhiteSpace(str, position = "head") {
 	}
 }
 /**
-* Checks whether the start or end of a string is adjacent to punctuation.
-* @example `。 hello`, `head` -> true
-* @example `hello .`, `tail` -> true
-*/
-function hasPunctuation(str, position = "head") {
-	if (!str) return false;
-	str = str.trim();
-	if (position === "head") return isPunctuation(str[0]);
-	else return isPunctuation(str[str.length - 1]);
-}
-/**
-* Gets the character adjacent to the start or end of a string.
-*/
-function getAdjacentChar(str, position) {
-	if (!str) return void 0;
-	str = str.trim();
-	return position === "head" ? str[0] : str[str.length - 1];
-}
-/**
-* Extracts the plain-text value of a phrasing node.
-* If the node does not expose `value`, recursively concatenates the text from its children.
-*/
-function getNodeValue(node) {
-	if (!node) return;
-	if ("value" in node) return node.value;
-	if (hasChildren(node)) return node.children.map(getNodeValue).join("") || void 0;
-}
-/**
 * Gets whitespace and punctuation information for text adjacent to a link or inline code node.
 */
 function getSpaceContext(nodeContext) {
@@ -273,6 +295,32 @@ function getSpaceContext(nodeContext) {
 		}
 	};
 }
+
+//#endregion
+//#region src/utils/inline-element.ts
+const INLINE_SPACE_MESSAGE_IDS = {
+	missingSpaceBefore: "missingSpaceBefore",
+	missingSpaceAfter: "missingSpaceAfter",
+	multipleSpacesBefore: "multipleSpacesBefore",
+	multipleSpacesAfter: "multipleSpacesAfter",
+	multipleSpacesAfterPunctuation: "multipleSpacesAfterPunctuation",
+	unexpectedSpaceBefore: "unexpectedSpaceBefore",
+	unexpectedSpaceAfter: "unexpectedSpaceAfter"
+};
+/**
+* Checks whether adjacent text is a custom container marker on the next line.
+*
+* @deprecated Temporary workaround to prevent space-between-link from reporting
+* false positives on custom containers. Remove this and handle the case in a
+* dedicated custom container rule when one exists.
+* @see https://vitepress.dev/guide/markdown#custom-containers
+* @example `\n:::` -> true
+* @example `\n::::` -> true
+* @example `:::` -> false
+*/
+function isCustomContainerMarker(str) {
+	return /^[ \t]*\n[ \t]*:{3,}[ \t]*$/u.test(str || "");
+}
 /**
 * Validates whether a spacing run contains exactly one required space.
 */
@@ -281,121 +329,168 @@ function validateSingleRequiredSpace(count, missingSpaceMessageId, multipleSpace
 	if (count > 1) return multipleSpacesMessageId;
 }
 /**
-* Validates the spacing before a link when the previous character is punctuation.
+* Validates spacing before an inline node when the previous character is punctuation.
 */
-function validateSpaceBeforeLinkAfterPunctuation(context) {
-	if (OPENING_PAIRED_PUNCTUATION.has(getAdjacentChar(context.value, "tail") || "")) {
-		if (context.whiteSpace.count > 0) return LINK_SPACE_MESSAGE_IDS.unexpectedSpaceBeforeLink;
+function validateBeforePunctuation(context) {
+	const adjacentChar = getAdjacentChar(context.value, "tail");
+	if (OPENING_PAIRED_PUNCTUATION.has(adjacentChar || "") || isSlashPunctuation(adjacentChar)) {
+		if (context.whiteSpace.count > 0) return INLINE_SPACE_MESSAGE_IDS.unexpectedSpaceBefore;
 		return;
 	}
-	if (context.punctuationType === "half") return validateSingleRequiredSpace(context.whiteSpace.count, LINK_SPACE_MESSAGE_IDS.missingSpaceBeforeLink, LINK_SPACE_MESSAGE_IDS.multipleSpacesAfterPunctuation);
-	if (context.whiteSpace.count > 0) return LINK_SPACE_MESSAGE_IDS.unexpectedSpaceBeforeLink;
+	if (context.punctuationType === "half") return validateSingleRequiredSpace(context.whiteSpace.count, INLINE_SPACE_MESSAGE_IDS.missingSpaceBefore, INLINE_SPACE_MESSAGE_IDS.multipleSpacesAfterPunctuation);
+	if (context.whiteSpace.count > 0) return INLINE_SPACE_MESSAGE_IDS.unexpectedSpaceBefore;
 }
 /**
-* Validates the spacing between the previous node and the current link.
+* Validates the spacing between the previous node and the current inline node.
 */
-function validateSpaceBeforeLink(context) {
-	if (context.hasPunctuation) return validateSpaceBeforeLinkAfterPunctuation(context);
-	return validateSingleRequiredSpace(context.whiteSpace.count, LINK_SPACE_MESSAGE_IDS.missingSpaceBeforeLink, LINK_SPACE_MESSAGE_IDS.multipleSpacesBeforeLink);
+function validateSpaceBeforeNode(context) {
+	if (context.hasPunctuation) return validateBeforePunctuation(context);
+	return validateSingleRequiredSpace(context.whiteSpace.count, INLINE_SPACE_MESSAGE_IDS.missingSpaceBefore, INLINE_SPACE_MESSAGE_IDS.multipleSpacesBefore);
 }
 /**
-* Validates the spacing after a link when the next character is punctuation.
+* Validates spacing after an inline node when the next character is punctuation.
 */
-function validateSpaceAfterLinkBeforePunctuation(context) {
-	if (isDashPunctuation(getAdjacentChar(context.value, "head"))) return validateSingleRequiredSpace(context.whiteSpace.count, LINK_SPACE_MESSAGE_IDS.missingSpaceAfterLink, LINK_SPACE_MESSAGE_IDS.multipleSpacesAfterLink);
+function validateSpaceAfterPunctuation(context) {
+	const adjacentChar = getAdjacentChar(context.value, "head");
 	if (getLikeAnchor(context.value) || isCustomContainerMarker(context.value)) return;
-	if (context.whiteSpace.count > 0) return LINK_SPACE_MESSAGE_IDS.unexpectedSpaceAfterLink;
+	if (CLOSING_PAIRED_PUNCTUATION.has(adjacentChar || "") && context.whiteSpace.count > 0) return INLINE_SPACE_MESSAGE_IDS.unexpectedSpaceAfter;
+	if (context.punctuationType === "half" && OPENING_PAIRED_PUNCTUATION.has(adjacentChar || "") || isDashPunctuation(adjacentChar)) return validateSingleRequiredSpace(context.whiteSpace.count, INLINE_SPACE_MESSAGE_IDS.missingSpaceAfter, INLINE_SPACE_MESSAGE_IDS.multipleSpacesAfter);
+	if (context.whiteSpace.count > 0) return INLINE_SPACE_MESSAGE_IDS.unexpectedSpaceAfter;
+}
+/**
+* Validates the spacing between the current inline node and the next node.
+*/
+function validateSpaceAfterNode(context) {
+	if (context.hasPunctuation) return validateSpaceAfterPunctuation(context);
+	return validateSingleRequiredSpace(context.whiteSpace.count, INLINE_SPACE_MESSAGE_IDS.missingSpaceAfter, INLINE_SPACE_MESSAGE_IDS.multipleSpacesAfter);
 }
 /**
-* Validates the spacing between the current link and the next node.
+* Validates spacing around an inline element inside a table cell.
+* Table cells skip checks when the next sibling is another inline element.
 */
-function validateSpaceAfterLink(context) {
-	if (context.hasPunctuation) return validateSpaceAfterLinkBeforePunctuation(context);
-	return validateSingleRequiredSpace(context.whiteSpace.count, LINK_SPACE_MESSAGE_IDS.missingSpaceAfterLink, LINK_SPACE_MESSAGE_IDS.multipleSpacesAfterLink);
+function validateTableCellSpace(nodeContext) {
+	const { prev, next } = getSpaceContext(nodeContext);
+	if (prev && prev.value) {
+		const beforeIssue = validateSpaceBeforeNode(prev);
+		if (beforeIssue) return beforeIssue;
+	}
+	if (!next || isInlineElement(nodeContext.next) || !next.value) return;
+	return validateSpaceAfterNode(next);
+}
+/**
+* Validates spacing around an inline element in the default text flow.
+*/
+function validateDefaultSpace(nodeContext) {
+	const { prev, next } = getSpaceContext(nodeContext);
+	if (prev && nodeContext.prev) {
+		const beforeIssue = validateSpaceBeforeNode(prev);
+		if (beforeIssue) return beforeIssue;
+	}
+	if (!next || isInlineElement(nodeContext.next) || !nodeContext.next) return;
+	return validateSpaceAfterNode(next);
 }
 /**
-* Validates whether the spacing around a link node follows the typography rules.
-* - Regular text and links should be separated by a single space.
-* - Fullwidth punctuation usually touches the link without spaces.
-* - Halfwidth punctuation, hyphens, and similar cases are handled by dedicated rules.
+* Validates spacing around an inline element by delegating to the appropriate strategy
+* for table cells or the default text flow.
+* - Regular text and selected inline elements should be separated by one space.
+* - Fullwidth punctuation and paired punctuation usually touch inline elements without spaces.
+* - Adjacent selected inline elements are handled by the following element to avoid duplicate fixes.
 */
 function validateSpace(nodeContext) {
-	const { prev, next } = nodeContext;
-	const spaceContext = getSpaceContext(nodeContext);
-	if (!prev || !spaceContext.prev) return;
-	const beforeLinkIssue = validateSpaceBeforeLink(spaceContext.prev);
-	if (beforeLinkIssue) return beforeLinkIssue;
-	if (!next || !spaceContext.next) return;
-	return validateSpaceAfterLink(spaceContext.next);
+	const { parent } = nodeContext;
+	if (parent && isTableCell(parent)) return validateTableCellSpace(nodeContext);
+	return validateDefaultSpace(nodeContext);
 }
 
 //#endregion
-//#region src/rules/space-between-link/index.ts
-const RULE_NAME$1 = "space-between-link";
-const BEFORE_LINK_MESSAGE_IDS = new Set([
-	LINK_SPACE_MESSAGE_IDS.missingSpaceBeforeLink,
-	LINK_SPACE_MESSAGE_IDS.multipleSpacesBeforeLink,
-	LINK_SPACE_MESSAGE_IDS.multipleSpacesAfterPunctuation,
-	LINK_SPACE_MESSAGE_IDS.unexpectedSpaceBeforeLink
+//#region src/rules/space-between-inline-element/index.ts
+const RULE_NAME$1 = "space-between-inline-element";
+const BEFORE_INLINE_ELEMENT_MESSAGE_IDS = new Set([
+	INLINE_SPACE_MESSAGE_IDS.missingSpaceBefore,
+	INLINE_SPACE_MESSAGE_IDS.multipleSpacesBefore,
+	INLINE_SPACE_MESSAGE_IDS.multipleSpacesAfterPunctuation,
+	INLINE_SPACE_MESSAGE_IDS.unexpectedSpaceBefore
 ]);
-var space_between_link_default = createRule({
+/**
+* Checks one selected inline element and reports the fix range around it.
+*/
+function checkInlineElement(context, node) {
+	const { position, start, end } = getNodePosition(node);
+	/* v8 ignore if -- @preserve */
+	if (!position) return;
+	const nodeContext = getNodeContext(context, node);
+	if (isNestedInlineElement(nodeContext)) return;
+	const spaceContext = getSpaceContext(nodeContext);
+	const messageId = validateSpace(nodeContext);
+	if (!messageId) return;
+	if (BEFORE_INLINE_ELEMENT_MESSAGE_IDS.has(messageId) && spaceContext.prev) {
+		const { count } = spaceContext.prev.whiteSpace;
+		const replaceText = messageId === INLINE_SPACE_MESSAGE_IDS.unexpectedSpaceBefore ? "" : " ";
+		context.report({
+			node,
+			messageId,
+			fix(fixer) {
+				return fixer.replaceTextRange([start - count, start], replaceText);
+			}
+		});
+		return;
+	}
+	if (spaceContext.next) {
+		const { count } = spaceContext.next.whiteSpace;
+		const replaceText = messageId === INLINE_SPACE_MESSAGE_IDS.unexpectedSpaceAfter ? "" : " ";
+		context.report({
+			node,
+			messageId,
+			fix(fixer) {
+				return fixer.replaceTextRange([end, end + count], replaceText);
+			}
+		});
+	}
+}
+var space_between_inline_element_default = createRule({
 	name: RULE_NAME$1,
 	meta: {
 		type: "layout",
-		docs: { description: "Enforce spacing around Markdown links: one space next to text, no spaces next to punctuation." },
+		docs: { description: "Enforce spacing around Markdown inline elements." },
 		messages: {
-			missingSpaceBeforeLink: "A space is required before the link.",
-			missingSpaceAfterLink: "A space is required after the link.",
-			multipleSpacesBeforeLink: "Use exactly one space before the link.",
-			multipleSpacesAfterLink: "Use exactly one space after the link.",
+			missingSpaceBefore: "A space is required before the inline element.",
+			missingSpaceAfter: "A space is required after the inline element.",
+			multipleSpacesBefore: "Use exactly one space before the inline element.",
+			multipleSpacesAfter: "Use exactly one space after the inline element.",
 			multipleSpacesAfterPunctuation: "Use one space after punctuation.",
-			unexpectedSpaceBeforeLink: "Do not add a space between punctuation and the link.",
-			unexpectedSpaceAfterLink: "Do not add a space between the link and punctuation."
+			unexpectedSpaceBefore: "Do not add a space between punctuation and the inline element.",
+			unexpectedSpaceAfter: "Do not add a space between the inline element and punctuation."
 		},
 		fixable: "whitespace",
 		schema: []
 	},
 	defaultOptions: [],
 	create(context) {
-		return { link(node) {
-			const { position, start, end } = getNodePosition(node);
-			if (!position) return;
-			const nodeContext = getNodeContext(context, node);
-			const spaceContext = getSpaceContext(nodeContext);
-			const messageId = validateSpace(nodeContext);
-			if (!messageId) return;
-			if (BEFORE_LINK_MESSAGE_IDS.has(messageId) && spaceContext.prev) {
-				const { count } = spaceContext.prev.whiteSpace;
-				const replaceText = messageId === LINK_SPACE_MESSAGE_IDS.unexpectedSpaceBeforeLink ? "" : " ";
-				context.report({
-					node,
-					messageId,
-					fix(fixer) {
-						return fixer.replaceTextRange([start - count, start], replaceText);
-					}
-				});
-				return;
-			}
-			if (spaceContext.next) {
-				const { count } = spaceContext.next.whiteSpace;
-				const replaceText = messageId === LINK_SPACE_MESSAGE_IDS.unexpectedSpaceAfterLink ? "" : " ";
-				context.report({
-					node,
-					messageId,
-					fix(fixer) {
-						return fixer.replaceTextRange([end, end + count], replaceText);
-					}
-				});
+		return {
+			link(node) {
+				checkInlineElement(context, node);
+			},
+			image(node) {
+				checkInlineElement(context, node);
+			},
+			inlineCode(node) {
+				checkInlineElement(context, node);
+			},
+			emphasis(node) {
+				checkInlineElement(context, node);
+			},
+			strong(node) {
+				checkInlineElement(context, node);
 			}
-		} };
+		};
 	}
 });
 
 //#endregion
 //#region src/utils/markdown.ts
-const language = new MarkdownLanguage({ mode: "commonmark" });
+const language = new MarkdownLanguage({ mode: "gfm" });
 /**
-* Parses Markdown with the same CommonMark language implementation used by the
+* Parses Markdown with the same GFM language implementation used by the
 * plugin tests and returns both the mdast tree and ESLint SourceCode wrapper.
 */
 function parseMarkdown(markdown$1) {
@@ -409,6 +504,7 @@ function parseMarkdown(markdown$1) {
 		...language.defaultLanguageOptions,
 		frontmatter: "yaml"
 	} });
+	/* v8 ignore if -- @preserve */
 	if (!parseResult.ok) throw new Error(parseResult.errors[0]?.message ?? "Failed to parse markdown.");
 	return {
 		ast: parseResult.ast,
@@ -417,7 +513,7 @@ function parseMarkdown(markdown$1) {
 }
 
 //#endregion
-//#region src/utils/rules/heading.ts
+//#region src/utils/heading.ts
 /**
 * Returns true when the Markdown document starts with YAML frontmatter.
 */
@@ -450,6 +546,7 @@ var valid_heading_anchor_default = createRule({
 	create(context) {
 		return { heading(node) {
 			const { position, start, end } = getNodePosition(node);
+			/* v8 ignore if -- @preserve */
 			if (!position) return;
 			const source = context.sourceCode.text.slice(start, end);
 			if (isStrictAnchor(source) || !hasChinese(source)) return;
@@ -481,7 +578,7 @@ var valid_heading_anchor_default = createRule({
 //#endregion
 //#region src/rules/index.ts
 const rules = {
-	"space-between-link": space_between_link_default,
+	"space-between-inline-element": space_between_inline_element_default,
 	"valid-heading-anchor": valid_heading_anchor_default
 };
 
@@ -490,10 +587,7 @@ const rules = {
 const plugin = {
 	rules,
 	processors: markdown.processors,
-	languages: {
-		commonmark: new MarkdownLanguage({ mode: "commonmark" }),
-		gfm: new MarkdownLanguage({ mode: "gfm" })
-	}
+	languages: { gfm: new MarkdownLanguage({ mode: "gfm" }) }
 };
 const allRuleEntries = Object.keys(rules).map((ruleName) => [`md-style/${ruleName}`, "error"]);
 const recommendedRules = Object.fromEntries(allRuleEntries);
@@ -503,14 +597,14 @@ const configs = {
 		name: "md-style/recommended",
 		files: ["**/*.md"],
 		plugins: { "md-style": plugin },
-		language: "md-style/commonmark",
+		language: "md-style/gfm",
 		rules: recommendedRules
 	},
 	all: {
 		name: "md-style/all",
 		files: ["**/*.md"],
 		plugins: { "md-style": plugin },
-		language: "md-style/commonmark",
+		language: "md-style/gfm",
 		rules: allRules
 	}
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-md-style",
   "type": "module",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0",
   "packageManager": "pnpm@10.21.0",
   "description": "ESLint plugin for enforcing style rules in Markdown-based documentation",
   "author": "noisefan <noisefan@163.com>",
@@ -43,8 +43,14 @@
     "prepare": "simple-git-hooks"
   },
   "peerDependencies": {
+    "@antfu/eslint-config": "^7.5.0",
     "@eslint/markdown": "^7.5.1",
-    "eslint": "^9.0.0 || ^10.0.0"
+    "eslint": "^9.30.0 || ^10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@antfu/eslint-config": {
+      "optional": true
+    }
   },
   "dependencies": {},
   "devDependencies": {