eslint-plugin-md-style 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2025-PRESENT Kevin Deng (https://github.com/sxzz)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# eslint-plugin-md-style
+
+ESLint plugin for enforcing style rules in Markdown-based documentation.
+
+## Install
+
+```bash
+pnpm add -D eslint @eslint/markdown eslint-plugin-md-style
+```
+
+`@eslint/markdown` is required because this plugin registers Markdown processors and languages on top of it.
+
+## Usage
+
+Use the built-in flat configs to lint Markdown files directly.
+
+### With `@antfu/eslint-config`
+
+```ts
+import antfu from '@antfu/eslint-config'
+import docsStyle from 'eslint-plugin-md-style'
+
+export default antfu(
+  {
+    formatters: true,
+    markdown: true,
+  },
+  docsStyle.configs.recommended,
+)
+```
+
+If you want full enforcement instead of the default recommended preset, replace `plugin.configs.recommended` with `plugin.configs.all`.
+
+For partial adoption, you can start from `recommended` and override individual rules:
+
+```ts
+import antfu from '@antfu/eslint-config'
+import docsStyle from 'eslint-plugin-md-style'
+
+export default antfu(
+  {
+    formatters: true,
+    markdown: true,
+  },
+  docsStyle.configs.recommended,
+  {
+    files: ['**/*.md'],
+    rules: {
+      'docs-style/valid-heading-anchor': 'off',
+    },
+  },
+)
+```
+
+If you only want to enable part of the plugin, register the plugin and select rules manually:
+
+```ts
+import antfu from '@antfu/eslint-config'
+import plugin from 'eslint-plugin-md-style'
+
+export default antfu(
+  {
+    formatters: true,
+    markdown: true,
+  },
+  {
+    files: ['**/*.md'],
+    plugins: {
+      'docs-style': plugin,
+    },
+    language: 'docs-style/commonmark',
+    rules: {
+      'docs-style/space-between-link': 'error',
+      'docs-style/valid-heading-anchor': 'error',
+    },
+  },
+)
+```
+
+### `recommended`
+
+```ts
+import plugin from 'eslint-plugin-md-style'
+
+export default [
+  plugin.configs.recommended,
+]
+```
+
+`recommended` is the default entry for production use. It targets `**/*.md`, uses the plugin's `commonmark` language, and enables the stable rules currently recommended by this package.
+
+### `all`
+
+```ts
+import plugin from 'eslint-plugin-md-style'
+
+export default [
+  plugin.configs.all,
+]
+```
+
+`all` enables every rule exported by this plugin. It is useful when you want full enforcement or when checking rule behavior during development.
+
+## Rules
+
+| Rule | Included in `recommended` | Autofix |
+| --- | --- | --- |
+| `docs-style/space-between-link` | Yes | Yes |
+| `docs-style/valid-heading-anchor` | Yes | Yes |
+
+## License
+
+[MIT](./LICENSE) License © 2025-PRESENT [Noise Fan](https://github.com/noisefan)

package/dist/index.d.mts

@@ -0,0 +1,15 @@
+import { ESLint, Linter } from "eslint";
+
+//#region src/index.d.ts
+declare const plugin: ESLint.Plugin;
+interface PluginConfigMap {
+  recommended: Linter.Config;
+  all: Linter.Config;
+}
+declare const configs: PluginConfigMap;
+type DocsStylePlugin = ESLint.Plugin & {
+  configs: PluginConfigMap;
+};
+declare const docsStylePlugin: DocsStylePlugin;
+//#endregion
+export { DocsStylePlugin, configs, docsStylePlugin as default, plugin };

package/dist/index.mjs

@@ -0,0 +1,528 @@
+import markdown, { MarkdownLanguage } from "@eslint/markdown";
+
+//#region src/utils/index.ts
+function createRule({ create, defaultOptions, meta }) {
+	return {
+		create,
+		meta: {
+			defaultOptions,
+			...meta
+		}
+	};
+}
+function getNodePosition(node) {
+	const start = node.position?.start.offset;
+	const end = node.position?.end.offset;
+	if (start == null || end == null) return {
+		position: false,
+		start: 0,
+		end: 0
+	};
+	return {
+		position: true,
+		start,
+		end
+	};
+}
+
+//#endregion
+//#region src/utils/ast.ts
+/**
+* Checks whether an unknown value behaves like an mdast parent node.
+*
+* This intentionally accepts unknown values because ESLint's ancestor API does
+* not expose mdast-specific types.
+*/
+function hasChildren(node) {
+	return !!node && typeof node === "object" && "children" in node && Array.isArray(node.children);
+}
+/**
+* Narrows any mdast node to a parent-like node with a children array.
+*
+* The Markdown parser can return both container nodes and leaf nodes. This
+* helper keeps traversal code type-safe without relying on a fixed list of
+* container node types.
+*/
+function isParentNode(node) {
+	return "children" in node && Array.isArray(node.children);
+}
+function getNodeContext(context, node) {
+	const parent = context.sourceCode.getAncestors(node).at(-1);
+	if (!hasChildren(parent)) return {
+		prev: void 0,
+		next: void 0,
+		current: node
+	};
+	const currentIndex = parent.children.findIndex((child) => child === node);
+	if (currentIndex === -1) return {
+		parent,
+		prev: void 0,
+		next: void 0,
+		current: node
+	};
+	return {
+		parent,
+		prev: parent.children[currentIndex - 1],
+		next: parent.children[currentIndex + 1],
+		current: node
+	};
+}
+
+//#endregion
+//#region src/utils/rules/anchor.ts
+/**
+* Match the trailing anchor-like fragment from a heading string.
+* @example `中文标题 {#Chinese-Title}` -> `{#Chinese-Title}`
+* @example `使用 describe #Grouping Tests` -> `#Grouping Tests`
+*/
+function getLikeAnchorMatch(str) {
+	const match = str.match(/(\{?#[\w\s`-]+\}?$)/);
+	return match ? match[0] : null;
+}
+/**
+* Parse the trailing anchor-like fragment from a heading string.
+* `isLike` is true when the fragment looks like a loose anchor such as
+* `# Your First Test`; false when it already looks like a compact anchor.
+* `rawLikeAnchor` is the cleaned anchor text without `{`, `}` or leading `#`.
+* @example `# Your First Test` -> { isLike: true, rawLikeAnchor: 'Your First Test' }
+* @example `{#built-in-slug}` -> { isLike: false, rawLikeAnchor: 'built-in-slug' }
+*/
+function getLikeAnchor(str) {
+	if (str === void 0) return null;
+	const match = getLikeAnchorMatch(str);
+	if (!match) return null;
+	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/rules/link.ts
+const LINK_SPACE_MESSAGE_IDS = {
+	missingSpaceBeforeLink: "missingSpaceBeforeLink",
+	missingSpaceAfterLink: "missingSpaceAfterLink",
+	multipleSpacesBeforeLink: "multipleSpacesBeforeLink",
+	multipleSpacesAfterLink: "multipleSpacesAfterLink",
+	multipleSpacesAfterPunctuation: "multipleSpacesAfterPunctuation",
+	unexpectedSpaceBeforeLink: "unexpectedSpaceBeforeLink",
+	unexpectedSpaceAfterLink: "unexpectedSpaceAfterLink"
+};
+const OPENING_PAIRED_PUNCTUATION = new Set([
+	"(",
+	"[",
+	"{",
+	"<",
+	"（",
+	"【",
+	"《",
+	"“",
+	"‘"
+]);
+/**
+* Checks whether the character is fullwidth punctuation.
+* @example `。` -> true
+* @example `,` -> false
+*/
+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 DASH_PUNCTUATION_RE = /^[-\u2013\u2014\u2212]$/u;
+/**
+* Checks whether the character is hyphen-like punctuation.
+* @example `—` -> true
+* @example `.` -> false
+*/
+function isDashPunctuation(str) {
+	if (!str || str.length !== 1) return false;
+	return DASH_PUNCTUATION_RE.test(str);
+}
+/**
+* Checks whether adjacent text is a custom container marker on the next line.
+*
+* @deprecated Temporary workaround to prevent space-between-link from reporting
+* false positives on custom containers. Remove this and handle the case in a
+* dedicated custom container rule when one exists.
+* @see https://vitepress.dev/guide/markdown#custom-containers
+* @example `\n:::` -> true
+* @example `\n::::` -> true
+* @example `:::` -> false
+*/
+function isCustomContainerMarker(str) {
+	return /^[ \t]*\n[ \t]*:{3,}[ \t]*$/u.test(str || "");
+}
+const PUNCTUATION_RE = /^\p{P}$/u;
+/**
+* Checks whether the character is punctuation.
+* Covers fullwidth punctuation, halfwidth punctuation, and other Unicode punctuation characters.
+* @example `。` -> true
+* @example `$` -> false
+*/
+function isPunctuation(str) {
+	if (!str || str.length !== 1) return false;
+	return PUNCTUATION_RE.test(str);
+}
+/**
+* Gets the count and range of consecutive whitespace at the start or end of a string.
+* @example `  text`, `head` -> { count: 2, start: 0, end: 2 }
+* @example `text  `, `tail` -> { count: 2, start: 4, end: 6 }
+*/
+function getWhiteSpace(str, position = "head") {
+	const defaultVal = {
+		count: 0,
+		start: 0,
+		end: 0
+	};
+	if (!str || str.length === 0) return defaultVal;
+	if (position === "head") {
+		const match = str.match(/^\s+/);
+		if (!match || !match[0]) return defaultVal;
+		return {
+			count: match[0].length,
+			start: 0,
+			end: match[0].length
+		};
+	} else {
+		const match = str.match(/\s+$/);
+		if (!match || match.index == null) return defaultVal;
+		return {
+			count: match[0].length,
+			start: match.index,
+			end: str.length
+		};
+	}
+}
+/**
+* Checks whether the start or end of a string is adjacent to punctuation.
+* @example `。 hello`, `head` -> true
+* @example `hello .`, `tail` -> true
+*/
+function hasPunctuation(str, position = "head") {
+	if (!str) return false;
+	str = str.trim();
+	if (position === "head") return isPunctuation(str[0]);
+	else return isPunctuation(str[str.length - 1]);
+}
+/**
+* Gets the character adjacent to the start or end of a string.
+*/
+function getAdjacentChar(str, position) {
+	if (!str) return void 0;
+	str = str.trim();
+	return position === "head" ? str[0] : str[str.length - 1];
+}
+/**
+* Extracts the plain-text value of a phrasing node.
+* If the node does not expose `value`, recursively concatenates the text from its children.
+*/
+function getNodeValue(node) {
+	if (!node) return;
+	if ("value" in node) return node.value;
+	if (isParentNode(node)) return node.children.map(getNodeValue).join("") || void 0;
+}
+/**
+* Gets whitespace and punctuation information for text adjacent to a link or inline code node.
+*/
+function getSpaceContext(nodeContext) {
+	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 whether a spacing run contains exactly one required space.
+*/
+function validateSingleRequiredSpace(count, missingSpaceMessageId, multipleSpacesMessageId) {
+	if (count < 1) return missingSpaceMessageId;
+	if (count > 1) return multipleSpacesMessageId;
+}
+/**
+* Validates the spacing before a link when the previous character is punctuation.
+*/
+function validateSpaceBeforeLinkAfterPunctuation(context) {
+	if (OPENING_PAIRED_PUNCTUATION.has(getAdjacentChar(context.value, "tail") || "")) {
+		if (context.whiteSpace.count > 0) return LINK_SPACE_MESSAGE_IDS.unexpectedSpaceBeforeLink;
+		return;
+	}
+	if (context.punctuationType === "half") return validateSingleRequiredSpace(context.whiteSpace.count, LINK_SPACE_MESSAGE_IDS.missingSpaceBeforeLink, LINK_SPACE_MESSAGE_IDS.multipleSpacesAfterPunctuation);
+	if (context.whiteSpace.count > 0) return LINK_SPACE_MESSAGE_IDS.unexpectedSpaceBeforeLink;
+}
+/**
+* Validates the spacing between the previous node and the current link.
+*/
+function validateSpaceBeforeLink(context) {
+	if (context.hasPunctuation) return validateSpaceBeforeLinkAfterPunctuation(context);
+	return validateSingleRequiredSpace(context.whiteSpace.count, LINK_SPACE_MESSAGE_IDS.missingSpaceBeforeLink, LINK_SPACE_MESSAGE_IDS.multipleSpacesBeforeLink);
+}
+/**
+* Validates the spacing after a link when the next character is punctuation.
+*/
+function validateSpaceAfterLinkBeforePunctuation(context) {
+	if (isDashPunctuation(getAdjacentChar(context.value, "head"))) return validateSingleRequiredSpace(context.whiteSpace.count, LINK_SPACE_MESSAGE_IDS.missingSpaceAfterLink, LINK_SPACE_MESSAGE_IDS.multipleSpacesAfterLink);
+	if (getLikeAnchor(context.value) || isCustomContainerMarker(context.value)) return;
+	if (context.whiteSpace.count > 0) return LINK_SPACE_MESSAGE_IDS.unexpectedSpaceAfterLink;
+}
+/**
+* Validates the spacing between the current link and the next node.
+*/
+function validateSpaceAfterLink(context) {
+	if (context.hasPunctuation) return validateSpaceAfterLinkBeforePunctuation(context);
+	return validateSingleRequiredSpace(context.whiteSpace.count, LINK_SPACE_MESSAGE_IDS.missingSpaceAfterLink, LINK_SPACE_MESSAGE_IDS.multipleSpacesAfterLink);
+}
+/**
+* Validates whether the spacing around a link node follows the typography rules.
+* - Regular text and links should be separated by a single space.
+* - Fullwidth punctuation usually touches the link without spaces.
+* - Halfwidth punctuation, hyphens, and similar cases are handled by dedicated rules.
+*/
+function validateSpace(nodeContext) {
+	const { prev, next } = nodeContext;
+	const spaceContext = getSpaceContext(nodeContext);
+	if (!prev || !spaceContext.prev) return;
+	const beforeLinkIssue = validateSpaceBeforeLink(spaceContext.prev);
+	if (beforeLinkIssue) return beforeLinkIssue;
+	if (!next || !spaceContext.next) return;
+	return validateSpaceAfterLink(spaceContext.next);
+}
+
+//#endregion
+//#region src/rules/space-between-link/index.ts
+const RULE_NAME$1 = "space-between-link";
+const BEFORE_LINK_MESSAGE_IDS = new Set([
+	LINK_SPACE_MESSAGE_IDS.missingSpaceBeforeLink,
+	LINK_SPACE_MESSAGE_IDS.multipleSpacesBeforeLink,
+	LINK_SPACE_MESSAGE_IDS.multipleSpacesAfterPunctuation,
+	LINK_SPACE_MESSAGE_IDS.unexpectedSpaceBeforeLink
+]);
+var space_between_link_default = createRule({
+	name: RULE_NAME$1,
+	meta: {
+		type: "layout",
+		docs: { description: "Enforce spacing around Markdown links: one space next to text, no spaces next to punctuation." },
+		messages: {
+			missingSpaceBeforeLink: "A space is required before the link.",
+			missingSpaceAfterLink: "A space is required after the link.",
+			multipleSpacesBeforeLink: "Use exactly one space before the link.",
+			multipleSpacesAfterLink: "Use exactly one space after the link.",
+			multipleSpacesAfterPunctuation: "Use one space after punctuation.",
+			unexpectedSpaceBeforeLink: "Do not add a space between punctuation and the link.",
+			unexpectedSpaceAfterLink: "Do not add a space between the link and punctuation."
+		},
+		fixable: "whitespace",
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		return { link(node) {
+			const { position, start, end } = getNodePosition(node);
+			if (!position) return;
+			const nodeContext = getNodeContext(context, node);
+			const spaceContext = getSpaceContext(nodeContext);
+			const messageId = validateSpace(nodeContext);
+			if (!messageId) return;
+			if (BEFORE_LINK_MESSAGE_IDS.has(messageId) && spaceContext.prev) {
+				const { count } = spaceContext.prev.whiteSpace;
+				const replaceText = messageId === LINK_SPACE_MESSAGE_IDS.unexpectedSpaceBeforeLink ? "" : " ";
+				context.report({
+					node,
+					messageId,
+					fix(fixer) {
+						return fixer.replaceTextRange([start - count, start], replaceText);
+					}
+				});
+				return;
+			}
+			if (spaceContext.next) {
+				const { count } = spaceContext.next.whiteSpace;
+				const replaceText = messageId === LINK_SPACE_MESSAGE_IDS.unexpectedSpaceAfterLink ? "" : " ";
+				context.report({
+					node,
+					messageId,
+					fix(fixer) {
+						return fixer.replaceTextRange([end, end + count], replaceText);
+					}
+				});
+			}
+		} };
+	}
+});
+
+//#endregion
+//#region src/utils/markdown.ts
+const language = new MarkdownLanguage({ mode: "commonmark" });
+/**
+* Parses Markdown with the same CommonMark language implementation used by the
+* plugin tests and returns both the mdast tree and ESLint SourceCode wrapper.
+*/
+function parseMarkdown(markdown$1) {
+	const file = {
+		path: "test.md",
+		physicalPath: "test.md",
+		bom: false,
+		body: markdown$1
+	};
+	const parseResult = language.parse(file, { languageOptions: {
+		...language.defaultLanguageOptions,
+		frontmatter: "yaml"
+	} });
+	if (!parseResult.ok) throw new Error(parseResult.errors[0]?.message ?? "Failed to parse markdown.");
+	return {
+		ast: parseResult.ast,
+		sourceCode: language.createSourceCode(file, parseResult)
+	};
+}
+
+//#endregion
+//#region src/utils/rules/heading.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);
+	return ast.children[0]?.type === "yaml";
+}
+
+//#endregion
+//#region src/rules/valid-heading-anchor/index.ts
+const RULE_NAME = "valid-heading-anchor";
+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);
+			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 = {
+	"space-between-link": space_between_link_default,
+	"valid-heading-anchor": valid_heading_anchor_default
+};
+
+//#endregion
+//#region src/index.ts
+const plugin = {
+	rules,
+	processors: markdown.processors,
+	languages: {
+		commonmark: new MarkdownLanguage({ mode: "commonmark" }),
+		gfm: new MarkdownLanguage({ mode: "gfm" })
+	}
+};
+const allRuleEntries = Object.keys(rules).map((ruleName) => [`docs-style/${ruleName}`, "error"]);
+const recommendedRules = Object.fromEntries(allRuleEntries);
+const allRules = Object.fromEntries(allRuleEntries);
+const configs = {
+	recommended: {
+		name: "docs-style/recommended",
+		files: ["**/*.md"],
+		plugins: { "docs-style": plugin },
+		language: "docs-style/commonmark",
+		rules: recommendedRules
+	},
+	all: {
+		name: "docs-style/all",
+		files: ["**/*.md"],
+		plugins: { "docs-style": plugin },
+		language: "docs-style/commonmark",
+		rules: allRules
+	}
+};
+const docsStylePlugin = Object.assign(plugin, { configs });
+var src_default = docsStylePlugin;
+
+//#endregion
+export { configs, src_default as default, plugin };

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "eslint-plugin-md-style",
+  "type": "module",
+  "version": "0.1.0-beta.1",
+  "packageManager": "pnpm@10.21.0",
+  "description": "ESLint plugin for enforcing style rules in Markdown-based documentation",
+  "author": "noisefan <noisefan@163.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/NoiseFan/eslint-plugin-md-style#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+github.com:NoiseFan/eslint-plugin-md-style.git"
+  },
+  "bugs": {
+    "url": "https://github.com/NoiseFan/eslint-plugin-md-style/issues"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "pnpm run lint --fix",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
+    "test:cov": "vitest --coverage",
+    "typecheck": "tsc --noEmit",
+    "release": "bumpp",
+    "prepublishOnly": "pnpm run build",
+    "prepare": "simple-git-hooks"
+  },
+  "peerDependencies": {
+    "@eslint/markdown": "^7.5.1",
+    "eslint": "^9.0.0 || ^10.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@antfu/eslint-config": "^6.2.0",
+    "@eslint/markdown": "^7.5.1",
+    "@types/mdast": "^4.0.4",
+    "@types/node": "^24.10.1",
+    "@typescript-eslint/utils": "^8.46.4",
+    "@vitest/coverage-v8": "^4.1.5",
+    "bumpp": "^10.3.1",
+    "eslint": "9.39.1",
+    "eslint-plugin-format": "^1.0.2",
+    "eslint-vitest-rule-tester": "^3.0.0",
+    "lint-staged": "^16.4.0",
+    "simple-git-hooks": "^2.13.1",
+    "tinyglobby": "^0.2.16",
+    "tsdown": "^0.16.4",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.9"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpx lint-staged"
+  },
+  "lint-staged": {
+    "*.{js,ts,md,yml,yaml,json}": [
+      "eslint --cache --fix"
+    ]
+  }
+}