eslint-plugin-md-style 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -1,18 +1,8 @@
 import markdown, { MarkdownLanguage } from "@eslint/markdown";
-
-//#region src/utils/index.ts
-function createRule({ create, defaultOptions, meta }) {
-	return {
-		create,
-		meta: {
-			defaultOptions,
-			...meta
-		}
-	};
+//#region src/parser/ast.ts
+function isObject(val) {
+	return !!val && typeof val === "object";
 }
-
-//#endregion
-//#region src/utils/ast.ts
 /**
 * Checks whether an unknown value behaves like an mdast parent node.
 *
@@ -20,30 +10,13 @@ function createRule({ create, defaultOptions, meta }) {
 * 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";
+	return isObject(node) && "children" in node && Array.isArray(node.children);
 }
-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);
+function isCodeNode(node) {
+	return node?.type === "code";
 }
-/**
-* Checks whether the current inline element is nested inside another selected inline element.
-*/
-function isNestedInlineElement(nodeContext) {
-	const { parent } = nodeContext;
-	return isInlineElement(parent);
+function isTableCell(node) {
+	return node?.type === "tableCell";
 }
 /**
 * Extracts the plain-text value of a phrasing node.
@@ -52,7 +25,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.
@@ -80,7 +53,6 @@ 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,
@@ -95,18 +67,606 @@ 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;
 	str = str.trim();
 	return position === "head" ? str[0] : str[str.length - 1];
 }
-
+//#endregion
+//#region src/parser/custom-container/parse.ts
+/**
+* Parses top-level text into container, blank-line, and text nodes.
+*/
+function parseCustomContainers(value) {
+	const state = {
+		splits: splitLines(value),
+		offset: 0
+	};
+	const nodes = [];
+	while (state.splits.length) {
+		const item = state.splits[0];
+		const previous = nodes.at(-1);
+		if (isOpenTag(item)) {
+			nodes.push(parseCustomContainer(state, 1, previous));
+			continue;
+		}
+		const consumed = consume(state);
+		if (isBlank(consumed.value)) {
+			const blankNode = parseBlankNode({
+				newline: consumed.value,
+				prevNode: previous
+			});
+			if (blankNode) nodes.push(blankNode);
+			continue;
+		}
+		nodes.push({
+			type: "text",
+			value: consumed.value,
+			position: consumed.position
+		});
+	}
+	return nodes;
+}
+/**
+* Parses one container by consuming its opening tag, nested containers, content,
+* and a closing fence whose marker is at least as wide as the opening fence.
+*/
+function parseCustomContainer(state, depth, parentNode) {
+	const children = [];
+	const raw = state.splits[0];
+	const openTag = parseOpenTag(raw, parentNode);
+	consume(state);
+	children.push(openTag);
+	while (state.splits.length) {
+		const item = state.splits[0];
+		const previous = children.at(-1);
+		if (parseOpenTag(item, previous)) {
+			children.push(parseCustomContainer(state, depth + 1, previous));
+			continue;
+		}
+		const closeTag = parseCloseTag(item, previous);
+		const consumed = consume(state);
+		if (closeTag && closeTag.markerLength >= openTag.markerLength) {
+			children.push(closeTag);
+			break;
+		}
+		if (isBlank(consumed.value)) {
+			const blankNode = parseBlankNode({
+				newline: consumed.value,
+				prevNode: previous
+			});
+			if (blankNode) children.push(blankNode);
+			continue;
+		}
+		children.push({
+			type: "text",
+			value: consumed.value,
+			position: consumed.position
+		});
+	}
+	return {
+		type: "custom-container",
+		depth,
+		children,
+		position: {
+			start: openTag.position.start,
+			end: children.at(-1)?.position.end ?? openTag.position.end
+		}
+	};
+}
+/**
+* Consumes the next split and advances its source offset.
+*/
+function consume(state) {
+	const value = state.splits.shift();
+	const start = state.offset;
+	state.offset += value.length;
+	return {
+		value,
+		position: {
+			start,
+			end: state.offset
+		}
+	};
+}
+/**
+* Splits text and keeps line-break tokens so their exact source ranges survive parsing.
+*/
+function splitLines(value) {
+	return value.split(/(\r?\n)/).filter(Boolean);
+}
+/**
+* Parses an opening custom-container tag and calculates its source ranges.
+*/
+function parseOpenTag(raw, prevNode) {
+	const match = raw.match(CUSTOM_CONTAINER_OPEN_MARKER_RE);
+	/* v8 ignore if -- @preserve */
+	if (!match) return null;
+	const [_, rawMarker, type, titleAndAttrs] = match;
+	const tag = rawMarker + type;
+	const marker = rawMarker.trim();
+	const offset = prevNode?.position.end || 0;
+	const valueStart = offset + tag.length - type.length;
+	const value = {
+		content: type,
+		start: valueStart,
+		end: valueStart + type.length
+	};
+	const titleAndAttrsValue = titleAndAttrs?.trim() || "";
+	const attributeMatch = titleAndAttrsValue.match(CUSTOM_CONTAINER_ATTRS_RE);
+	const attrs = attributeMatch ? {
+		content: attributeMatch[1].slice(1, -1),
+		raw: attributeMatch[1]
+	} : void 0;
+	const title = (attributeMatch ? titleAndAttrsValue.slice(0, attributeMatch.index).trim() : titleAndAttrsValue) || void 0;
+	return {
+		type: "open",
+		markerLength: marker.length,
+		raw,
+		value,
+		title,
+		...attrs ? { attribute: attrs } : {},
+		position: {
+			start: offset,
+			end: offset + raw.length
+		}
+	};
+}
+/**
+* Parses the exact closing marker,
+* `:::` and calculates its source range.
+*/
+function parseCloseTag(raw, prevNode) {
+	const match = raw.match(CUSTOM_CONTAINER_CLOSE_MARKER_STRICT_RE);
+	/* v8 ignore if -- @preserve */
+	if (!match) return null;
+	const marker = match[0].match(/:{3,}/)?.[0] ?? "";
+	const start = prevNode?.position.end || 0;
+	const end = start + raw.length;
+	return {
+		type: "close",
+		markerLength: marker.length,
+		raw,
+		value: {
+			content: raw,
+			start,
+			end
+		},
+		position: {
+			start,
+			end
+		}
+	};
+}
+/**
+* Adds a blank-line node
+* merging it with the preceding blank line when possible.
+*/
+function parseBlankNode(opts) {
+	const { newline = "\n", prevNode } = opts || {};
+	if (prevNode?.type === "blank") {
+		prevNode.value += newline;
+		prevNode.position.end += newline.length;
+		return null;
+	}
+	const start = prevNode?.position.end || 0;
+	return {
+		type: "blank",
+		value: newline,
+		position: {
+			start,
+			end: start + newline.length
+		}
+	};
+}
+const CUSTOM_CONTAINER_TYPE_SET = /* @__PURE__ */ new Set([
+	"info",
+	"tip",
+	"warning",
+	"danger",
+	"details",
+	"raw",
+	"code-group",
+	"v-pre",
+	"tabs"
+]);
+const CUSTOM_CONTAINER_MARKER_PATTERN = String.raw`(^ {0,3}:{3,}[ \t]*)`;
+const CUSTOM_CONTAINER_TYPE_PATTERN = String.raw`([\w-]+)(?=$|[ \t]|\r?\n)`;
+const CUSTOM_CONTAINER_TITLE_AND_ATTRS_PATTERN = String.raw`([ \t][^\r\n]*)?`;
+const CUSTOM_CONTAINER_CLOSE_MARKER_PATTERN = String.raw` {0,3}:{3,}[ \t]*`;
+const CUSTOM_CONTAINER_OPEN_MARKER_RE = new RegExp(`${CUSTOM_CONTAINER_MARKER_PATTERN}${CUSTOM_CONTAINER_TYPE_PATTERN}${CUSTOM_CONTAINER_TITLE_AND_ATTRS_PATTERN}`);
+const CUSTOM_CONTAINER_CLOSE_MARKER_RE = new RegExp(`^\r?\n${CUSTOM_CONTAINER_CLOSE_MARKER_PATTERN}$`);
+const CUSTOM_CONTAINER_CLOSE_MARKER_STRICT_RE = new RegExp(`^${CUSTOM_CONTAINER_CLOSE_MARKER_PATTERN}$`);
+const CUSTOM_CONTAINER_ATTRS_RE = /(\{[^{}]+\})\s*$/;
+/**
+* Checks whether a value is one of the custom-container types supported by VitePress.
+*/
+function isCustomContainerType(value) {
+	return CUSTOM_CONTAINER_TYPE_SET.has(value);
+}
+function isOpenTag(value) {
+	return CUSTOM_CONTAINER_OPEN_MARKER_RE.test(value);
+}
+function isBlank(value) {
+	return value === "\n" || value === "\r\n";
+}
+/**
+* Checks whether adjacent text is a custom container marker on the next line.
+*
+* @see https://vitepress.dev/guide/markdown#custom-containers
+* @example `::: info` -> true (open tag)
+* @example `:::: tip` -> true
+* @example `:::` -> false (close tag)
+*/
+function isCustomContainerMarker(str) {
+	if (!str) return false;
+	return CUSTOM_CONTAINER_CLOSE_MARKER_RE.test(str) || CUSTOM_CONTAINER_OPEN_MARKER_RE.test(str);
+}
+const isCustomContainerNode = (node) => !!node && node.type === "custom-container";
+const isBlankNode = (node) => !!node && node.type === "blank";
+const isOpenNode = (node) => !!node && node.type === "open";
+const isCloseNode = (node) => !!node && node.type === "close";
+/**
+* Ignore `Custom-containerNode` in `CodeNode` & `InlineCodeNode`.
+* Collects source offsets for fenced code blocks and inline code nodes.
+*/
+function getCodeNodeRanges(node) {
+	const ranges = [];
+	function visit(current) {
+		if (!isObject(current)) return;
+		if (isCodeNode(current)) {
+			const position = current.position;
+			if (!position) return;
+			const start = position.start?.offset;
+			const end = position.end?.offset;
+			if (start !== void 0 && end !== void 0) ranges.push({
+				start,
+				end
+			});
+		}
+		if (hasChildren(current)) for (const child of current.children) visit(child);
+	}
+	visit(node);
+	return ranges;
+}
+//#endregion
+//#region src/utils/index.ts
+function createRule({ create, defaultOptions, meta }) {
+	return {
+		create,
+		meta: {
+			defaultOptions,
+			...meta
+		}
+	};
+}
+//#endregion
+//#region src/rules/padding-around-custom-container/analyzs.ts
+/**
+* Analyzes custom containers and returns de-duplicated padding issues.
+*/
+function getNodesIssues(nodes, opts) {
+	const { offset = 0, ignoreRanges = [], mode = "loose" } = opts || {};
+	const issues = [];
+	/**
+	* Recursively analyzes every custom-container level in a parsed document.
+	*/
+	function analyzeLevel(nodes, opts) {
+		for (let index = 0; index < nodes.length; index++) {
+			const container = nodes[index];
+			if (!isCustomContainerNode(container)) continue;
+			const boundary = getContainerBoundary(container);
+			if (!boundary) continue;
+			analyzeInnerBoundary(container.children, boundary, opts);
+			analyzeOuterBoundary(nodes, index, opts);
+			analyzeLevel(container.children, opts);
+		}
+	}
+	analyzeLevel(nodes, {
+		offset,
+		issues,
+		mode
+	});
+	return dedupeIssues(issues).filter((issue) => !ignoreRanges.some((range) => issue.start < range.end && issue.end > range.start));
+}
+/**
+* Checks the blank lines immediately inside a container's opening and closing tags.
+*/
+function analyzeInnerBoundary(children, containerBoundary, opts) {
+	const { openIndex, closeIndex } = containerBoundary;
+	const first = children[openIndex + 1];
+	checkInnerSide(first, {
+		direction: 1,
+		children,
+		...opts
+	});
+	const last = children[closeIndex - 1];
+	if (last !== first) checkInnerSide(last, {
+		direction: -1,
+		children,
+		...opts
+	});
+}
+/**
+*  Checks one side of a container's inner boundary for the selected mode.
+*/
+function checkInnerSide(node, opts) {
+	const { direction, children, offset } = opts;
+	if (isBlankNode(node)) {
+		const lineBreak = getLineBreak(node.value);
+		const expected = opts.mode === "loose" ? `${lineBreak}${lineBreak}` : lineBreak;
+		if (node.value !== expected) opts.issues.push({
+			start: offset + node.position.start,
+			end: offset + node.position.end,
+			replacement: expected,
+			messageId: node.value.length < expected.length ? MESSAGE_IDS$4.missing : MESSAGE_IDS$4.unexpected
+		});
+		return;
+	}
+	if (opts.mode === "loose" && node && !isOpenNode(node) && !isCloseNode(node)) {
+		const insertion = direction === 1 ? node.position.start : node.position.end;
+		opts.issues.push({
+			start: offset + insertion,
+			end: offset + insertion,
+			replacement: getLineBreakFromChildren(children) + getLineBreakFromChildren(children),
+			messageId: MESSAGE_IDS$4.missing
+		});
+	}
+}
+/**
+* Finds the first opening tag and last closing tag for a custom container.
+*/
+function getContainerBoundary(container) {
+	const openIndex = container.children.findIndex(isOpenNode);
+	const closeIndex = container.children.findLastIndex(isCloseNode);
+	if (openIndex === -1 || closeIndex <= openIndex) return;
+	return {
+		openIndex,
+		closeIndex
+	};
+}
+/**
+*  Checks both sides of a container for the required external blank line.
+*/
+function analyzeOuterBoundary(children, boundaryIndex, opts) {
+	checkOuterSide(children, {
+		direction: -1,
+		boundaryIndex,
+		...opts
+	});
+	checkOuterSide(children, {
+		direction: 1,
+		boundaryIndex,
+		...opts
+	});
+}
+/**
+* Checks one side of a container and records insertion or normalization issues.
+*/
+function checkOuterSide(children, opts) {
+	const { boundaryIndex, direction, offset, issues } = opts;
+	const blankIndex = boundaryIndex + direction;
+	const blank = children[blankIndex];
+	const contentIndex = isBlankNode(blank) ? blankIndex + direction : blankIndex;
+	const content = children[contentIndex];
+	if (!isExternalContent(content, {
+		index: contentIndex,
+		length: children.length
+	})) return;
+	if (!isBlankNode(blank)) {
+		const insertion = direction === -1 ? children[boundaryIndex].position.start : children[boundaryIndex].position.end;
+		issues.push({
+			start: offset + insertion,
+			end: offset + insertion,
+			replacement: getLineBreakFromChildren(children),
+			messageId: MESSAGE_IDS$4.missing
+		});
+		return;
+	}
+	const lineBreak = getLineBreak(blank.value);
+	const expected = `${lineBreak}${lineBreak}`;
+	if (blank.value === expected) return;
+	issues.push({
+		start: offset + blank.position.start,
+		end: offset + blank.position.end,
+		replacement: expected,
+		messageId: blank.value.length < expected.length ? MESSAGE_IDS$4.missing : MESSAGE_IDS$4.unexpected
+	});
+}
+/**
+* Returns whether a node is content outside the container's own boundary tags.
+*/
+function isExternalContent(node, opts) {
+	if (!node || isBlankNode(node)) return false;
+	const { index, length } = opts;
+	if (index === 0 && isOpenNode(node)) return false;
+	if (index === length - 1 && isCloseNode(node)) return false;
+	return true;
+}
+/**
+* Removes issues that target the same range with the same replacement.
+*/
+function dedupeIssues(issues) {
+	const seen = /* @__PURE__ */ new Set();
+	return issues.filter((edit) => {
+		const key = `${edit.start}:${edit.end}:${edit.replacement}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+/**
+* Returns the line-break sequence used by a string.
+*/
+function getLineBreak(value) {
+	return value.includes("\r\n") ? "\r\n" : "\n";
+}
+/**
+* Uses the first blank child to infer a container's line-break sequence.
+*/
+function getLineBreakFromChildren(children) {
+	const blank = children.find((child) => isBlankNode(child));
+	return isBlankNode(blank) ? getLineBreak(blank.value) : "\n";
+}
+//#endregion
+//#region src/rules/padding-around-custom-container/index.ts
+const RULE_NAME$6 = "padding-around-custom-container";
+const MESSAGE_IDS$4 = {
+	missing: "missing",
+	unexpected: "unexpected"
+};
+var padding_around_custom_container_default = createRule({
+	name: RULE_NAME$6,
+	meta: {
+		type: "layout",
+		docs: { description: "Enforce padding around VitePress custom containers." },
+		messages: {
+			missing: "A custom container must be separated from surrounding content by one blank line.",
+			unexpected: "Unexpected blank lines around a custom container."
+		},
+		fixable: "whitespace",
+		schema: [{ enum: ["compact", "loose"] }]
+	},
+	defaultOptions: ["loose"],
+	create(context) {
+		return { root(node) {
+			const { position, start } = getNodePosition(node);
+			/* v8 ignore if -- @preserve */
+			if (!position) return;
+			const source = context.sourceCode.text;
+			const ignoreRanges = getCodeNodeRanges(node);
+			const nodes = parseCustomContainers(source.slice(start));
+			const [mode] = context.options;
+			const issues = getNodesIssues(nodes, {
+				offset: start,
+				ignoreRanges,
+				mode
+			});
+			for (const { start, end, messageId, replacement } of issues) context.report({
+				node,
+				messageId,
+				loc: {
+					start: context.sourceCode.getLocFromIndex(start),
+					end: context.sourceCode.getLocFromIndex(end)
+				},
+				fix: (fixer) => fixer.replaceTextRange([start, end], replacement)
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/space-around-custom-container/analyzs.ts
+/**
+* Finds custom-container marker lines and normalizes their surrounding spaces.
+*
+* Opening markers use exactly one space between the fence and the type,
+* while closing markers contain only the fence. Leading indentation is removed.
+* Ranges in `ignoredRanges` (for example fenced code blocks) are skipped.
+*/
+function getSourceIssues(source, ignoredRanges = []) {
+	const issues = [];
+	function visit(nodes) {
+		for (const node of nodes) {
+			if (!isCustomContainerNode(node)) continue;
+			for (const child of node.children) if (isOpenNode(child) || isCloseNode(child)) analyzeMarker(child, ignoredRanges, issues);
+			else if (isCustomContainerNode(child)) visit([child]);
+		}
+	}
+	visit(parseCustomContainers(source));
+	return issues;
+}
+/**
+* Adds a spacing issue for one parsed opening or closing marker.
+*/
+function analyzeMarker(tag, ignoredRanges, issues) {
+	if (ignoredRanges.some((range) => tag.position.start < range.end && tag.position.end > range.start)) return;
+	const replacement = normalizedMarker(tag);
+	if (tag.raw === replacement) return;
+	issues.push({
+		...tag.position,
+		replacement,
+		messageId: getMarkerMessageId(tag)
+	});
+}
+/**
+* Returns the normalized source text for a parsed container marker.
+*/
+function normalizedMarker(tag) {
+	const fence = ":".repeat(tag.markerLength);
+	if (isCloseNode(tag)) return fence;
+	const valueStart = tag.value.start - tag.position.start;
+	return `${fence} ${tag.raw.slice(valueStart).trim()}`;
+}
+/**
+* Classifies the spacing problem represented by a parsed marker.
+*/
+function getMarkerMessageId(tag) {
+	if (tag.raw.length !== tag.raw.trimStart().length) return MESSAGE_IDS$3.unexpectedIndentation;
+	if (isCloseNode(tag)) return MESSAGE_IDS$3.unexpectedTrailingSpace;
+	if (tag.raw.slice(tag.markerLength, tag.value.start - tag.position.start).length === 0) return MESSAGE_IDS$3.missingSeparator;
+	return MESSAGE_IDS$3.unexpectedSeparator;
+}
+//#endregion
+//#region src/rules/space-around-custom-container/index.ts
+const RULE_NAME$5 = "space-around-custom-container";
+const MESSAGE_IDS$3 = {
+	unexpectedIndentation: "unexpectedIndentation",
+	missingSeparator: "missingSeparator",
+	unexpectedSeparator: "unexpectedSeparator",
+	unexpectedTrailingSpace: "unexpectedTrailingSpace"
+};
+var space_around_custom_container_default = createRule({
+	name: RULE_NAME$5,
+	meta: {
+		type: "layout",
+		docs: { description: "Enforce spacing around VitePress custom-container markers." },
+		messages: {
+			unexpectedIndentation: "Do not indent a custom-container marker.",
+			missingSeparator: "Add one space between the opening fence and its type.",
+			unexpectedSeparator: "Use exactly one space between the opening fence and its type.",
+			unexpectedTrailingSpace: "Remove trailing spaces from a custom-container closing marker."
+		},
+		fixable: "whitespace",
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		return { root(node) {
+			const { position } = getNodePosition(node);
+			/* v8 ignore if -- @preserve */
+			if (!position) return;
+			const source = context.sourceCode.text;
+			const issues = getSourceIssues(source, getCodeNodeRanges(node));
+			for (const { start, end, messageId, replacement } of issues) context.report({
+				node,
+				messageId,
+				loc: {
+					start: context.sourceCode.getLocFromIndex(start),
+					end: context.sourceCode.getLocFromIndex(end)
+				},
+				fix: (fixer) => fixer.replaceTextRange([start, end], replacement)
+			});
+		} };
+	}
+});
 //#endregion
 //#region src/utils/anchor.ts
 /**
-* Match the trailing anchor-like fragment from a heading string.
+* Match the trailing anchor-like fragment from a heading or adjacent text.
 * @example `中文标题 {#Chinese-Title}` -> `{#Chinese-Title}`
 * @example `使用 describe #Grouping Tests` -> `#Grouping Tests`
 */
@@ -126,52 +686,15 @@ function getLikeAnchor(str) {
 	if (str === void 0) return null;
 	const match = getLikeAnchorMatch(str);
 	if (!match) return null;
-	const rawLikeAnchor = match.replace(/(\{|\})/g, "").replace(/^#/, "").trimStart();
+	const rawLikeAnchor = match.replace(/[{}]/g, "").replace(/^#/, "").trimStart();
 	return {
 		isLikeAnchor: rawLikeAnchor.includes(" "),
 		rawLikeAnchor
 	};
 }
-/**
-* Check if the string has an anchor.
-* @example: {#chinese-anchor}
-*/
-function isStrictAnchor(str) {
-	return /\s\{#[a-z0-9]+(?:-[a-z0-9]+)*\}/.test(str);
-}
-/**
-* Check whether the string contains CJK Han characters.
-*/
-function hasChinese(str) {
-	return /[\u4E00-\u9FA5]/.test(str);
-}
-/**
-* Normalize raw anchor text into the strict anchor format content.
-* - lowercase all letters
-* - convert spaces to `-`
-* - remove unsupported characters
-* - trim leading/trailing `-`
-*/
-function normalizeAnchor(anchor) {
-	return anchor.toLowerCase().replace(/[\s.]/g, "-").replace(/[^a-z0-9_-]/g, "").replace(/^-+|-+$/g, "");
-}
-/**
-* Count wrapper characters contributed by the trailing like-anchor fragment.
-* The value is the length difference between the raw matched fragment and the
-* cleaned anchor text returned by `getLikeAnchor`.
-* @example `# 中文标题 {#Chinese-Title}` -> 3
-* @example `## 使用 \`describe\` 编组测试 #Grouping Tests with \`describe\`` -> 1
-*/
-function calcAnchorPositionCompensate(content) {
-	const match = getLikeAnchorMatch(content);
-	const anchor = getLikeAnchor(content);
-	if (!match || !anchor) return 0;
-	return match.length - anchor.rawLikeAnchor.length;
-}
-
 //#endregion
 //#region src/utils/punctuation.ts
-const OPENING_PAIRED_PUNCTUATION = new Set([
+const OPENING_PAIRED_PUNCTUATION = /* @__PURE__ */ new Set([
 	"(",
 	"[",
 	"{",
@@ -182,7 +705,7 @@ const OPENING_PAIRED_PUNCTUATION = new Set([
 	"“",
 	"‘"
 ]);
-const CLOSING_PAIRED_PUNCTUATION = new Set([
+const CLOSING_PAIRED_PUNCTUATION = /* @__PURE__ */ new Set([
 	")",
 	"]",
 	"}",
@@ -208,6 +731,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.
@@ -240,7 +773,6 @@ function hasPunctuation(str, position = "head") {
 	if (position === "head") return isPunctuation(str[0]);
 	else return isPunctuation(str[str.length - 1]);
 }
-
 //#endregion
 //#region src/utils/space.ts
 /**
@@ -273,54 +805,8 @@ function getWhiteSpace(str, position = "head") {
 		};
 	}
 }
-/**
-* Gets whitespace and punctuation information for text adjacent to a link or inline code node.
-*/
-function getSpaceContext(nodeContext) {
-	const { prev, next } = nodeContext;
-	const prevValue = getNodeValue(prev);
-	const nextValue = getNodeValue(next);
-	return {
-		prev: {
-			value: prevValue,
-			whiteSpace: getWhiteSpace(prevValue, "tail"),
-			hasPunctuation: hasPunctuation(prevValue, "tail"),
-			punctuationType: isFullwidthPunctuation(getAdjacentChar(prevValue, "tail")) ? "full" : "half"
-		},
-		next: {
-			value: nextValue,
-			whiteSpace: getWhiteSpace(nextValue),
-			hasPunctuation: hasPunctuation(nextValue),
-			punctuationType: isFullwidthPunctuation(getAdjacentChar(nextValue, "head")) ? "full" : "half"
-		}
-	};
-}
-
 //#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 || "");
-}
+//#region src/rules/space-around-inline-element/analyze.ts
 /**
 * Validates whether a spacing run contains exactly one required space.
 */
@@ -334,18 +820,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 "unexpected-space-before";
 		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, "missing-space-before", "multiple-spaces-after-punctuation");
+	if (context.whiteSpace.count > 0) return "unexpected-space-before";
 }
 /**
 * 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, "missing-space-before", "multiple-spaces-before");
 }
 /**
 * Validates spacing after an inline node when the next character is punctuation.
@@ -353,16 +839,55 @@ 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 "unexpected-space-after";
+	if (context.punctuationType === "half" && OPENING_PAIRED_PUNCTUATION.has(adjacentChar || "") || isDashPunctuation(adjacentChar)) return validateSingleRequiredSpace(context.whiteSpace.count, "missing-space-after", "multiple-spaces-after");
+	if (context.whiteSpace.count > 0) return "unexpected-space-after";
 }
 /**
 * 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, "missing-space-after", "multiple-spaces-after");
+}
+const INLINE_ELEMENT_TYPES = /* @__PURE__ */ 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);
+}
+function getSpaceContext(nodeContext) {
+	const { prev, next } = nodeContext;
+	const prevValue = getNodeValue(prev);
+	const nextValue = getNodeValue(next);
+	return {
+		prev: {
+			value: prevValue,
+			whiteSpace: getWhiteSpace(prevValue, "tail"),
+			hasPunctuation: hasPunctuation(prevValue, "tail"),
+			punctuationType: isFullwidthPunctuation(getAdjacentChar(prevValue, "tail")) ? "full" : "half"
+		},
+		next: {
+			value: nextValue,
+			whiteSpace: getWhiteSpace(nextValue),
+			hasPunctuation: hasPunctuation(nextValue),
+			punctuationType: isFullwidthPunctuation(getAdjacentChar(nextValue, "head")) ? "full" : "half"
+		}
+	};
 }
 /**
 * Validates spacing around an inline element inside a table cell.
@@ -401,16 +926,71 @@ function validateSpace(nodeContext) {
 	if (parent && isTableCell(parent)) return validateTableCellSpace(nodeContext);
 	return validateDefaultSpace(nodeContext);
 }
-
 //#endregion
-//#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
+//#region src/rules/space-around-inline-element/index.ts
+const RULE_NAME$4 = "space-around-inline-element";
+const MESSAGE_IDS$2 = {
+	missingSpaceBefore: "missingSpaceBefore",
+	missingSpaceAfter: "missingSpaceAfter",
+	multipleSpacesBefore: "multipleSpacesBefore",
+	multipleSpacesAfter: "multipleSpacesAfter",
+	multipleSpacesAfterPunctuation: "multipleSpacesAfterPunctuation",
+	unexpectedSpaceBefore: "unexpectedSpaceBefore",
+	unexpectedSpaceAfter: "unexpectedSpaceAfter"
+};
+const ISSUE_TO_MESSAGE_ID = {
+	"missing-space-before": MESSAGE_IDS$2.missingSpaceBefore,
+	"missing-space-after": MESSAGE_IDS$2.missingSpaceAfter,
+	"multiple-spaces-before": MESSAGE_IDS$2.multipleSpacesBefore,
+	"multiple-spaces-after": MESSAGE_IDS$2.multipleSpacesAfter,
+	"multiple-spaces-after-punctuation": MESSAGE_IDS$2.multipleSpacesAfterPunctuation,
+	"unexpected-space-before": MESSAGE_IDS$2.unexpectedSpaceBefore,
+	"unexpected-space-after": MESSAGE_IDS$2.unexpectedSpaceAfter
+};
+const BEFORE_INLINE_ELEMENT_MESSAGE_IDS = /* @__PURE__ */ new Set([
+	MESSAGE_IDS$2.missingSpaceBefore,
+	MESSAGE_IDS$2.multipleSpacesBefore,
+	MESSAGE_IDS$2.multipleSpacesAfterPunctuation,
+	MESSAGE_IDS$2.unexpectedSpaceBefore
 ]);
+var space_around_inline_element_default = createRule({
+	name: RULE_NAME$4,
+	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.
 */
@@ -421,11 +1001,12 @@ function checkInlineElement(context, node) {
 	const nodeContext = getNodeContext(context, node);
 	if (isNestedInlineElement(nodeContext)) return;
 	const spaceContext = getSpaceContext(nodeContext);
-	const messageId = validateSpace(nodeContext);
-	if (!messageId) return;
+	const issue = validateSpace(nodeContext);
+	if (!issue) return;
+	const messageId = ISSUE_TO_MESSAGE_ID[issue];
 	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$2.unexpectedSpaceBefore ? "" : " ";
 		context.report({
 			node,
 			messageId,
@@ -437,7 +1018,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$2.unexpectedSpaceAfter ? "" : " ";
 		context.report({
 			node,
 			messageId,
@@ -447,58 +1028,443 @@ function checkInlineElement(context, node) {
 		});
 	}
 }
-var space_between_inline_element_default = createRule({
-	name: RULE_NAME$1,
+//#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 = /* @__PURE__ */ 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 isNumber(char, prev) {
+	return NUMBER_RE.test(char) || prev?.type === TEXT_TYPE.number && (char === "." || char === "%");
+}
+function isLatinWordType(type) {
+	if (!type) return false;
+	return type === "latin";
+}
+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) {
+	const { line, column, offset = 0 } = point;
+	if (NEWLINE_RE.test(char)) return {
+		line: line + 1,
+		column: 1,
+		offset: offset + char.length
+	};
+	return {
+		line,
+		column: column + char.length,
+		offset: 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/rules/shared/text-boundary-spacing.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 "missingSpacesAround";
+	if (boundary.unexpectedBefore && boundary.unexpectedAfter) return "unexpectedSpaceAround";
+	if (boundary.missingBefore) return "missingSpaceBefore";
+	if (boundary.missingAfter) return "missingSpaceAfter";
+	if (boundary.unexpectedBefore) return "unexpectedSpaceBefore";
+	return "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;
+}
+var space_around_number_default = createRule({
+	name: "space-around-number",
 	meta: {
 		type: "layout",
-		docs: { description: "Enforce spacing around Markdown inline elements." },
+		docs: { description: "Enforce a single space between CJK characters and numbers." },
 		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 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 {
-			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, (type) => type === "number");
+			if (fixed === node.value) return;
+			context.report({
+				node,
+				messageId: getBoundarySpaceMessageId({
+					missingBefore,
+					missingAfter,
+					unexpectedBefore,
+					unexpectedAfter
+				}),
+				fix: (fixer) => fixer.replaceText(node, fixed)
+			});
+		} };
+	}
+});
+var space_around_word_default = createRule({
+	name: "space-around-word",
+	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/rules/valid-custom-container-type/index.ts
+const RULE_NAME$1 = "valid-custom-container-type";
+const MESSAGE_IDS$1 = {
+	invalidType: "invalidType",
+	invalidTypeCase: "invalidTypeCase"
+};
+var valid_custom_container_type_default = createRule({
+	name: RULE_NAME$1,
+	meta: {
+		type: "problem",
+		docs: { description: "Require custom containers to use a supported type." },
+		messages: {
+			invalidType: "Invalid custom container type \"{{type}}\". Use info, tip, warning, danger, details, raw, code-group, v-pre, or tabs.",
+			invalidTypeCase: "Custom container type \"{{type}}\" must be lowercase."
+		},
+		fixable: "code",
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		return { text(node) {
+			const { position, start: startPoint } = getNodePosition(node);
+			/* v8 ignore if -- @preserve */
+			if (!position) return;
+			for (const tag of getOpeningTags(parseCustomContainers(node.value))) {
+				const issue = getTypeIssue(tag.value.content);
+				if (!issue) continue;
+				const normalizedType = "normalizedType" in issue ? issue.normalizedType : void 0;
+				const start = startPoint + tag.value.start;
+				const end = startPoint + tag.value.end;
+				context.report({
+					node,
+					messageId: issue.messageId,
+					data: { type: tag.value.content },
+					loc: {
+						start: context.sourceCode.getLocFromIndex(start),
+						end: context.sourceCode.getLocFromIndex(end)
+					},
+					fix: normalizedType ? (fixer) => fixer.replaceTextRange([start, end], normalizedType) : void 0
+				});
 			}
-		};
+		} };
 	}
 });
-
+function* getOpeningTags(nodes) {
+	for (const node of nodes) {
+		if (node.type !== "custom-container") continue;
+		yield* getOpeningTagsFromContainer(node);
+	}
+}
+function* getOpeningTagsFromContainer(container) {
+	for (const child of container.children) if (child.type === "custom-container") yield* getOpeningTagsFromContainer(child);
+	else if (child.type === "open") yield child;
+}
+function getTypeIssue(type) {
+	if (isCustomContainerType(type)) return null;
+	const normalizedType = type.toLowerCase();
+	if (isCustomContainerType(normalizedType)) return {
+		messageId: MESSAGE_IDS$1.invalidTypeCase,
+		normalizedType
+	};
+	return { messageId: MESSAGE_IDS$1.invalidType };
+}
+//#endregion
+//#region src/rules/valid-heading-anchor/anchor.ts
+/**
+* Check if the string has an anchor.
+* @example: {#chinese-anchor}
+*/
+function isStrictAnchor(str) {
+	return /\s\{#[a-z0-9]+(?:-[a-z0-9]+)*\}/.test(str);
+}
+/**
+* Check whether the string contains CJK Han characters.
+*/
+function hasChinese(str) {
+	return /\p{Script=Han}/u.test(str);
+}
+/**
+* Normalize raw anchor text into the strict anchor format content.
+* - lowercase all letters
+* - convert spaces to `-`
+* - remove unsupported characters
+* - trim leading/trailing `-`
+*/
+function normalizeAnchor(anchor) {
+	return anchor.toLowerCase().replace(/[\s.]+/g, "-").replace(/[^a-z0-9_-]/g, "").replace(/^-+|-+$/g, "");
+}
+/**
+* Count wrapper characters contributed by the trailing like-anchor fragment.
+* The value is the length difference between the raw matched fragment and the
+* cleaned anchor text returned by `getLikeAnchor`.
+* @example `# 中文标题 {#Chinese-Title}` -> 3
+* @example `## 使用 \`describe\` 编组测试 #Grouping Tests with \`describe\`` -> 1
+*/
+function calcAnchorPositionCompensate(content) {
+	const match = getLikeAnchorMatch(content);
+	const anchor = getLikeAnchor(content);
+	if (!match || !anchor) return 0;
+	return match.length - anchor.rawLikeAnchor.length;
+}
 //#endregion
-//#region src/utils/markdown.ts
+//#region src/parser/markdown.ts
 const language = new MarkdownLanguage({ mode: "gfm" });
 /**
 * 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) {
+function parseMarkdown(markdown) {
 	const file = {
 		path: "test.md",
 		physicalPath: "test.md",
 		bom: false,
-		body: markdown$1
+		body: markdown
 	};
 	const parseResult = language.parse(file, { languageOptions: {
 		...language.defaultLanguageOptions,
@@ -511,18 +1477,16 @@ function parseMarkdown(markdown$1) {
 		sourceCode: language.createSourceCode(file, parseResult)
 	};
 }
-
 //#endregion
-//#region src/utils/heading.ts
+//#region src/rules/valid-heading-anchor/frontmatter.ts
 /**
 * Returns true when the Markdown document starts with YAML frontmatter.
 */
-function hasFrontmatter(markdown$1, prevNode) {
-	if (prevNode?.type === "thematicBreak") markdown$1 = `---\n${markdown$1}`;
-	const { ast } = parseMarkdown(markdown$1);
+function hasFrontmatter(markdown, prevNode) {
+	if (prevNode?.type === "thematicBreak") markdown = `---\n${markdown}`;
+	const { ast } = parseMarkdown(markdown);
 	return ast.children[0]?.type === "yaml";
 }
-
 //#endregion
 //#region src/rules/valid-heading-anchor/index.ts
 const RULE_NAME = "valid-heading-anchor";
@@ -530,58 +1494,60 @@ const MESSAGE_IDS = {
 	missingAnchor: "missingAnchor",
 	invalidHeadingAnchor: "invalidHeadingAnchor"
 };
-var valid_heading_anchor_default = createRule({
-	name: RULE_NAME,
-	meta: {
-		type: "layout",
-		docs: { description: "Require strict lowercase anchors for headings that contain CJK text." },
-		messages: {
-			missingAnchor: "Non-ASCII heading must have an anchor in the format \"{#lowercase-anchor}\".",
-			invalidHeadingAnchor: "Anchor must use lowercase letters and valid characters only."
+//#endregion
+//#region src/rules/index.ts
+const rules = {
+	"padding-around-custom-container": padding_around_custom_container_default,
+	"space-around-inline-element": space_around_inline_element_default,
+	"space-around-number": space_around_number_default,
+	"space-around-word": space_around_word_default,
+	"space-around-custom-container": space_around_custom_container_default,
+	"valid-custom-container-type": valid_custom_container_type_default,
+	"valid-heading-anchor": createRule({
+		name: RULE_NAME,
+		meta: {
+			type: "layout",
+			docs: { description: "Require strict lowercase anchors for headings that contain CJK text." },
+			messages: {
+				missingAnchor: "Non-ASCII heading must have an anchor in the format \"{#lowercase-anchor}\".",
+				invalidHeadingAnchor: "Anchor must use lowercase letters and valid characters only."
+			},
+			fixable: "whitespace",
+			schema: []
 		},
-		fixable: "whitespace",
-		schema: []
-	},
-	defaultOptions: [],
-	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;
-			if (hasFrontmatter(source, getNodeContext(context, node).prev)) return;
-			const liked = getLikeAnchor(source);
-			if (!liked) {
+		defaultOptions: [],
+		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;
+				if (hasFrontmatter(source, getNodeContext(context, node).prev)) return;
+				const liked = getLikeAnchor(source);
+				if (!liked) {
+					context.report({
+						node,
+						messageId: MESSAGE_IDS.missingAnchor
+					});
+					return;
+				}
+				const { rawLikeAnchor, isLikeAnchor } = liked;
+				const compensate = calcAnchorPositionCompensate(source);
+				const remainingContent = source.slice(0, -rawLikeAnchor.length - compensate).trim();
+				const anchor = normalizeAnchor(rawLikeAnchor);
+				if (rawLikeAnchor === anchor) return;
 				context.report({
 					node,
-					messageId: MESSAGE_IDS.missingAnchor
+					messageId: isLikeAnchor ? MESSAGE_IDS.missingAnchor : MESSAGE_IDS.invalidHeadingAnchor,
+					fix(fixer) {
+						return fixer.replaceTextRange([start, end], `${remainingContent} {#${anchor}}`);
+					}
 				});
-				return;
-			}
-			const { rawLikeAnchor, isLikeAnchor } = liked;
-			const compensate = calcAnchorPositionCompensate(source);
-			const remainingContent = source.slice(0, -rawLikeAnchor.length - compensate).trim();
-			const anchor = normalizeAnchor(rawLikeAnchor);
-			if (rawLikeAnchor === anchor) return;
-			context.report({
-				node,
-				messageId: isLikeAnchor ? MESSAGE_IDS.missingAnchor : MESSAGE_IDS.invalidHeadingAnchor,
-				fix(fixer) {
-					return fixer.replaceTextRange([start, end], `${remainingContent} {#${anchor}}`);
-				}
-			});
-		} };
-	}
-});
-
-//#endregion
-//#region src/rules/index.ts
-const rules = {
-	"space-between-inline-element": space_between_inline_element_default,
-	"valid-heading-anchor": valid_heading_anchor_default
+			} };
+		}
+	})
 };
-
 //#endregion
 //#region src/index.ts
 const plugin = {
@@ -589,15 +1555,20 @@ 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",
+	"md-style/padding-around-custom-container": "error",
+	"md-style/valid-custom-container-type": "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,11 +1576,10 @@ const configs = {
 		files: ["**/*.md"],
 		plugins: { "md-style": plugin },
 		language: "md-style/gfm",
+		languageOptions: { frontmatter: "yaml" },
 		rules: allRules
 	}
 };
 const mdStylePlugin = Object.assign(plugin, { configs });
-var src_default = mdStylePlugin;
-
 //#endregion
-export { configs, src_default as default, plugin };
+export { configs, mdStylePlugin as default, plugin };