eslint-plugin-md-style 0.2.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);
+	return isObject(node) && "children" in node && Array.isArray(node.children);
 }
-function isTableCell(node) {
-	return node.type === "tableCell";
+function isCodeNode(node) {
+	return node?.type === "code";
 }
-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);
+function isTableCell(node) {
+	return node?.type === "tableCell";
 }
 /**
 * Extracts the plain-text value of a phrasing 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,
@@ -114,11 +86,587 @@ function getAdjacentChar(str, position) {
 	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`
 */
@@ -138,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 /\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/punctuation.ts
-const OPENING_PAIRED_PUNCTUATION = new Set([
+const OPENING_PAIRED_PUNCTUATION = /* @__PURE__ */ new Set([
 	"(",
 	"[",
 	"{",
@@ -194,7 +705,7 @@ const OPENING_PAIRED_PUNCTUATION = new Set([
 	"“",
 	"‘"
 ]);
-const CLOSING_PAIRED_PUNCTUATION = new Set([
+const CLOSING_PAIRED_PUNCTUATION = /* @__PURE__ */ new Set([
 	")",
 	"]",
 	"}",
@@ -262,17 +773,8 @@ 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
-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 }
@@ -303,45 +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
-/**
-* 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.
 */
@@ -355,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 MESSAGE_IDS$1.unexpectedSpaceBefore;
+		if (context.whiteSpace.count > 0) return "unexpected-space-before";
 		return;
 	}
-	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;
+	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, MESSAGE_IDS$1.missingSpaceBefore, MESSAGE_IDS$1.multipleSpacesBefore);
+	return validateSingleRequiredSpace(context.whiteSpace.count, "missing-space-before", "multiple-spaces-before");
 }
 /**
 * Validates spacing after an inline node when the next character is punctuation.
@@ -374,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 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;
+	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, MESSAGE_IDS$1.missingSpaceAfter, MESSAGE_IDS$1.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.
@@ -422,11 +926,10 @@ function validateSpace(nodeContext) {
 	if (parent && isTableCell(parent)) return validateTableCellSpace(nodeContext);
 	return validateDefaultSpace(nodeContext);
 }
-
 //#endregion
 //#region src/rules/space-around-inline-element/index.ts
-const RULE_NAME$3 = "space-around-inline-element";
-const MESSAGE_IDS$1 = {
+const RULE_NAME$4 = "space-around-inline-element";
+const MESSAGE_IDS$2 = {
 	missingSpaceBefore: "missingSpaceBefore",
 	missingSpaceAfter: "missingSpaceAfter",
 	multipleSpacesBefore: "multipleSpacesBefore",
@@ -435,14 +938,23 @@ const MESSAGE_IDS$1 = {
 	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
+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$3,
+	name: RULE_NAME$4,
 	meta: {
 		type: "layout",
 		docs: { description: "Enforce spacing around Markdown inline elements." },
@@ -489,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 === MESSAGE_IDS$1.unexpectedSpaceBefore ? "" : " ";
+		const replaceText = messageId === MESSAGE_IDS$2.unexpectedSpaceBefore ? "" : " ";
 		context.report({
 			node,
 			messageId,
@@ -505,7 +1018,7 @@ function checkInlineElement(context, node) {
 	}
 	if (spaceContext.next) {
 		const { count } = spaceContext.next.whiteSpace;
-		const replaceText = messageId === MESSAGE_IDS$1.unexpectedSpaceAfter ? "" : " ";
+		const replaceText = messageId === MESSAGE_IDS$2.unexpectedSpaceAfter ? "" : " ";
 		context.report({
 			node,
 			messageId,
@@ -515,7 +1028,6 @@ function checkInlineElement(context, node) {
 		});
 	}
 }
-
 //#endregion
 //#region src/utils/text/tokenizer.ts
 const TEXT_TYPE = {
@@ -539,7 +1051,7 @@ 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([
+const INVISIBLE_CODE_POINTS = /* @__PURE__ */ new Set([
 	173,
 	847,
 	1564,
@@ -560,15 +1072,13 @@ 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 === "%");
 }
+function isLatinWordType(type) {
+	if (!type) return false;
+	return type === "latin";
+}
 const TEXT_TYPE_MATCHERS = [
 	{
 		type: TEXT_TYPE.newline,
@@ -621,15 +1131,16 @@ const DEFAULT_START_POINT = {
 	offset: 0
 };
 function advancePoint(point, char) {
+	const { line, column, offset = 0 } = point;
 	if (NEWLINE_RE.test(char)) return {
-		line: point.line + 1,
+		line: line + 1,
 		column: 1,
-		offset: point.offset + char.length
+		offset: offset + char.length
 	};
 	return {
-		line: point.line,
-		column: point.column + char.length,
-		offset: point.offset + char.length
+		line,
+		column: column + char.length,
+		offset: offset + char.length
 	};
 }
 /**
@@ -694,9 +1205,8 @@ function buildTextNodeAst(node) {
 		node
 	};
 }
-
 //#endregion
-//#region src/utils/text/boundary-space.ts
+//#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
@@ -740,12 +1250,12 @@ function processTargetToken(ctx, result) {
 * 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;
+	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
@@ -770,12 +1280,8 @@ function fixBoundarySpace(node, isTargetType) {
 	}
 	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,
+	name: "space-around-number",
 	meta: {
 		type: "layout",
 		docs: { description: "Enforce a single space between CJK characters and numbers." },
@@ -793,7 +1299,7 @@ var space_around_number_default = createRule({
 	defaultOptions: [],
 	create(context) {
 		return { text(node) {
-			const { fixed, missingBefore, missingAfter, unexpectedBefore, unexpectedAfter } = fixBoundarySpace(node, isNumberType);
+			const { fixed, missingBefore, missingAfter, unexpectedBefore, unexpectedAfter } = fixBoundarySpace(node, (type) => type === "number");
 			if (fixed === node.value) return;
 			context.report({
 				node,
@@ -803,19 +1309,13 @@ var space_around_number_default = createRule({
 					unexpectedBefore,
 					unexpectedAfter
 				}),
-				fix(fixer) {
-					return fixer.replaceText(node, fixed);
-				}
+				fix: (fixer) => 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,
+	name: "space-around-word",
 	meta: {
 		type: "layout",
 		docs: { description: "Enforce a single space between CJK characters and Latin words." },
@@ -850,20 +1350,121 @@ var space_around_word_default = createRule({
 		} };
 	}
 });
-
 //#endregion
-//#region src/utils/markdown.ts
+//#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/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,
@@ -876,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";
@@ -895,60 +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."
-		},
-		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) {
-				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: isLikeAnchor ? MESSAGE_IDS.missingAnchor : MESSAGE_IDS.invalidHeadingAnchor,
-				fix(fixer) {
-					return fixer.replaceTextRange([start, end], `${remainingContent} {#${anchor}}`);
-				}
-			});
-		} };
-	}
-});
-
 //#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,
-	"valid-heading-anchor": valid_heading_anchor_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: []
+		},
+		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: isLikeAnchor ? MESSAGE_IDS.missingAnchor : MESSAGE_IDS.invalidHeadingAnchor,
+					fix(fixer) {
+						return fixer.replaceTextRange([start, end], `${remainingContent} {#${anchor}}`);
+					}
+				});
+			} };
+		}
+	})
 };
-
 //#endregion
 //#region src/index.ts
 const plugin = {
@@ -958,7 +1557,9 @@ const plugin = {
 };
 const recommendedRules = {
 	"md-style/valid-heading-anchor": "error",
-	"md-style/space-around-inline-element": "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 = {
@@ -980,7 +1581,5 @@ const configs = {
 	}
 };
 const mdStylePlugin = Object.assign(plugin, { configs });
-var src_default = mdStylePlugin;
-
 //#endregion
-export { configs, src_default as default, plugin };
+export { configs, mdStylePlugin as default, plugin };