eslint-linter-browserify 10.0.1 → 10.0.2

package/linter.cjs

@@ -4216,7 +4216,7 @@ function requireEslintVisitorKeys$2 () {
 	return eslintVisitorKeys$2;
 }
 
-var version = "10.0.1";
+var version = "10.0.2";
 var require$$3$1 = {
 	version: version};
 
@@ -45691,6 +45691,13 @@ function requireAstUtils () {
 		const globals = requireGlobals();
 		const { LATEST_ECMA_VERSION } = requireEcmaVersion();
 
+		//------------------------------------------------------------------------------
+		// Types
+		//------------------------------------------------------------------------------
+
+		/** @typedef {import("eslint-scope").Scope} Scope */
+		/** @typedef {import("eslint-scope").Variable} Variable */
+
 		//------------------------------------------------------------------------------
 		// Helpers
 		//------------------------------------------------------------------------------
@@ -47250,9 +47257,9 @@ function requireAstUtils () {
 
 			/**
 			 * Finds the variable by a given name in a given scope and its upper scopes.
-			 * @param {eslint-scope.Scope} initScope A scope to start find.
+			 * @param {Scope} initScope A scope to start find.
 			 * @param {string} name A variable name to find.
-			 * @returns {eslint-scope.Variable|null} A found variable or `null`.
+			 * @returns {Variable|null} A found variable or `null`.
 			 */
 			getVariableByName(initScope, name) {
 				let scope = initScope;
@@ -47279,7 +47286,7 @@ function requireAstUtils () {
 			 * - The given node is not `StaticBlock`.
 			 * - The function name does not start with uppercase. It's a convention to capitalize the names
 			 *   of constructor functions. This check is not performed if `capIsConstructor` is set to `false`.
-			 * - The function does not have a JSDoc comment that has a @this tag.
+			 * - The function does not have a JSDoc comment that has a `@this` tag.
 			 *
 			 * Next, this checks the location of the node.
 			 * If the location is below, this judges `this` is valid.
@@ -51331,6 +51338,13 @@ function requireBlockScopedVar () {
 	if (hasRequiredBlockScopedVar) return blockScopedVar;
 	hasRequiredBlockScopedVar = 1;
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Definition} Definition */
+	/** @typedef {import("eslint-scope").Reference} Reference */
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -51378,8 +51392,8 @@ function requireBlockScopedVar () {
 
 			/**
 			 * Reports a given reference.
-			 * @param {eslint-scope.Reference} reference A reference to report.
-			 * @param {eslint-scope.Definition} definition A definition for which to report reference.
+			 * @param {Reference} reference A reference to report.
+			 * @param {Definition} definition A definition for which to report reference.
 			 * @returns {void}
 			 */
 			function report(reference, definition) {
@@ -57994,9 +58008,19 @@ function requireFuncNames () {
 
 	const astUtils = requireAstUtils();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Variable} Variable */
+
+	//------------------------------------------------------------------------------
+	// Helpers
+	//------------------------------------------------------------------------------
+
 	/**
 	 * Checks whether or not a given variable is a function name.
-	 * @param {eslint-scope.Variable} variable A variable to check.
+	 * @param {Variable} variable A variable to check.
 	 * @returns {boolean} `true` if the variable is a function name.
 	 */
 	function isFunctionName(variable) {
@@ -74598,6 +74622,12 @@ function requireNoConsole () {
 
 	const astUtils = requireAstUtils();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Reference} Reference */
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -74649,7 +74679,7 @@ function requireNoConsole () {
 
 			/**
 			 * Checks whether the given reference is 'console' or not.
-			 * @param {eslint-scope.Reference} reference The reference to check.
+			 * @param {Reference} reference The reference to check.
 			 * @returns {boolean} `true` if the reference is 'console'.
 			 */
 			function isConsole(reference) {
@@ -74673,7 +74703,7 @@ function requireNoConsole () {
 			/**
 			 * Checks whether the given reference is a member access which is not
 			 * allowed by options or not.
-			 * @param {eslint-scope.Reference} reference The reference to check.
+			 * @param {Reference} reference The reference to check.
 			 * @returns {boolean} `true` if the reference is a member access which
 			 *      is not allowed by options.
 			 */
@@ -74750,7 +74780,7 @@ function requireNoConsole () {
 
 			/**
 			 * Reports the given reference as a violation.
-			 * @param {eslint-scope.Reference} reference The reference to report.
+			 * @param {Reference} reference The reference to report.
 			 * @returns {void}
 			 */
 			function report(reference) {
@@ -79188,6 +79218,12 @@ function requireNoDupeArgs () {
 
 	const astUtils = requireAstUtils();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Definition} Definition */
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -79220,7 +79256,7 @@ function requireNoDupeArgs () {
 
 			/**
 			 * Checks whether or not a given definition is a parameter's.
-			 * @param {eslint-scope.DefEntry} def A definition to check.
+			 * @param {Definition} def A definition to check.
 			 * @returns {boolean} `true` if the definition is a parameter's.
 			 */
 			function isParameter(def) {
@@ -80337,6 +80373,12 @@ function requireNoElseReturn () {
 	const astUtils = requireAstUtils();
 	const FixTracker = requireFixTracker();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Scope} Scope */
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -80391,7 +80433,7 @@ function requireNoElseReturn () {
 			 * This is not a generic function. In particular, it is assumed that the scope is a function scope or
 			 * a function's inner scope, and that the names can be valid identifiers in the given scope.
 			 * @param {string[]} names Array of variable names.
-			 * @param {eslint-scope.Scope} scope Function scope or a function's inner scope.
+			 * @param {Scope} scope Function scope or a function's inner scope.
 			 * @returns {boolean} True if all names can be safely declared, false otherwise.
 			 */
 			function isSafeToDeclare(names, scope) {
@@ -80483,7 +80525,7 @@ function requireNoElseReturn () {
 			/**
 			 * Checks whether the removal of `else` and its braces is safe from variable name collisions.
 			 * @param {Node} node The 'else' node.
-			 * @param {eslint-scope.Scope} scope The scope in which the node and the whole 'if' statement is.
+			 * @param {Scope} scope The scope in which the node and the whole 'if' statement is.
 			 * @returns {boolean} True if it is safe, false otherwise.
 			 */
 			function isSafeFromNameCollisions(node, scope) {
@@ -81526,6 +81568,12 @@ function requireNoEval () {
 
 	const astUtils = requireAstUtils();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Scope} Scope */
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -81653,7 +81701,7 @@ function requireNoEval () {
 
 			/**
 			 * Reports accesses of `eval` via the global object.
-			 * @param {eslint-scope.Scope} globalScope The global scope.
+			 * @param {Scope} globalScope The global scope.
 			 * @returns {void}
 			 */
 			function reportAccessingEvalViaGlobalObject(globalScope) {
@@ -81686,7 +81734,7 @@ function requireNoEval () {
 
 			/**
 			 * Reports all accesses of `eval` (excludes direct calls to eval).
-			 * @param {eslint-scope.Scope} globalScope The global scope.
+			 * @param {Scope} globalScope The global scope.
 			 * @returns {void}
 			 */
 			function reportAccessingEval(globalScope) {
@@ -88026,6 +88074,12 @@ function requireNoLoopFunc () {
 	if (hasRequiredNoLoopFunc) return noLoopFunc;
 	hasRequiredNoLoopFunc = 1;
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Reference} Reference */
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -88157,7 +88211,7 @@ function requireNoLoopFunc () {
 			 * Checks whether a given reference which refers to an upper scope's variable is
 			 * safe or not.
 			 * @param {ASTNode} loopNode A containing loop node.
-			 * @param {eslint-scope.Reference} reference A reference to check.
+			 * @param {Reference} reference A reference to check.
 			 * @returns {boolean} `true` if the reference is safe or not.
 			 */
 			function isSafe(loopNode, reference) {
@@ -88203,7 +88257,7 @@ function requireNoLoopFunc () {
 				 * It's safe if the reference matches one of the following condition.
 				 * - is readonly.
 				 * - doesn't exist inside a local function and after the border.
-				 * @param {eslint-scope.Reference} upperRef A reference to check.
+				 * @param {Reference} upperRef A reference to check.
 				 * @returns {boolean} `true` if the reference is safe.
 				 */
 				function isSafeReference(upperRef) {
@@ -97837,6 +97891,12 @@ function requireNoShadow () {
 
 	const astUtils = requireAstUtils();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Variable} Variable */
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -98278,7 +98338,7 @@ function requireNoShadow () {
 
 			/**
 			 * Get declared line and column of a variable.
-			 * @param {eslint-scope.Variable} variable The variable to get.
+			 * @param {Variable} variable The variable to get.
 			 * @returns {Object} The declared line and column of the variable.
 			 */
 			function getDeclaredLocation(variable) {
@@ -100101,6 +100161,12 @@ function requireNoUndefined () {
 	if (hasRequiredNoUndefined) return noUndefined;
 	hasRequiredNoUndefined = 1;
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Scope} Scope */
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -100142,7 +100208,7 @@ function requireNoUndefined () {
 			/**
 			 * Checks the given scope for references to `undefined` and reports
 			 * all references found.
-			 * @param {eslint-scope.Scope} scope The scope to check.
+			 * @param {Scope} scope The scope to check.
 			 * @returns {void}
 			 */
 			function checkScope(scope) {
@@ -100732,6 +100798,13 @@ function requireNoUnmodifiedLoopCondition () {
 	const Traverser = requireTraverser(),
 		astUtils = requireAstUtils();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Variable} Variable */
+	/** @typedef {import("eslint-scope").Reference} Reference */
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -100745,7 +100818,7 @@ function requireNoUnmodifiedLoopCondition () {
 
 	/**
 	 * @typedef {Object} LoopConditionInfo
-	 * @property {eslint-scope.Reference} reference - The reference.
+	 * @property {Reference} reference - The reference.
 	 * @property {ASTNode} group - BinaryExpression or ConditionalExpression nodes
 	 *      that the reference is belonging to.
 	 * @property {Function} isInLoop - The predicate which checks a given reference
@@ -100756,7 +100829,7 @@ function requireNoUnmodifiedLoopCondition () {
 
 	/**
 	 * Checks whether or not a given reference is a write reference.
-	 * @param {eslint-scope.Reference} reference A reference to check.
+	 * @param {Reference} reference A reference to check.
 	 * @returns {boolean} `true` if the reference is a write reference.
 	 */
 	function isWriteReference(reference) {
@@ -100793,7 +100866,7 @@ function requireNoUnmodifiedLoopCondition () {
 	/**
 	 * Checks whether or not a given reference is inside of a given node.
 	 * @param {ASTNode} node A node to check.
-	 * @param {eslint-scope.Reference} reference A reference to check.
+	 * @param {Reference} reference A reference to check.
 	 * @returns {boolean} `true` if the reference is inside of the node.
 	 */
 	function isInRange(node, reference) {
@@ -100806,7 +100879,7 @@ function requireNoUnmodifiedLoopCondition () {
 	/**
 	 * Checks whether or not a given reference is inside of a loop node's condition.
 	 * @param {ASTNode} node A node to check.
-	 * @param {eslint-scope.Reference} reference A reference to check.
+	 * @param {Reference} reference A reference to check.
 	 * @returns {boolean} `true` if the reference is inside of the loop node's
 	 *      condition.
 	 */
@@ -100824,7 +100897,7 @@ function requireNoUnmodifiedLoopCondition () {
 	/**
 	 * Gets the function which encloses a given reference.
 	 * This supports only FunctionDeclaration.
-	 * @param {eslint-scope.Reference} reference A reference to get.
+	 * @param {Reference} reference A reference to get.
 	 * @returns {ASTNode|null} The function node or null.
 	 */
 	function getEncloseFunctionDeclaration(reference) {
@@ -100844,7 +100917,7 @@ function requireNoUnmodifiedLoopCondition () {
 	/**
 	 * Updates the "modified" flags of given loop conditions with given modifiers.
 	 * @param {LoopConditionInfo[]} conditions The loop conditions to be updated.
-	 * @param {eslint-scope.Reference[]} modifiers The references to update.
+	 * @param {Reference[]} modifiers The references to update.
 	 * @returns {void}
 	 */
 	function updateModifiedFlag(conditions, modifiers) {
@@ -100978,7 +101051,7 @@ function requireNoUnmodifiedLoopCondition () {
 
 			/**
 			 * Creates the loop condition information from a given reference.
-			 * @param {eslint-scope.Reference} reference A reference to create.
+			 * @param {Reference} reference A reference to create.
 			 * @returns {LoopConditionInfo|null} Created loop condition info, or null.
 			 */
 			function toLoopCondition(reference) {
@@ -101029,7 +101102,7 @@ function requireNoUnmodifiedLoopCondition () {
 			/**
 			 * Finds unmodified references which are inside of a loop condition.
 			 * Then reports the references which are outside of groups.
-			 * @param {eslint-scope.Variable} variable A variable to report.
+			 * @param {Variable} variable A variable to report.
 			 * @returns {void}
 			 */
 			function checkReferences(variable) {
@@ -102989,6 +103062,13 @@ function requireNoUnusedVars () {
 
 	const astUtils = requireAstUtils();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Variable} Variable */
+	/** @typedef {import("eslint-scope").Reference} Reference */
+
 	//------------------------------------------------------------------------------
 	// Typedefs
 	//------------------------------------------------------------------------------
@@ -103502,7 +103582,7 @@ function requireNoUnusedVars () {
 			 * - 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 {Reference} ref A reference to check.
 			 * @param {ASTNode} prevRhsNode The previous RHS node.
 			 * @returns {ASTNode|null} The RHS node or null.
 			 * @private
@@ -103609,7 +103689,7 @@ function requireNoUnusedVars () {
 
 			/**
 			 * Checks whether a given reference is a read to update itself or not.
-			 * @param {eslint-scope.Reference} ref A reference to check.
+			 * @param {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
@@ -103710,7 +103790,7 @@ function requireNoUnusedVars () {
 
 			/**
 			 * Checks whether the given variable is after the last used parameter.
-			 * @param {eslint-scope.Variable} variable The variable to check.
+			 * @param {Variable} variable The variable to check.
 			 * @returns {boolean} `true` if the variable is defined after the last
 			 * used parameter.
 			 */
@@ -104730,6 +104810,13 @@ function requireNoUseBeforeDefine () {
 	if (hasRequiredNoUseBeforeDefine) return noUseBeforeDefine;
 	hasRequiredNoUseBeforeDefine = 1;
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Scope} Scope */
+	/** @typedef {import("eslint-scope").Reference} Reference */
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -104793,7 +104880,7 @@ function requireNoUseBeforeDefine () {
 	/**
 	 * Checks whether a given scope is the scope of a class static initializer.
 	 * Static initializers are static blocks and initializers of static fields.
-	 * @param {eslint-scope.Scope} scope A scope to check.
+	 * @param {Scope} scope A scope to check.
 	 * @returns {boolean} `true` if the scope is a class static initializer scope.
 	 */
 	function isClassStaticInitializerScope(scope) {
@@ -104844,7 +104931,7 @@ function requireNoUseBeforeDefine () {
 	 *           x; // returns `false`
 	 *       }
 	 *   }
-	 * @param {eslint-scope.Reference} reference A reference to check.
+	 * @param {Reference} reference A reference to check.
 	 * @returns {boolean} `true` if the reference is from a separate execution context.
 	 */
 	function isFromSeparateExecutionContext(reference) {
@@ -105058,7 +105145,7 @@ function requireNoUseBeforeDefine () {
 			 * - referring to a variable that is defined, but not in the given source code
 			 *   (e.g., global environment variable or `arguments` in functions).
 			 * - allowed by options.
-			 * @param {eslint-scope.Reference} reference The reference
+			 * @param {Reference} reference The reference
 			 * @returns {boolean} `true` if the reference should be checked
 			 */
 			function shouldCheck(reference) {
@@ -105137,7 +105224,7 @@ function requireNoUseBeforeDefine () {
 
 			/**
 			 * Finds and validates all references in a given scope and its child scopes.
-			 * @param {eslint-scope.Scope} scope The scope object.
+			 * @param {Scope} scope The scope object.
 			 * @returns {void}
 			 */
 			function checkReferencesInScope(scope) {
@@ -107942,13 +108029,21 @@ function requireNoVar () {
 
 	const astUtils = requireAstUtils();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Scope} Scope */
+	/** @typedef {import("eslint-scope").Variable} Variable */
+	/** @typedef {import("eslint-scope").Reference} Reference */
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
 
 	/**
 	 * Check whether a given variable is a global variable or not.
-	 * @param {eslint-scope.Variable} variable The variable to check.
+	 * @param {Variable} variable The variable to check.
 	 * @returns {boolean} `true` if the variable is a global variable.
 	 */
 	function isGlobal(variable) {
@@ -107958,8 +108053,8 @@ function requireNoVar () {
 	/**
 	 * Finds the nearest function scope or global scope walking up the scope
 	 * hierarchy.
-	 * @param {eslint-scope.Scope} scope The scope to traverse.
-	 * @returns {eslint-scope.Scope} a function scope or global scope containing the given
+	 * @param {Scope} scope The scope to traverse.
+	 * @returns {Scope} a function scope or global scope containing the given
 	 *      scope.
 	 */
 	function getEnclosingFunctionScope(scope) {
@@ -107974,7 +108069,7 @@ function requireNoVar () {
 	/**
 	 * Checks whether the given variable has any references from a more specific
 	 * function expression (i.e. a closure).
-	 * @param {eslint-scope.Variable} variable A variable to check.
+	 * @param {Variable} variable A variable to check.
 	 * @returns {boolean} `true` if the variable is used from a closure.
 	 */
 	function isReferencedInClosure(variable) {
@@ -108038,7 +108133,7 @@ function requireNoVar () {
 
 	/**
 	 * Checks whether a given variable is redeclared or not.
-	 * @param {eslint-scope.Variable} variable A variable to check.
+	 * @param {Variable} variable A variable to check.
 	 * @returns {boolean} `true` if the variable is redeclared.
 	 */
 	function isRedeclared(variable) {
@@ -108054,7 +108149,7 @@ function requireNoVar () {
 	function isUsedFromOutsideOf(scopeNode) {
 		/**
 		 * Checks whether a given reference is inside of the specified scope or not.
-		 * @param {eslint-scope.Reference} reference A reference to check.
+		 * @param {Reference} reference A reference to check.
 		 * @returns {boolean} `true` if the reference is inside of the specified
 		 *      scope.
 		 */
@@ -108115,7 +108210,7 @@ function requireNoVar () {
 	/**
 	 * Checks whether a given variable has name that is allowed for 'var' declarations,
 	 * but disallowed for `let` declarations.
-	 * @param {eslint-scope.Variable} variable The variable to check.
+	 * @param {Variable} variable The variable to check.
 	 * @returns {boolean} `true` if the variable has a disallowed name.
 	 */
 	function hasNameDisallowedForLetDeclarations(variable) {
@@ -113018,13 +113113,20 @@ function requirePreferArrowCallback () {
 
 	const astUtils = requireAstUtils();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Scope} Scope */
+	/** @typedef {import("eslint-scope").Variable} Variable */
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
 
 	/**
 	 * Checks whether or not a given variable is a function name.
-	 * @param {eslint-scope.Variable} variable A variable to check.
+	 * @param {Variable} variable A variable to check.
 	 * @returns {boolean} `true` if the variable is a function name.
 	 */
 	function isFunctionName(variable) {
@@ -113044,8 +113146,8 @@ function requirePreferArrowCallback () {
 
 	/**
 	 * Gets the variable object of `arguments` which is defined implicitly.
-	 * @param {eslint-scope.Scope} scope A scope to get.
-	 * @returns {eslint-scope.Variable} The found variable object.
+	 * @param {Scope} scope A scope to get.
+	 * @returns {Variable} The found variable object.
 	 */
 	function getVariableOfArguments(scope) {
 		const variables = scope.variables;
@@ -113468,6 +113570,14 @@ function requirePreferConst () {
 	const FixTracker = requireFixTracker();
 	const astUtils = requireAstUtils();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Scope} Scope */
+	/** @typedef {import("eslint-scope").Variable} Variable */
+	/** @typedef {import("eslint-scope").Reference} Reference */
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -113512,7 +113622,7 @@ function requirePreferConst () {
 	 * Checks if an property or element is from outer scope or function parameters
 	 * in destructing pattern.
 	 * @param {string} name A variable name to be checked.
-	 * @param {eslint-scope.Scope} initScope A scope to start find.
+	 * @param {Scope} initScope A scope to start find.
 	 * @returns {boolean} Indicates if the variable is from outer scope or function parameters.
 	 */
 	function isOuterVariableInDestructing(name, initScope) {
@@ -113538,7 +113648,7 @@ function requirePreferConst () {
 	 * belongs to.
 	 * This is used to detect a mix of reassigned and never reassigned in a
 	 * destructuring.
-	 * @param {eslint-scope.Reference} reference A reference to get.
+	 * @param {Reference} reference A reference to get.
 	 * @returns {ASTNode|null} A VariableDeclarator/AssignmentExpression node or
 	 *      null.
 	 */
@@ -113624,7 +113734,7 @@ function requirePreferConst () {
 	 *   `/*exported foo` directive comment makes such variables. This rule does not
 	 *   warn such variables because this rule cannot distinguish whether the
 	 *   exported variables are reassigned or not.
-	 * @param {eslint-scope.Variable} variable A variable to get.
+	 * @param {Variable} variable A variable to get.
 	 * @param {boolean} ignoreReadBeforeAssign
 	 *      The value of `ignoreReadBeforeAssign` option.
 	 * @returns {ASTNode|null}
@@ -113724,7 +113834,7 @@ function requirePreferConst () {
 	 * reference of given variables belongs to.
 	 * This is used to detect a mix of reassigned and never reassigned in a
 	 * destructuring.
-	 * @param {eslint-scope.Variable[]} variables Variables to group by destructuring.
+	 * @param {Variable[]} variables Variables to group by destructuring.
 	 * @param {boolean} ignoreReadBeforeAssign
 	 *      The value of `ignoreReadBeforeAssign` option.
 	 * @returns {Map<ASTNode, ASTNode[]>} Grouped identifier nodes.
@@ -113845,7 +113955,7 @@ function requirePreferConst () {
 			 * nullable. In simple declaration or assignment cases, the length of
 			 * the array is 1. In destructuring cases, the length of the array can
 			 * be 2 or more.
-			 * @param {(eslint-scope.Reference|null)[]} nodes
+			 * @param {(Reference|null)[]} nodes
 			 *      References which are grouped by destructuring to report.
 			 * @returns {void}
 			 */
@@ -116387,14 +116497,22 @@ function requirePreferRestParams () {
 	if (hasRequiredPreferRestParams) return preferRestParams;
 	hasRequiredPreferRestParams = 1;
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Scope} Scope */
+	/** @typedef {import("eslint-scope").Variable} Variable */
+	/** @typedef {import("eslint-scope").Reference} Reference */
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
 
 	/**
 	 * Gets the variable object of `arguments` which is defined implicitly.
-	 * @param {eslint-scope.Scope} scope A scope to get.
-	 * @returns {eslint-scope.Variable} The found variable object.
+	 * @param {Scope} scope A scope to get.
+	 * @returns {Variable} The found variable object.
 	 */
 	function getVariableOfArguments(scope) {
 		const variables = scope.variables;
@@ -116422,7 +116540,7 @@ function requirePreferRestParams () {
 	 * - arguments[i]      .... true    // computed member access
 	 * - arguments[0]      .... true    // computed member access
 	 * - arguments.length  .... false   // normal member access
-	 * @param {eslint-scope.Reference} reference The reference to check.
+	 * @param {Reference} reference The reference to check.
 	 * @returns {boolean} `true` if the reference is not normal member access.
 	 */
 	function isNotNormalMemberAccess(reference) {
@@ -116463,7 +116581,7 @@ function requirePreferRestParams () {
 
 			/**
 			 * Reports a given reference.
-			 * @param {eslint-scope.Reference} reference A reference to report.
+			 * @param {Reference} reference A reference to report.
 			 * @returns {void}
 			 */
 			function report(reference) {
@@ -118343,6 +118461,12 @@ function requireRadix () {
 
 	const astUtils = requireAstUtils();
 
+	//------------------------------------------------------------------------------
+	// Types
+	//------------------------------------------------------------------------------
+
+	/** @typedef {import("eslint-scope").Variable} Variable */
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -118353,7 +118477,7 @@ function requireRadix () {
 
 	/**
 	 * Checks whether a given variable is shadowed or not.
-	 * @param {eslint-scope.Variable} variable A variable to check.
+	 * @param {Variable} variable A variable to check.
 	 * @returns {boolean} `true` if the variable is shadowed.
 	 */
 	function isShadowed(variable) {