eslint-plugin-flawless 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1622 @@
+import { DefinitionType, ImplicitLibVariable, PatternVisitor, ScopeType, Visitor } from "@typescript-eslint/scope-manager";
+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";
+
+//#region package.json
+var name = "eslint-plugin-flawless";
+var version = "0.1.0";
+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`;
+});
+
+//#endregion
+//#region src/utils/is-type-import.ts
+/**
+* Determine whether a variable definition is a type import. E.g.:.
+*
+* ```ts
+* import type { Foo } from 'foo';
+* import { type Bar } from 'bar';
+* ```
+*
+* @param definition - The variable definition to check.
+* @returns True if the definition is a type import, false otherwise.
+*/
+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
+/**
+* Recursively checks whether a given reference has a type query declaration among its parents.
+* @param node - The AST node to check.
+* @returns True if a TSTypeQuery is found in the parent chain, false otherwise.
+*/
+function referenceContainsTypeQuery(node) {
+	switch (node.type) {
+		case AST_NODE_TYPES.Identifier:
+		case AST_NODE_TYPES.TSQualifiedName: return referenceContainsTypeQuery(node.parent);
+		case AST_NODE_TYPES.TSTypeQuery: return true;
+		default: return false;
+	}
+}
+
+//#endregion
+//#region src/utils/collect-variables.ts
+/**
+* This class leverages an AST visitor to mark variables as used via the
+* `eslintUsed` property.
+*/
+var UnusedVariablesVisitor = class extends Visitor {
+	/**
+	* We keep a weak cache so that multiple rules can share the calculation.
+	*/
+	static RESULTS_CACHE = /* @__PURE__ */ new WeakMap();
+	#scopeManager;
+	ClassDeclaration = this.visitClass;
+	ClassExpression = this.visitClass;
+	ForInStatement = this.visitForInForOf;
+	/**
+	* #region HELPERS
+	*/
+	ForOfStatement = this.visitForInForOf;
+	FunctionDeclaration = this.visitFunction;
+	FunctionExpression = this.visitFunction;
+	MethodDefinition = this.visitSetter;
+	Property = this.visitSetter;
+	TSCallSignatureDeclaration = this.visitFunctionTypeSignature;
+	TSConstructorType = this.visitFunctionTypeSignature;
+	TSConstructSignatureDeclaration = this.visitFunctionTypeSignature;
+	TSDeclareFunction = this.visitFunctionTypeSignature;
+	/**
+	* NOTE - This is a simple visitor - meaning it does not support selectors.
+	*/
+	TSEmptyBodyFunctionExpression = this.visitFunctionTypeSignature;
+	TSFunctionType = this.visitFunctionTypeSignature;
+	TSMethodSignature = this.visitFunctionTypeSignature;
+	constructor(scopeManager) {
+		super({ visitChildrenEvenIfSelectorExists: true });
+		this.#scopeManager = scopeManager;
+	}
+	static collectUnusedVariables(program, scopeManager) {
+		const cached = this.RESULTS_CACHE.get(program);
+		if (cached) return cached;
+		const visitor = new this(scopeManager);
+		visitor.visit(program);
+		const unusedVariables = visitor.collectUnusedVariables({ scope: visitor.getScope(program) });
+		this.RESULTS_CACHE.set(program, unusedVariables);
+		return unusedVariables;
+	}
+	Identifier(node) {
+		const scope = this.getScope(node);
+		if (scope.type === TSESLint.Scope.ScopeType.function && node.name === "this" && "params" in scope.block && scope.block.params.includes(node)) this.markVariableAsUsed(node);
+	}
+	TSEnumDeclaration(node) {
+		const scope = this.getScope(node);
+		for (const variable of scope.variables) this.markVariableAsUsed(variable);
+	}
+	TSMappedType(node) {
+		this.markVariableAsUsed(node.key);
+	}
+	TSModuleDeclaration(node) {
+		if (node.kind === "global") this.markVariableAsUsed("global", node.parent);
+	}
+	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);
+	}
+	collectUnusedVariables({ scope, variables = {
+		unusedVariables: /* @__PURE__ */ new Set(),
+		usedVariables: /* @__PURE__ */ new Set()
+	} }) {
+		if (!scope.functionExpressionScope) for (const variable of scope.variables) {
+			if (variable instanceof ImplicitLibVariable) continue;
+			if (variable.eslintUsed || isExported$1(variable) || isMergeableExported(variable) || isUsedVariable(variable)) variables.usedVariables.add(variable);
+			else variables.unusedVariables.add(variable);
+		}
+		for (const childScope of scope.childScopes) this.collectUnusedVariables({
+			scope: childScope,
+			variables
+		});
+		return variables;
+	}
+	getScope(currentNode) {
+		const inner = currentNode.type !== AST_NODE_TYPES.Program;
+		let node = currentNode;
+		while (node) {
+			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;
+				}
+				return scope;
+			}
+			node = node.parent;
+		}
+		const returnValue = this.#scopeManager.scopes[0];
+		assert(returnValue, "There should be at least one scope");
+		return returnValue;
+	}
+	markVariableAsUsed(variableOrIdentifierOrName, parent) {
+		if (typeof variableOrIdentifierOrName !== "string" && !("type" in variableOrIdentifierOrName)) {
+			variableOrIdentifierOrName.eslintUsed = true;
+			return;
+		}
+		let name$1;
+		let node;
+		if (typeof variableOrIdentifierOrName === "string") {
+			name$1 = variableOrIdentifierOrName;
+			assert(parent, "Parent node is required when marking by name");
+			node = parent;
+		} else {
+			({name: name$1} = variableOrIdentifierOrName);
+			node = variableOrIdentifierOrName;
+		}
+		let currentScope = this.getScope(node);
+		while (currentScope) {
+			const variable = currentScope.variables.find((scopeVariable) => scopeVariable.name === name$1);
+			if (variable) {
+				variable.eslintUsed = true;
+				return;
+			}
+			currentScope = currentScope.upper ?? void 0;
+		}
+	}
+	visitClass(node) {
+		const scope = this.getScope(node);
+		for (const variable of scope.variables) if (variable.identifiers[0] === scope.block.id) {
+			this.markVariableAsUsed(variable);
+			return;
+		}
+	}
+	visitForInForOf(node) {
+		/**
+		* // cspell:ignore Zacher
+		* (Brad Zacher): I hate that this has to exist.
+		* But it is required for compat with the base ESLint rule.
+		*
+		* In 2015, ESLint decided to add an exception for these two specific cases.
+		* ```
+		* for (var key in object) return;
+		*
+		* var key;
+		* for (key in object) return;
+		* ```
+		*
+		* I disagree with it, but what are you going to do...
+		*
+		* Https://github.com/eslint/eslint/issues/2342.
+		*/
+		let idOrVariable;
+		if (node.left.type === AST_NODE_TYPES.VariableDeclaration) {
+			const variable = this.#scopeManager.getDeclaredVariables(node.left).at(0);
+			if (!variable) return;
+			idOrVariable = variable;
+		}
+		if (node.left.type === AST_NODE_TYPES.Identifier) idOrVariable = node.left;
+		if (idOrVariable === void 0) return;
+		let { body } = node;
+		if (body.type === AST_NODE_TYPES.BlockStatement) {
+			if (body.body.length !== 1) return;
+			body = body.body[0];
+		}
+		if (body.type !== AST_NODE_TYPES.ReturnStatement) return;
+		this.markVariableAsUsed(idOrVariable);
+	}
+	visitFunction(node) {
+		const variable = this.getScope(node).set.get("arguments");
+		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);
+		});
+	}
+	visitSetter(node) {
+		if (node.kind === "set") for (const parameter of node.value.params) this.visitPattern(parameter, (id) => {
+			this.markVariableAsUsed(id);
+		});
+	}
+};
+/**
+* Checks the position of given nodes.
+* @param inner - A node which is expected as inside.
+* @param outer - A node which is expected as outside.
+* @returns `true` if the `inner` node exists in the `outer` node.
+*/
+function isInside(inner, outer) {
+	return inner.range[0] >= outer.range[0] && inner.range[1] <= outer.range[1];
+}
+/**
+* Determine if an identifier is referencing an enclosing name.
+* This only applies to declarations that create their own scope (modules, functions, classes).
+* @param ref - The reference to check.
+* @param nodes - The candidate function nodes.
+* @returns True if it's a self-reference, false if not.
+*/
+function isSelfReference(ref, nodes) {
+	let scope = ref.from;
+	while (scope) {
+		if (nodes.has(scope.block)) return true;
+		scope = scope.upper ?? void 0;
+	}
+	return false;
+}
+const MERGEABLE_TYPES = new Set([
+	AST_NODE_TYPES.ClassDeclaration,
+	AST_NODE_TYPES.FunctionDeclaration,
+	AST_NODE_TYPES.TSInterfaceDeclaration,
+	AST_NODE_TYPES.TSModuleDeclaration,
+	AST_NODE_TYPES.TSTypeAliasDeclaration
+]);
+/**
+* Determines if a given variable is being exported from a module.
+* @param variable - Eslint-scope variable object.
+* @returns True if the variable is exported, false if not.
+*/
+function isExported$1(variable) {
+	return variable.defs.some((definition) => {
+		let { node } = definition;
+		if (node.type === AST_NODE_TYPES.VariableDeclarator) node = node.parent;
+		else if (definition.type === TSESLint.Scope.DefinitionType.Parameter) return false;
+		return node.parent.type.startsWith("Export");
+	});
+}
+/**
+* Determine if the variable is directly exported.
+* @param variable - The variable to check.
+* @returns True if the variable is exported via a merged declaration.
+*/
+function isMergeableExported(variable) {
+	for (const definition of variable.defs) {
+		if (definition.type === TSESLint.Scope.DefinitionType.Parameter) continue;
+		if (MERGEABLE_TYPES.has(definition.node.type) && definition.node.parent.type === AST_NODE_TYPES.ExportNamedDeclaration || definition.node.parent.type === AST_NODE_TYPES.ExportDefaultDeclaration) return true;
+	}
+	return false;
+}
+const LOGICAL_ASSIGNMENT_OPERATORS = new Set([
+	"&&=",
+	"??=",
+	"||="
+]);
+/**
+* Collects the set of unused variables for a given context.
+*
+* Due to complexity, this does not take into consideration:
+* - variables within declaration files
+* - variables within ambient module declarations.
+* @param context - The rule context.
+* @returns The collected variables.
+* @template MessageIds
+* @template Options
+*/
+function collectVariables(context) {
+	return UnusedVariablesVisitor.collectUnusedVariables(context.sourceCode.ast, ESLintUtils.nullThrows(context.sourceCode.scopeManager, "Missing required scope manager"));
+}
+/**
+* Determines if the variable is used.
+* @param variable - The variable to check.
+* @returns True if the variable is used.
+*/
+function isUsedVariable(variable) {
+	/**
+	* Gets a list of function definitions for a specified variable.
+	* @param scopeVariable - Eslint-scope variable object.
+	* @returns Function nodes.
+	*/
+	function getFunctionDefinitions(scopeVariable) {
+		const functionDefinitions = /* @__PURE__ */ new Set();
+		for (const definition of scopeVariable.defs) {
+			if (definition.type === TSESLint.Scope.DefinitionType.FunctionName) functionDefinitions.add(definition.node);
+			if (definition.type === TSESLint.Scope.DefinitionType.Variable && (definition.node.init?.type === AST_NODE_TYPES.FunctionExpression || definition.node.init?.type === AST_NODE_TYPES.ArrowFunctionExpression)) functionDefinitions.add(definition.node.init);
+		}
+		return functionDefinitions;
+	}
+	function getTypeDeclarations(scopeVariable) {
+		const nodes = /* @__PURE__ */ new Set();
+		for (const definition of scopeVariable.defs) if (definition.node.type === AST_NODE_TYPES.TSInterfaceDeclaration || definition.node.type === AST_NODE_TYPES.TSTypeAliasDeclaration) nodes.add(definition.node);
+		return nodes;
+	}
+	function getModuleDeclarations(scopeVariable) {
+		const nodes = /* @__PURE__ */ new Set();
+		for (const definition of scopeVariable.defs) if (definition.node.type === AST_NODE_TYPES.TSModuleDeclaration) nodes.add(definition.node);
+		return nodes;
+	}
+	function getEnumDeclarations(scopeVariable) {
+		const nodes = /* @__PURE__ */ new Set();
+		for (const definition of scopeVariable.defs) if (definition.node.type === AST_NODE_TYPES.TSEnumDeclaration) nodes.add(definition.node);
+		return nodes;
+	}
+	/**
+	* Checks if the ref is contained within one of the given nodes.
+	* @param ref - A reference to check.
+	* @param nodes - A set of nodes.
+	* @returns `true` if the ref is inside one of the nodes.
+	*/
+	function isInsideOneOf(ref, nodes) {
+		for (const node of nodes) if (isInside(ref.identifier, node)) return true;
+		return false;
+	}
+	/**
+	* Checks whether a given node is unused expression or not.
+	* @param node - The node itself.
+	* @returns The node is an unused expression.
+	*/
+	function isUnusedExpression(node) {
+		const { parent } = node;
+		if (parent.type === AST_NODE_TYPES.ExpressionStatement) return true;
+		if (parent.type === AST_NODE_TYPES.SequenceExpression) {
+			if (!(parent.expressions[parent.expressions.length - 1] === node)) return true;
+			return isUnusedExpression(parent);
+		}
+		return false;
+	}
+	/**
+	* If a given reference is left-hand side of an assignment, this gets
+	* the right-hand side node of the assignment.
+	*
+	* In the following cases, this returns undefined.
+	*
+	* - The reference is not the LHS of an assignment expression.
+	* - The reference is inside of a loop.
+	* - The reference is inside of a function scope which is different from
+	*   the declaration.
+	* @param ref - A reference to check.
+	* @param previousRhsNode - The previous RHS node. This is for `a = a + a`-like code.
+	* @returns The RHS node or undefined.
+	*/
+	function getRhsNode(ref, previousRhsNode) {
+		/**
+		* Checks whether the given node is in a loop or not.
+		* @param node - The node to check.
+		* @returns `true` if the node is in a loop.
+		*/
+		function isInLoop(node) {
+			let currentNode = node;
+			while (currentNode) {
+				if (ASTUtils.isFunction(currentNode)) break;
+				if (ASTUtils.isLoop(currentNode)) return true;
+				currentNode = currentNode.parent;
+			}
+			return false;
+		}
+		const id = ref.identifier;
+		const { parent } = id;
+		const refScope = ref.from.variableScope;
+		const { variableScope } = ref.resolved.scope;
+		const canBeUsedLater = refScope !== variableScope || isInLoop(id);
+		if (previousRhsNode && isInside(id, previousRhsNode)) return previousRhsNode;
+		if (parent.type === AST_NODE_TYPES.AssignmentExpression && isUnusedExpression(parent) && id === parent.left && !canBeUsedLater) return parent.right;
+	}
+	/**
+	* Checks whether a given reference is a read to update itself or not.
+	* @param ref - A reference to check.
+	* @param rhsNode - The RHS node of the previous assignment.
+	* @returns The reference is a read to update itself.
+	*/
+	function isReadForItself(ref, rhsNode$1) {
+		/**
+		* Checks whether a given Identifier node exists inside of a function node which can be used later.
+		*
+		* "can be used later" means:
+		* - the function is assigned to a variable.
+		* - the function is bound to a property and the object can be used later.
+		* - the function is bound as an argument of a function call.
+		*
+		* If a reference exists in a function which can be used later, the reference is read when the function is called.
+		* @param id - An Identifier node to check.
+		* @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) {
+			/**
+			* Finds a function node from ancestors of a node.
+			* @param node - A start node to find.
+			* @returns A found function node.
+			*/
+			function getUpperFunction(node) {
+				let currentNode = node;
+				while (currentNode) {
+					if (ASTUtils.isFunction(currentNode)) return currentNode;
+					currentNode = currentNode.parent;
+				}
+			}
+			/**
+			* Checks whether a given function node is stored to somewhere or not.
+			* If the function node is stored, the function can be used later.
+			* @param funcNode - A function node to check.
+			* @param storableRhsNode - The RHS node of the previous assignment.
+			* @returns `true` if under the following conditions:
+			*      - the funcNode is assigned to a 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) {
+						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.SequenceExpression:
+							if (parent$1.expressions[parent$1.expressions.length - 1] !== node) return false;
+							break;
+						default: if (parent$1.type.endsWith("Statement") || parent$1.type.endsWith("Declaration")) return true;
+					}
+					node = parent$1;
+					({parent: parent$1} = parent$1);
+				}
+				return false;
+			}
+			const funcNode = getUpperFunction(id$1);
+			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));
+	}
+	const functionNodes = getFunctionDefinitions(variable);
+	const isFunctionDefinition = functionNodes.size > 0;
+	const typeDeclNodes = getTypeDeclarations(variable);
+	const isTypeDecl = typeDeclNodes.size > 0;
+	const moduleDeclNodes = getModuleDeclarations(variable);
+	const isModuleDecl = moduleDeclNodes.size > 0;
+	const enumDeclNodes = getEnumDeclarations(variable);
+	const isEnumDecl = enumDeclNodes.size > 0;
+	const isImportedAsType = variable.defs.every(isTypeImport);
+	let rhsNode;
+	return variable.references.some((ref) => {
+		const forItself = isReadForItself(ref, rhsNode);
+		rhsNode = getRhsNode(ref, rhsNode);
+		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 = {
+	variable: 1,
+	function: 2,
+	parameter: 4,
+	objectStyleEnum: 8,
+	parameterProperty: 16,
+	classicAccessor: 32,
+	enumMember: 64,
+	classMethod: 128,
+	objectLiteralMethod: 256,
+	typeMethod: 512,
+	classProperty: 1024,
+	objectLiteralProperty: 2048,
+	typeProperty: 4096,
+	autoAccessor: 8192,
+	class: 16384,
+	interface: 32768,
+	typeAlias: 65536,
+	enum: 131072,
+	typeParameter: 262144,
+	import: 524288
+};
+const MetaSelector = {
+	default: -1,
+	variableLike: 15,
+	memberLike: 16368,
+	typeLike: 507904,
+	method: 896,
+	property: 7168,
+	accessor: 8224
+};
+const Modifier = {
+	"const": 1,
+	"readonly": 2,
+	"static": 4,
+	"public": 8,
+	"protected": 16,
+	"private": 32,
+	"#private": 64,
+	"abstract": 128,
+	"destructured": 256,
+	"global": 512,
+	"exported": 1024,
+	"unused": 2048,
+	"requiresQuotes": 4096,
+	"override": 8192,
+	"async": 16384,
+	"default": 32768,
+	"namespace": 65536
+};
+const PredefinedFormat = {
+	camelCase: 1,
+	strictCamelCase: 2,
+	PascalCase: 3,
+	StrictPascalCase: 4,
+	snake_case: 5,
+	UPPER_CASE: 6
+};
+const PredefinedFormatValueToKey = Object.fromEntries(Object.entries(PredefinedFormat).map(([key, value]) => [value, key]));
+const TypeModifier = {
+	boolean: 131072,
+	string: 262144,
+	number: 524288,
+	function: 1048576,
+	array: 2097152
+};
+const TypeModifierValueToKey = Object.fromEntries(Object.entries(TypeModifier).map(([key, value]) => [value, key]));
+const UnderscoreOption = {
+	forbid: 1,
+	allow: 2,
+	require: 3,
+	requireDouble: 4,
+	allowDouble: 5,
+	allowSingleOrDouble: 6
+};
+
+//#endregion
+//#region src/rules/naming-convention/utils/shared.ts
+function isMetaSelector(selector) {
+	return selector in MetaSelector;
+}
+function isMethodOrPropertySelector(selector) {
+	return selector === MetaSelector.method || selector === MetaSelector.property;
+}
+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];
+		if (char === "_") return false;
+		if (isUpper === isUppercaseChar(char)) {
+			if (isUpper) return false;
+		} else isUpper = !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 isUppercaseChar(char) {
+	return char === char.toUpperCase() && char !== char.toLowerCase();
+}
+/**
+* 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;
+	let wasUnderscore = false;
+	for (let index = 1; index < name$1.length; ++index) if (name$1[index] === "_") {
+		if (wasUnderscore) return false;
+		wasUnderscore = true;
+	} else wasUnderscore = false;
+	return !wasUnderscore;
+}
+const FormatCheckersMap = {
+	[PredefinedFormat.camelCase]: isCamelCase,
+	[PredefinedFormat.PascalCase]: isPascalCase,
+	[PredefinedFormat.snake_case]: isSnakeCase,
+	[PredefinedFormat.strictCamelCase]: isStrictCamelCase,
+	[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) => {
+		return (configItem.selector & selectorType) !== 0 || configItem.selector === MetaSelector.default;
+	}).sort((a, b) => {
+		if (a.selector === b.selector) return b.modifierWeight - a.modifierWeight;
+		const aIsMeta = isMetaSelector(a.selector);
+		const bIsMeta = isMetaSelector(b.selector);
+		if (aIsMeta && !bIsMeta) return 1;
+		if (!aIsMeta && bIsMeta) return -1;
+		const aIsMethodOrProperty = isMethodOrPropertySelector(a.selector);
+		const bIsMethodOrProperty = isMethodOrPropertySelector(b.selector);
+		if (aIsMethodOrProperty && !bIsMethodOrProperty) return -1;
+		if (!aIsMethodOrProperty && bIsMethodOrProperty) return 1;
+		return b.selector - a.selector;
+	});
+	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) {
+			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({
+				config,
+				name: name$1,
+				node,
+				originalName,
+				position: "leading"
+			});
+			if (name$1 === void 0) return;
+			name$1 = validateUnderscore({
+				config,
+				name: name$1,
+				node,
+				originalName,
+				position: "trailing"
+			});
+			if (name$1 === void 0) return;
+			name$1 = validateAffix({
+				config,
+				name: name$1,
+				node,
+				originalName,
+				position: "prefix"
+			});
+			if (name$1 === void 0) return;
+			name$1 = validateAffix({
+				config,
+				name: name$1,
+				node,
+				originalName,
+				position: "suffix"
+			});
+			if (name$1 === void 0) return;
+			if (!validateCustom({
+				config,
+				name: name$1,
+				node,
+				originalName
+			})) return;
+			if (!validatePredefinedFormat({
+				config,
+				modifiers,
+				name: name$1,
+				node,
+				originalName
+			})) return;
+			return;
+		}
+	};
+	function formatReportData({ affixes, count, custom, formats, originalName, position, processedName }) {
+		let regexMatch = null;
+		if (custom?.match === true) regexMatch = "match";
+		else if (custom?.match === false) regexMatch = "not match";
+		return {
+			affixes: affixes?.join(", "),
+			count,
+			formats: formats?.map((formatItem) => PredefinedFormatValueToKey[formatItem]).join(", "),
+			name: originalName,
+			position,
+			processedName,
+			regex: custom?.regex.toString(),
+			regexMatch,
+			type: selectorTypeToMessageString(type)
+		};
+	}
+	function validateUnderscore({ config, name: name$1, 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);
+		switch (option) {
+			case UnderscoreOption.allow:
+				if (hasSingleUnderscore()) return trimSingleUnderscore();
+				return name$1;
+			case UnderscoreOption.allowDouble:
+				if (hasDoubleUnderscore()) return trimDoubleUnderscore();
+				return name$1;
+			case UnderscoreOption.allowSingleOrDouble:
+				if (hasDoubleUnderscore()) return trimDoubleUnderscore();
+				if (hasSingleUnderscore()) return trimSingleUnderscore();
+				return name$1;
+			case UnderscoreOption.forbid:
+				if (hasSingleUnderscore()) {
+					context.report({
+						data: formatReportData({
+							count: "one",
+							originalName,
+							position
+						}),
+						messageId: "unexpectedUnderscore",
+						node
+					});
+					return;
+				}
+				return name$1;
+			case UnderscoreOption.require:
+				if (!hasSingleUnderscore()) {
+					context.report({
+						data: formatReportData({
+							count: "one",
+							originalName,
+							position
+						}),
+						messageId: "missingUnderscore",
+						node
+					});
+					return;
+				}
+				return trimSingleUnderscore();
+			case UnderscoreOption.requireDouble:
+				if (!hasDoubleUnderscore()) {
+					context.report({
+						data: formatReportData({
+							count: "two",
+							originalName,
+							position
+						}),
+						messageId: "missingUnderscore",
+						node
+					});
+					return;
+				}
+				return trimDoubleUnderscore();
+		}
+	}
+	function validateAffix({ config, name: name$1, node, originalName, position }) {
+		const affixes = config[position];
+		if (!affixes || affixes.length === 0) return name$1;
+		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);
+			if (hasAffix) return trimAffix();
+		}
+		context.report({
+			data: formatReportData({
+				affixes,
+				originalName,
+				position
+			}),
+			messageId: "missingAffix",
+			node
+		});
+	}
+	function validateCustom({ config, name: name$1, node, originalName }) {
+		const { custom } = config;
+		if (!custom) return true;
+		const result = custom.regex.test(name$1);
+		if (custom.match && result) return true;
+		if (!custom.match && !result) return true;
+		context.report({
+			data: formatReportData({
+				custom,
+				originalName
+			}),
+			messageId: "satisfyCustom",
+			node
+		});
+		return false;
+	}
+	function validatePredefinedFormat({ config, modifiers, name: name$1, 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;
+		}
+		context.report({
+			data: formatReportData({
+				formats,
+				originalName,
+				processedName: name$1
+			}),
+			messageId: originalName === name$1 ? "doesNotMatchFormat" : "doesNotMatchFormatTrimmed",
+			node
+		});
+		return false;
+	}
+}
+const SelectorsAllowedToHaveTypes = Selector.variable | Selector.parameter | Selector.classProperty | Selector.objectLiteralProperty | Selector.typeProperty | Selector.parameterProperty | Selector.classicAccessor;
+function isAllTypesMatch(type, callback) {
+	if (type.isUnion()) return type.types.every((inner) => callback(inner));
+	return callback(type);
+}
+function isCorrectType(node, config, context, selector) {
+	if (config.types === void 0) return true;
+	if ((SelectorsAllowedToHaveTypes & selector) === 0) return true;
+	const services = getParserServices(context);
+	const checker = services.program.getTypeChecker();
+	const type = services.getTypeAtLocation(node).getNonNullableType();
+	for (const allowedType of config.types) switch (allowedType) {
+		case TypeModifier.array:
+			if (isAllTypesMatch(type, (inner) => checker.isArrayType(inner) || checker.isTupleType(inner))) return true;
+			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;
+			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) {
+	const normalizedOptions = context.options.flatMap(normalizeOption);
+	return Object.fromEntries(Object.keys(Selector).map((key) => [key, createValidator(key, context, normalizedOptions)]));
+}
+function normalizeOption(option) {
+	let weight = 0;
+	if (option.modifiers) for (const modifier of option.modifiers) weight |= Modifier[modifier];
+	if (option.types) for (const type of option.types) weight |= TypeModifier[type];
+	if (option.filter !== void 0) weight |= 1 << 30;
+	const normalizedOption = {
+		custom: option.custom ? {
+			match: option.custom.match,
+			regex: new RegExp(option.custom.regex, "u")
+		} : void 0,
+		filter: option.filter !== void 0 ? typeof option.filter === "string" ? {
+			match: true,
+			regex: new RegExp(option.filter, "u")
+		} : {
+			match: option.filter.match,
+			regex: new RegExp(option.filter.regex, "u")
+		} : void 0,
+		format: option.format ? option.format.map((format) => PredefinedFormat[format]) : void 0,
+		leadingUnderscore: option.leadingUnderscore !== void 0 ? UnderscoreOption[option.leadingUnderscore] : void 0,
+		modifiers: option.modifiers?.map((modifier) => Modifier[modifier]) ?? void 0,
+		modifierWeight: weight,
+		prefix: option.prefix && option.prefix.length > 0 ? option.prefix : void 0,
+		suffix: option.suffix && option.suffix.length > 0 ? option.suffix : void 0,
+		trailingUnderscore: option.trailingUnderscore !== void 0 ? UnderscoreOption[option.trailingUnderscore] : void 0,
+		types: option.types?.map((type) => TypeModifier[type]) ?? void 0
+	};
+	return (Array.isArray(option.selector) ? option.selector : [option.selector]).map((selector) => {
+		return {
+			selector: isMetaSelector(selector) ? MetaSelector[selector] : Selector[selector],
+			...normalizedOption
+		};
+	});
+}
+
+//#endregion
+//#region src/rules/naming-convention/utils/schema.ts
+const $DEFS = {
+	formatOptionsConfig: { oneOf: [{
+		additionalItems: false,
+		items: { $ref: "#/$defs/predefinedFormats" },
+		type: "array"
+	}, { type: "null" }] },
+	matchRegexConfig: {
+		additionalProperties: false,
+		properties: {
+			match: { type: "boolean" },
+			regex: { type: "string" }
+		},
+		required: ["match", "regex"],
+		type: "object"
+	},
+	predefinedFormats: {
+		enum: Object.keys(PredefinedFormat),
+		type: "string"
+	},
+	prefixSuffixConfig: {
+		additionalItems: false,
+		items: {
+			minLength: 1,
+			type: "string"
+		},
+		type: "array"
+	},
+	typeModifiers: {
+		enum: Object.keys(TypeModifier),
+		type: "string"
+	},
+	underscoreOptions: {
+		enum: Object.keys(UnderscoreOption),
+		type: "string"
+	}
+};
+const UNDERSCORE_SCHEMA = { $ref: "#/$defs/underscoreOptions" };
+const PREFIX_SUFFIX_SCHEMA = { $ref: "#/$defs/prefixSuffixConfig" };
+const MATCH_REGEX_SCHEMA = { $ref: "#/$defs/matchRegexConfig" };
+const FORMAT_OPTIONS_PROPERTIES = {
+	custom: MATCH_REGEX_SCHEMA,
+	failureMessage: { type: "string" },
+	format: { $ref: "#/$defs/formatOptionsConfig" },
+	leadingUnderscore: UNDERSCORE_SCHEMA,
+	prefix: PREFIX_SUFFIX_SCHEMA,
+	suffix: PREFIX_SUFFIX_SCHEMA,
+	trailingUnderscore: UNDERSCORE_SCHEMA
+};
+function selectorSchema(selectorString, allowType, modifiers) {
+	const selector = {
+		filter: { oneOf: [{
+			minLength: 1,
+			type: "string"
+		}, MATCH_REGEX_SCHEMA] },
+		selector: {
+			enum: [selectorString],
+			type: "string"
+		}
+	};
+	if (modifiers && modifiers.length > 0) selector["modifiers"] = {
+		additionalItems: false,
+		items: {
+			enum: modifiers,
+			type: "string"
+		},
+		type: "array"
+	};
+	if (allowType) selector["types"] = {
+		additionalItems: false,
+		items: { $ref: "#/$defs/typeModifiers" },
+		type: "array"
+	};
+	return [{
+		additionalProperties: false,
+		description: `Selector '${selectorString}'`,
+		properties: {
+			...FORMAT_OPTIONS_PROPERTIES,
+			...selector
+		},
+		required: ["selector", "format"],
+		type: "object"
+	}];
+}
+function selectorsSchema() {
+	return {
+		additionalProperties: false,
+		description: "Multiple selectors in one config",
+		properties: {
+			...FORMAT_OPTIONS_PROPERTIES,
+			filter: { oneOf: [{
+				minLength: 1,
+				type: "string"
+			}, MATCH_REGEX_SCHEMA] },
+			modifiers: {
+				additionalItems: false,
+				items: {
+					enum: Object.keys(Modifier),
+					type: "string"
+				},
+				type: "array"
+			},
+			selector: {
+				additionalItems: false,
+				items: {
+					enum: [...Object.keys(MetaSelector), ...Object.keys(Selector)],
+					type: "string"
+				},
+				type: "array"
+			},
+			types: {
+				additionalItems: false,
+				items: { $ref: "#/$defs/typeModifiers" },
+				type: "array"
+			}
+		},
+		required: ["selector", "format"],
+		type: "object"
+	};
+}
+const SCHEMA = {
+	$defs: $DEFS,
+	additionalItems: false,
+	items: { oneOf: [
+		selectorsSchema(),
+		...selectorSchema("default", false, Object.keys(Modifier)),
+		...selectorSchema("variableLike", false, ["unused", "async"]),
+		...selectorSchema("variable", true, [
+			"const",
+			"destructured",
+			"exported",
+			"global",
+			"unused",
+			"async"
+		]),
+		...selectorSchema("function", false, [
+			"exported",
+			"global",
+			"unused",
+			"async"
+		]),
+		...selectorSchema("parameter", true, ["destructured", "unused"]),
+		...selectorSchema("objectStyleEnum", false, [
+			"const",
+			"exported",
+			"global",
+			"unused"
+		]),
+		...selectorSchema("memberLike", false, [
+			"abstract",
+			"private",
+			"#private",
+			"protected",
+			"public",
+			"readonly",
+			"requiresQuotes",
+			"static",
+			"override",
+			"async"
+		]),
+		...selectorSchema("classProperty", true, [
+			"abstract",
+			"private",
+			"#private",
+			"protected",
+			"public",
+			"readonly",
+			"requiresQuotes",
+			"static",
+			"override"
+		]),
+		...selectorSchema("objectLiteralProperty", true, ["public", "requiresQuotes"]),
+		...selectorSchema("typeProperty", true, [
+			"public",
+			"readonly",
+			"requiresQuotes"
+		]),
+		...selectorSchema("parameterProperty", true, [
+			"private",
+			"protected",
+			"public",
+			"readonly"
+		]),
+		...selectorSchema("property", true, [
+			"abstract",
+			"private",
+			"#private",
+			"protected",
+			"public",
+			"readonly",
+			"requiresQuotes",
+			"static",
+			"override",
+			"async"
+		]),
+		...selectorSchema("classMethod", false, [
+			"abstract",
+			"private",
+			"#private",
+			"protected",
+			"public",
+			"requiresQuotes",
+			"static",
+			"override",
+			"async"
+		]),
+		...selectorSchema("objectLiteralMethod", false, [
+			"public",
+			"requiresQuotes",
+			"async"
+		]),
+		...selectorSchema("typeMethod", false, ["public", "requiresQuotes"]),
+		...selectorSchema("method", false, [
+			"abstract",
+			"private",
+			"#private",
+			"protected",
+			"public",
+			"requiresQuotes",
+			"static",
+			"override",
+			"async"
+		]),
+		...selectorSchema("classicAccessor", true, [
+			"abstract",
+			"private",
+			"protected",
+			"public",
+			"requiresQuotes",
+			"static",
+			"override"
+		]),
+		...selectorSchema("autoAccessor", true, [
+			"abstract",
+			"private",
+			"protected",
+			"public",
+			"requiresQuotes",
+			"static",
+			"override"
+		]),
+		...selectorSchema("accessor", true, [
+			"abstract",
+			"private",
+			"protected",
+			"public",
+			"requiresQuotes",
+			"static",
+			"override"
+		]),
+		...selectorSchema("enumMember", false, ["requiresQuotes"]),
+		...selectorSchema("typeLike", false, [
+			"abstract",
+			"exported",
+			"unused"
+		]),
+		...selectorSchema("class", false, [
+			"abstract",
+			"exported",
+			"unused"
+		]),
+		...selectorSchema("interface", false, ["exported", "unused"]),
+		...selectorSchema("typeAlias", false, ["exported", "unused"]),
+		...selectorSchema("enum", false, ["exported", "unused"]),
+		...selectorSchema("typeParameter", false, ["unused"]),
+		...selectorSchema("import", false, ["default", "namespace"])
+	] },
+	type: "array"
+};
+
+//#endregion
+//#region src/rules/naming-convention/rule.ts
+const RULE_NAME = "naming-convention";
+const messages = {
+	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}}",
+	missingUnderscore: "{{type}} name `{{name}}` must have {{count}} {{position}} underscore(s).",
+	satisfyCustom: "{{type}} name `{{name}}` must {{regexMatch}} the RegExp: {{regex}}",
+	unexpectedUnderscore: "{{type}} name `{{name}}` must not have a {{position}} underscore."
+};
+const camelCaseNamingConfig = [
+	{
+		format: ["camelCase"],
+		leadingUnderscore: "allow",
+		selector: "default",
+		trailingUnderscore: "allow"
+	},
+	{
+		format: ["camelCase", "PascalCase"],
+		selector: "import"
+	},
+	{
+		format: ["camelCase", "UPPER_CASE"],
+		leadingUnderscore: "allow",
+		selector: "variable",
+		trailingUnderscore: "allow"
+	},
+	{
+		format: ["PascalCase"],
+		selector: "typeLike"
+	}
+];
+function create(contextWithoutDefaults) {
+	const context = contextWithoutDefaults.options.length > 0 ? contextWithoutDefaults : Object.setPrototypeOf({ options: camelCaseNamingConfig }, contextWithoutDefaults);
+	const validators = parseOptions(context);
+	const compilerOptions = getParserServices(context, true).program?.getCompilerOptions() ?? {};
+	function handleMember(validator, node, modifiers) {
+		const { key } = node;
+		if (requiresQuoting$1(key, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
+		validator(key, modifiers);
+	}
+	function getMemberModifiers(node) {
+		const modifiers = /* @__PURE__ */ new Set();
+		if ("key" in node && node.key.type === AST_NODE_TYPES.PrivateIdentifier) modifiers.add(Modifier["#private"]);
+		else if (node.accessibility) modifiers.add(Modifier[node.accessibility]);
+		else modifiers.add(Modifier.public);
+		if (node.static) modifiers.add(Modifier.static);
+		if ("readonly" in node && node.readonly) modifiers.add(Modifier.readonly);
+		if ("override" in node && node.override) modifiers.add(Modifier.override);
+		if (node.type === AST_NODE_TYPES.TSAbstractPropertyDefinition || node.type === AST_NODE_TYPES.TSAbstractMethodDefinition || node.type === AST_NODE_TYPES.TSAbstractAccessorProperty) modifiers.add(Modifier.abstract);
+		return modifiers;
+	}
+	const { unusedVariables } = collectVariables(context);
+	function isUnused(name$1, initialScope) {
+		let variable = null;
+		let scope = initialScope;
+		while (scope) {
+			variable = scope.set.get(name$1) ?? null;
+			if (variable) break;
+			scope = scope.upper;
+		}
+		if (!variable) return false;
+		return unusedVariables.has(variable);
+	}
+	function isDestructured(id) {
+		return id.parent.type === AST_NODE_TYPES.Property && id.parent.shorthand || id.parent.type === AST_NODE_TYPES.AssignmentPattern && id.parent.parent.type === AST_NODE_TYPES.Property && id.parent.parent.shorthand;
+	}
+	function isAsyncMemberOrProperty(propertyOrMemberNode) {
+		return Boolean("value" in propertyOrMemberNode && propertyOrMemberNode.value && "async" in propertyOrMemberNode.value && propertyOrMemberNode.value.async);
+	}
+	function isAsyncVariableIdentifier(id) {
+		return Boolean("async" in id.parent && id.parent.async || "init" in id.parent && id.parent.init && "async" in id.parent.init && id.parent.init.async);
+	}
+	/**
+	* Determines if a VariableDeclarator represents an object-style enum declaration.
+	*
+	* Object-style enums are const assertions applied to object expressions, commonly
+	* used as an alternative to TypeScript enums. Examples:
+	* - `const Colors = { RED: 'red', BLUE: 'blue' } as const`
+	* - `const Status = <const>{ OK: 200, ERROR: 500 }`.
+	*
+	* @param node - The VariableDeclarator AST node to check.
+	* @param parent - The parent VariableDeclaration node.
+	* @returns True if this represents an object-style enum declaration.
+	*/
+	function isObjectStyleEnumDeclaration(node, parent) {
+		if (parent.kind !== "const") return false;
+		if (!node.init) return false;
+		if (node.init.type === AST_NODE_TYPES.TSAsExpression && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
+		if (node.init.type === AST_NODE_TYPES.TSTypeAssertion && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
+		return false;
+	}
+	/**
+	* Checks if a method name exists in any of the implemented interfaces.
+	*
+	* @param implementsList - List of implemented interfaces.
+	* @param methodName - Name of the method to check.
+	* @param checker - TypeScript type checker.
+	* @param services - Parser services.
+	* @returns True if the method name is found in any interface.
+	*/
+	function checkInterfacesForMethod(implementsList, methodName, checker, services) {
+		for (const implementsClause of implementsList) {
+			const interfaceType = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(implementsClause));
+			if (!interfaceType.getSymbol()) continue;
+			const interfaceMembers = checker.getPropertiesOfType(interfaceType);
+			for (const member of interfaceMembers) if (member.name === methodName) return true;
+		}
+		return false;
+	}
+	/**
+	* Determines if a class method is implementing an interface method.
+	*
+	* @param node - The class method node to check.
+	* @returns True if the method is implementing an interface method.
+	*/
+	function isImplementingInterfaceMethod(node) {
+		const services = getParserServices(context, true);
+		if (!services.program) return false;
+		const checker = services.program.getTypeChecker();
+		let parentClass = null;
+		let current = node.parent;
+		while (current) {
+			if (current.type === AST_NODE_TYPES.ClassDeclaration || current.type === AST_NODE_TYPES.ClassExpression) {
+				parentClass = current;
+				break;
+			}
+			current = current.parent;
+		}
+		if (!parentClass?.implements || parentClass.implements.length === 0) return false;
+		let methodName = null;
+		if (node.key.type === AST_NODE_TYPES.Identifier) methodName = node.key.name;
+		else if (node.key.type === AST_NODE_TYPES.Literal) methodName = String(node.key.value);
+		if (methodName === null) return false;
+		return checkInterfacesForMethod(parentClass.implements, methodName, checker, services);
+	}
+	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);
+			},
+			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);
+			},
+			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);
+			},
+			validator: validators.typeMethod
+		},
+		[[
+			":matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = \"ArrowFunctionExpression\"]",
+			":matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = \"FunctionExpression\"]",
+			":matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = \"TSEmptyBodyFunctionExpression\"]",
+			":matches(MethodDefinition, TSAbstractMethodDefinition)[computed = false][kind = \"method\"]"
+		].join(", ")]: {
+			handler: (node, validator) => {
+				if (isImplementingInterfaceMethod(node)) return;
+				const modifiers = getMemberModifiers(node);
+				if (isAsyncMemberOrProperty(node)) modifiers.add(Modifier.async);
+				handleMember(validator, node, modifiers);
+			},
+			validator: validators.classMethod
+		},
+		[["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);
+			},
+			validator: validators.classicAccessor
+		},
+		[[
+			"Property[computed = false][kind = \"init\"][value.type = \"ArrowFunctionExpression\"]",
+			"Property[computed = false][kind = \"init\"][value.type = \"FunctionExpression\"]",
+			"Property[computed = false][kind = \"init\"][value.type = \"TSEmptyBodyFunctionExpression\"]"
+		].join(", ")]: {
+			handler: (node, validator) => {
+				const modifiers = new Set([Modifier.public]);
+				if (isAsyncMemberOrProperty(node)) modifiers.add(Modifier.async);
+				handleMember(validator, node, modifiers);
+			},
+			validator: validators.objectLiteralMethod
+		},
+		[[AST_NODE_TYPES.AccessorProperty, AST_NODE_TYPES.TSAbstractAccessorProperty].join(", ")]: {
+			handler: (node, validator) => {
+				const modifiers = getMemberModifiers(node);
+				handleMember(validator, node, modifiers);
+			},
+			validator: validators.autoAccessor
+		},
+		"ClassDeclaration, ClassExpression": {
+			handler: (node, validator) => {
+				const { abstract, id } = node;
+				if (id === null) return;
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node).upper;
+				if (abstract) modifiers.add(Modifier.abstract);
+				if (isExported(node, id.name, scope)) modifiers.add(Modifier.exported);
+				if (isUnused(id.name, scope)) modifiers.add(Modifier.unused);
+				validator(id, modifiers);
+			},
+			validator: validators.class
+		},
+		"FunctionDeclaration, TSDeclareFunction, FunctionExpression": {
+			handler: (node, validator) => {
+				if (node.id === null) return;
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node).upper;
+				if (isGlobal(scope)) modifiers.add(Modifier.global);
+				if (isExported(node, node.id.name, scope)) modifiers.add(Modifier.exported);
+				if (isUnused(node.id.name, scope)) modifiers.add(Modifier.unused);
+				if (node.async) modifiers.add(Modifier.async);
+				validator(node.id, modifiers);
+			},
+			validator: validators.function
+		},
+		"FunctionDeclaration, TSDeclareFunction, TSEmptyBodyFunctionExpression, FunctionExpression, ArrowFunctionExpression": {
+			handler: (node, validator) => {
+				for (const parameter of node.params) {
+					if (parameter.type === AST_NODE_TYPES.TSParameterProperty) continue;
+					const identifiers = getIdentifiersFromPattern(parameter);
+					for (const index of identifiers) {
+						const modifiers = /* @__PURE__ */ new Set();
+						if (isDestructured(index)) modifiers.add(Modifier.destructured);
+						if (isUnused(index.name, context.sourceCode.getScope(index))) modifiers.add(Modifier.unused);
+						validator(index, modifiers);
+					}
+				}
+			},
+			validator: validators.parameter
+		},
+		"ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier": {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set();
+				switch (node.type) {
+					case AST_NODE_TYPES.ImportDefaultSpecifier:
+						modifiers.add(Modifier.default);
+						break;
+					case AST_NODE_TYPES.ImportNamespaceSpecifier:
+						modifiers.add(Modifier.namespace);
+						break;
+					case AST_NODE_TYPES.ImportSpecifier:
+						if (node.imported.type === AST_NODE_TYPES.Identifier && node.imported.name !== "default") return;
+						modifiers.add(Modifier.default);
+						break;
+				}
+				validator(node.local, modifiers);
+			},
+			validator: validators.import
+		},
+		"Property[computed = false]:matches([kind = \"get\"], [kind = \"set\"])": {
+			handler: (node, validator) => {
+				const modifiers = new Set([Modifier.public]);
+				handleMember(validator, node, modifiers);
+			},
+			validator: validators.classicAccessor
+		},
+		"TSEnumDeclaration": {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node).upper;
+				if (isExported(node, node.id.name, scope)) modifiers.add(Modifier.exported);
+				if (isUnused(node.id.name, scope)) modifiers.add(Modifier.unused);
+				validator(node.id, modifiers);
+			},
+			validator: validators.enum
+		},
+		"TSEnumMember": {
+			handler: (node, validator) => {
+				const { id } = node;
+				const modifiers = /* @__PURE__ */ new Set();
+				if (requiresQuoting$1(id, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
+				validator(id, modifiers);
+			},
+			validator: validators.enumMember
+		},
+		"TSInterfaceDeclaration": {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node);
+				if (isExported(node, node.id.name, scope)) modifiers.add(Modifier.exported);
+				if (isUnused(node.id.name, scope)) modifiers.add(Modifier.unused);
+				validator(node.id, modifiers);
+			},
+			validator: validators.interface
+		},
+		"TSParameterProperty": {
+			handler: (node, validator) => {
+				const modifiers = getMemberModifiers(node);
+				const identifiers = getIdentifiersFromPattern(node.parameter);
+				for (const index of identifiers) validator(index, modifiers);
+			},
+			validator: validators.parameterProperty
+		},
+		"TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type != \"TSFunctionType\"]": {
+			handler: (node, validator) => {
+				const modifiers = new Set([Modifier.public]);
+				if (node.readonly) modifiers.add(Modifier.readonly);
+				handleMember(validator, node, modifiers);
+			},
+			validator: validators.typeProperty
+		},
+		"TSTypeAliasDeclaration": {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node);
+				if (isExported(node, node.id.name, scope)) modifiers.add(Modifier.exported);
+				if (isUnused(node.id.name, scope)) modifiers.add(Modifier.unused);
+				validator(node.id, modifiers);
+			},
+			validator: validators.typeAlias
+		},
+		"TSTypeParameterDeclaration > TSTypeParameter": {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node);
+				if (isUnused(node.name.name, scope)) modifiers.add(Modifier.unused);
+				validator(node.name, modifiers);
+			},
+			validator: validators.typeParameter
+		},
+		"VariableDeclarator": {
+			handler: (node, validator) => {
+				const identifiers = getIdentifiersFromPattern(node.id);
+				const baseModifiers = /* @__PURE__ */ new Set();
+				const { parent } = node;
+				if (parent.kind === "const") baseModifiers.add(Modifier.const);
+				if (isGlobal(context.sourceCode.getScope(node))) baseModifiers.add(Modifier.global);
+				const isObjectStyleEnum = isObjectStyleEnumDeclaration(node, parent);
+				for (const id of identifiers) {
+					const modifiers = new Set(baseModifiers);
+					if (isDestructured(id)) modifiers.add(Modifier.destructured);
+					const scope = context.sourceCode.getScope(id);
+					if (isExported(parent, id.name, scope)) modifiers.add(Modifier.exported);
+					if (isUnused(id.name, scope)) modifiers.add(Modifier.unused);
+					if (isAsyncVariableIdentifier(id)) modifiers.add(Modifier.async);
+					if (isObjectStyleEnum) validators.objectStyleEnum(id, modifiers);
+					else validator(id, modifiers);
+				}
+			},
+			validator: validators.variable
+		}
+	};
+	return Object.fromEntries(Object.entries(selectors).map(([selector, { handler, validator }]) => {
+		return [selector, (node) => {
+			handler(node, validator);
+		}];
+	}));
+}
+const namingConvention = createEslintRule({
+	create,
+	defaultOptions: camelCaseNamingConfig,
+	meta: {
+		docs: {
+			description: "Enforce naming conventions for everything across a codebase",
+			recommended: true,
+			requiresTypeChecking: true
+		},
+		fixable: void 0,
+		hasSuggestions: false,
+		messages,
+		schema: SCHEMA,
+		type: "suggestion"
+	},
+	name: RULE_NAME
+});
+function getIdentifiersFromPattern(pattern) {
+	const identifiers = [];
+	new PatternVisitor({}, pattern, (id) => identifiers.push(id)).visit(pattern);
+	return identifiers;
+}
+function isExported(node, name$1, 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);
+	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;
+	}
+	return false;
+}
+function isGlobal(scope) {
+	if (scope === null) return false;
+	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);
+}
+
+//#endregion
+//#region src/plugin.ts
+const PLUGIN_NAME = name.replace(/^eslint-plugin-/, "");
+/**
+* Generates a rules record where all plugin rules are set to "error".
+*
+* @param pluginName - The plugin identifier used to prefix rule names.
+* @param rules - The rules record to transform.
+* @returns A Linter.RulesRecord with all rules enabled.
+*/
+function getRules(pluginName, rules) {
+	return Object.fromEntries(Object.keys(rules).map((ruleName) => [`${pluginName}/${ruleName}`, "error"]));
+}
+const plugin = {
+	meta: {
+		name: PLUGIN_NAME,
+		version
+	},
+	rules: { "naming-convention": namingConvention }
+};
+const allRules = 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 };