eslint-plugin-markdown-preferences 0.10.0 → 0.12.0

package/README.md

@@ -92,7 +92,10 @@ The rules with the following star ⭐ are included in the configs.
 
 | Rule ID | Description | Fixable | RECOMMENDED |
 |:--------|:------------|:-------:|:-----------:|
+| [markdown-preferences/canonical-code-block-language](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/canonical-code-block-language.html) | enforce canonical language names in code blocks | 🔧 |  |
+| [markdown-preferences/heading-casing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/heading-casing.html) | enforce consistent casing in headings. | 🔧 |  |
 | [markdown-preferences/no-text-backslash-linebreak](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-text-backslash-linebreak.html) | disallow text backslash at the end of a line. |  | ⭐ |
+| [markdown-preferences/ordered-list-marker-start](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-start.html) | enforce that ordered list markers start with 1 or 0 | 🔧 |  |
 | [markdown-preferences/prefer-inline-code-words](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-inline-code-words.html) | enforce the use of inline code for specific words. | 🔧 |  |
 | [markdown-preferences/prefer-linked-words](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-linked-words.html) | enforce the specified word to be a link. | 🔧 |  |
 
@@ -100,13 +103,14 @@ The rules with the following star ⭐ are included in the configs.
 
 | Rule ID | Description | Fixable | RECOMMENDED |
 |:--------|:------------|:-------:|:-----------:|
-| [markdown-preferences/canonical-code-block-language](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/canonical-code-block-language.html) | enforce canonical language names in code blocks | 🔧 |  |
 | [markdown-preferences/definitions-last](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html) | require link definitions and footnote definitions to be placed at the end of the document | 🔧 |  |
 | [markdown-preferences/hard-linebreak-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html) | enforce consistent hard linebreak style. | 🔧 | ⭐ |
-| [markdown-preferences/heading-casing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/heading-casing.html) | enforce consistent casing in headings. | 🔧 |  |
 | [markdown-preferences/no-laziness-blockquotes](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-laziness-blockquotes.html) | disallow laziness in blockquotes |  | ⭐ |
 | [markdown-preferences/no-multiple-empty-lines](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-multiple-empty-lines.html) | disallow multiple empty lines in Markdown files. | 🔧 |  |
 | [markdown-preferences/no-trailing-spaces](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-trailing-spaces.html) | disallow trailing whitespace at the end of lines in Markdown files. | 🔧 |  |
+| [markdown-preferences/ordered-list-marker-sequence](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-sequence.html) | enforce that ordered list markers use sequential numbers | 🔧 |  |
+| [markdown-preferences/prefer-autolinks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html) | enforce the use of autolinks for URLs | 🔧 | ⭐ |
+| [markdown-preferences/prefer-fenced-code-blocks](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-fenced-code-blocks.html) | enforce the use of fenced code blocks over indented code blocks | 🔧 | ⭐ |
 | [markdown-preferences/prefer-link-reference-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-link-reference-definitions.html) | enforce using link reference definitions instead of inline links | 🔧 |  |
 | [markdown-preferences/sort-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/sort-definitions.html) | enforce a specific order for link definitions and footnote definitions | 🔧 |  |
 
@@ -129,7 +133,7 @@ Please use GitHub's Issues/PRs.
 
 ## 🔒 License
 
-See the [LICENSE](LICENSE) file for license rights and limitations (MIT).
+See the [LICENSE](./LICENSE) file for license rights and limitations (MIT).
 
 [npm-package]: https://www.npmjs.com/package/eslint-plugin-markdown-preferences
 [npmtrends]: http://www.npmtrends.com/eslint-plugin-markdown-preferences

package/lib/index.d.ts

@@ -50,6 +50,26 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-trailing-spaces.html
    */
   'markdown-preferences/no-trailing-spaces'?: Linter.RuleEntry<MarkdownPreferencesNoTrailingSpaces>;
+  /**
+   * enforce that ordered list markers use sequential numbers
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-sequence.html
+   */
+  'markdown-preferences/ordered-list-marker-sequence'?: Linter.RuleEntry<[]>;
+  /**
+   * enforce that ordered list markers start with 1 or 0
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-start.html
+   */
+  'markdown-preferences/ordered-list-marker-start'?: Linter.RuleEntry<MarkdownPreferencesOrderedListMarkerStart>;
+  /**
+   * enforce the use of autolinks for URLs
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-autolinks.html
+   */
+  'markdown-preferences/prefer-autolinks'?: Linter.RuleEntry<[]>;
+  /**
+   * enforce the use of fenced code blocks over indented code blocks
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-fenced-code-blocks.html
+   */
+  'markdown-preferences/prefer-fenced-code-blocks'?: Linter.RuleEntry<[]>;
   /**
    * enforce the use of inline code for specific words.
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-inline-code-words.html
@@ -94,6 +114,9 @@ type MarkdownPreferencesNoTrailingSpaces = [] | [{
   skipBlankLines?: boolean;
   ignoreComments?: boolean;
 }];
+type MarkdownPreferencesOrderedListMarkerStart = [] | [{
+  start?: (1 | 0);
+}];
 type MarkdownPreferencesPreferInlineCodeWords = [] | [{
   words: string[];
   ignores?: {
@@ -129,11 +152,14 @@ type MarkdownPreferencesSortDefinitions = [] | [{
   alphabetical?: boolean;
 }];
 declare namespace recommended_d_exports {
-  export { files, language, name$1 as name, plugins, rules$1 as rules };
+  export { files, language, languageOptions, name$1 as name, plugins, rules$1 as rules };
 }
 declare const name$1 = "markdown-preferences/recommended";
 declare const files: string[];
-declare const language = "markdown/commonmark";
+declare const language = "markdown/gfm";
+declare const languageOptions: {
+  frontmatter: string;
+};
 declare const plugins: {
   markdown: typeof markdown;
   readonly "markdown-preferences": ESLint.Plugin;
@@ -143,7 +169,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.10.0";
+declare const version: "0.12.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -56,7 +56,7 @@ var canonical_code_block_language_default = createRule("canonical-code-block-lan
 		docs: {
 			description: "enforce canonical language names in code blocks",
 			categories: [],
-			listCategory: "Stylistic"
+			listCategory: "Preference"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -822,7 +822,7 @@ var heading_casing_default = createRule("heading-casing", {
 		docs: {
 			description: "enforce consistent casing in headings.",
 			categories: [],
-			listCategory: "Stylistic"
+			listCategory: "Preference"
 		},
 		fixable: "code",
 		hasSuggestions: false,
@@ -1464,6 +1464,378 @@ var no_trailing_spaces_default = createRule("no-trailing-spaces", {
 	}
 });
 
+//#endregion
+//#region src/utils/ast.ts
+/**
+* Get the kind of code block.
+*/
+function getCodeBlockKind(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	return text.startsWith("```") ? "backtick-fenced" : text.startsWith("~~~") ? "tilde-fenced" : "indented";
+}
+/**
+* Get the kind of link.
+*/
+function getLinkKind(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	return text.startsWith("[") ? "inline" : text.startsWith("<") && text.endsWith(">") ? "autolink" : "gfm-autolink";
+}
+/**
+* Get the marker of a list item.
+*/
+function getListItemMarker(sourceCode, node) {
+	const item = node.type === "list" ? node.children[0] || node : node;
+	const text = sourceCode.getText(item);
+	if (text.startsWith("-")) return {
+		kind: "-",
+		raw: "-"
+	};
+	if (text.startsWith("*")) return {
+		kind: "*",
+		raw: "*"
+	};
+	if (text.startsWith("+")) return {
+		kind: "+",
+		raw: "+"
+	};
+	const matchDot = /^(\d+)\./.exec(text);
+	if (matchDot) return {
+		kind: ".",
+		raw: matchDot[0],
+		sequence: Number(matchDot[1])
+	};
+	const matchParen = /^(\d+)\)/.exec(text);
+	return {
+		kind: ")",
+		raw: matchParen[0],
+		sequence: Number(matchParen[1])
+	};
+}
+
+//#endregion
+//#region src/rules/ordered-list-marker-sequence.ts
+var ordered_list_marker_sequence_default = createRule("ordered-list-marker-sequence", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce that ordered list markers use sequential numbers",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			inconsistent: "Ordered list marker should be '{{expected}}' but found '{{actual}}'.",
+			inconsistentStart: "Ordered list start should be {{expected}} but found '{{actual}}'.",
+			suggestStartFromN: "Change list marker to start from '{{expected}}'."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		let scope = {
+			node: sourceCode.ast,
+			upper: null,
+			last: null
+		};
+		/**
+		* Verify the list start sequence.
+		*/
+		function verifyStartSequence(node, marker) {
+			if (node.start == null || node.start <= 1) return true;
+			if (scope.last != null && scope.last.sequence + 1 === node.start && marker.kind === scope.last.kind) return true;
+			const expected = [0, 1];
+			if (scope.last != null && marker.kind === scope.last.kind) expected.push(scope.last.sequence + 1);
+			const suggest = [];
+			for (const n of [...expected].sort((a, b) => Math.abs(node.start - a) - Math.abs(node.start - b))) suggest.push({
+				messageId: "suggestStartFromN",
+				data: { expected: String(n) },
+				fix(fixer) {
+					const expectedMarker = `${n}${marker.kind}`;
+					const range = sourceCode.getRange(node);
+					return fixer.replaceTextRange([range[0], range[0] + marker.raw.length], expectedMarker);
+				}
+			});
+			context.report({
+				node: node.children[0] || node,
+				messageId: "inconsistentStart",
+				data: {
+					expected: new Intl.ListFormat("en-US", { type: "disjunction" }).format(expected.map((n) => `'${n}'`)),
+					actual: String(marker.sequence)
+				},
+				fix: scope.last == null ? (fixer) => {
+					const expectedMarker = `1${marker.kind}`;
+					const range = sourceCode.getRange(node);
+					return fixer.replaceTextRange([range[0], range[0] + marker.raw.length], expectedMarker);
+				} : null,
+				suggest
+			});
+			return false;
+		}
+		/**
+		* Verify the list item markers.
+		*/
+		function verifyListItems(node) {
+			if (node.start == null) return;
+			for (let i = 0; i < node.children.length; i++) {
+				const item = node.children[i];
+				const marker = getListItemMarker(sourceCode, item);
+				if (marker.kind !== "." && marker.kind !== ")") continue;
+				const expectedSequence = node.start + i;
+				if (marker.sequence !== expectedSequence) {
+					const expectedMarker = `${expectedSequence}${marker.kind}`;
+					context.report({
+						node: item,
+						messageId: "inconsistent",
+						data: {
+							expected: expectedMarker,
+							actual: marker.raw
+						},
+						fix(fixer) {
+							const range = sourceCode.getRange(item);
+							return fixer.replaceTextRange([range[0], range[0] + marker.raw.length], expectedMarker);
+						}
+					});
+				}
+			}
+		}
+		return {
+			"blockquote, listItem, footnoteDefinition"(node) {
+				scope = {
+					node,
+					upper: scope,
+					last: null
+				};
+			},
+			"blockquote, listItem, footnoteDefinition:exit"(node) {
+				if (scope.node === node) scope = scope.upper;
+			},
+			heading() {
+				scope.last = null;
+			},
+			list(node) {
+				if (!node.ordered || node.start == null) return;
+				const marker = getListItemMarker(sourceCode, node);
+				if (marker.kind !== "." && marker.kind !== ")") return;
+				verifyStartSequence(node, marker);
+				verifyListItems(node);
+				scope.last = {
+					kind: marker.kind,
+					sequence: node.start + node.children.length - 1
+				};
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/ordered-list-marker-start.ts
+var ordered_list_marker_start_default = createRule("ordered-list-marker-start", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce that ordered list markers start with 1 or 0",
+			categories: [],
+			listCategory: "Preference"
+		},
+		fixable: "code",
+		hasSuggestions: true,
+		schema: [{
+			type: "object",
+			properties: { start: { enum: [1, 0] } },
+			additionalProperties: false
+		}],
+		messages: {
+			wrongStart: "Ordered list should start with {{expected}} but found '{{actual}}'.",
+			suggestStartFromN: "Change list marker to start from '{{expected}}'."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const option = context.options[0] || {};
+		const expectedStart = option.start ?? 1;
+		let scope = {
+			node: sourceCode.ast,
+			upper: null,
+			last: null
+		};
+		/**
+		* Verify the list start sequence.
+		*/
+		function verifyStartSequence(node, marker) {
+			if (node.start == null || node.start === expectedStart) return;
+			if (scope.last != null && scope.last.sequence + 1 === node.start && marker.kind === scope.last.kind) return;
+			const expected = [expectedStart];
+			if (scope.last != null && marker.kind === scope.last.kind) expected.push(scope.last.sequence + 1);
+			if (expected.includes(node.start)) return;
+			const suggest = [];
+			for (const n of [...expected].sort((a, b) => Math.abs(node.start - a) - Math.abs(node.start - b))) suggest.push({
+				messageId: "suggestStartFromN",
+				data: { expected: String(n) },
+				fix(fixer) {
+					const expectedMarker = `${n}${marker.kind}`;
+					const range = sourceCode.getRange(node);
+					return fixer.replaceTextRange([range[0], range[0] + marker.raw.length], expectedMarker);
+				}
+			});
+			context.report({
+				node: node.children[0] || node,
+				messageId: "wrongStart",
+				data: {
+					expected: new Intl.ListFormat("en-US", { type: "disjunction" }).format(expected.map((n) => `'${n}'`)),
+					actual: String(node.start)
+				},
+				fix: suggest.length === 1 ? suggest[0].fix : void 0,
+				suggest: suggest.length === 1 ? [] : suggest
+			});
+		}
+		return {
+			"blockquote, listItem, footnoteDefinition"(node) {
+				scope = {
+					node,
+					upper: scope,
+					last: null
+				};
+			},
+			"blockquote, listItem, footnoteDefinition:exit"(node) {
+				if (scope.node === node) scope = scope.upper;
+			},
+			heading() {
+				scope.last = null;
+			},
+			list(node) {
+				if (!node.ordered || node.start == null) return;
+				const marker = getListItemMarker(sourceCode, node);
+				if (marker.kind !== "." && marker.kind !== ")") return;
+				verifyStartSequence(node, marker);
+				scope.last = {
+					kind: marker.kind,
+					sequence: node.start + node.children.length - 1
+				};
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/prefer-autolinks.ts
+var prefer_autolinks_default = createRule("prefer-autolinks", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce the use of autolinks for URLs",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [],
+		messages: {
+			useAutolinkInsteadGFMAutolink: "Use an autolink instead of a GFM autolink (bare url).",
+			useAutolinkInsteadInlineLink: "Use an autolink instead of an inline link with the same URL."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		return { link(node) {
+			const kind = getLinkKind(sourceCode, node);
+			if (kind === "autolink") return;
+			if (node.title) return;
+			if (node.children.some((child) => child.type !== "text")) return;
+			const label = node.children.map((child) => child.value).join("");
+			if (node.url !== label) return;
+			context.report({
+				node,
+				messageId: kind === "inline" ? "useAutolinkInsteadInlineLink" : "useAutolinkInsteadGFMAutolink",
+				fix(fixer) {
+					return fixer.replaceText(node, `<${node.url}>`);
+				}
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/prefer-fenced-code-blocks.ts
+var prefer_fenced_code_blocks_default = createRule("prefer-fenced-code-blocks", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce the use of fenced code blocks over indented code blocks",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [],
+		messages: { useFencedCodeBlock: "Use a fenced code block instead of an indented code block." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const lines = parseLines(sourceCode);
+		return { code(node) {
+			const kind = getCodeBlockKind(sourceCode, node);
+			if (kind === "backtick-fenced" || kind === "tilde-fenced") return;
+			const loc = sourceCode.getLoc(node);
+			context.report({
+				node,
+				messageId: "useFencedCodeBlock",
+				fix(fixer) {
+					if (!isFixableIndentedCodeBlock(node)) return null;
+					const startColumnOffset = loc.start.column - 1;
+					const removeRanges = [];
+					let prefixText = null;
+					for (let line = loc.start.line; line <= loc.end.line; line++) {
+						const parsedLine = lines.get(line);
+						const currentPrefix = normalizePrefix(parsedLine.text.slice(0, startColumnOffset));
+						if (!prefixText) prefixText = currentPrefix;
+						else if (currentPrefix !== prefixText) return null;
+						let removeRange = [parsedLine.range[0] + startColumnOffset, parsedLine.range[0] + startColumnOffset + 4];
+						for (let index = removeRange[0]; index < removeRange[1]; index++) {
+							const c = sourceCode.text[index];
+							if (c === " ") continue;
+							if (c === "	") {
+								removeRange = [removeRange[0], index + 1];
+								break;
+							}
+							return null;
+						}
+						removeRanges.push(removeRange);
+					}
+					const beginFenceInsertOffset = lines.get(loc.start.line).range[0];
+					const endFenceInsertOffset = lines.get(loc.end.line).range[1];
+					return [
+						fixer.insertTextBeforeRange([beginFenceInsertOffset, beginFenceInsertOffset], `${prefixText}\`\`\`\n`),
+						...removeRanges.map((removeRange) => fixer.removeRange(removeRange)),
+						fixer.insertTextAfterRange([endFenceInsertOffset, endFenceInsertOffset], `${prefixText}\`\`\`\n`)
+					];
+				}
+			});
+		} };
+		/**
+		* Determines whether the given indented code block is fixable or not.
+		*/
+		function isFixableIndentedCodeBlock(node) {
+			if (!node.value.startsWith(" ")) return true;
+			const loc = sourceCode.getLoc(node);
+			const firstLine = lines.get(loc.start.line);
+			const codeBlockFirstLine = normalizePrefix(node.value.split(/\r?\n/u)[0]);
+			const startColumnOffset = loc.start.column - 1;
+			const normalizedFirstLine = normalizePrefix(firstLine.text.slice(startColumnOffset));
+			return normalizedFirstLine.startsWith(codeBlockFirstLine);
+		}
+	}
+});
+/**
+* Normalize the prefix by removing tabs and replacing them with spaces.
+*/
+function normalizePrefix(prefix) {
+	let result = "";
+	for (const c of prefix) if (c !== "	") result += c;
+	else result += " ".repeat(4 - result.length % 4);
+	return result;
+}
+
 //#endregion
 //#region src/utils/search-words.ts
 const RE_BOUNDARY = /^[\s\p{Letter_Number}\p{Modifier_Letter}\p{Modifier_Symbol}\p{Nonspacing_Mark}\p{Other_Letter}\p{Other_Symbol}\p{Script=Han}!"#$%&'()*+,./:;<=>?\\{|}~\u{2ffc}-\u{303d}\u{30a0}-\u{30fb}\u{3192}-\u{32bf}\u{fe10}-\u{fe1f}\u{fe30}-\u{fe6f}\u{ff00}-\u{ffef}\u{2ebf0}-\u{2ee5d}]*$/u;
@@ -2201,6 +2573,10 @@ const rules$1 = [
 	no_multiple_empty_lines_default,
 	no_text_backslash_linebreak_default,
 	no_trailing_spaces_default,
+	ordered_list_marker_sequence_default,
+	ordered_list_marker_start_default,
+	prefer_autolinks_default,
+	prefer_fenced_code_blocks_default,
 	prefer_inline_code_words_default,
 	prefer_link_reference_definitions_default,
 	prefer_linked_words_default,
@@ -2213,13 +2589,15 @@ var recommended_exports = {};
 __export(recommended_exports, {
 	files: () => files,
 	language: () => language,
+	languageOptions: () => languageOptions,
 	name: () => name$1,
 	plugins: () => plugins,
 	rules: () => rules$2
 });
 const name$1 = "markdown-preferences/recommended";
 const files = ["*.md", "**/*.md"];
-const language = "markdown/commonmark";
+const language = "markdown/gfm";
+const languageOptions = { frontmatter: "yaml" };
 const plugins = {
 	markdown,
 	get "markdown-preferences"() {
@@ -2229,7 +2607,9 @@ const plugins = {
 const rules$2 = {
 	"markdown-preferences/hard-linebreak-style": "error",
 	"markdown-preferences/no-laziness-blockquotes": "error",
-	"markdown-preferences/no-text-backslash-linebreak": "error"
+	"markdown-preferences/no-text-backslash-linebreak": "error",
+	"markdown-preferences/prefer-autolinks": "error",
+	"markdown-preferences/prefer-fenced-code-blocks": "error"
 };
 
 //#endregion
@@ -2240,7 +2620,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.10.0";
+const version = "0.12.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {
@@ -83,7 +83,7 @@
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-eslint-plugin": "^7.0.0",
-    "eslint-plugin-jsdoc": "^52.0.0",
+    "eslint-plugin-jsdoc": "^54.0.0",
     "eslint-plugin-json-schema-validator": "^5.3.1",
     "eslint-plugin-jsonc": "^2.19.1",
     "eslint-plugin-markdown": "^5.1.0",
@@ -107,7 +107,7 @@
     "stylelint-config-recommended-vue": "^1.6.0",
     "stylelint-config-standard": "^39.0.0",
     "stylelint-config-standard-vue": "^1.0.0",
-    "tsdown": "^0.13.1",
+    "tsdown": "^0.14.0",
     "tsx": "^4.19.3",
     "twoslash-eslint": "^0.3.1",
     "type-fest": "^4.37.0",