eslint-plugin-md-style 0.1.0-beta.2 → 0.2.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-around-inline-element': 'error',
       'md-style/valid-heading-anchor': 'error',
     },
   },
@@ -113,14 +120,21 @@ export default antfu(
 
 | Rule | Included in `recommended` | Autofix |
 | --- | --- | --- |
-| `md-style/space-between-link` | ✅ | 🔧 |
+| `md-style/space-around-inline-element` | ✅ | 🔧 |
+| `md-style/space-around-number` |  | 🔧 |
+| `md-style/space-around-word` |  | 🔧 |
 | `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("");
+}
 /**
 * 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,29 @@ function getNodeContext(context, node) {
 		current: node
 	};
 }
+/**
+* Returns the current node and adjacent siblings from a known children array.
+* Useful when iterating a tokenized child list directly without an ESLint ancestor context.
+*/
+function getNodeContextByParent(childrenNodes, currentIndex) {
+	return {
+		prev: childrenNodes[currentIndex - 1],
+		current: childrenNodes[currentIndex],
+		next: childrenNodes[currentIndex + 1]
+	};
+}
+/**
+* Gets the first or last visible character of a string after trimming
+* surrounding whitespace.
+*/
+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}`
@@ -101,7 +155,7 @@ function isStrictAnchor(str) {
 * Check whether the string contains CJK Han characters.
 */
 function hasChinese(str) {
-	return /[\u4E00-\u9FA5]/.test(str);
+	return /\p{Script=Han}/u.test(str);
 }
 /**
 * Normalize raw anchor text into the strict anchor format content.
@@ -111,7 +165,7 @@ function hasChinese(str) {
 * - trim leading/trailing `-`
 */
 function normalizeAnchor(anchor) {
-	return anchor.toLowerCase().replace(/[\s.]/g, "-").replace(/[^a-z0-9_-]/g, "").replace(/^-+|-+$/g, "");
+	return anchor.toLowerCase().replace(/[\s.]+/g, "-").replace(/[^a-z0-9_-]/g, "").replace(/^-+|-+$/g, "");
 }
 /**
 * Count wrapper characters contributed by the trailing like-anchor fragment.
@@ -128,16 +182,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 +194,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
@@ -158,6 +220,16 @@ function isFullwidthPunctuation(str) {
 	if (!str || str.length !== 1) return false;
 	return /^[\u3001-\u303F\uFE10-\uFE1F\uFE30-\uFE4F\uFF01-\uFF0F\uFF1A-\uFF20\uFF3B-\uFF40\uFF5B-\uFF65“”‘’…]$/u.test(str);
 }
+const HALFWIDTH_PUNCTUATION_RE = /^\p{P}$/u;
+/**
+* Checks whether the character is halfwidth punctuation.
+* @example `,` -> true
+* @example `，` -> false
+*/
+function isHalfwidthPunctuation(str) {
+	if (!str || str.length !== 1) return false;
+	return str.charCodeAt(0) <= 126 && HALFWIDTH_PUNCTUATION_RE.test(str);
+}
 const DASH_PUNCTUATION_RE = /^[-\u2013\u2014\u2212]$/u;
 /**
 * Checks whether the character is hyphen-like punctuation.
@@ -168,20 +240,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 +252,28 @@ 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
+const SPACE_MESSAGE_IDS = {
+	missingSpaceBefore: "missingSpaceBefore",
+	missingSpaceAfter: "missingSpaceAfter",
+	missingSpacesAround: "missingSpacesAround",
+	unexpectedSpaceBefore: "unexpectedSpaceBefore",
+	unexpectedSpaceAfter: "unexpectedSpaceAfter",
+	unexpectedSpaceAround: "unexpectedSpaceAround"
+};
+/**
 * 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 +304,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 +325,23 @@ function getSpaceContext(nodeContext) {
 		}
 	};
 }
+
+//#endregion
+//#region src/utils/inline-element.ts
+/**
+* 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 +350,512 @@ 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 MESSAGE_IDS$1.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, MESSAGE_IDS$1.missingSpaceBefore, MESSAGE_IDS$1.multipleSpacesAfterPunctuation);
+	if (context.whiteSpace.count > 0) return MESSAGE_IDS$1.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, MESSAGE_IDS$1.missingSpaceBefore, MESSAGE_IDS$1.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 MESSAGE_IDS$1.unexpectedSpaceAfter;
+	if (context.punctuationType === "half" && OPENING_PAIRED_PUNCTUATION.has(adjacentChar || "") || isDashPunctuation(adjacentChar)) return validateSingleRequiredSpace(context.whiteSpace.count, MESSAGE_IDS$1.missingSpaceAfter, MESSAGE_IDS$1.multipleSpacesAfter);
+	if (context.whiteSpace.count > 0) return MESSAGE_IDS$1.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, MESSAGE_IDS$1.missingSpaceAfter, MESSAGE_IDS$1.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 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 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 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-around-inline-element/index.ts
+const RULE_NAME$3 = "space-around-inline-element";
+const MESSAGE_IDS$1 = {
+	missingSpaceBefore: "missingSpaceBefore",
+	missingSpaceAfter: "missingSpaceAfter",
+	multipleSpacesBefore: "multipleSpacesBefore",
+	multipleSpacesAfter: "multipleSpacesAfter",
+	multipleSpacesAfterPunctuation: "multipleSpacesAfterPunctuation",
+	unexpectedSpaceBefore: "unexpectedSpaceBefore",
+	unexpectedSpaceAfter: "unexpectedSpaceAfter"
+};
+const BEFORE_INLINE_ELEMENT_MESSAGE_IDS = new Set([
+	MESSAGE_IDS$1.missingSpaceBefore,
+	MESSAGE_IDS$1.multipleSpacesBefore,
+	MESSAGE_IDS$1.multipleSpacesAfterPunctuation,
+	MESSAGE_IDS$1.unexpectedSpaceBefore
 ]);
-var space_between_link_default = createRule({
-	name: RULE_NAME$1,
+var space_around_inline_element_default = createRule({
+	name: RULE_NAME$3,
 	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;
+		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);
 			}
-			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);
-					}
-				});
+		};
+	}
+});
+/**
+* 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 === MESSAGE_IDS$1.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 === MESSAGE_IDS$1.unexpectedSpaceAfter ? "" : " ";
+		context.report({
+			node,
+			messageId,
+			fix(fixer) {
+				return fixer.replaceTextRange([end, end + count], replaceText);
 			}
+		});
+	}
+}
+
+//#endregion
+//#region src/utils/text/tokenizer.ts
+const TEXT_TYPE = {
+	"cjk": "cjk",
+	"latin": "latin",
+	"number": "number",
+	"space": "space",
+	"newline": "newline",
+	"fullwidth-punctuation": "fullwidth-punctuation",
+	"halfwidth-punctuation": "halfwidth-punctuation",
+	"dash": "dash",
+	"symbol": "symbol",
+	"emoji": "emoji",
+	"invisible": "invisible",
+	"other": "other"
+};
+const CJK_RE = /^\p{Script=Han}$|^\p{Script=Hiragana}$|^\p{Script=Katakana}$|^\p{Script=Hangul}$/u;
+const LATIN_RE = /^\p{Script=Latin}$/u;
+const NUMBER_RE = /^\p{Number}$/u;
+const SYMBOL_RE = /^\p{Symbol}$/u;
+const EMOJI_RE = /^\p{Extended_Pictographic}$/u;
+const SPACE_RE = /^[\t\v\f \u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]$/u;
+const NEWLINE_RE = /^[\n\r\u2028\u2029]$/u;
+const INVISIBLE_CODE_POINTS = new Set([
+	173,
+	847,
+	1564,
+	4447,
+	4448,
+	6068,
+	6069,
+	6158,
+	65279,
+	65440
+]);
+/**
+* Checks whether the character is an invisible Unicode control or filler.
+* These characters affect rendering, cursor movement, or text direction but
+* should not be treated as visible spacing, punctuation, or symbols.
+*/
+function isInvisible(char) {
+	const codePoint = char.codePointAt(0);
+	return codePoint != null && (INVISIBLE_CODE_POINTS.has(codePoint) || codePoint >= 8203 && codePoint <= 8207 || codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8288 && codePoint <= 8303);
+}
+function isLatinWordType(type) {
+	return type === TEXT_TYPE.latin;
+}
+function isNumberType(type) {
+	return type === TEXT_TYPE.number;
+}
+function isNumber(char, prev) {
+	return NUMBER_RE.test(char) || prev?.type === TEXT_TYPE.number && (char === "." || char === "%");
+}
+const TEXT_TYPE_MATCHERS = [
+	{
+		type: TEXT_TYPE.newline,
+		test: (char) => NEWLINE_RE.test(char)
+	},
+	{
+		type: TEXT_TYPE.space,
+		test: (char) => SPACE_RE.test(char)
+	},
+	{
+		type: TEXT_TYPE.invisible,
+		test: (char) => isInvisible(char)
+	},
+	{
+		type: TEXT_TYPE.cjk,
+		test: (char) => CJK_RE.test(char)
+	},
+	{
+		type: TEXT_TYPE.latin,
+		test: (char) => LATIN_RE.test(char)
+	},
+	{
+		type: TEXT_TYPE.number,
+		test: isNumber
+	},
+	{
+		type: TEXT_TYPE.dash,
+		test: (char) => isDashPunctuation(char)
+	},
+	{
+		type: TEXT_TYPE["fullwidth-punctuation"],
+		test: (char) => isFullwidthPunctuation(char)
+	},
+	{
+		type: TEXT_TYPE["halfwidth-punctuation"],
+		test: (char) => isHalfwidthPunctuation(char)
+	},
+	{
+		type: TEXT_TYPE.emoji,
+		test: (char) => EMOJI_RE.test(char)
+	},
+	{
+		type: TEXT_TYPE.symbol,
+		test: (char) => SYMBOL_RE.test(char)
+	}
+];
+const DEFAULT_START_POINT = {
+	line: 1,
+	column: 1,
+	offset: 0
+};
+function advancePoint(point, char) {
+	if (NEWLINE_RE.test(char)) return {
+		line: point.line + 1,
+		column: 1,
+		offset: point.offset + char.length
+	};
+	return {
+		line: point.line,
+		column: point.column + char.length,
+		offset: point.offset + char.length
+	};
+}
+/**
+* Classifies a single Unicode code point for Markdown text style rules.
+*/
+function getTextType(char, prev) {
+	for (const matcher of TEXT_TYPE_MATCHERS) if (matcher.test(char, prev)) return matcher.type;
+	return TEXT_TYPE.other;
+}
+/**
+* Tokenizes text into consecutive typed runs while preserving source positions.
+*/
+function tokenizeText(value, start = DEFAULT_START_POINT) {
+	const tokens = [];
+	let point = start;
+	let prevToken;
+	for (const char of value) {
+		const type = getTextType(char, prevToken);
+		const tokenStart = point;
+		const tokenEnd = advancePoint(point, char);
+		if (prevToken?.type === type) {
+			prevToken.value += char;
+			prevToken.position.end = tokenEnd;
+		} else {
+			prevToken = {
+				type,
+				value: char,
+				position: {
+					start: tokenStart,
+					end: tokenEnd
+				}
+			};
+			tokens.push(prevToken);
+		}
+		point = tokenEnd;
+	}
+	return tokens;
+}
+/**
+* Converts an mdast text node into a tokenized text AST with normalized source positions.
+*/
+function buildTextNodeAst(node) {
+	const start = node.position?.start;
+	const end = node.position?.end;
+	const position = {
+		start: {
+			line: start?.line ?? DEFAULT_START_POINT.line,
+			column: start?.column ?? DEFAULT_START_POINT.column,
+			offset: start?.offset ?? DEFAULT_START_POINT.offset
+		},
+		end: {
+			line: end?.line ?? DEFAULT_START_POINT.line,
+			column: end?.column ?? DEFAULT_START_POINT.column + node.value.length,
+			offset: end?.offset ?? DEFAULT_START_POINT.offset + node.value.length
+		}
+	};
+	return {
+		type: "text",
+		value: node.value,
+		position,
+		children: tokenizeText(node.value, position.start),
+		node
+	};
+}
+
+//#endregion
+//#region src/utils/text/boundary-space.ts
+/**
+* Normalizes an existing space token around the target token type.
+* When multiple spaces are collapsed, the redundant side is recorded so the
+* caller can choose the most specific lint message.
+*/
+function processSpaceToken(ctx, result, isTargetType) {
+	const { prev, current, next } = ctx;
+	/* v8 ignore if -- @preserve */
+	if (!current) return;
+	const cjkToTarget = prev?.type === TEXT_TYPE.cjk && isTargetType(next?.type);
+	const targetToCjk = isTargetType(prev?.type) && next?.type === TEXT_TYPE.cjk;
+	const targets = isTargetType(prev?.type) && isTargetType(next?.type);
+	const hasUnexpectedSpaces = current.value.length !== 1;
+	if (hasUnexpectedSpaces) {
+		if (cjkToTarget || targets) result.unexpectedBefore = true;
+		if (targetToCjk || targets) result.unexpectedAfter = true;
+	}
+	if (cjkToTarget || targetToCjk || hasUnexpectedSpaces) result.fixed += " ";
+	else result.fixed += current.value;
+}
+/**
+* Inserts missing spaces before or after the target token when it directly
+* touches adjacent CJK text.
+*/
+function processTargetToken(ctx, result) {
+	const { prev, current, next } = ctx;
+	/* v8 ignore if -- @preserve */
+	if (!current) return;
+	if (prev?.type === TEXT_TYPE.cjk) {
+		result.fixed += " ";
+		result.missingBefore = true;
+	}
+	result.fixed += current.value;
+	if (next?.type === TEXT_TYPE.cjk) {
+		result.fixed += " ";
+		result.missingAfter = true;
+	}
+}
+/**
+* Chooses the most specific shared boundary-space message id from the
+* collected missing or redundant space flags.
+*/
+function getBoundarySpaceMessageId(boundary) {
+	if (boundary.missingBefore && boundary.missingAfter) return SPACE_MESSAGE_IDS.missingSpacesAround;
+	if (boundary.unexpectedBefore && boundary.unexpectedAfter) return SPACE_MESSAGE_IDS.unexpectedSpaceAround;
+	if (boundary.missingBefore) return SPACE_MESSAGE_IDS.missingSpaceBefore;
+	if (boundary.missingAfter) return SPACE_MESSAGE_IDS.missingSpaceAfter;
+	if (boundary.unexpectedBefore) return SPACE_MESSAGE_IDS.unexpectedSpaceBefore;
+	return SPACE_MESSAGE_IDS.unexpectedSpaceAfter;
+}
+/**
+* Rebuilds a text node with normalized spacing between CJK text and a target
+* token class such as Latin words or numbers.
+*/
+function fixBoundarySpace(node, isTargetType) {
+	const { children } = buildTextNodeAst(node);
+	const result = {
+		fixed: "",
+		missingBefore: false,
+		missingAfter: false,
+		unexpectedBefore: false,
+		unexpectedAfter: false
+	};
+	for (let i = 0; i < children.length; i += 1) {
+		const ctx = getNodeContextByParent(children, i);
+		/* v8 ignore if -- @preserve */
+		if (!ctx.current) continue;
+		if (ctx.current.type === TEXT_TYPE.space) processSpaceToken(ctx, result, isTargetType);
+		else if (isTargetType(ctx.current.type)) processTargetToken(ctx, result);
+		else result.fixed += ctx.current.value;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/rules/space-around-number/index.ts
+const RULE_NAME$2 = "space-around-number";
+var space_around_number_default = createRule({
+	name: RULE_NAME$2,
+	meta: {
+		type: "layout",
+		docs: { description: "Enforce a single space between CJK characters and numbers." },
+		messages: {
+			missingSpaceBefore: "Add a space before the number.",
+			missingSpaceAfter: "Add a space after the number.",
+			missingSpacesAround: "Add spaces before and after the number.",
+			unexpectedSpaceBefore: "Remove the unexpected space before the number.",
+			unexpectedSpaceAfter: "Remove the unexpected space after the number.",
+			unexpectedSpaceAround: "Remove the unexpected spaces around the number."
+		},
+		fixable: "whitespace",
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		return { text(node) {
+			const { fixed, missingBefore, missingAfter, unexpectedBefore, unexpectedAfter } = fixBoundarySpace(node, isNumberType);
+			if (fixed === node.value) return;
+			context.report({
+				node,
+				messageId: getBoundarySpaceMessageId({
+					missingBefore,
+					missingAfter,
+					unexpectedBefore,
+					unexpectedAfter
+				}),
+				fix(fixer) {
+					return fixer.replaceText(node, fixed);
+				}
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/space-around-word/index.ts
+const RULE_NAME$1 = "space-around-word";
+var space_around_word_default = createRule({
+	name: RULE_NAME$1,
+	meta: {
+		type: "layout",
+		docs: { description: "Enforce a single space between CJK characters and Latin words." },
+		messages: {
+			missingSpaceBefore: "Add a space before the word.",
+			missingSpaceAfter: "Add a space after the word.",
+			missingSpacesAround: "Add spaces before and after the word.",
+			unexpectedSpaceBefore: "Remove the unexpected space before the word.",
+			unexpectedSpaceAfter: "Remove the unexpected space after the word.",
+			unexpectedSpaceAround: "Remove the unexpected spaces around the word."
+		},
+		fixable: "whitespace",
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		return { text(node) {
+			const { fixed, missingBefore, missingAfter, unexpectedBefore, unexpectedAfter } = fixBoundarySpace(node, isLatinWordType);
+			if (fixed === node.value) return;
+			context.report({
+				node,
+				messageId: getBoundarySpaceMessageId({
+					missingBefore,
+					missingAfter,
+					unexpectedBefore,
+					unexpectedAfter
+				}),
+				fix(fixer) {
+					return fixer.replaceText(node, fixed);
+				}
+			});
 		} };
 	}
 });
 
 //#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 +869,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 +878,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 +911,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 +943,9 @@ var valid_heading_anchor_default = createRule({
 //#endregion
 //#region src/rules/index.ts
 const rules = {
-	"space-between-link": space_between_link_default,
+	"space-around-inline-element": space_around_inline_element_default,
+	"space-around-number": space_around_number_default,
+	"space-around-word": space_around_word_default,
 	"valid-heading-anchor": valid_heading_anchor_default
 };
 
@@ -490,27 +954,28 @@ 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 recommendedRules = {
+	"md-style/valid-heading-anchor": "error",
+	"md-style/space-around-inline-element": "error"
 };
-const allRuleEntries = Object.keys(rules).map((ruleName) => [`md-style/${ruleName}`, "error"]);
-const recommendedRules = Object.fromEntries(allRuleEntries);
-const allRules = Object.fromEntries(allRuleEntries);
+const allRules = Object.fromEntries(Object.keys(rules).map((ruleName) => [`md-style/${ruleName}`, "error"]));
 const configs = {
 	recommended: {
 		name: "md-style/recommended",
 		files: ["**/*.md"],
 		plugins: { "md-style": plugin },
-		language: "md-style/commonmark",
+		language: "md-style/gfm",
+		languageOptions: { frontmatter: "yaml" },
 		rules: recommendedRules
 	},
 	all: {
 		name: "md-style/all",
 		files: ["**/*.md"],
 		plugins: { "md-style": plugin },
-		language: "md-style/commonmark",
+		language: "md-style/gfm",
+		languageOptions: { frontmatter: "yaml" },
 		rules: allRules
 	}
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-md-style",
   "type": "module",
-  "version": "0.1.0-beta.2",
+  "version": "0.2.0",
   "packageManager": "pnpm@10.21.0",
   "description": "ESLint plugin for enforcing style rules in Markdown-based documentation",
   "author": "noisefan <noisefan@163.com>",
@@ -18,8 +18,6 @@
     ".": "./dist/index.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "files": [
     "dist"
@@ -43,27 +41,34 @@
     "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": {
-    "@antfu/eslint-config": "^6.2.0",
-    "@eslint/markdown": "^7.5.1",
+    "@antfu/eslint-config": "^9.0.0",
+    "@eslint/markdown": "^8.0.1",
     "@types/mdast": "^4.0.4",
-    "@types/node": "^24.10.1",
-    "@typescript-eslint/utils": "^8.46.4",
-    "@vitest/coverage-v8": "^4.1.5",
-    "bumpp": "^10.3.1",
-    "eslint": "9.39.1",
-    "eslint-plugin-format": "^1.0.2",
-    "eslint-vitest-rule-tester": "^3.0.0",
-    "lint-staged": "^16.4.0",
+    "@types/node": "^25.7.0",
+    "@typescript-eslint/utils": "^8.59.3",
+    "@vitest/coverage-v8": "^4.1.6",
+    "bumpp": "^11.1.0",
+    "eslint": "10.3.0",
+    "eslint-factory": "^0.1.2",
+    "eslint-plugin-format": "^2.0.1",
+    "eslint-plugin-md-style": "^0.1.0",
+    "eslint-vitest-rule-tester": "^3.1.0",
+    "lint-staged": "^17.0.4",
     "simple-git-hooks": "^2.13.1",
     "tinyglobby": "^0.2.16",
-    "tsdown": "^0.16.4",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.9"
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6"
   },
   "simple-git-hooks": {
     "pre-commit": "pnpx lint-staged"
@@ -72,5 +77,7 @@
     "*.{js,ts,md,yml,yaml,json}": [
       "eslint --cache --fix"
     ]
-  }
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs"
 }