eslint-plugin-flawless 0.1.0 → 0.1.2

package/README.md

@@ -171,12 +171,16 @@ pnpm eslint-docs
 
 <!-- begin auto-generated rules list -->
 
-💭 Requires
-[type information](https://typescript-eslint.io/linting/typed-linting).
-
-| Name                                                              | Description                                                 | 💭  |
-| :---------------------------------------------------------------- | :---------------------------------------------------------- | :-- |
-| [naming-convention](src/rules/naming-convention/documentation.md) | Enforce naming conventions for everything across a codebase | 💭  |
+🔧 Automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
+💭
+Requires [type information](https://typescript-eslint.io/linting/typed-linting).
+
+| Name                                                                                | Description                                                     | 🔧  | 💭  |
+| :---------------------------------------------------------------------------------- | :-------------------------------------------------------------- | :-- | :-- |
+| [naming-convention](src/rules/naming-convention/documentation.md)                   | Enforce naming conventions for everything across a codebase     |     | 💭  |
+| [toml-sort-keys](src/rules/toml-sort-keys/documentation.md)                         | Enforce a configured sort order for TOML keys and tables        | 🔧  |     |
+| [yaml-block-key-blank-lines](src/rules/yaml-block-key-blank-lines/documentation.md) | Enforce blank lines around top-level YAML block collection keys | 🔧  |     |
 
 <!-- end auto-generated rules list -->
 

package/dist/index.d.mts

@@ -1,6 +1,4 @@
 import { TSESLint } from "@typescript-eslint/utils";
-import "@typescript-eslint/utils/eslint-utils";
-import * as _typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 import { Linter } from "eslint";
 
 //#region src/util.d.ts
@@ -117,9 +115,22 @@ interface NamingSelector {
 }
 //#endregion
 //#region src/rules/naming-convention/rule.d.ts
-type MessageIds$1 = "doesNotMatchFormat" | "doesNotMatchFormatTrimmed" | "missingAffix" | "missingUnderscore" | "satisfyCustom" | "unexpectedUnderscore";
+type MessageIds = "doesNotMatchFormat" | "doesNotMatchFormatTrimmed" | "missingAffix" | "missingUnderscore" | "satisfyCustom" | "unexpectedUnderscore";
 type Options$1 = Array<NamingSelector>;
 //#endregion
+//#region src/rules/toml-sort-keys/rule.d.ts
+type Options = Array<SortSpec>;
+interface SortOrderObject {
+  caseSensitive?: boolean;
+  natural?: boolean;
+  type?: "asc" | "desc";
+}
+type SortOrder = Array<string> | SortOrderObject;
+interface SortSpec {
+  order: SortOrder;
+  pathPattern: string;
+}
+//#endregion
 //#region src/plugin.d.ts
 declare const plugin: {
   meta: {
@@ -127,7 +138,15 @@ declare const plugin: {
     version: string;
   };
   rules: {
-    "naming-convention": TSESLint.RuleModule<MessageIds$1, Options$1, PluginDocumentation, TSESLint.RuleListener>;
+    "naming-convention": TSESLint.RuleModule<MessageIds, Options$1, PluginDocumentation, TSESLint.RuleListener> & {
+      name: string;
+    };
+    "toml-sort-keys": TSESLint.RuleModule<"unsorted", Options, PluginDocumentation, TSESLint.RuleListener> & {
+      name: string;
+    };
+    "yaml-block-key-blank-lines": TSESLint.RuleModule<"blankLine", [], PluginDocumentation, TSESLint.RuleListener> & {
+      name: string;
+    };
   };
 };
 //#endregion
@@ -142,7 +161,15 @@ declare const _default: {
             version: string;
           };
           rules: {
-            "naming-convention": _typescript_eslint_utils_ts_eslint0.RuleModule<MessageIds$1, Options$1, PluginDocumentation, _typescript_eslint_utils_ts_eslint0.RuleListener>;
+            "naming-convention": import("${configDir}").RuleModule<MessageIds, Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+              name: string;
+            };
+            "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, PluginDocumentation, import("${configDir}").RuleListener> & {
+              name: string;
+            };
+            "yaml-block-key-blank-lines": import("${configDir}").RuleModule<"blankLine", [], PluginDocumentation, import("${configDir}").RuleListener> & {
+              name: string;
+            };
           };
         };
       };
@@ -154,10 +181,18 @@ declare const _default: {
     version: string;
   };
   rules: {
-    "naming-convention": _typescript_eslint_utils_ts_eslint0.RuleModule<MessageIds$1, Options$1, PluginDocumentation, _typescript_eslint_utils_ts_eslint0.RuleListener>;
+    "naming-convention": import("${configDir}").RuleModule<MessageIds, Options$1, PluginDocumentation, import("${configDir}").RuleListener> & {
+      name: string;
+    };
+    "toml-sort-keys": import("${configDir}").RuleModule<"unsorted", Options, PluginDocumentation, import("${configDir}").RuleListener> & {
+      name: string;
+    };
+    "yaml-block-key-blank-lines": import("${configDir}").RuleModule<"blankLine", [], PluginDocumentation, import("${configDir}").RuleListener> & {
+      name: string;
+    };
   };
 };
-type RuleOptions = { [K in keyof RuleDefinitions]: RuleDefinitions[K]["defaultOptions"] };
+type RuleOptions = { [K in keyof RuleDefinitions]: NonNullable<RuleDefinitions[K]["defaultOptions"]> };
 type Rules = { [K in keyof RuleOptions]: Linter.RuleEntry<RuleOptions[K]> };
 type RuleDefinitions = typeof plugin.rules;
 //#endregion

package/dist/index.mjs

@@ -3,21 +3,34 @@ import { requiresQuoting } from "@typescript-eslint/type-utils";
 import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
 import { RuleCreator, getParserServices } from "@typescript-eslint/utils/eslint-utils";
 import assert from "node:assert";
-
+import { getStaticTOMLValue } from "toml-eslint-parser";
 //#region package.json
 var name = "eslint-plugin-flawless";
-var version = "0.1.0";
+var version = "0.1.2";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
 };
-
 //#endregion
 //#region src/util.ts
-const createEslintRule = RuleCreator((name$1) => {
-	return `${repository.url.replace(/^git\+/, "").replace(/\.git$/, "")}/blob/v${version}/src/rules/${name$1}/documentation.md`;
+const createRule = RuleCreator((name) => {
+	return `${repository.url.replace(/^git\+/, "").replace(/\.git$/, "")}/blob/v${version}/src/rules/${name}/documentation.md`;
 });
-
+/**
+* Creates a rule with a docs URL, allowing a rule's `create` to receive a
+* context with a custom `sourceCode` type (such as a YAML source code). The
+* `SourceCode` type parameter defaults to ESLint's `SourceCode`, so standard
+* rules are unaffected.
+*
+* @template Options - The rule's options tuple.
+* @template MessageIds - The rule's message identifiers.
+* @template SourceCode - The source code type exposed on `context.sourceCode`.
+* @param rule - The rule definition (meta, name, defaultOptions, create).
+* @returns The created rule module.
+*/
+function createEslintRule(rule) {
+	return createRule(rule);
+}
 //#endregion
 //#region src/utils/is-type-import.ts
 /**
@@ -34,7 +47,6 @@ const createEslintRule = RuleCreator((name$1) => {
 function isTypeImport(definition) {
 	return definition?.type === DefinitionType.ImportBinding && (definition.parent.importKind === "type" || definition.node.type === AST_NODE_TYPES.ImportSpecifier && definition.node.importKind === "type");
 }
-
 //#endregion
 //#region src/utils/reference-contains-type-query.ts
 /**
@@ -50,7 +62,6 @@ function referenceContainsTypeQuery(node) {
 		default: return false;
 	}
 }
-
 //#endregion
 //#region src/utils/collect-variables.ts
 /**
@@ -113,10 +124,15 @@ var UnusedVariablesVisitor = class extends Visitor {
 	}
 	TSParameterProperty(node) {
 		let identifier;
-		if (node.parameter.type === AST_NODE_TYPES.AssignmentPattern) {
-			if (node.parameter.left.type === AST_NODE_TYPES.Identifier) identifier = node.parameter.left;
-		} else if (node.parameter.type === AST_NODE_TYPES.Identifier) identifier = node.parameter;
-		if (identifier) this.markVariableAsUsed(identifier);
+		switch (node.parameter.type) {
+			case AST_NODE_TYPES.AssignmentPattern:
+				identifier = node.parameter.left;
+				break;
+			case AST_NODE_TYPES.Identifier:
+				identifier = node.parameter;
+				break;
+		}
+		this.markVariableAsUsed(identifier);
 	}
 	collectUnusedVariables({ scope, variables = {
 		unusedVariables: /* @__PURE__ */ new Set(),
@@ -140,9 +156,9 @@ var UnusedVariablesVisitor = class extends Visitor {
 			const scope = this.#scopeManager.acquire(node, inner);
 			if (scope) {
 				if (scope.type === ScopeType.functionExpressionName) {
-					const returnValue$1 = scope.childScopes[0];
-					assert(returnValue$1, "Function expression name scope should have a child scope");
-					return returnValue$1;
+					const returnValue = scope.childScopes[0];
+					assert(returnValue, "Function expression name scope should have a child scope");
+					return returnValue;
 				}
 				return scope;
 			}
@@ -157,19 +173,19 @@ var UnusedVariablesVisitor = class extends Visitor {
 			variableOrIdentifierOrName.eslintUsed = true;
 			return;
 		}
-		let name$1;
+		let name;
 		let node;
 		if (typeof variableOrIdentifierOrName === "string") {
-			name$1 = variableOrIdentifierOrName;
+			name = variableOrIdentifierOrName;
 			assert(parent, "Parent node is required when marking by name");
 			node = parent;
 		} else {
-			({name: name$1} = variableOrIdentifierOrName);
+			({name} = variableOrIdentifierOrName);
 			node = variableOrIdentifierOrName;
 		}
 		let currentScope = this.getScope(node);
 		while (currentScope) {
-			const variable = currentScope.variables.find((scopeVariable) => scopeVariable.name === name$1);
+			const variable = currentScope.variables.find((scopeVariable) => scopeVariable.name === name);
 			if (variable) {
 				variable.eslintUsed = true;
 				return;
@@ -223,8 +239,8 @@ var UnusedVariablesVisitor = class extends Visitor {
 		if (variable?.defs.length === 0) this.markVariableAsUsed(variable);
 	}
 	visitFunctionTypeSignature(node) {
-		for (const parameter of node.params) this.visitPattern(parameter, (name$1) => {
-			this.markVariableAsUsed(name$1);
+		for (const parameter of node.params) this.visitPattern(parameter, (name) => {
+			this.markVariableAsUsed(name);
 		});
 	}
 	visitSetter(node) {
@@ -257,7 +273,7 @@ function isSelfReference(ref, nodes) {
 	}
 	return false;
 }
-const MERGEABLE_TYPES = new Set([
+const MERGEABLE_TYPES = /* @__PURE__ */ new Set([
 	AST_NODE_TYPES.ClassDeclaration,
 	AST_NODE_TYPES.FunctionDeclaration,
 	AST_NODE_TYPES.TSInterfaceDeclaration,
@@ -289,7 +305,7 @@ function isMergeableExported(variable) {
 	}
 	return false;
 }
-const LOGICAL_ASSIGNMENT_OPERATORS = new Set([
+const LOGICAL_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set([
 	"&&=",
 	"??=",
 	"||="
@@ -409,7 +425,7 @@ function isUsedVariable(variable) {
 	* @param rhsNode - The RHS node of the previous assignment.
 	* @returns The reference is a read to update itself.
 	*/
-	function isReadForItself(ref, rhsNode$1) {
+	function isReadForItself(ref, rhsNode) {
 		/**
 		* Checks whether a given Identifier node exists inside of a function node which can be used later.
 		*
@@ -423,7 +439,7 @@ function isUsedVariable(variable) {
 		* @param rightHandSideNode - The RHS node of the previous assignment.
 		* @returns `true` if the `id` node exists inside of a function node which can be used later.
 		*/
-		function isInsideOfStorableFunction(id$1, rightHandSideNode) {
+		function isInsideOfStorableFunction(id, rightHandSideNode) {
 			/**
 			* Finds a function node from ancestors of a node.
 			* @param node - A start node to find.
@@ -446,32 +462,32 @@ function isUsedVariable(variable) {
 			*      - the funcNode is bound as an argument of a function call.
 			*      - the function is bound to a property and the object satisfies above conditions.
 			*/
-			function isStorableFunction(funcNode$1, storableRhsNode) {
-				let node = funcNode$1;
-				let { parent: parent$1 } = funcNode$1;
-				while (parent$1 && isInside(parent$1, storableRhsNode)) {
-					switch (parent$1.type) {
+			function isStorableFunction(funcNode, storableRhsNode) {
+				let node = funcNode;
+				let { parent } = funcNode;
+				while (parent && isInside(parent, storableRhsNode)) {
+					switch (parent.type) {
 						case AST_NODE_TYPES.AssignmentExpression:
 						case AST_NODE_TYPES.TaggedTemplateExpression:
 						case AST_NODE_TYPES.YieldExpression: return true;
 						case AST_NODE_TYPES.CallExpression:
-						case AST_NODE_TYPES.NewExpression: return parent$1.callee !== node;
+						case AST_NODE_TYPES.NewExpression: return parent.callee !== node;
 						case AST_NODE_TYPES.SequenceExpression:
-							if (parent$1.expressions[parent$1.expressions.length - 1] !== node) return false;
+							if (parent.expressions[parent.expressions.length - 1] !== node) return false;
 							break;
-						default: if (parent$1.type.endsWith("Statement") || parent$1.type.endsWith("Declaration")) return true;
+						default: if (parent.type.endsWith("Statement") || parent.type.endsWith("Declaration")) return true;
 					}
-					node = parent$1;
-					({parent: parent$1} = parent$1);
+					node = parent;
+					({parent} = parent);
 				}
 				return false;
 			}
-			const funcNode = getUpperFunction(id$1);
+			const funcNode = getUpperFunction(id);
 			return !!funcNode && isInside(funcNode, rightHandSideNode) && isStorableFunction(funcNode, rightHandSideNode);
 		}
 		const id = ref.identifier;
 		const { parent } = id;
-		return ref.isRead() && (parent.type === AST_NODE_TYPES.AssignmentExpression && !LOGICAL_ASSIGNMENT_OPERATORS.has(parent.operator) && isUnusedExpression(parent) && parent.left === id || parent.type === AST_NODE_TYPES.UpdateExpression && isUnusedExpression(parent) || !!rhsNode$1 && isInside(id, rhsNode$1) && !isInsideOfStorableFunction(id, rhsNode$1));
+		return ref.isRead() && (parent.type === AST_NODE_TYPES.AssignmentExpression && !LOGICAL_ASSIGNMENT_OPERATORS.has(parent.operator) && isUnusedExpression(parent) && parent.left === id || parent.type === AST_NODE_TYPES.UpdateExpression && isUnusedExpression(parent) || !!rhsNode && isInside(id, rhsNode) && !isInsideOfStorableFunction(id, rhsNode));
 	}
 	const functionNodes = getFunctionDefinitions(variable);
 	const isFunctionDefinition = functionNodes.size > 0;
@@ -489,7 +505,6 @@ function isUsedVariable(variable) {
 		return ref.isRead() && !forItself && (isImportedAsType || !referenceContainsTypeQuery(ref.identifier)) && (!isFunctionDefinition || !isSelfReference(ref, functionNodes)) && (!isTypeDecl || !isInsideOneOf(ref, typeDeclNodes)) && (!isModuleDecl || !isSelfReference(ref, moduleDeclNodes)) && (!isEnumDecl || !isSelfReference(ref, enumDeclNodes));
 	});
 }
-
 //#endregion
 //#region src/rules/naming-convention/utils/enums.ts
 const Selector = {
@@ -567,7 +582,6 @@ const UnderscoreOption = {
 	allowDouble: 5,
 	allowSingleOrDouble: 6
 };
-
 //#endregion
 //#region src/rules/naming-convention/utils/shared.ts
 function isMetaSelector(selector) {
@@ -580,13 +594,15 @@ function selectorTypeToMessageString(selectorType) {
 	const notCamelCase = selectorType.replaceAll(/([A-Z])/g, " $1");
 	return notCamelCase.charAt(0).toUpperCase() + notCamelCase.slice(1);
 }
-
 //#endregion
 //#region src/rules/naming-convention/utils/format.ts
-function hasStrictCamelHumps(name$1, isUpper) {
-	if (name$1.startsWith("_")) return false;
-	for (let index = 1; index < name$1.length; ++index) {
-		const char = name$1[index];
+function isUppercaseChar(char) {
+	return char === char.toUpperCase() && char !== char.toLowerCase();
+}
+function hasStrictCamelHumps(name, isUpper) {
+	if (name.startsWith("_")) return false;
+	for (let index = 1; index < name.length; ++index) {
+		const char = name[index];
 		if (char === "_") return false;
 		if (isUpper === isUppercaseChar(char)) {
 			if (isUpper) return false;
@@ -594,41 +610,38 @@ function hasStrictCamelHumps(name$1, isUpper) {
 	}
 	return true;
 }
-function isCamelCase(name$1) {
-	return name$1.length === 0 || name$1[0] === name$1[0]?.toLowerCase() && !name$1.includes("_");
-}
-function isPascalCase(name$1) {
-	return name$1.length === 0 || name$1[0] === name$1[0]?.toUpperCase() && !name$1.includes("_");
-}
-function isSnakeCase(name$1) {
-	return name$1.length === 0 || name$1 === name$1.toLowerCase() && validateUnderscores(name$1);
-}
-function isStrictCamelCase(name$1) {
-	return name$1.length === 0 || name$1[0] === name$1[0]?.toLowerCase() && hasStrictCamelHumps(name$1, false);
-}
-function isStrictPascalCase(name$1) {
-	return name$1.length === 0 || name$1[0] === name$1[0]?.toUpperCase() && hasStrictCamelHumps(name$1, true);
-}
-function isUpperCase(name$1) {
-	return name$1.length === 0 || name$1 === name$1.toUpperCase() && validateUnderscores(name$1);
+function isCamelCase(name) {
+	return name.length === 0 || name[0] === name[0]?.toLowerCase() && !name.includes("_");
 }
-function isUppercaseChar(char) {
-	return char === char.toUpperCase() && char !== char.toLowerCase();
+function isPascalCase(name) {
+	return name.length === 0 || name[0] === name[0]?.toUpperCase() && !name.includes("_");
 }
 /**
 * Check for leading trailing and adjacent underscores.
 * @param name - The name to check.
 * @returns True if the underscores are valid.
 */
-function validateUnderscores(name$1) {
-	if (name$1.startsWith("_")) return false;
+function validateUnderscores(name) {
+	if (name.startsWith("_")) return false;
 	let wasUnderscore = false;
-	for (let index = 1; index < name$1.length; ++index) if (name$1[index] === "_") {
+	for (let index = 1; index < name.length; ++index) if (name[index] === "_") {
 		if (wasUnderscore) return false;
 		wasUnderscore = true;
 	} else wasUnderscore = false;
 	return !wasUnderscore;
 }
+function isSnakeCase(name) {
+	return name.length === 0 || name === name.toLowerCase() && validateUnderscores(name);
+}
+function isStrictCamelCase(name) {
+	return name.length === 0 || name[0] === name[0]?.toLowerCase() && hasStrictCamelHumps(name, false);
+}
+function isStrictPascalCase(name) {
+	return name.length === 0 || name[0] === name[0]?.toUpperCase() && hasStrictCamelHumps(name, true);
+}
+function isUpperCase(name) {
+	return name.length === 0 || name === name.toUpperCase() && validateUnderscores(name);
+}
 const FormatCheckersMap = {
 	[PredefinedFormat.camelCase]: isCamelCase,
 	[PredefinedFormat.PascalCase]: isPascalCase,
@@ -637,12 +650,11 @@ const FormatCheckersMap = {
 	[PredefinedFormat.StrictPascalCase]: isStrictPascalCase,
 	[PredefinedFormat.UPPER_CASE]: isUpperCase
 };
-
 //#endregion
 //#region src/rules/naming-convention/utils/validator.ts
 function createValidator(type, context, allConfigs) {
 	const selectorType = Selector[type];
-	const configs$1 = allConfigs.filter((configItem) => {
+	const configs = allConfigs.filter((configItem) => {
 		return (configItem.selector & selectorType) !== 0 || configItem.selector === MetaSelector.default;
 	}).sort((a, b) => {
 		if (a.selector === b.selector) return b.modifierWeight - a.modifierWeight;
@@ -658,53 +670,53 @@ function createValidator(type, context, allConfigs) {
 	});
 	return (node, modifiers = /* @__PURE__ */ new Set()) => {
 		const originalName = node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`;
-		for (const config of configs$1) {
+		for (const config of configs) {
 			if (config.filter?.regex.test(originalName) !== config.filter?.match) continue;
 			if (config.modifiers?.some((modifier) => !modifiers.has(modifier)) === true) continue;
 			if (!isCorrectType(node, config, context, selectorType)) continue;
-			let name$1 = originalName;
-			name$1 = validateUnderscore({
+			let name = originalName;
+			name = validateUnderscore({
+				name,
 				config,
-				name: name$1,
 				node,
 				originalName,
 				position: "leading"
 			});
-			if (name$1 === void 0) return;
-			name$1 = validateUnderscore({
+			if (name === void 0) return;
+			name = validateUnderscore({
+				name,
 				config,
-				name: name$1,
 				node,
 				originalName,
 				position: "trailing"
 			});
-			if (name$1 === void 0) return;
-			name$1 = validateAffix({
+			if (name === void 0) return;
+			name = validateAffix({
+				name,
 				config,
-				name: name$1,
 				node,
 				originalName,
 				position: "prefix"
 			});
-			if (name$1 === void 0) return;
-			name$1 = validateAffix({
+			if (name === void 0) return;
+			name = validateAffix({
+				name,
 				config,
-				name: name$1,
 				node,
 				originalName,
 				position: "suffix"
 			});
-			if (name$1 === void 0) return;
+			if (name === void 0) return;
 			if (!validateCustom({
+				name,
 				config,
-				name: name$1,
 				node,
 				originalName
 			})) return;
 			if (!validatePredefinedFormat({
+				name,
 				config,
 				modifiers,
-				name: name$1,
 				node,
 				originalName
 			})) return;
@@ -716,10 +728,10 @@ function createValidator(type, context, allConfigs) {
 		if (custom?.match === true) regexMatch = "match";
 		else if (custom?.match === false) regexMatch = "not match";
 		return {
+			name: originalName,
 			affixes: affixes?.join(", "),
 			count,
 			formats: formats?.map((formatItem) => PredefinedFormatValueToKey[formatItem]).join(", "),
-			name: originalName,
 			position,
 			processedName,
 			regex: custom?.regex.toString(),
@@ -727,24 +739,24 @@ function createValidator(type, context, allConfigs) {
 			type: selectorTypeToMessageString(type)
 		};
 	}
-	function validateUnderscore({ config, name: name$1, node, originalName, position }) {
+	function validateUnderscore({ name, config, node, originalName, position }) {
 		const option = position === "leading" ? config.leadingUnderscore : config.trailingUnderscore;
-		if (!option) return name$1;
-		const hasSingleUnderscore = position === "leading" ? () => name$1.startsWith("_") : () => name$1.endsWith("_");
-		const trimSingleUnderscore = position === "leading" ? () => name$1.slice(1) : () => name$1.slice(0, -1);
-		const hasDoubleUnderscore = position === "leading" ? () => name$1.startsWith("__") : () => name$1.endsWith("__");
-		const trimDoubleUnderscore = position === "leading" ? () => name$1.slice(2) : () => name$1.slice(0, -2);
+		if (!option) return name;
+		const hasSingleUnderscore = position === "leading" ? () => name.startsWith("_") : () => name.endsWith("_");
+		const trimSingleUnderscore = position === "leading" ? () => name.slice(1) : () => name.slice(0, -1);
+		const hasDoubleUnderscore = position === "leading" ? () => name.startsWith("__") : () => name.endsWith("__");
+		const trimDoubleUnderscore = position === "leading" ? () => name.slice(2) : () => name.slice(0, -2);
 		switch (option) {
 			case UnderscoreOption.allow:
 				if (hasSingleUnderscore()) return trimSingleUnderscore();
-				return name$1;
+				return name;
 			case UnderscoreOption.allowDouble:
 				if (hasDoubleUnderscore()) return trimDoubleUnderscore();
-				return name$1;
+				return name;
 			case UnderscoreOption.allowSingleOrDouble:
 				if (hasDoubleUnderscore()) return trimDoubleUnderscore();
 				if (hasSingleUnderscore()) return trimSingleUnderscore();
-				return name$1;
+				return name;
 			case UnderscoreOption.forbid:
 				if (hasSingleUnderscore()) {
 					context.report({
@@ -758,7 +770,7 @@ function createValidator(type, context, allConfigs) {
 					});
 					return;
 				}
-				return name$1;
+				return name;
 			case UnderscoreOption.require:
 				if (!hasSingleUnderscore()) {
 					context.report({
@@ -789,12 +801,12 @@ function createValidator(type, context, allConfigs) {
 				return trimDoubleUnderscore();
 		}
 	}
-	function validateAffix({ config, name: name$1, node, originalName, position }) {
+	function validateAffix({ name, config, node, originalName, position }) {
 		const affixes = config[position];
-		if (!affixes || affixes.length === 0) return name$1;
+		if (!affixes || affixes.length === 0) return name;
 		for (const affix of affixes) {
-			const hasAffix = position === "prefix" ? name$1.startsWith(affix) : name$1.endsWith(affix);
-			const trimAffix = position === "prefix" ? () => name$1.slice(affix.length) : () => name$1.slice(0, -affix.length);
+			const hasAffix = position === "prefix" ? name.startsWith(affix) : name.endsWith(affix);
+			const trimAffix = position === "prefix" ? () => name.slice(affix.length) : () => name.slice(0, -affix.length);
 			if (hasAffix) return trimAffix();
 		}
 		context.report({
@@ -807,10 +819,10 @@ function createValidator(type, context, allConfigs) {
 			node
 		});
 	}
-	function validateCustom({ config, name: name$1, node, originalName }) {
+	function validateCustom({ name, config, node, originalName }) {
 		const { custom } = config;
 		if (!custom) return true;
-		const result = custom.regex.test(name$1);
+		const result = custom.regex.test(name);
 		if (custom.match && result) return true;
 		if (!custom.match && !result) return true;
 		context.report({
@@ -823,20 +835,20 @@ function createValidator(type, context, allConfigs) {
 		});
 		return false;
 	}
-	function validatePredefinedFormat({ config, modifiers, name: name$1, node, originalName }) {
+	function validatePredefinedFormat({ name, config, modifiers, node, originalName }) {
 		const formats = config.format;
 		if (!formats || formats.length === 0) return true;
 		if (!modifiers.has(Modifier.requiresQuotes)) for (const format of formats) {
 			const checker = FormatCheckersMap[format];
-			if (checker(name$1)) return true;
+			if (checker(name)) return true;
 		}
 		context.report({
 			data: formatReportData({
 				formats,
 				originalName,
-				processedName: name$1
+				processedName: name
 			}),
-			messageId: originalName === name$1 ? "doesNotMatchFormat" : "doesNotMatchFormatTrimmed",
+			messageId: originalName === name ? "doesNotMatchFormat" : "doesNotMatchFormatTrimmed",
 			node
 		});
 		return false;
@@ -859,19 +871,15 @@ function isCorrectType(node, config, context, selector) {
 			break;
 		case TypeModifier.boolean:
 		case TypeModifier.number:
-		case TypeModifier.string: {
-			const typeString = checker.typeToString(checker.getWidenedType(checker.getBaseTypeOfLiteralType(type)));
-			const allowedTypeString = TypeModifierValueToKey[allowedType];
-			if (typeString === allowedTypeString) return true;
+		case TypeModifier.string:
+			if (checker.typeToString(checker.getWidenedType(checker.getBaseTypeOfLiteralType(type))) === TypeModifierValueToKey[allowedType]) return true;
 			break;
-		}
 		case TypeModifier.function:
 			if (isAllTypesMatch(type, (inner) => inner.getCallSignatures().length > 0)) return true;
 			break;
 	}
 	return false;
 }
-
 //#endregion
 //#region src/rules/naming-convention/utils/parse-options.ts
 function parseOptions(context) {
@@ -911,7 +919,6 @@ function normalizeOption(option) {
 		};
 	});
 }
-
 //#endregion
 //#region src/rules/naming-convention/utils/schema.ts
 const $DEFS = {
@@ -1182,11 +1189,10 @@ const SCHEMA = {
 	] },
 	type: "array"
 };
-
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME = "naming-convention";
-const messages = {
+const RULE_NAME$2 = "naming-convention";
+const messages$2 = {
 	doesNotMatchFormat: "{{type}} name `{{name}}` must match one of the following formats: {{formats}}",
 	doesNotMatchFormatTrimmed: "{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}",
 	missingAffix: "{{type}} name `{{name}}` must have one of the following {{position}}es: {{affixes}}",
@@ -1216,7 +1222,7 @@ const camelCaseNamingConfig = [
 		selector: "typeLike"
 	}
 ];
-function create(contextWithoutDefaults) {
+function create$2(contextWithoutDefaults) {
 	const context = contextWithoutDefaults.options.length > 0 ? contextWithoutDefaults : Object.setPrototypeOf({ options: camelCaseNamingConfig }, contextWithoutDefaults);
 	const validators = parseOptions(context);
 	const compilerOptions = getParserServices(context, true).program?.getCompilerOptions() ?? {};
@@ -1237,11 +1243,11 @@ function create(contextWithoutDefaults) {
 		return modifiers;
 	}
 	const { unusedVariables } = collectVariables(context);
-	function isUnused(name$1, initialScope) {
+	function isUnused(name, initialScope) {
 		let variable = null;
 		let scope = initialScope;
 		while (scope) {
-			variable = scope.set.get(name$1) ?? null;
+			variable = scope.set.get(name) ?? null;
 			if (variable) break;
 			scope = scope.upper;
 		}
@@ -1323,22 +1329,19 @@ function create(contextWithoutDefaults) {
 	const selectors = {
 		":matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type != \"ArrowFunctionExpression\"][value.type != \"FunctionExpression\"][value.type != \"TSEmptyBodyFunctionExpression\"]": {
 			handler: (node, validator) => {
-				const modifiers = getMemberModifiers(node);
-				handleMember(validator, node, modifiers);
+				handleMember(validator, node, getMemberModifiers(node));
 			},
 			validator: validators.classProperty
 		},
 		":not(ObjectPattern) > Property[computed = false][kind = \"init\"][value.type != \"ArrowFunctionExpression\"][value.type != \"FunctionExpression\"][value.type != \"TSEmptyBodyFunctionExpression\"]": {
 			handler: (node, validator) => {
-				const modifiers = new Set([Modifier.public]);
-				handleMember(validator, node, modifiers);
+				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
 			},
 			validator: validators.objectLiteralProperty
 		},
 		[["TSMethodSignature[computed = false]", "TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type = \"TSFunctionType\"]"].join(", ")]: {
 			handler: (node, validator) => {
-				const modifiers = new Set([Modifier.public]);
-				handleMember(validator, node, modifiers);
+				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
 			},
 			validator: validators.typeMethod
 		},
@@ -1358,8 +1361,7 @@ function create(contextWithoutDefaults) {
 		},
 		[["MethodDefinition[computed = false]:matches([kind = \"get\"], [kind = \"set\"])", "TSAbstractMethodDefinition[computed = false]:matches([kind=\"get\"], [kind=\"set\"])"].join(", ")]: {
 			handler: (node, validator) => {
-				const modifiers = getMemberModifiers(node);
-				handleMember(validator, node, modifiers);
+				handleMember(validator, node, getMemberModifiers(node));
 			},
 			validator: validators.classicAccessor
 		},
@@ -1369,7 +1371,7 @@ function create(contextWithoutDefaults) {
 			"Property[computed = false][kind = \"init\"][value.type = \"TSEmptyBodyFunctionExpression\"]"
 		].join(", ")]: {
 			handler: (node, validator) => {
-				const modifiers = new Set([Modifier.public]);
+				const modifiers = /* @__PURE__ */ new Set([Modifier.public]);
 				if (isAsyncMemberOrProperty(node)) modifiers.add(Modifier.async);
 				handleMember(validator, node, modifiers);
 			},
@@ -1377,14 +1379,13 @@ function create(contextWithoutDefaults) {
 		},
 		[[AST_NODE_TYPES.AccessorProperty, AST_NODE_TYPES.TSAbstractAccessorProperty].join(", ")]: {
 			handler: (node, validator) => {
-				const modifiers = getMemberModifiers(node);
-				handleMember(validator, node, modifiers);
+				handleMember(validator, node, getMemberModifiers(node));
 			},
 			validator: validators.autoAccessor
 		},
 		"ClassDeclaration, ClassExpression": {
 			handler: (node, validator) => {
-				const { abstract, id } = node;
+				const { id, abstract } = node;
 				if (id === null) return;
 				const modifiers = /* @__PURE__ */ new Set();
 				const scope = context.sourceCode.getScope(node).upper;
@@ -1444,8 +1445,7 @@ function create(contextWithoutDefaults) {
 		},
 		"Property[computed = false]:matches([kind = \"get\"], [kind = \"set\"])": {
 			handler: (node, validator) => {
-				const modifiers = new Set([Modifier.public]);
-				handleMember(validator, node, modifiers);
+				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
 			},
 			validator: validators.classicAccessor
 		},
@@ -1488,7 +1488,7 @@ function create(contextWithoutDefaults) {
 		},
 		"TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type != \"TSFunctionType\"]": {
 			handler: (node, validator) => {
-				const modifiers = new Set([Modifier.public]);
+				const modifiers = /* @__PURE__ */ new Set([Modifier.public]);
 				if (node.readonly) modifiers.add(Modifier.readonly);
 				handleMember(validator, node, modifiers);
 			},
@@ -1542,7 +1542,8 @@ function create(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	create,
+	name: RULE_NAME$2,
+	create: create$2,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
 		docs: {
@@ -1552,21 +1553,22 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages,
+		messages: messages$2,
 		schema: SCHEMA,
 		type: "suggestion"
-	},
-	name: RULE_NAME
+	}
 });
 function getIdentifiersFromPattern(pattern) {
 	const identifiers = [];
-	new PatternVisitor({}, pattern, (id) => identifiers.push(id)).visit(pattern);
+	new PatternVisitor({}, pattern, (id) => {
+		identifiers.push(id);
+	}).visit(pattern);
 	return identifiers;
 }
-function isExported(node, name$1, scope) {
+function isExported(node, name, scope) {
 	if (node?.parent?.type === AST_NODE_TYPES.ExportDefaultDeclaration || node?.parent?.type === AST_NODE_TYPES.ExportNamedDeclaration) return true;
 	if (scope === null) return false;
-	const variable = scope.set.get(name$1);
+	const variable = scope.set.get(name);
 	if (variable) for (const ref of variable.references) {
 		const refParent = ref.identifier.parent;
 		if (refParent.type === AST_NODE_TYPES.ExportDefaultDeclaration || refParent.type === AST_NODE_TYPES.ExportSpecifier) return true;
@@ -1578,10 +1580,285 @@ function isGlobal(scope) {
 	return scope.type === TSESLint.Scope.ScopeType.global || scope.type === TSESLint.Scope.ScopeType.module;
 }
 function requiresQuoting$1(node, target) {
-	const name$1 = node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`;
-	return requiresQuoting(name$1, target);
+	return requiresQuoting(node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`, target);
+}
+//#endregion
+//#region src/rules/toml-sort-keys/rule.ts
+const RULE_NAME$1 = "toml-sort-keys";
+const MESSAGE_ID = "unsorted";
+const messages$1 = { [MESSAGE_ID]: "Expected {{target}} to follow the configured order." };
+const schema = {
+	items: {
+		additionalProperties: false,
+		properties: {
+			order: { oneOf: [{
+				items: { type: "string" },
+				type: "array"
+			}, {
+				additionalProperties: false,
+				properties: {
+					caseSensitive: { type: "boolean" },
+					natural: { type: "boolean" },
+					type: {
+						enum: ["asc", "desc"],
+						type: "string"
+					}
+				},
+				type: "object"
+			}] },
+			pathPattern: { type: "string" }
+		},
+		required: ["order", "pathPattern"],
+		type: "object"
+	},
+	type: "array"
+};
+function isTable(entry) {
+	return entry.type === "TOMLTable";
+}
+/**
+* The dotted name of an entry, e.g. `settings`, `settings.node`, `_.path`.
+*
+* @param entry - The table header or key-value entry.
+* @returns The dotted key path as a string.
+*/
+function nameOf(entry) {
+	return getStaticTOMLValue(entry.key).join(".");
+}
+/**
+* Builds a rank function from an explicit order list. An entry matches an order
+* item when it equals it or is a dotted child of it (`settings.node` matches
+* `settings`), which keeps sub-tables grouped under their parent's slot.
+*
+* @param order - The configured names in their desired order.
+* @returns A function giving a name's rank, or `Infinity` when unlisted.
+*/
+function makeRank(order) {
+	return (name) => {
+		for (const [index, item] of order.entries()) if (name === item || name.startsWith(`${item}.`)) return index;
+		return Number.POSITIVE_INFINITY;
+	};
+}
+function makeFallback(config) {
+	const { caseSensitive = true, natural = false, type = "asc" } = config;
+	const sensitivity = caseSensitive ? "variant" : "accent";
+	return (a, b) => {
+		const result = a.localeCompare(b, "en", {
+			numeric: natural,
+			sensitivity
+		});
+		return type === "desc" ? -result : result;
+	};
 }
-
+/**
+* Builds a comparator for one table body. Explicit-order entries sort first by
+* their listed position, then unlisted entries fall back to a natural/asc sort
+* (mirroring `yaml/sort-keys`). At the top level, bare key-values are always
+* kept before any `[table]` header, since TOML would otherwise re-scope them.
+*
+* @param order - The order configuration for this table's path.
+* @param isTopLevel - Whether the body is the top-level table.
+* @returns A comparator over two entries.
+*/
+function makeComparator(order, isTopLevel) {
+	const rank = Array.isArray(order) ? makeRank(order) : void 0;
+	const fallback = makeFallback(Array.isArray(order) ? {
+		natural: true,
+		type: "asc"
+	} : order);
+	return (a, b) => {
+		if (isTopLevel) {
+			const aRank = isTable(a) ? 1 : 0;
+			const bRank = isTable(b) ? 1 : 0;
+			if (aRank !== bRank) return aRank - bRank;
+		}
+		if (rank !== void 0) {
+			const aRank = rank(nameOf(a));
+			const bRank = rank(nameOf(b));
+			if (aRank !== bRank) {
+				if (aRank === Number.POSITIVE_INFINITY) return 1;
+				if (bRank === Number.POSITIVE_INFINITY) return -1;
+				return aRank - bRank;
+			}
+		}
+		return fallback(nameOf(a), nameOf(b));
+	};
+}
+function create$1(context) {
+	const { options, sourceCode } = context;
+	if (sourceCode.parserServices.isTOML !== true) return {};
+	const specs = options.map(({ order, pathPattern }) => {
+		return {
+			order,
+			pattern: new RegExp(pathPattern, "u")
+		};
+	});
+	if (specs.length === 0) return {};
+	function resolveOrder(path) {
+		for (const spec of specs) if (spec.pattern.test(path)) return spec.order;
+	}
+	/**
+	* A comment counts as attached to an entry when it sits on its own line
+	* directly above it (no blank line, no trailing code). Such comments travel
+	* with the entry when it moves.
+	*
+	* @param comment - The comment to classify.
+	* @returns Whether the comment stands alone on its line.
+	*/
+	function isOwnLineComment(comment) {
+		const before = sourceCode.getTokenBefore(comment, { includeComments: true });
+		return before === null || before.loc.end.line < comment.loc.start.line;
+	}
+	function leadingStart(entry) {
+		const comments = sourceCode.getCommentsBefore(entry);
+		let start = entry.range[0];
+		let boundaryLine = entry.loc.start.line;
+		for (let index = comments.length - 1; index >= 0; index -= 1) {
+			const comment = comments[index];
+			if (comment === void 0) break;
+			if (comment.loc.end.line !== boundaryLine - 1 || !isOwnLineComment(comment)) break;
+			start = comment.range[0];
+			boundaryLine = comment.loc.start.line;
+		}
+		return start;
+	}
+	function trailingEnd(entry) {
+		const [comment] = sourceCode.getCommentsAfter(entry);
+		if (comment?.loc.start.line === entry.loc.end.line) return comment.range[1];
+		return entry.range[1];
+	}
+	function buildFix(entries, target) {
+		const text = sourceCode.getText();
+		const blocks = entries.map((entry) => {
+			return {
+				end: trailingEnd(entry),
+				entry,
+				start: leadingStart(entry)
+			};
+		});
+		for (let index = 1; index < blocks.length; index += 1) {
+			const previous = blocks[index - 1];
+			const current = blocks[index];
+			if (previous === void 0 || current === void 0) return;
+			if (/\S/u.test(text.slice(previous.end, current.start))) return;
+		}
+		const first = blocks[0];
+		const last = blocks[blocks.length - 1];
+		if (first === void 0 || last === void 0) return;
+		const textByEntry = new Map(blocks.map((block) => [block.entry, text.slice(block.start, block.end)]));
+		const parts = [];
+		for (const [index, entry] of target.entries()) {
+			const previous = target[index - 1];
+			if (previous !== void 0) parts.push(isTable(entry) || isTable(previous) ? "\n\n" : "\n");
+			parts.push(textByEntry.get(entry) ?? "");
+		}
+		const sortedText = parts.join("");
+		return (fixer) => fixer.replaceTextRange([first.start, last.end], sortedText);
+	}
+	function verify(path, body, isTopLevel) {
+		if (body.length < 2) return;
+		const order = resolveOrder(path);
+		if (order === void 0) return;
+		const entries = [...body];
+		const target = [...entries].sort(makeComparator(order, isTopLevel));
+		let outOfPlace;
+		for (const [index, entry] of entries.entries()) if (entry !== target[index]) {
+			outOfPlace = entry;
+			break;
+		}
+		if (outOfPlace === void 0) return;
+		context.report({
+			data: { target: path === "" ? "top-level tables" : `keys in "${path}"` },
+			fix: buildFix(entries, target),
+			loc: outOfPlace.key.loc,
+			messageId: MESSAGE_ID
+		});
+	}
+	return {
+		TOMLTable(node) {
+			verify(getStaticTOMLValue(node.key).join("."), node.body, false);
+		},
+		TOMLTopLevelTable(node) {
+			verify("", node.body, true);
+		}
+	};
+}
+const tomlSortKeys = createEslintRule({
+	name: RULE_NAME$1,
+	create: create$1,
+	defaultOptions: [],
+	meta: {
+		defaultOptions: [],
+		docs: {
+			description: "Enforce a configured sort order for TOML keys and tables",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$1,
+		schema,
+		type: "layout"
+	}
+});
+//#endregion
+//#region src/rules/yaml-block-key-blank-lines/rule.ts
+const RULE_NAME = "yaml-block-key-blank-lines";
+const messages = { blankLine: "Expected {{count}} blank line(s) around this top-level key." };
+/**
+* Determines whether a pair value is a block collection (block mapping or block
+* sequence). Flow collections (`{ ... }` / `[ ... ]`) count as scalars.
+*
+* @param value - The value node of a YAML pair.
+* @returns True if the value is a block mapping or block sequence.
+*/
+function isBlock(value) {
+	return value !== null && (value.type === "YAMLMapping" || value.type === "YAMLSequence") && value.style === "block";
+}
+function create(context) {
+	const { sourceCode } = context;
+	if (sourceCode.parserServices.isYAML !== true) return {};
+	return { YAMLMapping(yamlNode) {
+		if (yamlNode.parent.type !== "YAMLDocument") return;
+		const { pairs } = yamlNode;
+		for (let index = 1; index < pairs.length; index += 1) {
+			const previous = pairs[index - 1];
+			const current = pairs[index];
+			if (previous === void 0 || current === void 0) continue;
+			const left = sourceCode.getLastToken(previous);
+			const right = sourceCode.getFirstToken(current);
+			if (sourceCode.commentsExistBetween(left, right)) continue;
+			const blanks = right.loc.start.line - left.loc.end.line - 1;
+			const want = isBlock(previous.value) || isBlock(current.value) ? 1 : 0;
+			if (blanks === want) continue;
+			context.report({
+				data: { count: want },
+				fix(fixer) {
+					return fixer.replaceTextRange([left.range[1], right.range[0]], "\n".repeat(want + 1));
+				},
+				loc: (current.key ?? current).loc,
+				messageId: "blankLine"
+			});
+		}
+	} };
+}
+const yamlBlockKeyBlankLines = createEslintRule({
+	name: RULE_NAME,
+	create,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Enforce blank lines around top-level YAML block collection keys",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		messages,
+		schema: [],
+		type: "layout"
+	}
+});
 //#endregion
 //#region src/plugin.ts
 const PLUGIN_NAME = name.replace(/^eslint-plugin-/, "");
@@ -1600,23 +1877,24 @@ const plugin = {
 		name: PLUGIN_NAME,
 		version
 	},
-	rules: { "naming-convention": namingConvention }
+	rules: {
+		"naming-convention": namingConvention,
+		"toml-sort-keys": tomlSortKeys,
+		"yaml-block-key-blank-lines": yamlBlockKeyBlankLines
+	}
 };
-const allRules = getRules(PLUGIN_NAME, plugin.rules);
-
+getRules(PLUGIN_NAME, plugin.rules);
 //#endregion
 //#region src/configs/index.ts
 const configs = { recommended: {
 	plugins: { [PLUGIN_NAME]: plugin },
 	rules: {}
 } };
-
 //#endregion
 //#region src/index.ts
 var src_default = {
 	...plugin,
 	configs
 };
-
 //#endregion
-export { src_default as default };
+export { src_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-flawless",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Your ESLint plugin description",
   "keywords": [
     "eslint",
@@ -34,44 +34,47 @@
     "*": "eslint --fix --cache"
   },
   "dependencies": {
-    "@typescript-eslint/scope-manager": "8.44.0",
-    "@typescript-eslint/type-utils": "^8.44.0",
-    "@typescript-eslint/utils": "8.44.0"
+    "@typescript-eslint/scope-manager": "8.62.1",
+    "@typescript-eslint/type-utils": "8.62.1",
+    "@typescript-eslint/utils": "8.62.1",
+    "toml-eslint-parser": "1.0.3"
   },
   "devDependencies": {
-    "@antfu/ni": "25.0.0",
-    "@isentinel/eslint-config": "3.0.0",
-    "@isentinel/tsconfig": "1.0.0",
+    "@antfu/ni": "30.2.0",
+    "@isentinel/eslint-config": "5.2.0",
+    "@isentinel/tsconfig": "1.2.0",
     "@types/node": "24.0.13",
-    "@typescript-eslint/eslint-plugin": "8.44.0",
-    "@typescript-eslint/parser": "8.44.0",
-    "@vitest/eslint-plugin": "1.3.4",
-    "bumpp": "10.2.2",
-    "eslint": "9.35.0",
-    "eslint-doc-generator": "2.2.2",
-    "eslint-plugin-eslint-plugin": "7.0.0",
-    "eslint-plugin-n": "17.23.1",
-    "eslint-plugin-pnpm": "1.1.0",
-    "eslint-vitest-rule-tester": "2.2.1",
-    "jiti": "2.5.1",
-    "lint-staged": "16.1.4",
-    "publint": "0.3.12",
+    "@typescript-eslint/eslint-plugin": "8.62.1",
+    "@typescript-eslint/parser": "8.62.1",
+    "@vitest/eslint-plugin": "1.6.20",
+    "bumpp": "11.1.0",
+    "eslint": "9.39.4",
+    "eslint-doc-generator": "3.6.0",
+    "eslint-plugin-eslint-plugin": "7.4.1",
+    "eslint-plugin-n": "18.2.1",
+    "eslint-plugin-pnpm": "1.6.1",
+    "eslint-plugin-toml": "1.4.0",
+    "eslint-plugin-yml": "3.5.0",
+    "eslint-vitest-rule-tester": "3.1.0",
+    "jiti": "2.7.0",
+    "lint-staged": "17.0.8",
+    "publint": "0.3.21",
     "simple-git-hooks": "2.13.1",
-    "ts-api-utils": "2.1.0",
-    "tsdown": "0.13.3",
-    "tsx": "4.20.3",
-    "typescript": "5.8.3",
-    "unplugin-unused": "0.5.1",
-    "vitest": "3.2.4"
+    "ts-api-utils": "2.5.0",
+    "tsdown": "0.22.3",
+    "tsx": "4.22.4",
+    "typescript": "6.0.3",
+    "unplugin-unused": "0.5.7",
+    "vitest": "4.1.9",
+    "yaml-eslint-parser": "2.0.0"
   },
   "peerDependencies": {
     "eslint": ">=9.15.0"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=24.12.0"
   },
   "publishConfig": {
-    "access": "public",
     "provenance": true
   },
   "scripts": {