eslint-plugin-flawless 0.1.10 → 0.1.12

package/dist/index.mjs

@@ -1,3070 +1,4 @@
-import { RuleCreator, getParserServices } from "@typescript-eslint/utils/eslint-utils";
-import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
-import { DefinitionType, ImplicitLibVariable, PatternVisitor, ScopeType, Visitor } from "@typescript-eslint/scope-manager";
-import { requiresQuoting } from "@typescript-eslint/type-utils";
-import assert from "node:assert";
-import * as core from "@eslint-react/core";
-import { findVariable } from "@typescript-eslint/utils/ast-utils";
-import { getStaticTOMLValue } from "toml-eslint-parser";
-//#region package.json
-var name = "eslint-plugin-flawless";
-var version = "0.1.10";
-var repository = {
-	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
-	"type": "git"
-};
-//#endregion
-//#region src/util.ts
-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/rules/jsx-shorthand-boolean/rule.ts
-const RULE_NAME$9 = "jsx-shorthand-boolean";
-const MESSAGE_ID$4 = "setAttributeValue";
-const messages$9 = { [MESSAGE_ID$4]: "Set an explicit value for boolean attribute '{{name}}'." };
-function create$9(context) {
-	const { sourceCode } = context;
-	return { JSXAttribute(node) {
-		if (node.value !== null) return;
-		context.report({
-			data: { name: sourceCode.getText(node.name) },
-			fix: (fixer) => fixer.insertTextAfter(node.name, "={true}"),
-			messageId: MESSAGE_ID$4,
-			node
-		});
-	} };
-}
-const jsxShorthandBoolean = createEslintRule({
-	name: RULE_NAME$9,
-	create: create$9,
-	defaultOptions: [],
-	meta: {
-		docs: {
-			description: "Disallow shorthand boolean JSX attributes",
-			recommended: false,
-			requiresTypeChecking: false
-		},
-		fixable: "code",
-		hasSuggestions: false,
-		messages: messages$9,
-		schema: [],
-		type: "suggestion"
-	}
-});
-//#endregion
-//#region src/rules/jsx-shorthand-fragment/rule.ts
-const RULE_NAME$8 = "jsx-shorthand-fragment";
-const MESSAGE_ID_NAMED = "useNamedFragment";
-const MESSAGE_ID_SHORTHAND = "useShorthandFragment";
-const DEFAULT_MODE = "syntax";
-const DEFAULT_FRAGMENT_NAME = "Fragment";
-const messages$8 = {
-	[MESSAGE_ID_NAMED]: "Use the '{{name}}' component instead of fragment shorthand syntax.",
-	[MESSAGE_ID_SHORTHAND]: "Use the fragment shorthand syntax '<>...</>' instead of the '{{name}}' component."
-};
-const schema$2 = [{
-	additionalProperties: false,
-	properties: {
-		fragmentName: {
-			description: "The identifier to use for the named fragment element in \"element\" mode.",
-			type: "string"
-		},
-		mode: {
-			description: "Which form to enforce: \"syntax\" (shorthand `<>...</>`, default) or \"element\" (a named fragment).",
-			enum: ["element", "syntax"],
-			type: "string"
-		}
-	},
-	type: "object"
-}];
-/**
-* Flattens a JSX element name into a dotted string, e.g. `Fragment` or
-* `React.Fragment`. Returns `null` for namespaced names (`<a:b>`) which cannot
-* be a fragment.
-*
-* @param node - The JSX element name node.
-* @returns The dotted name, or `null` when it is not a plain identifier chain.
-*/
-function jsxNameToString(node) {
-	if (node.type === AST_NODE_TYPES.JSXIdentifier) return node.name;
-	if (node.type === AST_NODE_TYPES.JSXMemberExpression) {
-		const object = jsxNameToString(node.object);
-		if (object === null) return null;
-		return `${object}.${node.property.name}`;
-	}
-	return null;
-}
-function create$8(context) {
-	const options = context.options[0] ?? {};
-	const mode = options.mode ?? DEFAULT_MODE;
-	const fragmentName = options.fragmentName ?? DEFAULT_FRAGMENT_NAME;
-	if (mode === "element") return { JSXFragment(node) {
-		const { closingFragment, openingFragment } = node;
-		context.report({
-			data: { name: fragmentName },
-			fix: (fixer) => {
-				return [fixer.replaceText(openingFragment, `<${fragmentName}>`), fixer.replaceText(closingFragment, `</${fragmentName}>`)];
-			},
-			messageId: MESSAGE_ID_NAMED,
-			node
-		});
-	} };
-	const namedFragments = /* @__PURE__ */ new Set([
-		"Fragment",
-		fragmentName,
-		"React.Fragment"
-	]);
-	return { JSXElement(node) {
-		const { openingElement } = node;
-		const name = jsxNameToString(openingElement.name);
-		if (name === null || !namedFragments.has(name)) return;
-		if (openingElement.attributes.length > 0) return;
-		context.report({
-			data: { name },
-			fix: (fixer) => {
-				const { closingElement } = node;
-				if (closingElement === null) return fixer.replaceText(node, "<></>");
-				return [fixer.replaceText(openingElement, "<>"), fixer.replaceText(closingElement, "</>")];
-			},
-			messageId: MESSAGE_ID_SHORTHAND,
-			node
-		});
-	} };
-}
-const jsxShorthandFragment = createEslintRule({
-	name: RULE_NAME$8,
-	create: create$8,
-	defaultOptions: [{
-		fragmentName: DEFAULT_FRAGMENT_NAME,
-		mode: DEFAULT_MODE
-	}],
-	meta: {
-		defaultOptions: [{
-			fragmentName: DEFAULT_FRAGMENT_NAME,
-			mode: DEFAULT_MODE
-		}],
-		docs: {
-			description: "Enforce a consistent fragment form: the shorthand `<>...</>` or a named fragment",
-			recommended: false,
-			requiresTypeChecking: false
-		},
-		fixable: "code",
-		hasSuggestions: false,
-		messages: messages$8,
-		schema: schema$2,
-		type: "suggestion"
-	}
-});
-//#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;
-		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(),
-		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 = scope.childScopes[0];
-					assert(returnValue, "Function expression name scope should have a child scope");
-					return returnValue;
-				}
-				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;
-		let node;
-		if (typeof variableOrIdentifierOrName === "string") {
-			name = variableOrIdentifierOrName;
-			assert(parent, "Parent node is required when marking by name");
-			node = parent;
-		} else {
-			({name} = variableOrIdentifierOrName);
-			node = variableOrIdentifierOrName;
-		}
-		let currentScope = this.getScope(node);
-		while (currentScope) {
-			const variable = currentScope.variables.find((scopeVariable) => scopeVariable.name === name);
-			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) => {
-			this.markVariableAsUsed(name);
-		});
-	}
-	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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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) {
-		/**
-		* 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, 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, 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.callee !== node;
-						case AST_NODE_TYPES.SequenceExpression:
-							if (parent.expressions[parent.expressions.length - 1] !== node) return false;
-							break;
-						default: if (parent.type.endsWith("Statement") || parent.type.endsWith("Declaration")) return true;
-					}
-					node = parent;
-					({parent} = parent);
-				}
-				return false;
-			}
-			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 && isInside(id, rhsNode) && !isInsideOfStorableFunction(id, rhsNode));
-	}
-	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 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;
-		} else isUpper = !isUpper;
-	}
-	return true;
-}
-function isCamelCase(name) {
-	return name.length === 0 || name[0] === name[0]?.toLowerCase() && !name.includes("_");
-}
-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) {
-	if (name.startsWith("_")) return false;
-	let wasUnderscore = false;
-	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,
-	[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 = 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) {
-			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 = originalName;
-			name = validateUnderscore({
-				name,
-				config,
-				node,
-				originalName,
-				position: "leading"
-			});
-			if (name === void 0) return;
-			name = validateUnderscore({
-				name,
-				config,
-				node,
-				originalName,
-				position: "trailing"
-			});
-			if (name === void 0) return;
-			name = validateAffix({
-				name,
-				config,
-				node,
-				originalName,
-				position: "prefix"
-			});
-			if (name === void 0) return;
-			name = validateAffix({
-				name,
-				config,
-				node,
-				originalName,
-				position: "suffix"
-			});
-			if (name === void 0) return;
-			if (!validateCustom({
-				name,
-				config,
-				node,
-				originalName
-			})) return;
-			if (!validatePredefinedFormat({
-				name,
-				config,
-				modifiers,
-				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 {
-			name: originalName,
-			affixes: affixes?.join(", "),
-			count,
-			formats: formats?.map((formatItem) => PredefinedFormatValueToKey[formatItem]).join(", "),
-			position,
-			processedName,
-			regex: custom?.regex.toString(),
-			regexMatch,
-			type: selectorTypeToMessageString(type)
-		};
-	}
-	function validateUnderscore({ name, config, node, originalName, position }) {
-		const option = position === "leading" ? config.leadingUnderscore : config.trailingUnderscore;
-		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;
-			case UnderscoreOption.allowDouble:
-				if (hasDoubleUnderscore()) return trimDoubleUnderscore();
-				return name;
-			case UnderscoreOption.allowSingleOrDouble:
-				if (hasDoubleUnderscore()) return trimDoubleUnderscore();
-				if (hasSingleUnderscore()) return trimSingleUnderscore();
-				return name;
-			case UnderscoreOption.forbid:
-				if (hasSingleUnderscore()) {
-					context.report({
-						data: formatReportData({
-							count: "one",
-							originalName,
-							position
-						}),
-						messageId: "unexpectedUnderscore",
-						node
-					});
-					return;
-				}
-				return name;
-			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({ name, config, node, originalName, position }) {
-		const affixes = config[position];
-		if (!affixes || affixes.length === 0) return name;
-		for (const affix of affixes) {
-			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({
-			data: formatReportData({
-				affixes,
-				originalName,
-				position
-			}),
-			messageId: "missingAffix",
-			node
-		});
-	}
-	function validateCustom({ name, config, node, originalName }) {
-		const { custom } = config;
-		if (!custom) return true;
-		const result = custom.regex.test(name);
-		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({ 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)) return true;
-		}
-		context.report({
-			data: formatReportData({
-				formats,
-				originalName,
-				processedName: name
-			}),
-			messageId: originalName === name ? "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:
-			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) {
-	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$7 = "naming-convention";
-const messages$7 = {
-	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$7(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, { key }, modifiers) {
-		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, initialScope) {
-		let variable = null;
-		let scope = initialScope;
-		while (scope) {
-			variable = scope.set.get(name) ?? 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) => {
-				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) => {
-				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) => {
-				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
-			},
-			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) => {
-				handleMember(validator, node, getMemberModifiers(node));
-			},
-			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 = /* @__PURE__ */ 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) => {
-				handleMember(validator, node, getMemberModifiers(node));
-			},
-			validator: validators.autoAccessor
-		},
-		"ClassDeclaration, ClassExpression": {
-			handler: (node, validator) => {
-				const { id, abstract } = 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) => {
-				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
-			},
-			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: ({ id }, validator) => {
-				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 = /* @__PURE__ */ 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({
-	name: RULE_NAME$7,
-	create: create$7,
-	defaultOptions: camelCaseNamingConfig,
-	meta: {
-		docs: {
-			description: "Enforce naming conventions for everything across a codebase",
-			recommended: true,
-			requiresTypeChecking: true
-		},
-		fixable: void 0,
-		hasSuggestions: false,
-		messages: messages$7,
-		schema: SCHEMA,
-		type: "suggestion"
-	}
-});
-function getIdentifiersFromPattern(pattern) {
-	const identifiers = [];
-	new PatternVisitor({}, pattern, (id) => {
-		identifiers.push(id);
-	}).visit(pattern);
-	return identifiers;
-}
-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);
-	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) {
-	return requiresQuoting(node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`, target);
-}
-//#endregion
-//#region src/utils/nested-expressions.ts
-/**
-* Determines whether the given AST subtree contains a call or `new`
-* expression.
-*
-* Replaces `@eslint-react/ast`'s `getNestedCallExpressions` /
-* `getNestedNewExpressions` (not exposed by `@eslint-react/kit`). The `useMemo`
-* rule uses this to avoid flagging a factory that performs real computation.
-* The walk descends into every child node (skipping the `parent` back-link to
-* avoid cycles), so calls nested in awaits, tagged templates, computed member
-* expressions, call targets and the like are all detected.
-*
-* @param root - The subtree root to inspect (typically a function body).
-* @returns `true` if a `CallExpression` or `NewExpression` is present.
-*/
-function hasNestedCallOrNew(root) {
-	const stack = [root];
-	while (stack.length > 0) {
-		const current = stack.pop();
-		if (current === void 0) break;
-		if (current.type === AST_NODE_TYPES.CallExpression || current.type === AST_NODE_TYPES.NewExpression) return true;
-		pushChildNodes(current, stack);
-	}
-	return false;
-}
-/**
-* Type guard for an AST node value encountered while walking arbitrary
-* properties of a parent node.
-*
-* @param value - The candidate value.
-* @returns `true` if the value looks like a `TSESTree.Node`.
-*/
-function isNode(value) {
-	return typeof value === "object" && value !== null && typeof value.type === "string";
-}
-/**
-* Pushes every child node of `node` onto the traversal stack, skipping the
-* `parent` back-link.
-*
-* @param node - The node whose children to enqueue.
-* @param stack - The traversal stack to push onto.
-*/
-function pushChildNodes(node, stack) {
-	for (const key of Object.keys(node)) {
-		if (key === "parent") continue;
-		const value = node[key];
-		if (Array.isArray(value)) {
-			for (const item of value) if (isNode(item)) stack.push(item);
-		} else if (isNode(value)) stack.push(value);
-	}
-}
-//#endregion
-//#region src/utils/resolve.ts
-/**
-* Resolves an identifier to the AST node that represents its value.
-*
-* This is a focused re-implementation of `@eslint-react/var`'s `resolve`
-* covering only the cases the unnecessary-hook rules need: variable
-* initializers and function/class declarations. Every other definition kind
-* (imports, parameters, catch bindings, ...) resolves to `null`.
-*
-* @param sourceCode - Provides the scope used to look up the binding.
-* @param node - The identifier to resolve.
-* @returns The resolved value node, or `null` when it cannot be determined.
-*/
-function resolve(sourceCode, node) {
-	const variable = findVariable(sourceCode.getScope(node), node);
-	if (variable === null) return null;
-	const definition = variable.defs.at(0);
-	if (definition === void 0) return null;
-	if (definition.type === DefinitionType.ClassName || definition.type === DefinitionType.FunctionName) return definition.node;
-	if (definition.type === DefinitionType.Variable) return definition.node.init;
-	return null;
-}
-//#endregion
-//#region src/utils/unnecessary-hook.ts
-/**
-* Builds the `create` for the `no-unnecessary-use-memo` /
-* `no-unnecessary-use-callback` rules.
-*
-* Faithfully ports the rules removed from `eslint-plugin-react-x` (they were
-* dropped because the React Compiler makes them redundant; the Roblox /
-* `@rbxts/react` ecosystem has no Compiler). Hook detection is delegated to
-* `@eslint-react/core` so it matches the upstream semantics (fully-qualified
-* name resolution across imports, namespaces and `require`).
-*
-* @param config - The hook-specific configuration.
-* @returns A rule `create` function.
-* @template MessageIds - The rule's message identifiers.
-*/
-function createUnnecessaryHookRule({ hook, messageIds }) {
-	const skipComputation = hook === "useMemo";
-	return (context) => {
-		const { sourceCode } = context;
-		const reactContext = context;
-		const detectHookCall = hook === "useMemo" ? core.isUseMemoCall : core.isUseCallbackCall;
-		return { VariableDeclarator(node) {
-			const { id, init } = node;
-			if (id.type !== AST_NODE_TYPES.Identifier || init?.type !== AST_NODE_TYPES.CallExpression || !detectHookCall(reactContext, init)) return;
-			const [variable, ...rest] = sourceCode.getDeclaredVariables(node);
-			if (variable === void 0 || rest.length > 0) return;
-			const insideEffectReport = checkForUsageInsideUseEffect(sourceCode, init, messageIds.insideUseEffect);
-			const component = sourceCode.getScope(init).block;
-			if (!ASTUtils.isFunction(component)) return;
-			const [argument0, argument1] = init.arguments;
-			if (argument0 === void 0 || argument1 === void 0) return;
-			if (skipComputation && ASTUtils.isFunction(argument0) && hasNestedCallOrNew(argument0.body)) {
-				reportIf(context, insideEffectReport);
-				return;
-			}
-			if (!hasEmptyDeps(sourceCode, argument1)) {
-				reportIf(context, insideEffectReport);
-				return;
-			}
-			const factory = resolveFactory(sourceCode, argument0);
-			if (factory === null) return;
-			if (!referencesComponentScope(sourceCode, factory, component)) {
-				context.report({
-					messageId: messageIds.default,
-					node
-				});
-				return;
-			}
-			reportIf(context, insideEffectReport);
-		} };
-	};
-}
-/**
-* Finds the nearest ancestor that is a `useEffect`-like call.
-*
-* @param node - The node to search upward from.
-* @returns The enclosing effect call, or `null` when there is none.
-*/
-function findEnclosingEffect(node) {
-	let current = node.parent;
-	while (current !== void 0) {
-		if (core.isUseEffectLikeCall(current)) return current;
-		if (current.type === AST_NODE_TYPES.Program) return null;
-		current = current.parent;
-	}
-	return null;
-}
-/**
-* Reports the "used inside a single useEffect" case when applicable.
-*
-* @param sourceCode - Provides declared-variable and text lookups.
-* @param node - The hook call expression.
-* @param messageId - The message id to report.
-* @returns A report descriptor, or `null` when the case does not apply.
-* @template MessageIds - The rule's message identifiers.
-*/
-function checkForUsageInsideUseEffect(sourceCode, node, messageId) {
-	if (!/use\w*Effect/u.test(sourceCode.text)) return null;
-	const { parent } = node;
-	if (parent.type !== AST_NODE_TYPES.VariableDeclarator || parent.id.type !== AST_NODE_TYPES.Identifier) return null;
-	const usages = (sourceCode.getDeclaredVariables(parent).at(0)?.references ?? []).filter((reference) => reference.init !== true);
-	if (usages.length === 0) return null;
-	const effects = /* @__PURE__ */ new Set();
-	for (const usage of usages) {
-		const effect = findEnclosingEffect(usage.identifier);
-		if (effect === null) return null;
-		effects.add(effect);
-		if (effects.size > 1) return null;
-	}
-	return {
-		data: { name: parent.id.name },
-		messageId,
-		node
-	};
-}
-/**
-* Determines whether a dependency argument is an empty array (directly or via a
-* resolvable identifier).
-*
-* @param sourceCode - Provides scope lookup to resolve identifiers.
-* @param node - The dependency argument node.
-* @returns `true` if the dependencies are empty.
-*/
-function hasEmptyDeps(sourceCode, node) {
-	if (node.type === AST_NODE_TYPES.ArrayExpression) return node.elements.length === 0;
-	if (node.type === AST_NODE_TYPES.Identifier) {
-		const resolved = resolve(sourceCode, node);
-		return resolved?.type === AST_NODE_TYPES.ArrayExpression && resolved.elements.length === 0;
-	}
-	return false;
-}
-/**
-* Collects a scope together with all of its descendant scopes.
-*
-* @param scope - The root scope.
-* @returns The scope and every nested child scope.
-*/
-function flattenScopes(scope) {
-	return scope.childScopes.reduce((accumulator, child) => [...accumulator, ...flattenScopes(child)], [scope]);
-}
-/**
-* Determines whether any reference inside the factory resolves to a binding
-* declared in the component's scope.
-*
-* @param sourceCode - Provides scope lookup for the factory.
-* @param factory - The memoized factory function node.
-* @param component - The enclosing component function node.
-* @returns `true` if the factory reads from the component scope.
-*/
-function referencesComponentScope(sourceCode, factory, component) {
-	return flattenScopes(sourceCode.getScope(factory)).flatMap((scope) => scope.references).some((reference) => reference.resolved?.scope.block === component);
-}
-/**
-* Reports the descriptor when it is present.
-*
-* @param context - The rule context.
-* @param descriptor - The descriptor to report, or `null` to skip.
-* @template MessageIds - The rule's message identifiers.
-*/
-function reportIf(context, descriptor) {
-	if (descriptor !== null) context.report(descriptor);
-}
-/**
-* Resolves the first argument of the hook call to the underlying factory
-* function node, unwrapping a curried arrow (`() => () => ...`) and resolving
-* identifiers to their initializer.
-*
-* @param sourceCode - Provides scope lookup to resolve identifiers.
-* @param node - The first hook argument.
-* @returns The factory function node, or `null` when it is not a function.
-*/
-function resolveFactory(sourceCode, node) {
-	if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) return node.body.type === AST_NODE_TYPES.ArrowFunctionExpression ? node.body : node;
-	if (node.type === AST_NODE_TYPES.FunctionExpression) return node;
-	if (node.type === AST_NODE_TYPES.Identifier) {
-		const resolved = resolve(sourceCode, node);
-		if (resolved?.type === AST_NODE_TYPES.ArrowFunctionExpression || resolved?.type === AST_NODE_TYPES.FunctionExpression) return resolved;
-	}
-	return null;
-}
-//#endregion
-//#region src/rules/no-unnecessary-use-callback/rule.ts
-const RULE_NAME$6 = "no-unnecessary-use-callback";
-const MESSAGE_ID_DEFAULT$1 = "default";
-const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
-const messages$6 = {
-	[MESSAGE_ID_DEFAULT$1]: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary.",
-	[MESSAGE_ID_INSIDE_USE_EFFECT$1]: "'{{name}}' is only used inside 1 useEffect, which may be unnecessary. You can move the computation into useEffect directly and merge the dependency arrays."
-};
-const noUnnecessaryUseCallback = createEslintRule({
-	name: RULE_NAME$6,
-	create: createUnnecessaryHookRule({
-		hook: "useCallback",
-		messageIds: {
-			default: MESSAGE_ID_DEFAULT$1,
-			insideUseEffect: MESSAGE_ID_INSIDE_USE_EFFECT$1
-		}
-	}),
-	defaultOptions: [],
-	meta: {
-		docs: {
-			description: "Disallow unnecessary usage of 'useCallback'",
-			recommended: false,
-			requiresTypeChecking: false
-		},
-		hasSuggestions: false,
-		messages: messages$6,
-		schema: [],
-		type: "suggestion"
-	}
-});
-//#endregion
-//#region src/rules/no-unnecessary-use-memo/rule.ts
-const RULE_NAME$5 = "no-unnecessary-use-memo";
-const MESSAGE_ID_DEFAULT = "default";
-const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
-const messages$5 = {
-	[MESSAGE_ID_DEFAULT]: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary.",
-	[MESSAGE_ID_INSIDE_USE_EFFECT]: "'{{name}}' is only used inside 1 useEffect, which may be unnecessary. You can move the computation into useEffect directly and merge the dependency arrays."
-};
-const noUnnecessaryUseMemo = createEslintRule({
-	name: RULE_NAME$5,
-	create: createUnnecessaryHookRule({
-		hook: "useMemo",
-		messageIds: {
-			default: MESSAGE_ID_DEFAULT,
-			insideUseEffect: MESSAGE_ID_INSIDE_USE_EFFECT
-		}
-	}),
-	defaultOptions: [],
-	meta: {
-		docs: {
-			description: "Disallow unnecessary usage of 'useMemo'",
-			recommended: false,
-			requiresTypeChecking: false
-		},
-		hasSuggestions: false,
-		messages: messages$5,
-		schema: [],
-		type: "suggestion"
-	}
-});
-//#endregion
-//#region src/rules/prefer-destructuring-assignment/rule.ts
-const RULE_NAME$4 = "prefer-destructuring-assignment";
-const MESSAGE_ID$3 = "default";
-const messages$4 = { [MESSAGE_ID$3]: "Use destructuring assignment for component props." };
-/**
-* Identifiers that cannot be used as a binding name in strict-mode module code.
-* A property may be accessed with such a name (`props.default`), but a shorthand
-* destructuring pattern built from it (`{ default }`) would be a syntax error,
-* so the autofix bails when one is encountered.
-*/
-const RESERVED_WORDS = /* @__PURE__ */ new Set([
-	"arguments",
-	"await",
-	"break",
-	"case",
-	"catch",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"finally",
-	"for",
-	"function",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"interface",
-	"let",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"static",
-	"super",
-	"switch",
-	"this",
-	"throw",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"while",
-	"with",
-	"yield"
-]);
-/**
-* Collects the unique accessed property names, in first-seen order, when every
-* member reference is a simple non-computed `props.<identifier>` access.
-*
-* @param memberReferences - The member accesses to inspect.
-* @returns The property names, or `null` when any access is not destructurable
-*   (computed access such as `props[key]`, `props` used as a computed key, or a
-*   property whose name is a reserved word that cannot be a binding).
-*/
-function collectPropertyNames(memberReferences) {
-	const names = [];
-	for (const { member, reference } of memberReferences) {
-		if (member.object !== reference.identifier || member.computed || member.property.type !== AST_NODE_TYPES.Identifier || RESERVED_WORDS.has(member.property.name)) return null;
-		if (!names.includes(member.property.name)) names.push(member.property.name);
-	}
-	return names;
-}
-/**
-* Determines whether rewriting `props.foo` to `foo` would resolve to a different
-* binding than the new destructured parameter at any access site.
-*
-* A name is unsafe when it is already bound in the component scope (other than by
-* the props parameter itself) or in any scope nested between an access and the
-* component, since the rewritten `foo` reference would then resolve to that
-* binding instead of the destructured prop.
-*
-* @param sourceCode - Provides scope lookup for each reference.
-* @param componentScope - The component function's scope.
-* @param propsVariable - The props parameter variable (excluded from the check).
-* @param memberReferences - The member accesses that would be rewritten.
-* @returns `true` if any rewritten name would collide with an existing binding.
-*/
-function wouldShadowExistingBinding(sourceCode, componentScope, propsVariable, memberReferences) {
-	for (const { member, reference } of memberReferences) {
-		const { name } = member.property;
-		let scope = sourceCode.getScope(reference.identifier);
-		while (scope !== null) {
-			if (scope.variables.some((variable) => variable.name === name && variable !== propsVariable)) return true;
-			if (scope === componentScope) break;
-			scope = scope.upper;
-		}
-	}
-	return false;
-}
-/**
-* Reports every `props.<member>` access on a component's props parameter,
-* attaching an autofix when the parameter can be safely destructured.
-*
-* @param context - The rule context.
-* @param scope - The component function's scope.
-* @param propsParameter - The props parameter identifier.
-* @param propertyVariable - The resolved variable for the props parameter.
-*/
-function reportComponent(context, scope, propsParameter, propertyVariable) {
-	const memberReferences = [];
-	let hasNonMemberReference = false;
-	for (const reference of propertyVariable.references) {
-		const { parent } = reference.identifier;
-		if (parent.type === AST_NODE_TYPES.MemberExpression) memberReferences.push({
-			member: parent,
-			reference
-		});
-		else hasNonMemberReference = true;
-	}
-	if (memberReferences.length === 0) return;
-	memberReferences.sort((left, right) => left.member.range[0] - right.member.range[0]);
-	const propertyNames = collectPropertyNames(memberReferences);
-	if (!(!hasNonMemberReference && propertyNames !== null && !wouldShadowExistingBinding(context.sourceCode, scope, propertyVariable, memberReferences))) {
-		for (const { member } of memberReferences) context.report({
-			messageId: MESSAGE_ID$3,
-			node: member
-		});
-		return;
-	}
-	const needsParentheses = propsParameter.parent.type === AST_NODE_TYPES.ArrowFunctionExpression && context.sourceCode.getTokenAfter(propsParameter)?.value === "=>";
-	const destructured = `{ ${propertyNames.join(", ")} }`;
-	const pattern = needsParentheses ? `(${destructured})` : destructured;
-	const nameEnd = propsParameter.typeAnnotation?.range[0] ?? propsParameter.range[1];
-	for (const [index, { member }] of memberReferences.entries()) {
-		const propertyName = member.property.name;
-		context.report({
-			fix(fixer) {
-				const replaceAccess = fixer.replaceText(member, propertyName);
-				if (index === 0) return [fixer.replaceTextRange([propsParameter.range[0], nameEnd], pattern), replaceAccess];
-				return replaceAccess;
-			},
-			messageId: MESSAGE_ID$3,
-			node: member
-		});
-	}
-}
-/**
-* Faithfully ports `react-x/prefer-destructuring-assignment`, removed from
-* `eslint-plugin-react-x` in v5.0.0 (deprecated due to low usage). Component
-* detection is delegated to `@eslint-react/core` so it matches the upstream
-* semantics.
-*
-* Unlike upstream, this port adds an autofix that rewrites the props parameter
-* into a destructuring pattern (`(props) => props.id` becomes `({ id }) => id`).
-* The fix is only offered when it is unambiguously safe; see
-* {@link collectPropertyNames} and {@link wouldShadowExistingBinding}.
-*
-* @param context - The rule context.
-* @returns The rule listener.
-*/
-function create$4(context) {
-	const { api, visitor } = core.getFunctionComponentCollector(context);
-	return {
-		...visitor,
-		"Program:exit": function(program) {
-			for (const component of api.getAllComponents(program)) {
-				if (component.name === null || component.isExportDefaultDeclaration) continue;
-				const [propsParameter] = component.node.params;
-				if (propsParameter?.type !== AST_NODE_TYPES.Identifier) continue;
-				const scope = context.sourceCode.getScope(component.node);
-				const propertyVariable = scope.variables.find((variable) => variable.name === propsParameter.name);
-				if (propertyVariable === void 0) continue;
-				reportComponent(context, scope, propsParameter, propertyVariable);
-			}
-		}
-	};
-}
-const preferDestructuringAssignment = createEslintRule({
-	name: RULE_NAME$4,
-	create: create$4,
-	defaultOptions: [],
-	meta: {
-		docs: {
-			description: "Enforce destructuring assignment for component props",
-			recommended: false,
-			requiresTypeChecking: false
-		},
-		fixable: "code",
-		hasSuggestions: false,
-		messages: messages$4,
-		schema: [],
-		type: "problem"
-	}
-});
-//#endregion
-//#region src/rules/prefer-parameter-destructuring/rule.ts
-const RULE_NAME$3 = "prefer-parameter-destructuring";
-const MESSAGE_ID$2 = "default";
-const messages$3 = { [MESSAGE_ID$2]: "Destructure parameter '{{name}}' in the function signature instead of the body." };
-/**
-* Collects the binding names introduced by a pattern (or parameter), including
-* names nested in object/array patterns, defaults, and rest elements.
-*
-* @param node - The pattern node to walk.
-* @param out - Receives every bound name, in source order.
-*/
-function collectBoundNames(node, out) {
-	switch (node.type) {
-		case AST_NODE_TYPES.ArrayPattern:
-			for (const element of node.elements) if (element !== null) collectBoundNames(element, out);
-			break;
-		case AST_NODE_TYPES.AssignmentPattern:
-			collectBoundNames(node.left, out);
-			break;
-		case AST_NODE_TYPES.Identifier:
-			out.push(node.name);
-			break;
-		case AST_NODE_TYPES.ObjectPattern:
-			for (const property of node.properties) collectBoundNames(property, out);
-			break;
-		case AST_NODE_TYPES.Property:
-			collectBoundNames(node.value, out);
-			break;
-		case AST_NODE_TYPES.RestElement:
-			collectBoundNames(node.argument, out);
-			break;
-		case AST_NODE_TYPES.TSParameterProperty:
-			collectBoundNames(node.parameter, out);
-			break;
-		default: break;
-	}
-}
-/**
-* Collects every top-level-body object destructuring of the parameter, or
-* bails when the parameter has any other reference (member access, call
-* argument, reassignment, a destructure inside a nested block or closure, …) —
-* those mean the parameter is genuinely used and must stay.
-*
-* @param variable - The parameter's resolved scope variable.
-* @param identifier - The parameter identifier (its default-value write
-*   reference is not a use).
-* @param body - The function body; only its direct child declarations qualify.
-* @returns The qualifying destructuring statements in source order, or `null`
-*   when the parameter has a non-destructuring reference.
-*/
-function collectDestructureStatements(variable, identifier, body) {
-	const statements = [];
-	for (const reference of variable.references) {
-		const referenceIdentifier = reference.identifier;
-		if (referenceIdentifier === identifier) continue;
-		const { parent } = referenceIdentifier;
-		if (parent.type === AST_NODE_TYPES.VariableDeclarator && parent.init === referenceIdentifier && parent.id.type === AST_NODE_TYPES.ObjectPattern && parent.parent.parent === body) statements.push({
-			declaration: parent.parent,
-			declarator: parent,
-			pattern: parent.id
-		});
-		else return null;
-	}
-	statements.sort((left, right) => left.declarator.range[0] - right.declarator.range[0]);
-	return statements;
-}
-/**
-* Collects the binding names of every parameter other than the target one, so
-* the fix can avoid creating a duplicate parameter name (a SyntaxError in a
-* non-simple parameter list).
-*
-* @param node - The function whose parameters are inspected.
-* @param parameter - The parameter being rewritten (excluded).
-* @returns The other parameters' bound names.
-*/
-function collectOtherParameterNames(node, parameter) {
-	const names = [];
-	for (const other of node.params) if (other !== parameter) collectBoundNames(other, names);
-	return new Set(names);
-}
-/**
-* A structural check for AST nodes reached through visitor keys.
-*
-* @param value - The child value to test.
-* @returns `true` when the value is an AST node.
-*/
-function isNodeLike(value) {
-	return typeof value === "object" && value !== null && typeof value.type === "string";
-}
-/**
-* Checks whether a pattern subtree contains `await` or `yield` (in a computed
-* key or default value). Parameter initializers may not contain either, so no
-* signature form exists and the destructuring is not reported.
-*
-* @param root - The pattern to walk.
-* @param visitorKeys - The parser's visitor keys, used to walk without
-*   following `parent` links.
-* @returns `true` if `await`/`yield` appears anywhere in the pattern.
-*/
-function containsAwaitOrYield(root, visitorKeys) {
-	const stack = [root];
-	for (let current = stack.pop(); current !== void 0; current = stack.pop()) {
-		if (current.type === AST_NODE_TYPES.AwaitExpression || current.type === AST_NODE_TYPES.YieldExpression) return true;
-		for (const key of visitorKeys[current.type] ?? []) {
-			const child = current[key];
-			const children = Array.isArray(child) ? child : [child];
-			for (const item of children) if (isNodeLike(item)) stack.push(item);
-		}
-	}
-	return false;
-}
-/**
-* Extracts the identifier a parameter binds, unwrapping a default value
-* (`obj = {}`); patterns, rest parameters, and TS parameter properties yield
-* `null`.
-*
-* @param parameter - The parameter node.
-* @returns The parameter's identifier, or `null` when it is not a plain one.
-*/
-function getParameterIdentifier(parameter) {
-	if (parameter.type === AST_NODE_TYPES.Identifier) return parameter;
-	if (parameter.type === AST_NODE_TYPES.AssignmentPattern && parameter.left.type === AST_NODE_TYPES.Identifier) return parameter.left;
-	return null;
-}
-/**
-* Determines whether any expression inside the patterns (computed keys,
-* default values, moved type annotations) references a binding that would be
-* out of scope — or in its temporal dead zone — at the parameter position:
-* anything declared in the function body, a parameter at or after the target,
-* or this function's own `arguments`.
-*
-* @param query - The rewrite being planned.
-* @param patterns - The object patterns being moved.
-* @returns `true` when moving the patterns would break a reference.
-*/
-function hasUnsafePatternReferences({ body, identifier, node, scope }, patterns) {
-	function inPattern(range) {
-		return patterns.some((pattern) => range[0] >= pattern.range[0] && range[1] <= pattern.range[1]);
-	}
-	const stack = [scope];
-	for (let current = stack.pop(); current !== void 0; current = stack.pop()) {
-		stack.push(...current.childScopes);
-		for (const reference of current.references) {
-			if (!inPattern(reference.identifier.range)) continue;
-			const { resolved } = reference;
-			if (resolved === null) continue;
-			if (resolved.defs.length === 0) {
-				const blockRange = resolved.scope.block.range;
-				if (blockRange[0] >= node.range[0] && blockRange[1] <= node.range[1]) return true;
-				continue;
-			}
-			if (resolved.defs.some((definition) => {
-				const { range } = definition.name;
-				if (inPattern(range)) return false;
-				if (range[1] <= node.range[0] || range[0] >= node.range[1]) return false;
-				if (range[0] >= body.range[0]) return true;
-				return range[0] >= identifier.range[0];
-			})) return true;
-		}
-	}
-	return false;
-}
-/**
-* Checks whether a function body opens with a `"use strict"` directive. A
-* destructured parameter makes the parameter list non-simple, and a function
-* with a non-simple parameter list may not contain a `"use strict"` directive,
-* so such functions are skipped entirely.
-*
-* @param body - The function body.
-* @returns `true` if the body has a `"use strict"` directive.
-*/
-function hasUseStrictDirective(body) {
-	for (const statement of body.body) {
-		if (statement.type !== AST_NODE_TYPES.ExpressionStatement || typeof statement.directive !== "string") break;
-		if (statement.directive === "use strict") return true;
-	}
-	return false;
-}
-/**
-* Checks whether evaluating the pattern can execute arbitrary code — a default
-* value or a computed key — as opposed to only performing property reads.
-*
-* @param node - The pattern node to walk.
-* @returns `true` when the pattern contains a default value or computed key.
-*/
-function patternExecutesCode(node) {
-	if (node.type === AST_NODE_TYPES.AssignmentPattern) return true;
-	if (node.type === AST_NODE_TYPES.Property) return node.computed || patternExecutesCode(node.value);
-	if (node.type === AST_NODE_TYPES.ObjectPattern) return node.properties.some((property) => patternExecutesCode(property));
-	if (node.type === AST_NODE_TYPES.ArrayPattern) return node.elements.some((element) => element !== null && patternExecutesCode(element));
-	if (node.type === AST_NODE_TYPES.RestElement) return patternExecutesCode(node.argument);
-	return false;
-}
-/**
-* Computes the removal range for a declaration, swallowing the whole line
-* (indentation and trailing newline) when the declaration is alone on it.
-*
-* @param sourceCode - Provides the raw text around the declaration.
-* @param statement - The declaration to remove.
-* @returns The range to delete.
-*/
-function statementRemovalRange({ text }, statement) {
-	const [start, end] = statement.range;
-	const lineStart = text.lastIndexOf("\n", start - 1) + 1;
-	const newlineIndex = text.indexOf("\n", end);
-	const lineEnd = newlineIndex === -1 ? text.length : newlineIndex + 1;
-	const leadingIsBlank = text.slice(lineStart, start).trim().length === 0;
-	const trailingIsBlank = text.slice(end, newlineIndex === -1 ? text.length : newlineIndex).trim().length === 0;
-	if (leadingIsBlank && trailingIsBlank) return [lineStart, lineEnd];
-	return [start, end];
-}
-/**
-* Builds the autofix, or returns `null` when the rewrite is not unambiguously
-* safe: unrelated sibling declarators, unmergeable or annotated patterns,
-* duplicate or colliding binding names, expressions that reference bindings
-* unavailable at the parameter position, a defused temporal dead zone, or —
-* with `allowSideEffectReordering: false` — side effects that would be
-* reordered.
-*
-* @param query - The rewrite being planned.
-* @returns The fix plan, or `null` when only a report should be emitted.
-*/
-function planFix(query) {
-	const { allowSideEffectReordering, body, identifier, node, otherParameterNames, sourceCode, statements } = query;
-	const declaratorSet = new Set(statements.map((statement) => statement.declarator));
-	const declarations = [...new Set(statements.map((statement) => statement.declaration))];
-	if (!declarations.every((declaration) => {
-		return declaration.declarations.every((declarator) => declaratorSet.has(declarator));
-	})) return null;
-	const patterns = statements.map((statement) => statement.pattern);
-	if (!allowSideEffectReordering && patterns.some((pattern) => patternExecutesCode(pattern))) {
-		const leadingStatements = new Set(body.body.slice(0, declarations.length));
-		if (!declarations.every((declaration) => leadingStatements.has(declaration))) return null;
-	}
-	if (declarations.some((declaration) => {
-		return sourceCode.getDeclaredVariables(declaration).some((declared) => {
-			return declared.references.some((reference) => reference.identifier.range[0] < declaration.range[0]);
-		});
-	})) return null;
-	if (patterns.some((pattern) => pattern.typeAnnotation !== void 0) && (patterns.length > 1 || identifier.typeAnnotation !== void 0)) return null;
-	if (patterns.length > 1) {
-		if (patterns.some((pattern) => {
-			return pattern.properties.some((property) => property.type === AST_NODE_TYPES.RestElement);
-		})) return null;
-	}
-	const boundNames = [];
-	for (const pattern of patterns) collectBoundNames(pattern, boundNames);
-	if (new Set(boundNames).size !== boundNames.length) return null;
-	if (boundNames.some((name) => otherParameterNames.has(name))) return null;
-	if (hasUnsafePatternReferences(query, patterns)) return null;
-	const [firstPattern] = patterns;
-	let parameterText;
-	if (patterns.length === 1 && firstPattern !== void 0) parameterText = sourceCode.getText(firstPattern);
-	else {
-		const innerTexts = patterns.map((pattern) => sourceCode.getText(pattern).slice(1, -1).trim().replace(/,$/u, "").trim()).filter((text) => text.length > 0);
-		parameterText = innerTexts.length === 0 ? "{}" : `{ ${innerTexts.join(", ")} }`;
-	}
-	if (node.type === AST_NODE_TYPES.ArrowFunctionExpression && sourceCode.getTokenAfter(identifier)?.value === "=>") parameterText = `(${parameterText})`;
-	const parameterRange = [identifier.range[0], identifier.typeAnnotation?.range[0] ?? identifier.range[1]];
-	const removalRanges = declarations.map((declaration) => {
-		return statementRemovalRange(sourceCode, declaration);
-	});
-	return {
-		parameterRange,
-		parameterText,
-		removalRanges
-	};
-}
-/**
-* Reports body destructuring statements of parameters that have no other use,
-* preferring the pattern in the function signature. The autofix rewrites the
-* parameter (merging multiple statements into one pattern) and removes the
-* statements; it is withheld when the rewrite is not unambiguously safe, see
-* {@link planFix}.
-*
-* @param context - The rule context.
-* @param optionsWithDefault - The resolved rule options.
-* @returns The rule listener.
-*/
-function create$3(context, optionsWithDefault) {
-	const [{ allowSideEffectReordering = true }] = optionsWithDefault;
-	function checkFunction(node) {
-		const { body, params } = node;
-		if (body.type !== AST_NODE_TYPES.BlockStatement || hasUseStrictDirective(body)) return;
-		const scope = context.sourceCode.getScope(node);
-		for (const parameter of params) {
-			const identifier = getParameterIdentifier(parameter);
-			if (identifier === null || identifier.name === "this") continue;
-			const variable = scope.variables.find((candidate) => {
-				return candidate.defs.some((definition) => definition.name === identifier);
-			});
-			if (variable?.defs.length !== 1) continue;
-			const statements = collectDestructureStatements(variable, identifier, body);
-			if (statements === null || statements.length === 0) continue;
-			if (statements.some(({ pattern }) => {
-				return containsAwaitOrYield(pattern, context.sourceCode.visitorKeys);
-			})) continue;
-			const otherParameterNames = collectOtherParameterNames(node, parameter);
-			if (otherParameterNames.has(identifier.name)) continue;
-			const plan = planFix({
-				allowSideEffectReordering,
-				body,
-				identifier,
-				node,
-				otherParameterNames,
-				scope,
-				sourceCode: context.sourceCode,
-				statements
-			});
-			for (const [index, statement] of statements.entries()) context.report({
-				data: { name: identifier.name },
-				fix(fixer) {
-					if (index !== 0 || plan === null) return null;
-					return [fixer.replaceTextRange(plan.parameterRange, plan.parameterText), ...plan.removalRanges.map((range) => fixer.removeRange(range))];
-				},
-				messageId: MESSAGE_ID$2,
-				node: statement.declarator
-			});
-		}
-	}
-	return {
-		ArrowFunctionExpression: checkFunction,
-		FunctionDeclaration: checkFunction,
-		FunctionExpression: checkFunction
-	};
-}
-const preferParameterDestructuring = createEslintRule({
-	name: RULE_NAME$3,
-	create: create$3,
-	defaultOptions: [{ allowSideEffectReordering: true }],
-	meta: {
-		defaultOptions: [{ allowSideEffectReordering: true }],
-		docs: {
-			description: "Enforce destructuring parameters in the function signature",
-			recommended: false,
-			requiresTypeChecking: false
-		},
-		fixable: "code",
-		hasSuggestions: false,
-		messages: messages$3,
-		schema: [{
-			additionalProperties: false,
-			properties: { allowSideEffectReordering: {
-				description: "Whether the autofix may hoist pattern defaults and computed keys past earlier statements, reordering their side effects. Set to false to withhold the fix in those cases.",
-				type: "boolean"
-			} },
-			type: "object"
-		}],
-		type: "suggestion"
-	}
-});
-//#endregion
-//#region src/rules/purity/rule.ts
-const RULE_NAME$2 = "purity";
-const MESSAGE_ID$1 = "impureCall";
-/**
-* Non-deterministic Luau / Roblox calls, written as dotted paths matching how
-* they appear in roblox-ts source. `new Random()` is normalized to
-* `"Random.new"` (see the `NewExpression` visitor).
-*/
-const DEFAULT_SIGNATURES = [
-	"DateTime.now",
-	"HttpService.GenerateGUID",
-	"Random.new",
-	"Workspace.GetServerTimeNow",
-	"elapsedTime",
-	"math.random",
-	"math.randomseed",
-	"os.clock",
-	"os.date",
-	"os.time",
-	"tick",
-	"time"
-];
-/**
-* Bare Luau globals for which a matching local binding means the reference is
-* shadowed rather than the ambient global. Service objects are intentionally
-* excluded because they are impure even when imported from `@rbxts/services`.
-*/
-const GUARDED_GLOBALS = /* @__PURE__ */ new Set([
-	"elapsedTime",
-	"math",
-	"os",
-	"tick",
-	"time"
-]);
-const messages$2 = { [MESSAGE_ID$1]: "Do not call '{{name}}' during render. Components and hooks must be pure. Move this call into an event handler, effect, or state initializer." };
-const schema$1 = [{
-	additionalProperties: false,
-	properties: {
-		additionalFunctions: {
-			description: "Extra dotted call signatures to treat as impure (e.g. \"Math.random\").",
-			items: { type: "string" },
-			type: "array",
-			uniqueItems: true
-		},
-		ignore: {
-			description: "Default signatures to exclude (e.g. \"os.date\").",
-			items: { type: "string" },
-			type: "array",
-			uniqueItems: true
-		}
-	},
-	type: "object"
-}];
-/**
-* Strips wrappers that are irrelevant to the callee identity so that
-* `a.b?.()` and `a.b!()` still match.
-*
-* @param node - The node to unwrap.
-* @returns The unwrapped node.
-*/
-function unwrap(node) {
-	let current = node;
-	while (current.type === AST_NODE_TYPES.ChainExpression || current.type === AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
-	return current;
-}
-/**
-* Builds the dotted path for a callee, e.g. `math.random` or `tick`.
-*
-* @param callee - The callee expression.
-* @returns The match, or `null` when the callee cannot be represented as a
-*   simple dotted path (computed access, or an object that is an expression).
-*/
-function dottedCalleePath(callee) {
-	let current = unwrap(callee);
-	const parts = [];
-	while (current.type === AST_NODE_TYPES.MemberExpression) {
-		if (current.computed || current.property.type !== AST_NODE_TYPES.Identifier) return null;
-		parts.unshift(current.property.name);
-		current = unwrap(current.object);
-	}
-	if (current.type !== AST_NODE_TYPES.Identifier) return null;
-	parts.unshift(current.name);
-	return {
-		path: parts.join("."),
-		root: current
-	};
-}
-/**
-* Determines whether an identifier resolves to a real user binding (import,
-* parameter, or local declaration) rather than the ambient Luau global.
-*
-* @param sourceCode - Provides scope lookup.
-* @param node - The identifier node.
-* @returns `true` when the identifier is a user binding rather than the ambient
-*   global.
-*/
-function isUserBinding(sourceCode, node) {
-	let scope = sourceCode.getScope(node);
-	while (scope !== null) {
-		const variable = scope.variables.find((candidate) => candidate.name === node.name);
-		if (variable !== void 0) return variable.defs.length > 0;
-		scope = scope.upper;
-	}
-	return false;
-}
-/**
-* Finds the immediate enclosing function of a node, stopping at the program.
-*
-* @param node - The node to search upward from.
-* @returns The enclosing function, or `null` when the node is at module level.
-*/
-function enclosingFunction(node) {
-	let current = node.parent;
-	while (current !== void 0) {
-		if (ASTUtils.isFunction(current)) return current;
-		if (current.type === AST_NODE_TYPES.Program) return null;
-		current = current.parent;
-	}
-	return null;
-}
-/**
-* Determines whether a function executes during render: a component body, a
-* custom/builtin hook body, or a `useMemo` callback.
-*
-* @param reactContext - The context `@eslint-react/core` predicates expect.
-* @param func - The enclosing function node.
-* @returns `true` when the function runs during render.
-*/
-function isRenderContext(reactContext, func) {
-	if (core.isFunctionComponentDefinition(reactContext, func, core.DEFAULT_COMPONENT_DETECTION_HINT)) return true;
-	if (core.isHookDefinition(func)) return true;
-	const { parent } = func;
-	return parent.type === AST_NODE_TYPES.CallExpression && parent.arguments[0] === func && core.isUseMemoCall(reactContext, parent);
-}
-function create$2(context) {
-	const { sourceCode } = context;
-	const reactContext = context;
-	const options = context.options[0] ?? {};
-	const signatures = new Set(DEFAULT_SIGNATURES);
-	for (const signature of options.additionalFunctions ?? []) signatures.add(signature);
-	for (const signature of options.ignore ?? []) signatures.delete(signature);
-	function handle(node, match, path) {
-		if (!signatures.has(path)) return;
-		if (path === "Random.new" && node.arguments.length > 0) return;
-		if (GUARDED_GLOBALS.has(match.root.name) && isUserBinding(sourceCode, match.root)) return;
-		const func = enclosingFunction(node);
-		if (func === null || !isRenderContext(reactContext, func)) return;
-		context.report({
-			data: { name: path },
-			messageId: MESSAGE_ID$1,
-			node
-		});
-	}
-	return {
-		CallExpression(node) {
-			const match = dottedCalleePath(node.callee);
-			if (match !== null) handle(node, match, match.path);
-		},
-		NewExpression(node) {
-			const match = dottedCalleePath(node.callee);
-			if (match !== null) handle(node, match, `${match.path}.new`);
-		}
-	};
-}
-const purity = createEslintRule({
-	name: RULE_NAME$2,
-	create: create$2,
-	defaultOptions: [{}],
-	meta: {
-		defaultOptions: [{}],
-		docs: {
-			description: "Disallow impure calls such as `math.random` or `os.clock` during render",
-			recommended: false,
-			requiresTypeChecking: false
-		},
-		hasSuggestions: false,
-		messages: messages$2,
-		schema: schema$1,
-		type: "problem"
-	}
-});
-//#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({ caseSensitive = true, natural = false, type = "asc" }) {
-	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`). The fallback compares keys as written in
-* source, so quotes participate in the order and quoted keys (e.g.
-* `"github:owner/repo"`) group before bare 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.
-* @param rawName - Returns an entry's key exactly as written in source.
-* @returns A comparator over two entries.
-*/
-function makeComparator(order, isTopLevel, rawName) {
-	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(rawName(a), rawName(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, (entry) => sourceCode.getText(entry.key)));
-		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-/, "");
-/**
-* 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: {
-		"jsx-shorthand-boolean": jsxShorthandBoolean,
-		"jsx-shorthand-fragment": jsxShorthandFragment,
-		"naming-convention": namingConvention,
-		"no-unnecessary-use-callback": noUnnecessaryUseCallback,
-		"no-unnecessary-use-memo": noUnnecessaryUseMemo,
-		"prefer-destructuring-assignment": preferDestructuringAssignment,
-		"prefer-parameter-destructuring": preferParameterDestructuring,
-		"purity": purity,
-		"toml-sort-keys": tomlSortKeys,
-		"yaml-block-key-blank-lines": yamlBlockKeyBlankLines
-	}
-};
-getRules(PLUGIN_NAME, plugin.rules);
-//#endregion
+import { n as plugin, t as PLUGIN_NAME } from "./plugin-DYVtpuio.mjs";
 //#region src/configs/index.ts
 const configs = { recommended: {
 	plugins: { [PLUGIN_NAME]: plugin },