eslint-plugin-md-style 0.1.0 → 0.2.0

package/README.md

@@ -70,7 +70,7 @@ export default [
     },
     language: 'md-style/gfm',
     rules: {
-      'md-style/space-between-inline-element': 'error',
+      'md-style/space-around-inline-element': 'error',
       'md-style/valid-heading-anchor': 'error',
     },
   },
@@ -120,7 +120,9 @@ export default antfu(
 
 | Rule | Included in `recommended` | Autofix |
 | --- | --- | --- |
-| `md-style/space-between-inline-element` | ✅ | 🔧 |
+| `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

package/dist/index.mjs

@@ -52,7 +52,7 @@ function isNestedInlineElement(nodeContext) {
 function getNodeValue(node) {
 	if (!node) return;
 	if ("value" in node) return node.value;
-	if (hasChildren(node)) return node.children.map(getNodeValue).join("") || void 0;
+	if (hasChildren(node)) return node.children.map(getNodeValue).join("");
 }
 /**
 * Gets the start and end offsets for a node.
@@ -95,7 +95,19 @@ function getNodeContext(context, node) {
 	};
 }
 /**
-* Gets the character adjacent to the start or end of a string.
+* 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;
@@ -143,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.
@@ -153,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.
@@ -208,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.
@@ -243,6 +265,14 @@ function hasPunctuation(str, position = "head") {
 
 //#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 }
@@ -298,15 +328,6 @@ 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.
 *
@@ -334,18 +355,18 @@ function validateSingleRequiredSpace(count, missingSpaceMessageId, multipleSpace
 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;
+		if (context.whiteSpace.count > 0) return MESSAGE_IDS$1.unexpectedSpaceBefore;
 		return;
 	}
-	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;
+	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 inline node.
 */
 function validateSpaceBeforeNode(context) {
 	if (context.hasPunctuation) return validateBeforePunctuation(context);
-	return validateSingleRequiredSpace(context.whiteSpace.count, INLINE_SPACE_MESSAGE_IDS.missingSpaceBefore, INLINE_SPACE_MESSAGE_IDS.multipleSpacesBefore);
+	return validateSingleRequiredSpace(context.whiteSpace.count, MESSAGE_IDS$1.missingSpaceBefore, MESSAGE_IDS$1.multipleSpacesBefore);
 }
 /**
 * Validates spacing after an inline node when the next character is punctuation.
@@ -353,16 +374,16 @@ function validateSpaceBeforeNode(context) {
 function validateSpaceAfterPunctuation(context) {
 	const adjacentChar = getAdjacentChar(context.value, "head");
 	if (getLikeAnchor(context.value) || isCustomContainerMarker(context.value)) return;
-	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;
+	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, INLINE_SPACE_MESSAGE_IDS.missingSpaceAfter, INLINE_SPACE_MESSAGE_IDS.multipleSpacesAfter);
+	return validateSingleRequiredSpace(context.whiteSpace.count, MESSAGE_IDS$1.missingSpaceAfter, MESSAGE_IDS$1.multipleSpacesAfter);
 }
 /**
 * Validates spacing around an inline element inside a table cell.
@@ -403,14 +424,61 @@ function validateSpace(nodeContext) {
 }
 
 //#endregion
-//#region src/rules/space-between-inline-element/index.ts
-const RULE_NAME$1 = "space-between-inline-element";
+//#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([
-	INLINE_SPACE_MESSAGE_IDS.missingSpaceBefore,
-	INLINE_SPACE_MESSAGE_IDS.multipleSpacesBefore,
-	INLINE_SPACE_MESSAGE_IDS.multipleSpacesAfterPunctuation,
-	INLINE_SPACE_MESSAGE_IDS.unexpectedSpaceBefore
+	MESSAGE_IDS$1.missingSpaceBefore,
+	MESSAGE_IDS$1.multipleSpacesBefore,
+	MESSAGE_IDS$1.multipleSpacesAfterPunctuation,
+	MESSAGE_IDS$1.unexpectedSpaceBefore
 ]);
+var space_around_inline_element_default = createRule({
+	name: RULE_NAME$3,
+	meta: {
+		type: "layout",
+		docs: { description: "Enforce spacing around Markdown inline elements." },
+		messages: {
+			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.",
+			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) {
+				checkInlineElement(context, node);
+			},
+			image(node) {
+				checkInlineElement(context, node);
+			},
+			inlineCode(node) {
+				checkInlineElement(context, node);
+			},
+			emphasis(node) {
+				checkInlineElement(context, node);
+			},
+			strong(node) {
+				checkInlineElement(context, node);
+			}
+		};
+	}
+});
 /**
 * Checks one selected inline element and reports the fix range around it.
 */
@@ -425,7 +493,7 @@ function checkInlineElement(context, node) {
 	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 ? "" : " ";
+		const replaceText = messageId === MESSAGE_IDS$1.unexpectedSpaceBefore ? "" : " ";
 		context.report({
 			node,
 			messageId,
@@ -437,7 +505,7 @@ function checkInlineElement(context, node) {
 	}
 	if (spaceContext.next) {
 		const { count } = spaceContext.next.whiteSpace;
-		const replaceText = messageId === INLINE_SPACE_MESSAGE_IDS.unexpectedSpaceAfter ? "" : " ";
+		const replaceText = messageId === MESSAGE_IDS$1.unexpectedSpaceAfter ? "" : " ";
 		context.report({
 			node,
 			messageId,
@@ -447,42 +515,339 @@ function checkInlineElement(context, node) {
 		});
 	}
 }
-var space_between_inline_element_default = createRule({
+
+//#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 spacing around Markdown inline elements." },
+		docs: { description: "Enforce a single space between CJK characters and Latin words." },
 		messages: {
-			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.",
-			unexpectedSpaceBefore: "Do not add a space between punctuation and the inline element.",
-			unexpectedSpaceAfter: "Do not add a space between the inline element and punctuation."
+			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 {
-			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);
-			}
-		};
+		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);
+				}
+			});
+		} };
 	}
 });
 
@@ -578,7 +943,9 @@ var valid_heading_anchor_default = createRule({
 //#endregion
 //#region src/rules/index.ts
 const rules = {
-	"space-between-inline-element": space_between_inline_element_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
 };
 
@@ -589,15 +956,18 @@ const plugin = {
 	processors: markdown.processors,
 	languages: { gfm: new MarkdownLanguage({ mode: "gfm" }) }
 };
-const allRuleEntries = Object.keys(rules).map((ruleName) => [`md-style/${ruleName}`, "error"]);
-const recommendedRules = Object.fromEntries(allRuleEntries);
-const allRules = Object.fromEntries(allRuleEntries);
+const recommendedRules = {
+	"md-style/valid-heading-anchor": "error",
+	"md-style/space-around-inline-element": "error"
+};
+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/gfm",
+		languageOptions: { frontmatter: "yaml" },
 		rules: recommendedRules
 	},
 	all: {
@@ -605,6 +975,7 @@ const configs = {
 		files: ["**/*.md"],
 		plugins: { "md-style": plugin },
 		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",
+  "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"
@@ -52,24 +50,25 @@
       "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"
@@ -78,5 +77,7 @@
     "*.{js,ts,md,yml,yaml,json}": [
       "eslint --cache --fix"
     ]
-  }
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs"
 }