@kazupon/eslint-plugin 0.4.0 → 0.6.0

package/README.md

@@ -61,11 +61,12 @@ The rules with the following star ⭐ are included in the configs.
 
 ### @kazupon/eslint-plugin Rules
 
-| Rule ID                                                                                                          | Description                                     | Category | Fixable | RECOMMENDED |
-| :--------------------------------------------------------------------------------------------------------------- | :---------------------------------------------- | :------- | :-----: | :---------: |
-| [@kazupon/enforce-header-comment](https://eslint-plugin.kazupon.dev/rules/enforce-header-comment.html)           | Enforce heading the comment in source code file | Comment  |         |     ⭐      |
-| [@kazupon/no-tag-comments](https://eslint-plugin.kazupon.dev/rules/no-tag-comments.html)                         | disallow tag comments                           | Comment  |         |     ⭐      |
-| [@kazupon/prefer-scope-on-tag-comment](https://eslint-plugin.kazupon.dev/rules/prefer-scope-on-tag-comment.html) | enforce adding a scope to tag comments          | Comment  |         |     ⭐      |
+| Rule ID                                                                                                                      | Description                                                   | Category | Fixable | RECOMMENDED |
+| :--------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------ | :------- | :-----: | :---------: |
+| [@kazupon/enforce-header-comment](https://eslint-plugin.kazupon.dev/rules/enforce-header-comment.html)                       | Enforce heading the comment in source code file               | Comment  |         |     ⭐      |
+| [@kazupon/no-tag-comments](https://eslint-plugin.kazupon.dev/rules/no-tag-comments.html)                                     | disallow tag comments                                         | Comment  |         |     ⭐      |
+| [@kazupon/prefer-inline-code-words-comments](https://eslint-plugin.kazupon.dev/rules/prefer-inline-code-words-comments.html) | enforce the use of inline code for specific words on comments | Comment  |   🔧    |     ⭐      |
+| [@kazupon/prefer-scope-on-tag-comment](https://eslint-plugin.kazupon.dev/rules/prefer-scope-on-tag-comment.html)             | enforce adding a scope to tag comments                        | Comment  |         |     ⭐      |
 
 <!--RULES_TABLE_END-->
 

package/lib/index.d.ts

@@ -10,8 +10,17 @@ declare const plugin: Omit<ESLint.Plugin, "configs"> & {
 };
 declare const recommendedConfig: Linter.Config[];
 declare const commentConfig: Linter.Config[];
+/**
+* Plugin Configurations.
+*/
 declare const configs: {
+  /**
+  * Recommended configuration
+  */
   recommended: typeof recommendedConfig;
+  /**
+  * Comment configuration
+  */
   comment: typeof commentConfig;
 };
 /** @alias */

package/lib/index.js

@@ -1,5 +1,194 @@
 import { parseComment } from "@es-joy/jsdoccomment";
 
+//#region src/utils/comment.ts
+/**
+* Remove JSDoc asterisk prefix if present
+*
+* @param line - The line of text to strip
+* @returns The stripped line of text
+*/
+function stripJSDocPrefix(line) {
+	const trimmed = line.trim();
+	return trimmed.startsWith("*") ? trimmed.slice(1).trim() : trimmed;
+}
+/**
+* Check if the text starts with any of the given tags
+*
+* @param text - The text to check
+* @param tags - Array of tags to search for
+* @returns Tag detection result or null if no tag found
+*/
+function detectTag(text, tags) {
+	for (const tag of tags) {
+		const tagRegex = /* @__PURE__ */ new RegExp(`^${tag}\\b`);
+		const match = text.match(tagRegex);
+		if (match) {
+			const afterTag = text.slice(tag.length);
+			if (afterTag.startsWith("(")) {
+				const closingParenIndex = afterTag.indexOf(")");
+				if (closingParenIndex > 0) {
+					const scope = afterTag.slice(1, closingParenIndex).trim();
+					return {
+						tag,
+						hasScope: scope.length > 0
+					};
+				}
+				return {
+					tag,
+					hasScope: false
+				};
+			}
+			if (afterTag === "" || afterTag.startsWith(":") || afterTag.startsWith(" ")) return {
+				tag,
+				hasScope: false
+			};
+		}
+	}
+	return null;
+}
+/**
+* Calculate the exact location of a tag in a comment
+*
+* @param comment - The comment containing the tag
+* @param line - The line of text containing the tag
+* @param lineIndex - The index of the line within the comment
+* @param tag - The tag to locate
+* @returns Location with line and column, or null if not found
+*/
+function calculateTagLocation(comment, line, lineIndex, tag) {
+	const tagIndex = line.indexOf(tag);
+	if (tagIndex === -1) return null;
+	if (lineIndex === 0) {
+		const tagIndexInValue = comment.value.indexOf(tag);
+		return tagIndexInValue === -1 ? null : {
+			line: comment.loc.start.line,
+			column: comment.loc.start.column + 2 + tagIndexInValue
+		};
+	} else return {
+		line: comment.loc.start.line + lineIndex,
+		column: tagIndex
+	};
+}
+/**
+* Process all comments in a source file
+*
+* @param sourceCode - The ESLint source code object
+* @param callback - Function to call for each comment
+*/
+function processAllComments(sourceCode, callback) {
+	const comments = sourceCode.getAllComments();
+	for (const comment of comments) callback(comment);
+}
+/**
+* Calculate the position of a word in a comment
+*
+* @param comment - The comment containing the word
+* @param wordIndex - The index of the word in the comment value
+* @param _word - The word itself (unused but needed for API compatibility)
+* @returns Location with line and column
+*/
+function calculateWordPosition(comment, wordIndex, _word) {
+	const { value, type } = comment;
+	if (type === "Line") return {
+		line: comment.loc.start.line,
+		column: comment.loc.start.column + 2 + wordIndex
+	};
+	const beforeMatch = value.slice(0, Math.max(0, wordIndex));
+	const beforeLines = beforeMatch.split("\n");
+	const lineIndex = beforeLines.length - 1;
+	const line = comment.loc.start.line + lineIndex;
+	if (lineIndex === 0) return {
+		line,
+		column: comment.loc.start.column + 2 + beforeMatch.length
+	};
+	else {
+		const columnInValue = beforeMatch.length - beforeLines.slice(0, -1).join("\n").length - 1;
+		return {
+			line,
+			column: Math.max(0, columnInValue)
+		};
+	}
+}
+/**
+* Report a comment violation with standardized location handling
+*
+* @param ctx - The ESLint rule context
+* @param comment - The comment where the violation occurred
+* @param messageId - The message ID to report
+* @param data - Data for the message template
+* @param location - Optional specific location within the comment
+*/
+function reportCommentViolation(ctx, comment, messageId, data, location) {
+	if (!comment.loc) {
+		ctx.report({
+			messageId,
+			data,
+			node: ctx.sourceCode.ast
+		});
+		return;
+	}
+	if (location) ctx.report({
+		messageId,
+		data,
+		loc: {
+			start: {
+				line: location.line,
+				column: location.column
+			},
+			end: {
+				line: location.line,
+				column: location.column + (location.length || 0)
+			}
+		}
+	});
+	else ctx.report({
+		messageId,
+		data,
+		loc: comment.loc
+	});
+}
+/**
+* Parse directive comment and extract description
+* Handles both eslint-style (--) and TypeScript-style (space) separators
+*
+* @param text - The comment text to parse
+* @param directives - List of directive patterns to check for
+* @returns Parsed directive info or null if not a directive
+*/
+function parseDirectiveComment(text, directives) {
+	const trimmedText = text.trim();
+	for (const directive of directives) if (trimmedText.startsWith(directive)) {
+		const afterDirective = trimmedText.slice(directive.length);
+		const separatorIndex = afterDirective.indexOf("--");
+		if (separatorIndex !== -1) {
+			const description = afterDirective.slice(separatorIndex + 2).trim();
+			const separatorPos = text.indexOf("--");
+			const afterSeparator = text.slice(separatorPos + 2);
+			const descriptionStart = separatorPos + 2 + (afterSeparator.length - afterSeparator.trimStart().length);
+			return {
+				directive,
+				description,
+				descriptionStart
+			};
+		}
+		if (afterDirective.trim()) {
+			const spaceMatch = afterDirective.match(/^\s+/);
+			if (spaceMatch) {
+				const description = afterDirective.trim();
+				const directiveIndex = text.indexOf(directive);
+				const descriptionStart = directiveIndex + directive.length + spaceMatch[0].length;
+				return {
+					directive,
+					description,
+					descriptionStart
+				};
+			}
+		}
+	}
+	return null;
+}
+
+//#endregion
 //#region src/utils/constants.ts
 /**
 * @author kazuya kawaguchi (a.k.a. kazupon)
@@ -12,7 +201,7 @@ const name = "@kazupon/eslint-plugin";
 /**
 * The plugin version.
 */
-const version = "0.4.0";
+const version = "0.6.0";
 /**
 * The namespace for rules
 */
@@ -22,7 +211,7 @@ const namespace = "@kazupon";
 //#region src/utils/rule.ts
 const BLOB_URL = "https://eslint-plugin.kazupon.dev/rules";
 function RuleCreator(urlCreator, namespace$1 = "") {
-	return function createNamedRule({ meta, name: name$1,...rule$3 }) {
+	return function createNamedRule({ meta, name: name$1,...rule$4 }) {
 		const ruleId = namespace$1 ? `${namespace$1}/${name$1}` : name$1;
 		return {
 			meta: {
@@ -34,7 +223,7 @@ function RuleCreator(urlCreator, namespace$1 = "") {
 					ruleId
 				}
 			},
-			...rule$3
+			...rule$4
 		};
 	};
 }
@@ -53,7 +242,7 @@ function initializeTagDiagnosis(tags) {
 function validTagDiagnosis(tagDiagnosis) {
 	return Object.keys(tagDiagnosis).every((tag) => tagDiagnosis[tag] === "ok");
 }
-const rule$2 = createRule({
+const rule$3 = createRule({
 	name: "enforce-header-comment",
 	meta: {
 		type: "suggestion",
@@ -74,6 +263,7 @@ const rule$2 = createRule({
 	create(ctx) {
 		/**
 		* Report the tag diagnosis
+		*
 		* @param comment - A target comment node
 		* @param tags - A list of tags to check
 		* @param tagDiagnosis - A map of tag diagnosis
@@ -83,11 +273,7 @@ const rule$2 = createRule({
 			let reported = false;
 			for (const tag of tags) {
 				if (tagDiagnosis[tag] === "ok") continue;
-				ctx.report({
-					loc: comment.loc,
-					messageId: tagDiagnosis[tag] === "require" ? "headerCommentNeedTag" : "headerCommentNeedTagValue",
-					data: { tag }
-				});
+				reportCommentViolation(ctx, comment, tagDiagnosis[tag] === "require" ? "headerCommentNeedTag" : "headerCommentNeedTagValue", { tag });
 				reported = true;
 			}
 			return reported;
@@ -181,78 +367,33 @@ const rule$2 = createRule({
 		};
 	}
 });
-var enforce_header_comment_default = rule$2;
+var enforce_header_comment_default = rule$3;
 
 //#endregion
-//#region src/utils/comment.ts
-/**
-* Remove JSDoc asterisk prefix if present
-*/
-function stripJSDocPrefix(line) {
-	const trimmed = line.trim();
-	return trimmed.startsWith("*") ? trimmed.slice(1).trim() : trimmed;
-}
+//#region src/utils/options.ts
 /**
-* Check if the text starts with any of the given tags
-* @param text The text to check
-* @param tags Array of tags to search for
-* @returns Tag detection result or null if no tag found
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
 */
-function detectTag(text, tags) {
-	for (const tag of tags) {
-		const tagRegex = new RegExp(`^${tag}\\b`);
-		const match = text.match(tagRegex);
-		if (match) {
-			const afterTag = text.slice(tag.length);
-			if (afterTag.startsWith("(")) {
-				const closingParenIndex = afterTag.indexOf(")");
-				if (closingParenIndex > 0) {
-					const scope = afterTag.slice(1, closingParenIndex).trim();
-					return {
-						tag,
-						hasScope: scope.length > 0
-					};
-				}
-				return {
-					tag,
-					hasScope: false
-				};
-			}
-			if (afterTag === "" || afterTag.startsWith(":") || afterTag.startsWith(" ")) return {
-				tag,
-				hasScope: false
-			};
-		}
-	}
-	return null;
-}
 /**
-* Calculate the exact location of a tag in a comment
-* @param comment The comment containing the tag
-* @param line The line of text containing the tag
-* @param lineIndex The index of the line within the comment
-* @param tag The tag to locate
-* @returns Location with line and column, or null if not found
+* Parse array options with defaults
+*
+* @typeParam T - The type of the options object
+*
+* @param options - The options object that may contain array fields
+* @param arrayFields - Object mapping field names to their default arrays
+* @returns The parsed options with default arrays applied
 */
-function calculateTagLocation(comment, line, lineIndex, tag) {
-	const tagIndex = line.indexOf(tag);
-	if (tagIndex === -1) return null;
-	if (lineIndex === 0) {
-		const tagIndexInValue = comment.value.indexOf(tag);
-		return tagIndexInValue === -1 ? null : {
-			line: comment.loc.start.line,
-			column: comment.loc.start.column + 2 + tagIndexInValue
-		};
-	} else return {
-		line: comment.loc.start.line + lineIndex,
-		column: tagIndex
-	};
+function parseArrayOptions(options, arrayFields) {
+	const result = options ? { ...options } : {};
+	for (const [field, defaultArray] of Object.entries(arrayFields)) if (!result[field] || !Array.isArray(result[field])) result[field] = defaultArray;
+	return result;
 }
 
 //#endregion
 //#region src/rules/no-tag-comments.ts
 const DEFAULT_TAGS$1 = ["FIXME", "BUG"];
-const rule$1 = createRule({
+const rule$2 = createRule({
 	name: "no-tag-comments",
 	meta: {
 		type: "problem",
@@ -275,35 +416,26 @@ const rule$1 = createRule({
 		}]
 	},
 	create(ctx) {
-		const options = ctx.options[0] || { tags: DEFAULT_TAGS$1 };
-		const tags = options.tags || DEFAULT_TAGS$1;
+		const options = parseArrayOptions(ctx.options[0], { tags: DEFAULT_TAGS$1 });
+		const tags = options.tags;
 		const sourceCode = ctx.sourceCode;
 		/**
 		* Report a tag comment violation
+		*
+		* @param comment - The comment node to report
+		* @param tag - The tag that was found in the comment
+		* @param loc - Optional location information for the tag
 		*/
 		function reportTag(comment, tag, loc) {
-			if (loc && comment.loc) ctx.report({
-				messageId: "tagComment",
-				data: { tag },
-				loc: {
-					start: {
-						line: loc.line,
-						column: loc.column
-					},
-					end: {
-						line: loc.line,
-						column: loc.column + tag.length
-					}
-				}
-			});
-			else ctx.report({
-				messageId: "tagComment",
-				data: { tag },
-				loc: comment.loc
-			});
+			reportCommentViolation(ctx, comment, "tagComment", { tag }, loc ? {
+				...loc,
+				length: tag.length
+			} : void 0);
 		}
 		/**
 		* Check a comment for tag violations
+		*
+		* @param comment - The comment node to check
 		*/
 		function checkComment(comment) {
 			const { value, type } = comment;
@@ -334,12 +466,124 @@ const rule$1 = createRule({
 			}
 		}
 		return { Program() {
-			const comments = sourceCode.getAllComments();
-			for (const comment of comments) checkComment(comment);
+			processAllComments(sourceCode, checkComment);
+		} };
+	}
+});
+var no_tag_comments_default = rule$2;
+
+//#endregion
+//#region src/utils/regex.ts
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Escape special regex characters in a string
+*
+* @param str - The string to escape
+* @returns The escaped string
+*/
+function escapeRegExp(str) {
+	return str.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+/**
+* Create a regex pattern with word boundaries
+*
+* @param word - The word to match
+* @param flags - Optional regex flags
+* @returns A RegExp that matches the word with boundaries
+*/
+function createWordBoundaryRegex(word, flags = "g") {
+	const escapedWord = escapeRegExp(word);
+	return new RegExp(`\\b${escapedWord}\\b`, flags);
+}
+/**
+* Check if a word at a given index is wrapped with specific delimiters
+*
+* @param text - The text to check
+* @param index - The starting index of the word
+* @param word - The word to check
+* @param startDelimiter - The starting delimiter (default: '`')
+* @param endDelimiter - The ending delimiter (default: '`')
+* @returns True if the word is wrapped with the delimiters
+*/
+function isWordWrapped(text, index, word, startDelimiter = "`", endDelimiter = "`") {
+	const beforeIndex = index - 1;
+	const afterIndex = index + word.length;
+	return beforeIndex >= 0 && afterIndex < text.length && text[beforeIndex] === startDelimiter && text[afterIndex] === endDelimiter;
+}
+
+//#endregion
+//#region src/rules/prefer-inline-code-words-comments.ts
+const rule$1 = createRule({
+	name: "prefer-inline-code-words-comments",
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "enforce the use of inline code for specific words on comments",
+			category: "Comment",
+			recommended: true,
+			defaultSeverity: "error"
+		},
+		fixable: "code",
+		messages: { missingInlineCode: "The word \"{{word}}\" should be wrapped in inline code" },
+		schema: [{
+			type: "object",
+			properties: { words: {
+				type: "array",
+				items: { type: "string" },
+				minItems: 1,
+				uniqueItems: true
+			} },
+			required: ["words"],
+			additionalProperties: false
+		}]
+	},
+	create(ctx) {
+		const options = ctx.options[0];
+		if (!options || !options.words || options.words.length === 0) return {};
+		const words = options.words;
+		const sourceCode = ctx.sourceCode;
+		/**
+		* Check a comment for words that should be wrapped in inline code
+		*
+		* @param comment - The comment node to check
+		*/
+		function checkComment(comment) {
+			const { value } = comment;
+			for (const word of words) {
+				const regex = createWordBoundaryRegex(word);
+				let match;
+				while ((match = regex.exec(value)) !== null) {
+					const index = match.index;
+					if (isWordWrapped(value, index, word)) continue;
+					const position = calculateWordPosition(comment, index, word);
+					ctx.report({
+						messageId: "missingInlineCode",
+						data: { word },
+						loc: {
+							start: position,
+							end: {
+								line: position.line,
+								column: position.column + word.length
+							}
+						},
+						fix(fixer) {
+							const startOffset = comment.range[0] + 2 + index;
+							const endOffset = startOffset + word.length;
+							return fixer.replaceTextRange([startOffset, endOffset], `\`${word}\``);
+						}
+					});
+				}
+			}
+		}
+		return { Program() {
+			processAllComments(sourceCode, checkComment);
 		} };
 	}
 });
-var no_tag_comments_default = rule$1;
+var prefer_inline_code_words_comments_default = rule$1;
 
 //#endregion
 //#region src/rules/prefer-scope-on-tag-comment.ts
@@ -350,6 +594,14 @@ const DEFAULT_TAGS = [
 	"BUG",
 	"NOTE"
 ];
+const DEFAULT_DIRECTIVES = [
+	"eslint-disable",
+	"eslint-disable-next-line",
+	"eslint-disable-line",
+	"@ts-expect-error",
+	"@ts-ignore",
+	"@ts-nocheck"
+];
 const rule = createRule({
 	name: "prefer-scope-on-tag-comment",
 	meta: {
@@ -363,57 +615,63 @@ const rule = createRule({
 		messages: { missingScope: "Tag comment '{{tag}}' is missing a scope. Use format: {{tag}}(scope)" },
 		schema: [{
 			type: "object",
-			properties: { tags: {
-				type: "array",
-				items: { type: "string" },
-				minItems: 1,
-				uniqueItems: true
-			} },
+			properties: {
+				tags: {
+					type: "array",
+					items: { type: "string" },
+					minItems: 1,
+					uniqueItems: true
+				},
+				directives: {
+					type: "array",
+					items: { type: "string" },
+					minItems: 1,
+					uniqueItems: true
+				}
+			},
 			additionalProperties: false
 		}]
 	},
 	create(ctx) {
-		const options = ctx.options[0] || { tags: DEFAULT_TAGS };
-		const tags = options.tags || DEFAULT_TAGS;
+		const options = parseArrayOptions(ctx.options[0], {
+			tags: DEFAULT_TAGS,
+			directives: DEFAULT_DIRECTIVES
+		});
+		const tags = options.tags;
+		const directives = options.directives;
 		const sourceCode = ctx.sourceCode;
 		/**
 		* Report a missing scope violation
+		*
+		* @param comment - The comment node to report
+		* @param tag - The tag that is missing a scope
 		*/
 		function reportMissingScope(comment, tag, loc) {
-			if (!comment.loc) {
-				ctx.report({
-					messageId: "missingScope",
-					data: { tag },
-					node: ctx.sourceCode.ast
-				});
-				return;
-			}
-			if (loc && comment.loc) ctx.report({
-				messageId: "missingScope",
-				data: { tag },
-				loc: {
-					start: {
-						line: loc.line,
-						column: loc.column
-					},
-					end: {
-						line: loc.line,
-						column: loc.column + tag.length
-					}
-				}
-			});
-			else ctx.report({
-				messageId: "missingScope",
-				data: { tag },
-				loc: comment.loc
-			});
+			reportCommentViolation(ctx, comment, "missingScope", { tag }, loc ? {
+				...loc,
+				length: tag.length
+			} : void 0);
 		}
 		/**
 		* Check a comment for missing scope
+		*
+		* @param comment - The comment node to check
 		*/
 		function checkComment(comment) {
 			const { value, type } = comment;
 			if (type === "Line") {
+				const directiveInfo$1 = parseDirectiveComment(value, directives);
+				if (directiveInfo$1) {
+					const tagInfo$1 = detectTag(directiveInfo$1.description, tags);
+					if (tagInfo$1 && !tagInfo$1.hasScope) {
+						const tagIndex = directiveInfo$1.description.indexOf(tagInfo$1.tag);
+						if (tagIndex !== -1) reportMissingScope(comment, tagInfo$1.tag, {
+							line: comment.loc.start.line,
+							column: comment.loc.start.column + 2 + directiveInfo$1.descriptionStart + tagIndex
+						});
+					}
+					return;
+				}
 				const tagInfo = detectTag(value.trim(), tags);
 				if (tagInfo && !tagInfo.hasScope) {
 					const tagIndex = value.indexOf(tagInfo.tag);
@@ -425,6 +683,44 @@ const rule = createRule({
 				return;
 			}
 			const lines = value.split("\n");
+			const directiveInfo = parseDirectiveComment(value, directives);
+			if (directiveInfo) {
+				const tagInfo = detectTag(directiveInfo.description, tags);
+				if (tagInfo && !tagInfo.hasScope) if (lines.length === 1) {
+					const tagIndexInDesc = directiveInfo.description.indexOf(tagInfo.tag);
+					if (tagIndexInDesc !== -1) {
+						const tagIndexInValue = directiveInfo.descriptionStart + tagIndexInDesc;
+						const location = {
+							line: comment.loc.start.line,
+							column: comment.loc.start.column + 2 + tagIndexInValue
+						};
+						reportMissingScope(comment, tagInfo.tag, location);
+					}
+				} else {
+					const descLines = directiveInfo.description.split("\n");
+					for (const [descLineIndex, descLine] of descLines.entries()) {
+						const lineTagInfo = detectTag(descLine.trim(), tags);
+						if (lineTagInfo && !lineTagInfo.hasScope) {
+							const descStartInComment = value.indexOf(directiveInfo.description);
+							const linesBeforeDesc = value.slice(0, descStartInComment).split("\n").length - 1;
+							const actualLineIndex = linesBeforeDesc + descLineIndex;
+							if (actualLineIndex < lines.length) {
+								const actualLine = lines[actualLineIndex];
+								const tagIndex = actualLine.indexOf(lineTagInfo.tag);
+								if (tagIndex !== -1) {
+									const location = {
+										line: comment.loc.start.line + actualLineIndex,
+										column: actualLineIndex === 0 ? comment.loc.start.column + 2 + tagIndex : tagIndex
+									};
+									reportMissingScope(comment, lineTagInfo.tag, location);
+									break;
+								}
+							}
+						}
+					}
+				}
+				return;
+			}
 			for (const [i, line] of lines.entries()) {
 				const trimmedLine = line.trim();
 				if (!trimmedLine) continue;
@@ -440,8 +736,7 @@ const rule = createRule({
 			}
 		}
 		return { Program() {
-			const comments = sourceCode.getAllComments();
-			for (const comment of comments) checkComment(comment);
+			processAllComments(sourceCode, checkComment);
 		} };
 	}
 });
@@ -452,7 +747,8 @@ var prefer_scope_on_tag_comment_default = rule;
 const rules = {
 	"enforce-header-comment": enforce_header_comment_default,
 	"no-tag-comments": no_tag_comments_default,
-	"prefer-scope-on-tag-comment": prefer_scope_on_tag_comment_default
+	"prefer-scope-on-tag-comment": prefer_scope_on_tag_comment_default,
+	"prefer-inline-code-words-comments": prefer_inline_code_words_comments_default
 };
 
 //#endregion
@@ -474,10 +770,10 @@ const recommendedConfig = [{
 		"**/*.config.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"
 	],
 	plugins: { [namespace]: plugin },
-	rules: Object.entries(rules).reduce((acc, [ruleName, rule$3]) => {
-		if (rule$3.meta?.docs?.recommended) {
-			const ruleId = rule$3.meta?.docs?.ruleId || (namespace ? `${namespace}/${ruleName}` : ruleName);
-			acc[ruleId] = rule$3.meta?.docs?.defaultSeverity || "warn";
+	rules: Object.entries(rules).reduce((acc, [ruleName, rule$4]) => {
+		if (rule$4.meta?.docs?.recommended) {
+			const ruleId = rule$4.meta?.docs?.ruleId || (namespace ? `${namespace}/${ruleName}` : ruleName);
+			acc[ruleId] = rule$4.meta?.docs?.defaultSeverity || "warn";
 		}
 		return acc;
 	}, Object.create(null))
@@ -491,12 +787,15 @@ const commentConfig = [{
 		"**/*.config.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"
 	],
 	plugins: { [namespace]: plugin },
-	rules: Object.entries(rules).reduce((rules$1, [ruleName, rule$3]) => {
-		const ruleId = rule$3.meta?.docs?.ruleId || (namespace ? `${namespace}/${ruleName}` : ruleName);
-		rules$1[ruleId] = rule$3.meta?.docs?.defaultSeverity || "warn";
+	rules: Object.entries(rules).reduce((rules$1, [ruleName, rule$4]) => {
+		const ruleId = rule$4.meta?.docs?.ruleId || (namespace ? `${namespace}/${ruleName}` : ruleName);
+		rules$1[ruleId] = rule$4.meta?.docs?.defaultSeverity || "warn";
 		return rules$1;
 	}, Object.create(null))
 }];
+/**
+* Plugin Configurations.
+*/
 const configs = {
 	recommended: recommendedConfig,
 	comment: commentConfig

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kazupon/eslint-plugin",
   "description": "ESLint plugin for @kazupon",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "license": "MIT",
   "funding": "https://github.com/sponsors/kazupon",
   "bugs": {
@@ -47,48 +47,50 @@
     }
   },
   "dependencies": {
-    "@es-joy/jsdoccomment": "^0.50.2",
-    "@eslint/core": "^0.14.0"
+    "@es-joy/jsdoccomment": "^0.52.0",
+    "@eslint/core": "^0.15.1"
   },
   "peerDependencies": {
     "eslint": "^9.0.0"
   },
   "devDependencies": {
-    "@eslint/compat": "^1.2.9",
-    "@eslint/markdown": "^6.5.0",
-    "@kazupon/eslint-config": "^0.31.0",
+    "@eslint/compat": "^1.3.1",
+    "@eslint/markdown": "^7.1.0",
+    "@kazupon/eslint-config": "^0.34.0",
     "@kazupon/prettier-config": "^0.1.1",
-    "@shikijs/vitepress-twoslash": "^3.6.0",
-    "@types/node": "^22.15.30",
-    "@vitest/eslint-plugin": "^1.2.1",
-    "bumpp": "^10.1.1",
-    "eslint": "^9.28.0",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-import-resolver-typescript": "^4.4.3",
-    "eslint-plugin-import": "^2.31.0",
+    "@shikijs/vitepress-twoslash": "^3.9.1",
+    "@types/node": "^22.17.0",
+    "@vitest/eslint-plugin": "^1.3.4",
+    "bumpp": "^10.2.2",
+    "eslint": "^9.32.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jsdoc": "^52.0.2",
     "eslint-plugin-jsonc": "^2.20.1",
+    "eslint-plugin-markdown-preferences": "^0.4.0",
     "eslint-plugin-module-interop": "^0.3.1",
     "eslint-plugin-promise": "^7.2.1",
-    "eslint-plugin-regexp": "^2.8.0",
-    "eslint-plugin-unicorn": "^59.0.0",
+    "eslint-plugin-regexp": "^2.9.1",
+    "eslint-plugin-unicorn": "^60.0.0",
     "eslint-plugin-unused-imports": "^4.1.4",
     "eslint-plugin-yml": "^1.18.0",
-    "eslint-vitest-rule-tester": "^2.2.0",
+    "eslint-vitest-rule-tester": "^2.2.1",
     "gh-changelogen": "^0.2.8",
-    "knip": "^5.60.2",
-    "lint-staged": "^16.0.0",
-    "pkg-pr-new": "^0.0.51",
-    "prettier": "^3.5.3",
+    "knip": "^5.62.0",
+    "lint-staged": "^16.1.2",
+    "pkg-pr-new": "^0.0.54",
+    "prettier": "^3.6.2",
     "publint": "^0.3.12",
-    "tsdown": "^0.12.7",
-    "tsx": "^4.19.4",
-    "twoslash-eslint": "^0.3.1",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.33.1",
-    "vite-plugin-eslint4b": "^0.5.1",
+    "tsdown": "^0.13.2",
+    "tsx": "^4.20.3",
+    "twoslash-eslint": "^0.3.3",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.38.0",
+    "vite-plugin-eslint4b": "^0.6.0",
     "vitepress": "^1.6.3",
-    "vitepress-plugin-group-icons": "^1.6.0",
-    "vitest": "^3.2.2"
+    "vitepress-plugin-group-icons": "^1.6.1",
+    "vitest": "^3.2.4"
   },
   "prettier": "@kazupon/prettier-config",
   "lint-staged": {
@@ -118,11 +120,11 @@
     "fix": "pnpm run --stream --color \"/^fix:/\"",
     "fix:eslint": "eslint . --fix",
     "fix:knip": "knip --fix --no-exit-code",
-    "fix:prettier": "prettier . --write",
+    "fix:prettier": "prettier . --write --experimental-cli",
     "lint": "pnpm run --stream --color \"/^lint:/\"",
     "lint:eslint": "eslint .",
     "lint:knip": "knip",
-    "lint:prettier": "prettier . --check",
+    "lint:prettier": "prettier . --check --experimental-cli",
     "release": "bumpp --commit \"release: v%s\" --all --push --tag",
     "test": "vitest run",
     "typecheck": "pnpm run --stream --color \"/^typecheck:/\"",