FM / rules

/home/techb158/balavpn.abdallabala.com/node_modules/eslint/lib/rules/

/home/techb158/balavpn.abdallabala.com/node_modules/eslint/lib/rules

Name	Size	Mode	Actions
utils/	-	0777	rm
accessor-pairs.js	11210	0666	edit dl rm
array-bracket-newline.js	8123	0666	edit dl rm
array-bracket-spacing.js	8071	0666	edit dl rm
array-callback-return.js	12815	0666	edit dl rm
array-element-newline.js	9070	0666	edit dl rm
arrow-body-style.js	10365	0666	edit dl rm
arrow-parens.js	7119	0666	edit dl rm
arrow-spacing.js	4618	0666	edit dl rm
block-scoped-var.js	3501	0666	edit dl rm
block-spacing.js	5159	0666	edit dl rm
brace-style.js	7592	0666	edit dl rm
callback-return.js	5879	0666	edit dl rm
camelcase.js	10363	0666	edit dl rm
capitalized-comments.js	9285	0666	edit dl rm
class-methods-use-this.js	6393	0666	edit dl rm
comma-dangle.js	11652	0666	edit dl rm
comma-spacing.js	5892	0666	edit dl rm
comma-style.js	10241	0666	edit dl rm
complexity.js	5194	0666	edit dl rm
computed-property-spacing.js	6703	0666	edit dl rm
consistent-return.js	5739	0666	edit dl rm
consistent-this.js	4429	0666	edit dl rm
constructor-super.js	12051	0666	edit dl rm
curly.js	11758	0666	edit dl rm
default-case-last.js	1103	0666	edit dl rm
default-case.js	2311	0666	edit dl rm
default-param-last.js	1690	0666	edit dl rm
dot-location.js	3404	0666	edit dl rm
dot-notation.js	5192	0666	edit dl rm
eol-last.js	3566	0666	edit dl rm
eqeqeq.js	4874	0666	edit dl rm
for-direction.js	4305	0666	edit dl rm
func-call-spacing.js	8290	0666	edit dl rm
func-name-matching.js	8835	0666	edit dl rm
func-names.js	5135	0666	edit dl rm
func-style.js	5337	0666	edit dl rm
function-call-argument-newline.js	4222	0666	edit dl rm
function-paren-newline.js	10198	0666	edit dl rm
generator-star-spacing.js	6319	0666	edit dl rm
getter-return.js	5756	0666	edit dl rm
global-require.js	2853	0666	edit dl rm
grouped-accessor-pairs.js	7185	0666	edit dl rm
guard-for-in.js	1924	0666	edit dl rm
handle-callback-err.js	3247	0666	edit dl rm
id-blacklist.js	6700	0666	edit dl rm
id-denylist.js	6357	0666	edit dl rm
id-length.js	5613	0666	edit dl rm
id-match.js	9208	0666	edit dl rm
implicit-arrow-linebreak.js	3147	0666	edit dl rm
indent-legacy.js	35743	0666	edit dl rm
indent.js	66474	0666	edit dl rm
index.js	17913	0666	edit dl rm
init-declarations.js	3974	0666	edit dl rm
jsx-quotes.js	3147	0666	edit dl rm
key-spacing.js	21268	0666	edit dl rm
keyword-spacing.js	20417	0666	edit dl rm
line-comment-position.js	3736	0666	edit dl rm
linebreak-style.js	3569	0666	edit dl rm
lines-around-comment.js	15497	0666	edit dl rm
lines-around-directive.js	7023	0666	edit dl rm
lines-between-class-members.js	10129	0666	edit dl rm
logical-assignment-operators.js	19047	0666	edit dl rm
max-classes-per-file.js	1858	0666	edit dl rm
max-depth.js	3633	0666	edit dl rm
max-len.js	13652	0666	edit dl rm
max-lines-per-function.js	6050	0666	edit dl rm
max-lines.js	4403	0666	edit dl rm
max-nested-callbacks.js	2691	0666	edit dl rm
max-params.js	3075	0666	edit dl rm
max-statements-per-line.js	6738	0666	edit dl rm
max-statements.js	4575	0666	edit dl rm
multiline-comment-style.js	18395	0666	edit dl rm
multiline-ternary.js	6541	0666	edit dl rm
new-cap.js	7204	0666	edit dl rm
new-parens.js	3167	0666	edit dl rm
newline-after-var.js	8852	0666	edit dl rm
newline-before-return.js	7126	0666	edit dl rm
newline-per-chained-call.js	3883	0666	edit dl rm
no-alert.js	3843	0666	edit dl rm
no-array-constructor.js	4995	0666	edit dl rm
no-async-promise-executor.js	1007	0666	edit dl rm
no-await-in-loop.js	2494	0666	edit dl rm
no-bitwise.js	2948	0666	edit dl rm
no-buffer-constructor.js	1868	0666	edit dl rm
no-caller.js	1086	0666	edit dl rm
no-case-declarations.js	1867	0666	edit dl rm
no-catch-shadow.js	2515	0666	edit dl rm
no-class-assign.js	1566	0666	edit dl rm
no-compare-neg-zero.js	1662	0666	edit dl rm
no-cond-assign.js	4837	0666	edit dl rm
no-confusing-arrow.js	3232	0666	edit dl rm
no-console.js	6233	0666	edit dl rm
no-const-assign.js	1848	0666	edit dl rm
no-constant-binary-expression.js	18150	0666	edit dl rm
no-constant-condition.js	4469	0666	edit dl rm
no-constructor-return.js	1191	0666	edit dl rm
no-continue.js	784	0666	edit dl rm
no-control-regex.js	3830	0666	edit dl rm
no-debugger.js	793	0666	edit dl rm
no-delete-var.js	852	0666	edit dl rm
no-div-regex.js	1245	0666	edit dl rm
no-dupe-args.js	2387	0666	edit dl rm
no-dupe-class-members.js	2905	0666	edit dl rm
no-dupe-else-if.js	4197	0666	edit dl rm
no-dupe-keys.js	3963	0666	edit dl rm
no-duplicate-case.js	1765	0666	edit dl rm
no-duplicate-imports.js	10024	0666	edit dl rm
no-else-return.js	13405	0666	edit dl rm
no-empty-character-class.js	1938	0666	edit dl rm
no-empty-function.js	5754	0666	edit dl rm
no-empty-pattern.js	1841	0666	edit dl rm
no-empty-static-block.js	1589	0666	edit dl rm
no-empty.js	3202	0666	edit dl rm
no-eq-null.js	1117	0666	edit dl rm
no-eval.js	7542	0666	edit dl rm
no-ex-assign.js	1301	0666	edit dl rm
no-extend-native.js	5421	0666	edit dl rm
no-extra-bind.js	6007	0666	edit dl rm
no-extra-boolean-cast.js	10590	0666	edit dl rm
no-extra-label.js	4265	0666	edit dl rm
no-extra-parens.js	43596	0666	edit dl rm
no-extra-semi.js	4628	0666	edit dl rm
no-fallthrough.js	6966	0666	edit dl rm
no-floating-decimal.js	2568	0666	edit dl rm
no-func-assign.js	1861	0666	edit dl rm
no-global-assign.js	2426	0666	edit dl rm
no-implicit-coercion.js	12600	0666	edit dl rm
no-implicit-globals.js	4626	0666	edit dl rm
no-implied-eval.js	4339	0666	edit dl rm
no-import-assign.js	6179	0666	edit dl rm
no-inline-comments.js	2691	0666	edit dl rm
no-inner-declarations.js	3221	0666	edit dl rm
no-invalid-regexp.js	5962	0666	edit dl rm
no-invalid-this.js	4488	0666	edit dl rm
no-irregular-whitespace.js	7853	0666	edit dl rm
no-iterator.js	1110	0666	edit dl rm
no-label-var.js	2063	0666	edit dl rm
no-labels.js	3365	0666	edit dl rm
no-lone-blocks.js	3320	0666	edit dl rm
no-lonely-if.js	3303	0666	edit dl rm
no-loop-func.js	7035	0666	edit dl rm
no-loss-of-precision.js	7393	0666	edit dl rm
no-magic-numbers.js	10580	0666	edit dl rm
no-misleading-character-class.js	16369	0666	edit dl rm
no-mixed-operators.js	7147	0666	edit dl rm
no-mixed-requires.js	6383	0666	edit dl rm
no-mixed-spaces-and-tabs.js	3465	0666	edit dl rm
no-multi-assign.js	1327	0666	edit dl rm
no-multi-spaces.js	4588	0666	edit dl rm
no-multi-str.js	1610	0666	edit dl rm
no-multiple-empty-lines.js	5581	0666	edit dl rm
no-native-reassign.js	2765	0666	edit dl rm
no-negated-condition.js	2431	0666	edit dl rm
no-negated-in-lhs.js	1338	0666	edit dl rm
no-nested-ternary.js	960	0666	edit dl rm
no-new-func.js	2393	0666	edit dl rm
no-new-native-nonconstructor.js	1754	0666	edit dl rm
no-new-object.js	1866	0666	edit dl rm
no-new-require.js	1588	0666	edit dl rm
no-new-symbol.js	1739	0666	edit dl rm
no-new-wrappers.js	1460	0666	edit dl rm
no-new.js	905	0666	edit dl rm
no-nonoctal-decimal-escape.js	4566	0666	edit dl rm
no-obj-calls.js	2466	0666	edit dl rm
no-object-constructor.js	2923	0666	edit dl rm
no-octal-escape.js	1175	0666	edit dl rm
no-octal.js	832	0666	edit dl rm
no-param-reassign.js	6363	0666	edit dl rm
no-path-concat.js	2012	0666	edit dl rm
no-plusplus.js	2672	0666	edit dl rm
no-process-env.js	1646	0666	edit dl rm
no-process-exit.js	1735	0666	edit dl rm
no-promise-executor-return.js	6675	0666	edit dl rm
no-proto.js	1093	0666	edit dl rm
no-prototype-builtins.js	4721	0666	edit dl rm
no-redeclare.js	4425	0666	edit dl rm
no-regex-spaces.js	5276	0666	edit dl rm
no-restricted-exports.js	5636	0666	edit dl rm
no-restricted-globals.js	6229	0666	edit dl rm
no-restricted-imports.js	23880	0666	edit dl rm
no-restricted-modules.js	6128	0666	edit dl rm
no-restricted-properties.js	5948	0666	edit dl rm
no-restricted-syntax.js	1698	0666	edit dl rm
no-return-assign.js	2259	0666	edit dl rm
no-return-await.js	4457	0666	edit dl rm
no-script-url.js	1512	0666	edit dl rm
no-self-assign.js	4666	0666	edit dl rm
no-self-compare.js	1705	0666	edit dl rm
no-sequences.js	4011	0666	edit dl rm
no-setter-return.js	5725	0666	edit dl rm
no-shadow-restricted-names.js	2672	0666	edit dl rm
no-shadow.js	17353	0666	edit dl rm
no-spaced-func.js	2603	0666	edit dl rm
no-sparse-arrays.js	1483	0666	edit dl rm
no-sync.js	1887	0666	edit dl rm
no-tabs.js	2449	0666	edit dl rm
no-template-curly-in-string.js	989	0666	edit dl rm
no-ternary.js	785	0666	edit dl rm
no-this-before-super.js	9043	0666	edit dl rm
no-throw-literal.js	1088	0666	edit dl rm
no-trailing-spaces.js	6110	0666	edit dl rm
no-unassigned-vars.js	1964	0666	edit dl rm
no-undef-init.js	2409	0666	edit dl rm
no-undef.js	1899	0666	edit dl rm
no-undefined.js	1861	0666	edit dl rm
no-underscore-dangle.js	9535	0666	edit dl rm
no-unexpected-multiline.js	3477	0666	edit dl rm
no-unmodified-loop-condition.js	10035	0666	edit dl rm
no-unneeded-ternary.js	5935	0666	edit dl rm
no-unreachable-loop.js	5076	0666	edit dl rm
no-unreachable.js	7498	0666	edit dl rm
no-unsafe-finally.js	3339	0666	edit dl rm
no-unsafe-negation.js	3972	0666	edit dl rm
no-unsafe-optional-chaining.js	5389	0666	edit dl rm
no-unused-expressions.js	5520	0666	edit dl rm
no-unused-labels.js	3878	0666	edit dl rm
no-unused-private-class-members.js	6277	0666	edit dl rm
no-unused-vars.js	48552	0666	edit dl rm
no-use-before-define.js	11866	0666	edit dl rm
no-useless-assignment.js	19334	0666	edit dl rm
no-useless-backreference.js	7662	0666	edit dl rm
no-useless-call.js	2779	0666	edit dl rm
no-useless-catch.js	1310	0666	edit dl rm
no-useless-computed-key.js	5936	0666	edit dl rm
no-useless-concat.js	2966	0666	edit dl rm
no-useless-constructor.js	6986	0666	edit dl rm
no-useless-escape.js	11065	0666	edit dl rm
no-useless-rename.js	4929	0666	edit dl rm
no-useless-return.js	11954	0666	edit dl rm
no-var.js	11461	0666	edit dl rm
no-void.js	1366	0666	edit dl rm
no-warning-comments.js	5670	0666	edit dl rm
no-whitespace-before-property.js	3883	0666	edit dl rm
no-with.js	757	0666	edit dl rm
nonblock-statement-body-position.js	4418	0666	edit dl rm
object-curly-newline.js	10115	0666	edit dl rm
object-curly-spacing.js	10399	0666	edit dl rm
object-property-newline.js	3758	0666	edit dl rm
object-shorthand.js	18543	0666	edit dl rm
one-var-declaration-per-line.js	2995	0666	edit dl rm
one-var.js	19182	0666	edit dl rm
operator-assignment.js	7536	0666	edit dl rm
operator-linebreak.js	8901	0666	edit dl rm
padded-blocks.js	8910	0666	edit dl rm
padding-line-between-statements.js	16989	0666	edit dl rm
prefer-arrow-callback.js	11667	0666	edit dl rm
prefer-const.js	15780	0666	edit dl rm
prefer-destructuring.js	8931	0666	edit dl rm
prefer-exponentiation-operator.js	6727	0666	edit dl rm
prefer-named-capture-group.js	5048	0666	edit dl rm
prefer-numeric-literals.js	4504	0666	edit dl rm
prefer-object-has-own.js	3804	0666	edit dl rm
prefer-object-spread.js	9489	0666	edit dl rm
prefer-promise-reject-errors.js	4614	0666	edit dl rm
prefer-reflect.js	3828	0666	edit dl rm
prefer-regex-literals.js	14379	0666	edit dl rm
prefer-rest-params.js	3032	0666	edit dl rm
prefer-spread.js	2555	0666	edit dl rm
prefer-template.js	10537	0666	edit dl rm
preserve-caught-error.js	16269	0666	edit dl rm
quote-props.js	10129	0666	edit dl rm
quotes.js	10934	0666	edit dl rm
radix.js	5549	0666	edit dl rm
require-atomic-updates.js	9293	0666	edit dl rm
require-await.js	4564	0666	edit dl rm
require-unicode-regexp.js	7765	0666	edit dl rm
require-yield.js	1718	0666	edit dl rm
rest-spread-spacing.js	3739	0666	edit dl rm
semi-spacing.js	7384	0666	edit dl rm
semi-style.js	5246	0666	edit dl rm
semi.js	13324	0666	edit dl rm
sort-imports.js	8603	0666	edit dl rm
sort-keys.js	5880	0666	edit dl rm
sort-vars.js	3320	0666	edit dl rm
space-before-blocks.js	6328	0666	edit dl rm
space-before-function-paren.js	5253	0666	edit dl rm
space-in-parens.js	9314	0666	edit dl rm
space-infix-ops.js	5890	0666	edit dl rm
space-unary-ops.js	10644	0666	edit dl rm
spaced-comment.js	11246	0666	edit dl rm
strict.js	9141	0666	edit dl rm
switch-colon-spacing.js	4701	0666	edit dl rm
symbol-description.js	1701	0666	edit dl rm
template-curly-spacing.js	4337	0666	edit dl rm
template-tag-spacing.js	3059	0666	edit dl rm
unicode-bom.js	1716	0666	edit dl rm
use-isnan.js	7130	0666	edit dl rm
valid-typeof.js	4262	0666	edit dl rm
vars-on-top.js	4304	0666	edit dl rm
wrap-iife.js	6914	0666	edit dl rm
wrap-regex.js	2167	0666	edit dl rm
yield-star-spacing.js	3992	0666	edit dl rm
yoda.js	9713	0666	edit dl rm

Edit: /home/techb158/balavpn.abdallabala.com/node_modules/eslint/lib/rules/no-unused-vars.js (48552B)

/**
 * @fileoverview Rule to flag declared but unused variables
 * @author Ilya Volodin
 */

"use strict";

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const astUtils = require("./utils/ast-utils");

//------------------------------------------------------------------------------
// Typedefs
//------------------------------------------------------------------------------

/**
 * A simple name for the types of variables that this rule supports
 * @typedef {'array-destructure'|'catch-clause'|'parameter'|'variable'} VariableType
 */

/**
 * Bag of data used for formatting the `unusedVar` lint message.
 * @typedef {Object} UnusedVarMessageData
 * @property {string} varName The name of the unused var.
 * @property {'defined'|'assigned a value'} action Description of the vars state.
 * @property {string} additional Any additional info to be appended at the end.
 */

/**
 * Bag of data used for formatting the `usedIgnoredVar` lint message.
 * @typedef {Object} UsedIgnoredVarMessageData
 * @property {string} varName The name of the unused var.
 * @property {string} additional Any additional info to be appended at the end.
 */

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

/** @type {import('../types').Rule.RuleModule} */
module.exports = {
	meta: {
		type: "problem",

docs: {
			description: "Disallow unused variables",
			recommended: true,
			url: "https://eslint.org/docs/latest/rules/no-unused-vars",
		},

hasSuggestions: true,

schema: [
			{
				oneOf: [
					{
						enum: ["all", "local"],
					},
					{
						type: "object",
						properties: {
							vars: {
								enum: ["all", "local"],
							},
							varsIgnorePattern: {
								type: "string",
							},
							args: {
								enum: ["all", "after-used", "none"],
							},
							ignoreRestSiblings: {
								type: "boolean",
							},
							argsIgnorePattern: {
								type: "string",
							},
							caughtErrors: {
								enum: ["all", "none"],
							},
							caughtErrorsIgnorePattern: {
								type: "string",
							},
							destructuredArrayIgnorePattern: {
								type: "string",
							},
							ignoreClassWithStaticInitBlock: {
								type: "boolean",
							},
							ignoreUsingDeclarations: {
								type: "boolean",
							},
							reportUsedIgnorePattern: {
								type: "boolean",
							},
						},
						additionalProperties: false,
					},
				],
			},
		],

messages: {
			unusedVar:
				"'{{varName}}' is {{action}} but never used{{additional}}.",
			usedIgnoredVar:
				"'{{varName}}' is marked as ignored but is used{{additional}}.",
			removeVar: "Remove unused variable '{{varName}}'.",
		},
	},

create(context) {
		const sourceCode = context.sourceCode;

const REST_PROPERTY_TYPE =
			/^(?:RestElement|(?:Experimental)?RestProperty)$/u;

const config = {
			vars: "all",
			args: "after-used",
			ignoreRestSiblings: false,
			caughtErrors: "all",
			ignoreClassWithStaticInitBlock: false,
			ignoreUsingDeclarations: false,
			reportUsedIgnorePattern: false,
		};

const firstOption = context.options[0];

if (firstOption) {
			if (typeof firstOption === "string") {
				config.vars = firstOption;
			} else {
				config.vars = firstOption.vars || config.vars;
				config.args = firstOption.args || config.args;
				config.ignoreRestSiblings =
					firstOption.ignoreRestSiblings || config.ignoreRestSiblings;
				config.caughtErrors =
					firstOption.caughtErrors || config.caughtErrors;
				config.ignoreClassWithStaticInitBlock =
					firstOption.ignoreClassWithStaticInitBlock ||
					config.ignoreClassWithStaticInitBlock;
				config.ignoreUsingDeclarations =
					firstOption.ignoreUsingDeclarations ||
					config.ignoreUsingDeclarations;
				config.reportUsedIgnorePattern =
					firstOption.reportUsedIgnorePattern ||
					config.reportUsedIgnorePattern;

if (firstOption.varsIgnorePattern) {
					config.varsIgnorePattern = new RegExp(
						firstOption.varsIgnorePattern,
						"u",
					);
				}

if (firstOption.argsIgnorePattern) {
					config.argsIgnorePattern = new RegExp(
						firstOption.argsIgnorePattern,
						"u",
					);
				}

if (firstOption.caughtErrorsIgnorePattern) {
					config.caughtErrorsIgnorePattern = new RegExp(
						firstOption.caughtErrorsIgnorePattern,
						"u",
					);
				}

if (firstOption.destructuredArrayIgnorePattern) {
					config.destructuredArrayIgnorePattern = new RegExp(
						firstOption.destructuredArrayIgnorePattern,
						"u",
					);
				}
			}
		}

/**
		 * Determines what variable type a def is.
		 * @param  {Object} def the declaration to check
		 * @returns {VariableType} a simple name for the types of variables that this rule supports
		 */
		function defToVariableType(def) {
			/*
			 * This `destructuredArrayIgnorePattern` error report works differently from the catch
			 * clause and parameter error reports. _Both_ the `varsIgnorePattern` and the
			 * `destructuredArrayIgnorePattern` will be checked for array destructuring. However,
			 * for the purposes of the report, the currently defined behavior is to only inform the
			 * user of the `destructuredArrayIgnorePattern` if it's present (regardless of the fact
			 * that the `varsIgnorePattern` would also apply). If it's not present, the user will be
			 * informed of the `varsIgnorePattern`, assuming that's present.
			 */
			if (
				config.destructuredArrayIgnorePattern &&
				def.name.parent.type === "ArrayPattern"
			) {
				return "array-destructure";
			}

switch (def.type) {
				case "CatchClause":
					return "catch-clause";
				case "Parameter":
					return "parameter";

default:
					return "variable";
			}
		}

/**
		 * Gets a given variable's description and configured ignore pattern
		 * based on the provided variableType
		 * @param {VariableType} variableType a simple name for the types of variables that this rule supports
		 * @throws {Error} (Unreachable)
		 * @returns {[string | undefined, string | undefined]} the given variable's description and
		 * ignore pattern
		 */
		function getVariableDescription(variableType) {
			let pattern;
			let variableDescription;

switch (variableType) {
				case "array-destructure":
					pattern = config.destructuredArrayIgnorePattern;
					variableDescription = "elements of array destructuring";
					break;

case "catch-clause":
					pattern = config.caughtErrorsIgnorePattern;
					variableDescription = "caught errors";
					break;

case "parameter":
					pattern = config.argsIgnorePattern;
					variableDescription = "args";
					break;

case "variable":
					pattern = config.varsIgnorePattern;
					variableDescription = "vars";
					break;

default:
					throw new Error(
						`Unexpected variable type: ${variableType}`,
					);
			}

if (pattern) {
				pattern = pattern.toString();
			}

return [variableDescription, pattern];
		}

/**
		 * Generates the message data about the variable being defined and unused,
		 * including the ignore pattern if configured.
		 * @param {Variable} unusedVar eslint-scope variable object.
		 * @returns {UnusedVarMessageData} The message data to be used with this unused variable.
		 */
		function getDefinedMessageData(unusedVar) {
			const def = unusedVar.defs && unusedVar.defs[0];
			let additionalMessageData = "";

if (def) {
				const [variableDescription, pattern] = getVariableDescription(
					defToVariableType(def),
				);

if (pattern && variableDescription) {
					additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
				}
			}

return {
				varName: unusedVar.name,
				action: "defined",
				additional: additionalMessageData,
			};
		}

/**
		 * Generate the warning message about the variable being
		 * assigned and unused, including the ignore pattern if configured.
		 * @param {Variable} unusedVar eslint-scope variable object.
		 * @returns {UnusedVarMessageData} The message data to be used with this unused variable.
		 */
		function getAssignedMessageData(unusedVar) {
			const def = unusedVar.defs && unusedVar.defs[0];
			let additionalMessageData = "";

if (def) {
				const [variableDescription, pattern] = getVariableDescription(
					defToVariableType(def),
				);

if (pattern && variableDescription) {
					additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
				}
			}

return {
				varName: unusedVar.name,
				action: "assigned a value",
				additional: additionalMessageData,
			};
		}

/**
		 * Generate the warning message about a variable being used even though
		 * it is marked as being ignored.
		 * @param {Variable} variable eslint-scope variable object
		 * @param {VariableType} variableType a simple name for the types of variables that this rule supports
		 * @returns {UsedIgnoredVarMessageData} The message data to be used with
		 * this used ignored variable.
		 */
		function getUsedIgnoredMessageData(variable, variableType) {
			const [variableDescription, pattern] =
				getVariableDescription(variableType);

let additionalMessageData = "";

if (pattern && variableDescription) {
				additionalMessageData = `. Used ${variableDescription} must not match ${pattern}`;
			}

return {
				varName: variable.name,
				additional: additionalMessageData,
			};
		}

//--------------------------------------------------------------------------
		// Helpers
		//--------------------------------------------------------------------------

const STATEMENT_TYPE = /(?:Statement|Declaration)$/u;

/**
		 * Determines if a given variable is being exported from a module.
		 * @param {Variable} variable eslint-scope variable object.
		 * @returns {boolean} True if the variable is exported, false if not.
		 * @private
		 */
		function isExported(variable) {
			const definition = variable.defs[0];

if (definition) {
				let node = definition.node;

if (node.type === "VariableDeclarator") {
					node = node.parent;
				} else if (definition.type === "Parameter") {
					return false;
				}

return node.parent.type.indexOf("Export") === 0;
			}
			return false;
		}

/**
		 * Determines if a given variable uses the explicit resource management protocol.
		 * @param {Variable} variable eslint-scope variable object.
		 * @returns {boolean} True if the variable is declared with "using" or "await using"
		 * @private
		 */
		function usesExplicitResourceManagement(variable) {
			const [definition] = variable.defs;

return (
				definition?.type === "Variable" &&
				(definition.parent.kind === "using" ||
					definition.parent.kind === "await using")
			);
		}

/**
		 * Checks whether a node is a sibling of the rest property or not.
		 * @param {ASTNode} node a node to check
		 * @returns {boolean} True if the node is a sibling of the rest property, otherwise false.
		 */
		function hasRestSibling(node) {
			return (
				node.type === "Property" &&
				node.parent.type === "ObjectPattern" &&
				REST_PROPERTY_TYPE.test(node.parent.properties.at(-1).type)
			);
		}

/**
		 * Determines if a variable has a sibling rest property
		 * @param {Variable} variable eslint-scope variable object.
		 * @returns {boolean} True if the variable has a sibling rest property, false if not.
		 * @private
		 */
		function hasRestSpreadSibling(variable) {
			if (config.ignoreRestSiblings) {
				const hasRestSiblingDefinition = variable.defs.some(def =>
					hasRestSibling(def.name.parent),
				);
				const hasRestSiblingReference = variable.references.some(ref =>
					hasRestSibling(ref.identifier.parent),
				);

return hasRestSiblingDefinition || hasRestSiblingReference;
			}

return false;
		}

/**
		 * Determines if a reference is a read operation.
		 * @param {Reference} ref An eslint-scope Reference
		 * @returns {boolean} whether the given reference represents a read operation
		 * @private
		 */
		function isReadRef(ref) {
			return ref.isRead();
		}

/**
		 * Determine if an identifier is referencing an enclosing function name.
		 * @param {Reference} ref The reference to check.
		 * @param {ASTNode[]} nodes The candidate function nodes.
		 * @returns {boolean} True if it's a self-reference, false if not.
		 * @private
		 */
		function isSelfReference(ref, nodes) {
			let scope = ref.from;

while (scope) {
				if (nodes.includes(scope.block)) {
					return true;
				}

scope = scope.upper;
			}

return false;
		}

/**
		 * Gets a list of function definitions for a specified variable.
		 * @param {Variable} variable eslint-scope variable object.
		 * @returns {ASTNode[]} Function nodes.
		 * @private
		 */
		function getFunctionDefinitions(variable) {
			const functionDefinitions = [];

variable.defs.forEach(def => {
				const { type, node } = def;

// FunctionDeclarations
				if (type === "FunctionName") {
					functionDefinitions.push(node);
				}

// FunctionExpressions
				if (
					type === "Variable" &&
					node.init &&
					(node.init.type === "FunctionExpression" ||
						node.init.type === "ArrowFunctionExpression")
				) {
					functionDefinitions.push(node.init);
				}
			});
			return functionDefinitions;
		}

/**
		 * Checks the position of given nodes.
		 * @param {ASTNode} inner A node which is expected as inside.
		 * @param {ASTNode} outer A node which is expected as outside.
		 * @returns {boolean} `true` if the `inner` node exists in the `outer` node.
		 * @private
		 */
		function isInside(inner, outer) {
			return (
				inner.range[0] >= outer.range[0] &&
				inner.range[1] <= outer.range[1]
			);
		}

/**
		 * Checks whether a given node is unused expression or not.
		 * @param {ASTNode} node The node itself
		 * @returns {boolean} The node is an unused expression.
		 * @private
		 */
		function isUnusedExpression(node) {
			const parent = node.parent;

if (parent.type === "ExpressionStatement") {
				return true;
			}

if (parent.type === "SequenceExpression") {
				const isLastExpression = parent.expressions.at(-1) === node;

if (!isLastExpression) {
					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 null.
		 *
		 * - 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 {eslint-scope.Reference} ref A reference to check.
		 * @param {ASTNode} prevRhsNode The previous RHS node.
		 * @returns {ASTNode|null} The RHS node or null.
		 * @private
		 */
		function getRhsNode(ref, prevRhsNode) {
			const id = ref.identifier;
			const parent = id.parent;
			const refScope = ref.from.variableScope;
			const varScope = ref.resolved.scope.variableScope;
			const canBeUsedLater =
				refScope !== varScope || astUtils.isInLoop(id);

/*
			 * Inherits the previous node if this reference is in the node.
			 * This is for `a = a + a`-like code.
			 */
			if (prevRhsNode && isInside(id, prevRhsNode)) {
				return prevRhsNode;
			}

if (
				parent.type === "AssignmentExpression" &&
				isUnusedExpression(parent) &&
				id === parent.left &&
				!canBeUsedLater
			) {
				return parent.right;
			}
			return null;
		}

/**
		 * 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 {ASTNode} funcNode A function node to check.
		 * @param {ASTNode} rhsNode The RHS node of the previous assignment.
		 * @returns {boolean} `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.
		 * @private
		 */
		function isStorableFunction(funcNode, rhsNode) {
			let node = funcNode;
			let parent = funcNode.parent;

while (parent && isInside(parent, rhsNode)) {
				switch (parent.type) {
					case "SequenceExpression":
						if (parent.expressions.at(-1) !== node) {
							return false;
						}
						break;

case "CallExpression":
					case "NewExpression":
						return parent.callee !== node;

case "AssignmentExpression":
					case "TaggedTemplateExpression":
					case "YieldExpression":
						return true;

default:
						if (STATEMENT_TYPE.test(parent.type)) {
							/*
							 * If it encountered statements, this is a complex pattern.
							 * Since analyzing complex patterns is hard, this returns `true` to avoid false positive.
							 */
							return true;
						}
				}

node = parent;
				parent = parent.parent;
			}

return false;
		}

/**
		 * 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 {ASTNode} id An Identifier node to check.
		 * @param {ASTNode} rhsNode The RHS node of the previous assignment.
		 * @returns {boolean} `true` if the `id` node exists inside of a function node which can be used later.
		 * @private
		 */
		function isInsideOfStorableFunction(id, rhsNode) {
			const funcNode = astUtils.getUpperFunction(id);

return (
				funcNode &&
				isInside(funcNode, rhsNode) &&
				isStorableFunction(funcNode, rhsNode)
			);
		}

/**
		 * Checks whether a given reference is a read to update itself or not.
		 * @param {eslint-scope.Reference} ref A reference to check.
		 * @param {ASTNode} rhsNode The RHS node of the previous assignment.
		 * @returns {boolean} The reference is a read to update itself.
		 * @private
		 */
		function isReadForItself(ref, rhsNode) {
			const id = ref.identifier;
			const parent = id.parent;

return (
				ref.isRead() &&
				// self update. e.g. `a += 1`, `a++`
				((parent.type === "AssignmentExpression" &&
					parent.left === id &&
					isUnusedExpression(parent) &&
					!astUtils.isLogicalAssignmentOperator(parent.operator)) ||
					(parent.type === "UpdateExpression" &&
						isUnusedExpression(parent)) ||
					// in RHS of an assignment for itself. e.g. `a = a + 1`
					(rhsNode &&
						isInside(id, rhsNode) &&
						!isInsideOfStorableFunction(id, rhsNode)))
			);
		}

/**
		 * Determine if an identifier is used either in for-in or for-of loops.
		 * @param {Reference} ref The reference to check.
		 * @returns {boolean} whether reference is used in the for-in loops
		 * @private
		 */
		function isForInOfRef(ref) {
			let target = ref.identifier.parent;

// "for (var ...) { return; }"
			if (target.type === "VariableDeclarator") {
				target = target.parent.parent;
			}

if (
				target.type !== "ForInStatement" &&
				target.type !== "ForOfStatement"
			) {
				return false;
			}

// "for (...) { return; }"
			if (target.body.type === "BlockStatement") {
				target = target.body.body[0];

// "for (...) return;"
			} else {
				target = target.body;
			}

// For empty loop body
			if (!target) {
				return false;
			}

return target.type === "ReturnStatement";
		}

/**
		 * Determines if the variable is used.
		 * @param {Variable} variable The variable to check.
		 * @returns {boolean} True if the variable is used
		 * @private
		 */
		function isUsedVariable(variable) {
			if (variable.eslintUsed) {
				return true;
			}

const functionNodes = getFunctionDefinitions(variable);
			const isFunctionDefinition = functionNodes.length > 0;

let rhsNode = null;

return variable.references.some(ref => {
				if (isForInOfRef(ref)) {
					return true;
				}

const forItself = isReadForItself(ref, rhsNode);

rhsNode = getRhsNode(ref, rhsNode);

return (
					isReadRef(ref) &&
					!forItself &&
					!(
						isFunctionDefinition &&
						isSelfReference(ref, functionNodes)
					)
				);
			});
		}

/**
		 * Checks whether the given variable is after the last used parameter.
		 * @param {eslint-scope.Variable} variable The variable to check.
		 * @returns {boolean} `true` if the variable is defined after the last
		 * used parameter.
		 */
		function isAfterLastUsedArg(variable) {
			const def = variable.defs[0];
			const params = sourceCode.getDeclaredVariables(def.node);
			const posteriorParams = params.slice(params.indexOf(variable) + 1);

// If any used parameters occur after this parameter, do not report.
			return !posteriorParams.some(
				v => v.references.length > 0 || v.eslintUsed,
			);
		}

/**
		 * Gets an array of variables without read references.
		 * @param {Scope} scope an eslint-scope Scope object.
		 * @param {Variable[]} unusedVars an array that saving result.
		 * @returns {Variable[]} unused variables of the scope and descendant scopes.
		 * @private
		 */
		function collectUnusedVariables(scope, unusedVars) {
			const variables = scope.variables;
			const childScopes = scope.childScopes;
			let i, l;

if (scope.type !== "global" || config.vars === "all") {
				for (i = 0, l = variables.length; i < l; ++i) {
					const variable = variables[i];

// skip a variable of class itself name in the class scope
					if (
						scope.type === "class" &&
						scope.block.id === variable.identifiers[0]
					) {
						continue;
					}

// skip function expression names
					if (scope.functionExpressionScope) {
						continue;
					}

// skip variables marked with markVariableAsUsed()
					if (
						!config.reportUsedIgnorePattern &&
						variable.eslintUsed
					) {
						continue;
					}

// skip implicit "arguments" variable
					if (
						scope.type === "function" &&
						variable.name === "arguments" &&
						variable.identifiers.length === 0
					) {
						continue;
					}

// explicit global variables don't have definitions.
					const def = variable.defs[0];

if (def) {
						const type = def.type;
						const refUsedInArrayPatterns = variable.references.some(
							ref =>
								ref.identifier.parent.type === "ArrayPattern",
						);

// skip elements of array destructuring patterns
						if (
							(def.name.parent.type === "ArrayPattern" ||
								refUsedInArrayPatterns) &&
							config.destructuredArrayIgnorePattern &&
							config.destructuredArrayIgnorePattern.test(
								def.name.name,
							)
						) {
							if (
								config.reportUsedIgnorePattern &&
								isUsedVariable(variable)
							) {
								context.report({
									node: def.name,
									messageId: "usedIgnoredVar",
									data: getUsedIgnoredMessageData(
										variable,
										"array-destructure",
									),
								});
							}

continue;
						}

if (type === "ClassName") {
							const hasStaticBlock = def.node.body.body.some(
								node => node.type === "StaticBlock",
							);

if (
								config.ignoreClassWithStaticInitBlock &&
								hasStaticBlock
							) {
								continue;
							}
						}

// skip catch variables
						if (type === "CatchClause") {
							if (config.caughtErrors === "none") {
								continue;
							}

// skip ignored parameters
							if (
								config.caughtErrorsIgnorePattern &&
								config.caughtErrorsIgnorePattern.test(
									def.name.name,
								)
							) {
								if (
									config.reportUsedIgnorePattern &&
									isUsedVariable(variable)
								) {
									context.report({
										node: def.name,
										messageId: "usedIgnoredVar",
										data: getUsedIgnoredMessageData(
											variable,
											"catch-clause",
										),
									});
								}

continue;
							}
						} else if (type === "Parameter") {
							// skip any setter argument
							if (
								(def.node.parent.type === "Property" ||
									def.node.parent.type ===
										"MethodDefinition") &&
								def.node.parent.kind === "set"
							) {
								continue;
							}

// if "args" option is "none", skip any parameter
							if (config.args === "none") {
								continue;
							}

// skip ignored parameters
							if (
								config.argsIgnorePattern &&
								config.argsIgnorePattern.test(def.name.name)
							) {
								if (
									config.reportUsedIgnorePattern &&
									isUsedVariable(variable)
								) {
									context.report({
										node: def.name,
										messageId: "usedIgnoredVar",
										data: getUsedIgnoredMessageData(
											variable,
											"parameter",
										),
									});
								}

continue;
							}

// if "args" option is "after-used", skip used variables
							if (
								config.args === "after-used" &&
								astUtils.isFunction(def.name.parent) &&
								!isAfterLastUsedArg(variable)
							) {
								continue;
							}
						} else {
							// skip ignored variables
							if (
								config.varsIgnorePattern &&
								config.varsIgnorePattern.test(def.name.name)
							) {
								if (
									config.reportUsedIgnorePattern &&
									isUsedVariable(variable)
								) {
									context.report({
										node: def.name,
										messageId: "usedIgnoredVar",
										data: getUsedIgnoredMessageData(
											variable,
											"variable",
										),
									});
								}

continue;
							}
						}
					}

if (
						!isUsedVariable(variable) &&
						!isExported(variable) &&
						!(
							config.ignoreUsingDeclarations &&
							usesExplicitResourceManagement(variable)
						) &&
						!hasRestSpreadSibling(variable)
					) {
						unusedVars.push(variable);
					}
				}
			}

for (i = 0, l = childScopes.length; i < l; ++i) {
				collectUnusedVariables(childScopes[i], unusedVars);
			}

return unusedVars;
		}

/**
		 * fixes unused variables
		 * @param {Object} fixer fixer object
		 * @param {Object} unusedVar unused variable to fix
		 * @returns {Object} fixer object
		 */
		function handleFixes(fixer, unusedVar) {
			const id = unusedVar.identifiers[0];
			const parent = id.parent;
			const parentType = parent.type;
			const tokenBefore = sourceCode.getTokenBefore(id);
			const tokenAfter = sourceCode.getTokenAfter(id);
			const isFunction = astUtils.isFunction;
			const isLoop = astUtils.isLoop;
			const allWriteReferences = unusedVar.references.filter(ref =>
				ref.isWrite(),
			);

/**
			 * get range from token before of a given node
			 * @param {ASTNode} node node of identifier
			 * @param {number} skips number of token to skip
			 * @returns {number} start range of token before the identifier
			 */
			function getPreviousTokenStart(node, skips) {
				return sourceCode.getTokenBefore(node, skips).range[0];
			}

/**
			 * get range to token after of a given node
			 * @param {ASTNode} node node of identifier
			 * @param {number} skips number of token to skip
			 * @returns {number} end range of token after the identifier
			 */
			function getNextTokenEnd(node, skips) {
				return sourceCode.getTokenAfter(node, skips).range[1];
			}

/**
			 * get the value of token before of a given node
			 * @param {ASTNode} node node of identifier
			 * @returns {string} value of token before the identifier
			 */
			function getTokenBeforeValue(node) {
				return sourceCode.getTokenBefore(node).value;
			}

/**
			 * get the value of token after of a given node
			 * @param {ASTNode} node node of identifier
			 * @returns {string} value of token after the identifier
			 */
			function getTokenAfterValue(node) {
				return sourceCode.getTokenAfter(node).value;
			}

/**
			 * Check if an array has a single element with null as other element.
			 * @param {ASTNode} node ArrayPattern node
			 * @returns {boolean} true if array has single element with other null elements
			 */
			function hasSingleElement(node) {
				return node.elements.filter(e => e !== null).length === 1;
			}

/**
			 * check whether import specifier has an import of particular type
			 * @param {ASTNode} node ImportDeclaration node
			 * @param {string} type type of import to check
			 * @returns {boolean} true if import specifier has import of specified type
			 */
			function hasImportOfCertainType(node, type) {
				return node.specifiers.some(e => e.type === type);
			}

/**
			 * Check whether declaration is safe to remove or not
			 * @param {ASTNode} nextToken next token of unused variable
			 * @param {ASTNode} prevToken previous token of unused variable
			 * @returns {boolean} true if declaration is not safe to remove
			 */
			function isDeclarationNotSafeToRemove(nextToken, prevToken) {
				return (
					nextToken.type === "String" ||
					(prevToken &&
						!astUtils.isSemicolonToken(prevToken) &&
						!astUtils.isOpeningBraceToken(prevToken))
				);
			}

/**
			 * give fixes for unused variables in function parameters
			 * @param {ASTNode} node node to check
			 * @returns {Object} fixer object
			 */
			function fixFunctionParameters(node) {
				const parentNode = node.parent;

if (isFunction(parentNode)) {
					// remove unused function parameter if there is only a single parameter
					if (parentNode.params.length === 1) {
						return fixer.removeRange(node.range);
					}

// remove first unused function parameter when there are multiple parameters
					if (
						getTokenBeforeValue(node) === "(" &&
						getTokenAfterValue(node) === ","
					) {
						return fixer.removeRange([
							node.range[0],
							getNextTokenEnd(node),
						]);
					}

// remove unused function parameters except first one when there are multiple parameters
					return fixer.removeRange([
						getPreviousTokenStart(node),
						node.range[1],
					]);
				}

return null;
			}

/**
			 * fix unused variable declarations and function parameters
			 * @param {ASTNode} node parent node to identifier
			 * @returns {Object} fixer object
			 */
			function fixVariables(node) {
				const parentNode = node.parent;

// remove unused declared variables such as var a = b; or var a = b, c;
				if (parentNode.type === "VariableDeclarator") {
					// skip variable in for (const [ foo ] of bar);
					if (isLoop(parentNode.parent.parent)) {
						return null;
					}

/*
					 * remove unused declared variable with single declaration such as 'var a = b;'
					 * remove complete declaration when there is an unused variable in 'const { a } = foo;', same for arrays.
					 */
					if (parentNode.parent.declarations.length === 1) {
						// if next token is a string it could become a directive if node is removed -> no suggestion.
						const nextToken = sourceCode.getTokenAfter(
							parentNode.parent,
						);

// if previous token exists and is not ";" or "{" not sure about ASI rules -> no suggestion.
						const prevToken = sourceCode.getTokenBefore(
							parentNode.parent,
						);

if (
							nextToken &&
							isDeclarationNotSafeToRemove(nextToken, prevToken)
						) {
							return null;
						}

return fixer.removeRange(parentNode.parent.range);
					}

/*
					 * remove unused declared variable with multiple declaration except first one such as 'var a = b, c = d;'
					 * fix 'let bar = "hello", { a } = foo;' to 'let bar = "hello";' if 'a' is unused, same for arrays.
					 */
					if (getTokenBeforeValue(parentNode) === ",") {
						return fixer.removeRange([
							getPreviousTokenStart(parentNode),
							parentNode.range[1],
						]);
					}

/*
					 * remove first unused declared variable when there are multiple declarations
					 * fix 'let { a } = foo, bar = "hello";' to 'let  bar = "hello";' if 'a' is unused, same for arrays.
					 */
					return fixer.removeRange([
						parentNode.range[0],
						getNextTokenEnd(parentNode),
					]);
				}

// fixes [{a: {k}}], [{a: [k]}]
				if (getTokenBeforeValue(node) === ":") {
					if (parentNode.parent.type === "ObjectPattern") {
						// eslint-disable-next-line no-use-before-define -- due to interdependency of functions
						return fixObjectWithValueSeparator(node);
					}
				}

// fix unused function parameters
				return fixFunctionParameters(node);
			}

/**
			 * fix nested object like { a: { b } }
			 * @param {ASTNode} node parent node to check
			 * @returns {Object} fixer object
			 */
			function fixNestedObjectVariable(node) {
				const parentNode = node.parent;

// fix for { a: { b: { c: { d } } } }
				if (
					parentNode.parent.parent.parent.type === "ObjectPattern" &&
					parentNode.parent.properties.length === 1
				) {
					return fixNestedObjectVariable(parentNode.parent);
				}

// fix for { a: { b } }
				if (parentNode.parent.type === "ObjectPattern") {
					// fix for unused variables in destructured object with single property in variable declaration and function parameter
					if (parentNode.parent.properties.length === 1) {
						return fixVariables(parentNode.parent);
					}

// fix for first unused property when there are multiple properties such as '{ a: { b }, c }'
					if (getTokenBeforeValue(parentNode) === "{") {
						return fixer.removeRange([
							parentNode.range[0],
							getNextTokenEnd(parentNode),
						]);
					}

// fix for unused property except first one when there are multiple properties such as '{ k, a: { b } }'
					return fixer.removeRange([
						getPreviousTokenStart(parentNode),
						parentNode.range[1],
					]);
				}

return null;
			}

/**
			 * fix unused variables in array and nested array
			 * @param {ASTNode} node parent node to check
			 * @returns {Object} fixer object
			 */
			function fixNestedArrayVariable(node) {
				const parentNode = node.parent;

// fix for nested arrays [[ a ]]
				if (
					parentNode.parent.type === "ArrayPattern" &&
					hasSingleElement(parentNode)
				) {
					return fixNestedArrayVariable(parentNode);
				}

if (hasSingleElement(parentNode)) {
					// fixes { a: [{ b }] } or { a: [[ b ]] }
					if (getTokenBeforeValue(parentNode) === ":") {
						return fixVariables(parentNode);
					}

// fixes [a, ...[[ b ]]] or [a, ...[{ b }]]
					if (parentNode.parent.type === "RestElement") {
						// eslint-disable-next-line no-use-before-define -- due to interdependency of functions
						return fixRestInPattern(parentNode.parent);
					}

// fix unused variables in destructured array in variable declaration or function parameter
					return fixVariables(parentNode);
				}

// remove last unused array element
				if (
					getTokenBeforeValue(node) === "," &&
					getTokenAfterValue(node) === "]"
				) {
					return fixer.removeRange([
						getPreviousTokenStart(node),
						node.range[1],
					]);
				}

// remove unused array element
				return fixer.removeRange(node.range);
			}

/**
			 * fix cases like {a: {k}} or {a: [k]}
			 * @param {ASTNode} node parent node to check
			 * @returns {Object} fixer object
			 */
			function fixObjectWithValueSeparator(node) {
				const parentNode = node.parent.parent;

// fix cases like [{a : { b }}] or [{a : [ b ]}]
				if (
					parentNode.parent.type === "ArrayPattern" &&
					parentNode.properties.length === 1
				) {
					return fixNestedArrayVariable(parentNode);
				}

// fix cases like {a: {k}} or {a: [k]}
				return fixNestedObjectVariable(node);
			}

/**
			 * fix ...[[a]] or ...[{a}] like patterns
			 * @param {ASTNode} node parent node to check
			 * @returns {Object} fixer object
			 */
			function fixRestInPattern(node) {
				const parentNode = node.parent;

// fix ...[[a]] or ...[{a}] in function parameters
				if (isFunction(parentNode)) {
					if (parentNode.params.length === 1) {
						return fixer.removeRange(node.range);
					}

return fixer.removeRange([
						getPreviousTokenStart(node),
						node.range[1],
					]);
				}

// fix rest in nested array pattern like [[a, ...[b]]]
				if (parentNode.type === "ArrayPattern") {
					// fix [[...[b]]]
					if (hasSingleElement(parentNode)) {
						if (parentNode.parent.type === "ArrayPattern") {
							return fixNestedArrayVariable(parentNode);
						}

// fix 'const [...[b]] = foo; and function foo([...[b]]) {}
						return fixVariables(parentNode);
					}

// fix [[a, ...[b]]]
					return fixer.removeRange([
						getPreviousTokenStart(node),
						node.range[1],
					]);
				}

return null;
			}

// skip fix when variable has references that would be left behind
			if (
				allWriteReferences.some(
					ref => ref.identifier.range[0] !== id.range[0],
				)
			) {
				return null;
			}

// remove declared variables such as var a; or var a, b;
			if (parentType === "VariableDeclarator") {
				if (parent.parent.declarations.length === 1) {
					// prevent fix of variable in forOf and forIn loops.
					if (
						isLoop(parent.parent.parent) &&
						parent.parent.parent.body !== parent.parent
					) {
						return null;
					}

// removes only variable not semicolon in 'if (foo()) var bar;' or in 'loops' or in 'with' statement.
					if (
						parent.parent.parent.type === "IfStatement" ||
						isLoop(parent.parent.parent) ||
						(parent.parent.parent.type === "WithStatement" &&
							parent.parent.parent.body === parent.parent)
					) {
						return fixer.replaceText(parent.parent, ";");
					}

// if next token is a string it could become a directive if node is removed -> no suggestion.
					const nextToken = sourceCode.getTokenAfter(parent.parent);

// if previous token exists and is not ";" or "{" not sure about ASI rules -> no suggestion.
					const prevToken = sourceCode.getTokenBefore(parent.parent);

if (
						nextToken &&
						isDeclarationNotSafeToRemove(nextToken, prevToken)
					) {
						return null;
					}

// remove unused declared variable with single declaration like 'var a = b;'
					return fixer.removeRange(parent.parent.range);
				}

// remove unused declared variable with multiple declaration except first one like 'var a = b, c = d;'
				if (tokenBefore.value === ",") {
					return fixer.removeRange([
						tokenBefore.range[0],
						parent.range[1],
					]);
				}

// remove first unused declared variable when there are multiple declarations
				return fixer.removeRange([
					parent.range[0],
					getNextTokenEnd(parent),
				]);
			}

// remove variables in object patterns
			if (parent.parent.type === "ObjectPattern") {
				if (parent.parent.properties.length === 1) {
					// fix [a, ...{b}]
					if (parent.parent.parent.type === "RestElement") {
						return fixRestInPattern(parent.parent.parent);
					}

// fix [{ a }]
					if (parent.parent.parent.type === "ArrayPattern") {
						return fixNestedArrayVariable(parent.parent);
					}

/*
					 * var {a} = foo;
					 * function a({a}) {}
					 * fix const { a: { b } } = foo;
					 */
					return fixVariables(parent.parent);
				}

// fix const { a:b } = foo;
				if (tokenBefore.value === ":") {
					// remove first unused variable in const { a:b } = foo;
					if (
						getTokenBeforeValue(parent) === "{" &&
						getTokenAfterValue(parent) === ","
					) {
						return fixer.removeRange([
							parent.range[0],
							getNextTokenEnd(parent),
						]);
					}

// remove unused variables in const { a: b, c: d } = foo; except first one
					return fixer.removeRange([
						getPreviousTokenStart(parent),
						id.range[1],
					]);
				}
			}

// remove unused variables inside an array
			if (parentType === "ArrayPattern") {
				if (hasSingleElement(parent)) {
					// fix [a, ...[b]]
					if (parent.parent.type === "RestElement") {
						return fixRestInPattern(parent.parent);
					}

// fix [ [a] ]
					if (parent.parent.type === "ArrayPattern") {
						return fixNestedArrayVariable(parent);
					}

/*
					 * fix var [a] = foo;
					 * fix function foo([a]) {}
					 * fix const { a: [b] } = foo;
					 */
					return fixVariables(parent);
				}

// if "a" is unused in [a, b ,c] fixes to [, b, c]
				if (tokenBefore.value === "," && tokenAfter.value === ",") {
					return fixer.removeRange(id.range);
				}
			}

// remove unused rest elements
			if (parentType === "RestElement") {
				// fix [a, ...rest]
				if (parent.parent.type === "ArrayPattern") {
					if (hasSingleElement(parent.parent)) {
						// fix [[...rest]] when there is only rest element
						if (parent.parent.parent.type === "ArrayPattern") {
							return fixNestedArrayVariable(parent.parent);
						}

// fix 'const [...rest] = foo;' and 'function foo([...rest]) {}'
						return fixVariables(parent.parent);
					}

// fix [a, ...rest]
					return fixer.removeRange([
						getPreviousTokenStart(id, 1),
						id.range[1],
					]);
				}

// fix { a, ...rest}
				if (parent.parent.type === "ObjectPattern") {
					// fix 'const {...rest} = foo;' and 'function foo({...rest}) {}'
					if (parent.parent.properties.length === 1) {
						return fixVariables(parent.parent);
					}

// fix { a, ...rest} when there are multiple properties
					return fixer.removeRange([
						getPreviousTokenStart(id, 1),
						id.range[1],
					]);
				}

// fix function foo(...rest) {}
				if (isFunction(parent.parent)) {
					// remove unused rest in function parameter if there is only single parameter
					if (parent.parent.params.length === 1) {
						return fixer.removeRange(parent.range);
					}

// remove unused rest in function parameter if there multiple parameter
					return fixer.removeRange([
						getPreviousTokenStart(parent),
						parent.range[1],
					]);
				}
			}

if (parentType === "AssignmentPattern") {
				// fix [a = aDefault]
				if (parent.parent.type === "ArrayPattern") {
					return fixNestedArrayVariable(parent);
				}

// fix {a = aDefault}
				if (parent.parent.parent.type === "ObjectPattern") {
					if (parent.parent.parent.properties.length === 1) {
						// fixes [{a = aDefault}]
						if (
							parent.parent.parent.parent.type === "ArrayPattern"
						) {
							return fixNestedArrayVariable(parent.parent.parent);
						}

// fix 'const {a = aDefault} = foo;' and 'function foo({a = aDefault}) {}'
						return fixVariables(parent.parent.parent);
					}

// fix unused 'a' in {a = aDefault} if it is the first property
					if (
						getTokenBeforeValue(parent.parent) === "{" &&
						getTokenAfterValue(parent.parent) === ","
					) {
						return fixer.removeRange([
							parent.parent.range[0],
							getNextTokenEnd(parent.parent),
						]);
					}

// fix unused 'b' in {a, b = aDefault} if it is not the first property
					return fixer.removeRange([
						getPreviousTokenStart(parent.parent),
						parent.parent.range[1],
					]);
				}

// fix unused assignment patterns in function parameters
				if (isFunction(parent.parent)) {
					return fixFunctionParameters(parent);
				}
			}

// remove unused functions
			if (parentType === "FunctionDeclaration" && parent.id === id) {
				return fixer.removeRange(parent.range);
			}

// remove unused default import
			if (parentType === "ImportDefaultSpecifier") {
				// remove unused default import when there are not other imports
				if (
					!hasImportOfCertainType(parent.parent, "ImportSpecifier") &&
					!hasImportOfCertainType(
						parent.parent,
						"ImportNamespaceSpecifier",
					)
				) {
					return fixer.removeRange([
						parent.range[0],
						parent.parent.source.range[0],
					]);
				}

// remove unused default import when there are other imports also
				return fixer.removeRange([id.range[0], tokenAfter.range[1]]);
			}

if (parentType === "ImportSpecifier") {
				// remove unused imports when there is a single import
				if (
					parent.parent.specifiers.filter(
						e => e.type === "ImportSpecifier",
					).length === 1
				) {
					// remove unused import when there is no default import
					if (
						!hasImportOfCertainType(
							parent.parent,
							"ImportDefaultSpecifier",
						)
					) {
						return fixer.removeRange(parent.parent.range);
					}

// fixes "import foo from 'module';" to "import 'module';"
					return fixer.removeRange([
						getPreviousTokenStart(parent, 1),
						tokenAfter.range[1],
					]);
				}

if (getTokenBeforeValue(parent) === "{") {
					return fixer.removeRange([
						parent.range[0],
						getNextTokenEnd(parent),
					]);
				}

return fixer.removeRange([
					getPreviousTokenStart(parent),
					parent.range[1],
				]);
			}

if (parentType === "ImportNamespaceSpecifier") {
				if (
					hasImportOfCertainType(
						parent.parent,
						"ImportDefaultSpecifier",
					)
				) {
					return fixer.removeRange([
						getPreviousTokenStart(parent),
						parent.range[1],
					]);
				}

// fixes "import * as foo from 'module';" to "import 'module';"
				return fixer.removeRange([
					parent.range[0],
					parent.parent.source.range[0],
				]);
			}

// skip error in catch(error) variable
			if (parentType === "CatchClause") {
				return null;
			}

// remove unused declared classes
			if (parentType === "ClassDeclaration") {
				return fixer.removeRange(parent.range);
			}

// remove unused variable that is in a sequence [a,b] fixes to [a]
			if (tokenBefore?.value === ",") {
				return fixer.removeRange([tokenBefore.range[0], id.range[1]]);
			}

// remove unused variable that is in a sequence inside function arguments and object pattern
			if (tokenAfter.value === ",") {
				// fix function foo(a, b) {}
				if (tokenBefore.value === "(") {
					return fixer.removeRange([
						id.range[0],
						tokenAfter.range[1],
					]);
				}

// fix const {a, b} = foo;
				if (tokenBefore.value === "{") {
					return fixer.removeRange([
						id.range[0],
						tokenAfter.range[1],
					]);
				}
			}

if (
				parentType === "ArrowFunctionExpression" &&
				parent.params.length === 1 &&
				tokenAfter?.value !== ")"
			) {
				return fixer.replaceText(id, "()");
			}

return fixer.removeRange(id.range);
		}

//--------------------------------------------------------------------------
		// Public
		//--------------------------------------------------------------------------

return {
			"Program:exit"(programNode) {
				const unusedVars = collectUnusedVariables(
					sourceCode.getScope(programNode),
					[],
				);

for (let i = 0, l = unusedVars.length; i < l; ++i) {
					const unusedVar = unusedVars[i];

// Report the first declaration.
					if (unusedVar.defs.length > 0) {
						// report last write reference, https://github.com/eslint/eslint/issues/14324
						const writeReferences = unusedVar.references.filter(
							ref =>
								ref.isWrite() &&
								ref.from.variableScope ===
									unusedVar.scope.variableScope,
						);

let referenceToReport;

if (writeReferences.length > 0) {
							referenceToReport = writeReferences.at(-1);
						}

context.report({
							node: referenceToReport
								? referenceToReport.identifier
								: unusedVar.identifiers[0],
							messageId: "unusedVar",
							data: unusedVar.references.some(ref =>
								ref.isWrite(),
							)
								? getAssignedMessageData(unusedVar)
								: getDefinedMessageData(unusedVar),
							suggest: [
								{
									messageId: "removeVar",
									data: {
										varName: unusedVar.name,
									},
									fix(fixer) {
										return handleFixes(fixer, unusedVar);
									},
								},
							],
						});

// If there are no regular declaration, report the first `/*globals*/` comment directive.
					} else if (unusedVar.eslintExplicitGlobalComments) {
						const directiveComment =
							unusedVar.eslintExplicitGlobalComments[0];

context.report({
							node: programNode,
							loc: astUtils.getNameLocationInGlobalDirectiveComment(
								sourceCode,
								directiveComment,
								unusedVar.name,
							),
							messageId: "unusedVar",
							data: getDefinedMessageData(unusedVar),
						});
					}
				}
			},
		};
	},
};

cmd: