oxlint-plugin-eslint 1.52.0

package/rules/prefer-arrow-callback.cjs

@@ -0,0 +1,185 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/prefer-arrow-callback.js
+/**
+* @fileoverview A rule to suggest using arrow functions as callbacks.
+* @author Toru Nagashima
+*/
+var require_prefer_arrow_callback = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether or not a given variable is a function name.
+	* @param {eslint-scope.Variable} variable A variable to check.
+	* @returns {boolean} `true` if the variable is a function name.
+	*/
+	function isFunctionName(variable) {
+		return variable && variable.defs[0].type === "FunctionName";
+	}
+	/**
+	* Checks whether or not a given MetaProperty node equals to a given value.
+	* @param {ASTNode} node A MetaProperty node to check.
+	* @param {string} metaName The name of `MetaProperty.meta`.
+	* @param {string} propertyName The name of `MetaProperty.property`.
+	* @returns {boolean} `true` if the node is the specific value.
+	*/
+	function checkMetaProperty(node, metaName, propertyName) {
+		return node.meta.name === metaName && node.property.name === propertyName;
+	}
+	/**
+	* 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.
+	*/
+	function getVariableOfArguments(scope) {
+		let variables = scope.variables;
+		for (let i = 0; i < variables.length; ++i) {
+			let variable = variables[i];
+			if (variable.name === "arguments") return variable.identifiers.length === 0 ? variable : null;
+		}
+		/* c8 ignore next */
+		return null;
+	}
+	/**
+	* Checks whether or not a given node is a callback.
+	* @param {ASTNode} node A node to check.
+	* @throws {Error} (Unreachable.)
+	* @returns {Object}
+	*   {boolean} retv.isCallback - `true` if the node is a callback.
+	*   {boolean} retv.isLexicalThis - `true` if the node is with `.bind(this)`.
+	*/
+	function getCallbackInfo(node) {
+		let retv = {
+			isCallback: !1,
+			isLexicalThis: !1
+		}, currentNode = node, parent = node.parent, bound = !1;
+		for (; currentNode;) {
+			switch (parent.type) {
+				case "LogicalExpression":
+				case "ChainExpression":
+				case "ConditionalExpression": break;
+				case "MemberExpression":
+					if (parent.object === currentNode && !parent.property.computed && parent.property.type === "Identifier" && parent.property.name === "bind") {
+						let maybeCallee = parent.parent.type === "ChainExpression" ? parent.parent : parent;
+						if (astUtils.isCallee(maybeCallee)) bound || (bound = !0, retv.isLexicalThis = maybeCallee.parent.arguments.length === 1 && maybeCallee.parent.arguments[0].type === "ThisExpression"), parent = maybeCallee.parent;
+						else return retv;
+					} else return retv;
+					break;
+				case "CallExpression":
+				case "NewExpression": return parent.callee !== currentNode && (retv.isCallback = !0), retv;
+				default: return retv;
+			}
+			currentNode = parent, parent = parent.parent;
+		}
+		/* c8 ignore next */
+		throw Error("unreachable");
+	}
+	/**
+	* Checks whether a simple list of parameters contains any duplicates. This does not handle complex
+	* parameter lists (e.g. with destructuring), since complex parameter lists are a SyntaxError with duplicate
+	* parameter names anyway. Instead, it always returns `false` for complex parameter lists.
+	* @param {ASTNode[]} paramsList The list of parameters for a function
+	* @returns {boolean} `true` if the list of parameters contains any duplicates
+	*/
+	function hasDuplicateParams(paramsList) {
+		return paramsList.every((param) => param.type === "Identifier") && paramsList.length !== new Set(paramsList.map((param) => param.name)).size;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			defaultOptions: [{
+				allowNamedFunctions: !1,
+				allowUnboundThis: !0
+			}],
+			docs: {
+				description: "Require using arrow functions for callbacks",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/prefer-arrow-callback"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					allowNamedFunctions: { type: "boolean" },
+					allowUnboundThis: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			fixable: "code",
+			messages: { preferArrowCallback: "Unexpected function expression." }
+		},
+		create(context) {
+			let [{ allowNamedFunctions, allowUnboundThis }] = context.options, sourceCode = context.sourceCode, stack = [];
+			/**
+			* Pushes new function scope with all `false` flags.
+			* @returns {void}
+			*/
+			function enterScope() {
+				stack.push({
+					this: !1,
+					super: !1,
+					meta: !1
+				});
+			}
+			/**
+			* Pops a function scope from the stack.
+			* @returns {{this: boolean, super: boolean, meta: boolean}} The information of the last scope.
+			*/
+			function exitScope() {
+				return stack.pop();
+			}
+			return {
+				Program() {
+					stack = [];
+				},
+				ThisExpression() {
+					let info = stack.at(-1);
+					info && (info.this = !0);
+				},
+				Super() {
+					let info = stack.at(-1);
+					info && (info.super = !0);
+				},
+				MetaProperty(node) {
+					let info = stack.at(-1);
+					info && checkMetaProperty(node, "new", "target") && (info.meta = !0);
+				},
+				FunctionDeclaration: enterScope,
+				"FunctionDeclaration:exit": exitScope,
+				FunctionExpression: enterScope,
+				"FunctionExpression:exit"(node) {
+					let scopeInfo = exitScope();
+					if (allowNamedFunctions && node.id && node.id.name || node.generator) return;
+					let nameVar = sourceCode.getDeclaredVariables(node)[0];
+					if (isFunctionName(nameVar) && nameVar.references.length > 0) return;
+					let variable = getVariableOfArguments(sourceCode.getScope(node));
+					if (variable && variable.references.length > 0) return;
+					let callbackInfo = getCallbackInfo(node);
+					callbackInfo.isCallback && (!allowUnboundThis || !scopeInfo.this || callbackInfo.isLexicalThis) && !scopeInfo.super && !scopeInfo.meta && context.report({
+						node,
+						messageId: "preferArrowCallback",
+						*fix(fixer) {
+							if (!callbackInfo.isLexicalThis && scopeInfo.this || hasDuplicateParams(node.params) || node.params.length && node.params[0].name === "this") return;
+							if (callbackInfo.isLexicalThis) {
+								let memberNode = node.parent;
+								if (memberNode.type !== "MemberExpression") return;
+								let callNode = memberNode.parent, firstTokenToRemove = sourceCode.getTokenAfter(memberNode.object, astUtils.isNotClosingParenToken), lastTokenToRemove = sourceCode.getLastToken(callNode);
+								if (astUtils.isParenthesised(sourceCode, memberNode) || sourceCode.commentsExistBetween(firstTokenToRemove, lastTokenToRemove)) return;
+								yield fixer.removeRange([firstTokenToRemove.range[0], lastTokenToRemove.range[1]]);
+							}
+							let functionToken = sourceCode.getFirstToken(node, node.async ? 1 : 0), leftParenToken = sourceCode.getTokenAfter(functionToken, astUtils.isOpeningParenToken), tokenBeforeBody = sourceCode.getTokenBefore(node.body);
+							sourceCode.commentsExistBetween(functionToken, leftParenToken) ? (yield fixer.remove(functionToken), node.id && (yield fixer.remove(node.id))) : yield fixer.removeRange([functionToken.range[0], leftParenToken.range[0]]), yield fixer.insertTextAfter(tokenBeforeBody, " =>");
+							let replacedNode = callbackInfo.isLexicalThis ? node.parent.parent : node;
+							replacedNode.type === "ChainExpression" && (replacedNode = replacedNode.parent), replacedNode.parent.type !== "CallExpression" && replacedNode.parent.type !== "ConditionalExpression" && !astUtils.isParenthesised(sourceCode, replacedNode) && !astUtils.isParenthesised(sourceCode, node) && (yield fixer.insertTextBefore(replacedNode, "("), yield fixer.insertTextAfter(replacedNode, ")"));
+						}
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-arrow-callback.cjs
+module.exports = require_prefer_arrow_callback().create;
+//#endregion

package/rules/prefer-const.cjs

@@ -0,0 +1,240 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_fix_tracker$1 = require("../common/fix-tracker.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/prefer-const.js
+/**
+* @fileoverview A rule to suggest using of const declaration for variables that are never reassigned after declared.
+* @author Toru Nagashima
+*/
+var require_prefer_const = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let FixTracker = require_fix_tracker$1.t(), astUtils = require_ast_utils$1.t(), PATTERN_TYPE = /^(?:.+?Pattern|RestElement|SpreadProperty|ExperimentalRestProperty|Property)$/u, DECLARATION_HOST_TYPE = /^(?:Program|BlockStatement|StaticBlock|SwitchCase)$/u, DESTRUCTURING_HOST_TYPE = /^(?:VariableDeclarator|AssignmentExpression)$/u;
+	/**
+	* Checks whether a given node is located at `ForStatement.init` or not.
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if the node is located at `ForStatement.init`.
+	*/
+	function isInitOfForStatement(node) {
+		return node.parent.type === "ForStatement" && node.parent.init === node;
+	}
+	/**
+	* Checks whether a given Identifier node becomes a VariableDeclaration or not.
+	* @param {ASTNode} identifier An Identifier node to check.
+	* @returns {boolean} `true` if the node can become a VariableDeclaration.
+	*/
+	function canBecomeVariableDeclaration(identifier) {
+		let node = identifier.parent;
+		for (; PATTERN_TYPE.test(node.type);) node = node.parent;
+		return node.type === "VariableDeclarator" || node.type === "AssignmentExpression" && node.parent.type === "ExpressionStatement" && DECLARATION_HOST_TYPE.test(node.parent.parent.type);
+	}
+	/**
+	* 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.
+	* @returns {boolean} Indicates if the variable is from outer scope or function parameters.
+	*/
+	function isOuterVariableInDestructing(name, initScope) {
+		if (initScope.through.some((ref) => ref.resolved && ref.resolved.name === name)) return !0;
+		let variable = astUtils.getVariableByName(initScope, name);
+		return variable === null ? !1 : variable.defs.some((def) => def.type === "Parameter");
+	}
+	/**
+	* Gets the VariableDeclarator/AssignmentExpression node that a given reference
+	* 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.
+	* @returns {ASTNode|null} A VariableDeclarator/AssignmentExpression node or
+	*      null.
+	*/
+	function getDestructuringHost(reference) {
+		if (!reference.isWrite()) return null;
+		let node = reference.identifier.parent;
+		for (; PATTERN_TYPE.test(node.type);) node = node.parent;
+		return DESTRUCTURING_HOST_TYPE.test(node.type) ? node : null;
+	}
+	/**
+	* Determines if a destructuring assignment node contains
+	* any MemberExpression nodes. This is used to determine if a
+	* variable that is only written once using destructuring can be
+	* safely converted into a const declaration.
+	* @param {ASTNode} node The ObjectPattern or ArrayPattern node to check.
+	* @returns {boolean} True if the destructuring pattern contains
+	*      a MemberExpression, false if not.
+	*/
+	function hasMemberExpressionAssignment(node) {
+		switch (node.type) {
+			case "ObjectPattern": return node.properties.some((prop) => prop ? hasMemberExpressionAssignment(prop.argument || prop.value) : !1);
+			case "ArrayPattern": return node.elements.some((element) => element ? hasMemberExpressionAssignment(element) : !1);
+			case "AssignmentPattern": return hasMemberExpressionAssignment(node.left);
+			case "MemberExpression": return !0;
+		}
+		return !1;
+	}
+	/**
+	* Gets an identifier node of a given variable.
+	*
+	* If the initialization exists or one or more reading references exist before
+	* the first assignment, the identifier node is the node of the declaration.
+	* Otherwise, the identifier node is the node of the first assignment.
+	*
+	* If the variable should not change to const, this function returns null.
+	* - If the variable is reassigned.
+	* - If the variable is never initialized nor assigned.
+	* - If the variable is initialized in a different scope from the declaration.
+	* - If the unique assignment of the variable cannot change to a declaration.
+	*   e.g. `if (a) b = 1` / `return (b = 1)`
+	* - If the variable is declared in the global scope and `eslintUsed` is `true`.
+	*   `/*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 {boolean} ignoreReadBeforeAssign
+	*      The value of `ignoreReadBeforeAssign` option.
+	* @returns {ASTNode|null}
+	*      An Identifier node if the variable should change to const.
+	*      Otherwise, null.
+	*/
+	function getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign) {
+		if (variable.eslintUsed && variable.scope.type === "global") return null;
+		let writer = null, isReadBeforeInit = !1, references = variable.references;
+		for (let i = 0; i < references.length; ++i) {
+			let reference = references[i];
+			if (reference.isWrite()) {
+				if (writer !== null && writer.identifier !== reference.identifier) return null;
+				let destructuringHost = getDestructuringHost(reference);
+				if (destructuringHost !== null && destructuringHost.left !== void 0) {
+					let leftNode = destructuringHost.left, hasOuterVariables = !1, hasNonIdentifiers = !1;
+					if (leftNode.type === "ObjectPattern" ? (hasOuterVariables = leftNode.properties.filter((prop) => prop.value).map((prop) => prop.value.name).some((name) => isOuterVariableInDestructing(name, variable.scope)), hasNonIdentifiers = hasMemberExpressionAssignment(leftNode)) : leftNode.type === "ArrayPattern" && (hasOuterVariables = leftNode.elements.map((element) => element && element.name).some((name) => isOuterVariableInDestructing(name, variable.scope)), hasNonIdentifiers = hasMemberExpressionAssignment(leftNode)), hasOuterVariables || hasNonIdentifiers) return null;
+				}
+				writer = reference;
+			} else if (reference.isRead() && writer === null) {
+				if (ignoreReadBeforeAssign) return null;
+				isReadBeforeInit = !0;
+			}
+		}
+		return writer !== null && writer.from === variable.scope && canBecomeVariableDeclaration(writer.identifier) ? isReadBeforeInit ? variable.defs[0].name : writer.identifier : null;
+	}
+	/**
+	* Groups by the VariableDeclarator/AssignmentExpression node that each
+	* 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 {boolean} ignoreReadBeforeAssign
+	*      The value of `ignoreReadBeforeAssign` option.
+	* @returns {Map<ASTNode, ASTNode[]>} Grouped identifier nodes.
+	*/
+	function groupByDestructuring(variables, ignoreReadBeforeAssign) {
+		let identifierMap = /* @__PURE__ */ new Map();
+		for (let i = 0; i < variables.length; ++i) {
+			let variable = variables[i], references = variable.references, identifier = getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign), prevId = null;
+			for (let j = 0; j < references.length; ++j) {
+				let reference = references[j], id = reference.identifier;
+				if (id === prevId) continue;
+				prevId = id;
+				let group = getDestructuringHost(reference);
+				group && (identifierMap.has(group) ? identifierMap.get(group).push(identifier) : identifierMap.set(group, [identifier]));
+			}
+		}
+		return identifierMap;
+	}
+	/**
+	* Finds the nearest parent of node with a given type.
+	* @param {ASTNode} node The node to search from.
+	* @param {string} type The type field of the parent node.
+	* @param {Function} shouldStop A predicate that returns true if the traversal should stop, and false otherwise.
+	* @returns {ASTNode} The closest ancestor with the specified type; null if no such ancestor exists.
+	*/
+	function findUp(node, type, shouldStop) {
+		return !node || shouldStop(node) ? null : node.type === type ? node : findUp(node.parent, type, shouldStop);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{
+				destructuring: "any",
+				ignoreReadBeforeAssign: !1
+			}],
+			docs: {
+				description: "Require `const` declarations for variables that are never reassigned after declared",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/prefer-const"
+			},
+			fixable: "code",
+			schema: [{
+				type: "object",
+				properties: {
+					destructuring: { enum: ["any", "all"] },
+					ignoreReadBeforeAssign: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: { useConst: "'{{name}}' is never reassigned. Use 'const' instead." }
+		},
+		create(context) {
+			let [{ destructuring, ignoreReadBeforeAssign }] = context.options, shouldMatchAnyDestructuredVariable = destructuring !== "all", sourceCode = context.sourceCode, variables = [], reportCount = 0, checkedId = null, checkedName = "";
+			/**
+			* Reports given identifier nodes if all of the nodes should be declared
+			* as const.
+			*
+			* The argument 'nodes' is an array of Identifier nodes.
+			* This node is the result of 'getIdentifierIfShouldBeConst()', so it's
+			* 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
+			*      References which are grouped by destructuring to report.
+			* @returns {void}
+			*/
+			function checkGroup(nodes) {
+				let nodesToReport = nodes.filter(Boolean);
+				if (nodes.length && (shouldMatchAnyDestructuredVariable || nodesToReport.length === nodes.length)) {
+					let varDeclParent = findUp(nodes[0], "VariableDeclaration", (parentNode) => parentNode.type.endsWith("Statement")), isVarDecParentNull = varDeclParent === null;
+					if (!isVarDecParentNull && varDeclParent.declarations.length > 0) {
+						let firstDeclaration = varDeclParent.declarations[0];
+						if (firstDeclaration.init) {
+							let firstDecParent = firstDeclaration.init.parent;
+							firstDecParent.type === "VariableDeclarator" && (firstDecParent.id.name !== checkedName && (checkedName = firstDecParent.id.name, reportCount = 0), firstDecParent.id.type === "ObjectPattern" && firstDecParent.init.name !== checkedName && (checkedName = firstDecParent.init.name, reportCount = 0), firstDecParent.id !== checkedId && (checkedId = firstDecParent.id, reportCount = 0));
+						}
+					}
+					let shouldFix = varDeclParent && (varDeclParent.parent.type === "ForInStatement" || varDeclParent.parent.type === "ForOfStatement" || varDeclParent.declarations.every((declaration) => declaration.init)) && nodesToReport.length === nodes.length;
+					if (!isVarDecParentNull && varDeclParent.declarations && varDeclParent.declarations.length !== 1 && varDeclParent && varDeclParent.declarations && varDeclParent.declarations.length >= 1) {
+						reportCount += nodesToReport.length;
+						let totalDeclarationsCount = 0;
+						varDeclParent.declarations.forEach((declaration) => {
+							declaration.id.type === "ObjectPattern" ? totalDeclarationsCount += declaration.id.properties.length : declaration.id.type === "ArrayPattern" ? totalDeclarationsCount += declaration.id.elements.length : totalDeclarationsCount += 1;
+						}), shouldFix &&= reportCount === totalDeclarationsCount;
+					}
+					nodesToReport.forEach((node) => {
+						context.report({
+							node,
+							messageId: "useConst",
+							data: node,
+							fix: shouldFix ? (fixer) => {
+								let letKeywordToken = sourceCode.getFirstToken(varDeclParent, (t) => t.value === varDeclParent.kind);
+								/**
+								* Extend the replacement range to the whole declaration,
+								* in order to prevent other fixes in the same pass
+								* https://github.com/eslint/eslint/issues/13899
+								*/
+								return new FixTracker(fixer, sourceCode).retainRange(varDeclParent.range).replaceTextRange(letKeywordToken.range, "const");
+							} : null
+						});
+					});
+				}
+			}
+			return {
+				"Program:exit"() {
+					groupByDestructuring(variables, ignoreReadBeforeAssign).forEach(checkGroup);
+				},
+				VariableDeclaration(node) {
+					node.kind === "let" && !isInitOfForStatement(node) && variables.push(...sourceCode.getDeclaredVariables(node));
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-const.cjs
+module.exports = require_prefer_const().create;
+//#endregion

package/rules/prefer-destructuring.cjs

@@ -0,0 +1,188 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/prefer-destructuring.js
+/**
+* @fileoverview Prefer destructuring from arrays and objects
+* @author Alex LaFroscia
+*/
+var require_prefer_destructuring = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), PRECEDENCE_OF_ASSIGNMENT_EXPR = astUtils.getPrecedence({ type: "AssignmentExpression" });
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require destructuring from arrays and/or objects",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/prefer-destructuring"
+			},
+			fixable: "code",
+			schema: [{ oneOf: [{
+				type: "object",
+				properties: {
+					VariableDeclarator: {
+						type: "object",
+						properties: {
+							array: { type: "boolean" },
+							object: { type: "boolean" }
+						},
+						additionalProperties: !1
+					},
+					AssignmentExpression: {
+						type: "object",
+						properties: {
+							array: { type: "boolean" },
+							object: { type: "boolean" }
+						},
+						additionalProperties: !1
+					}
+				},
+				additionalProperties: !1
+			}, {
+				type: "object",
+				properties: {
+					array: { type: "boolean" },
+					object: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}] }, {
+				type: "object",
+				properties: { enforceForRenamedProperties: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: { preferDestructuring: "Use {{type}} destructuring." }
+		},
+		create(context) {
+			let enabledTypes = context.options[0], enforceForRenamedProperties = context.options[1] && context.options[1].enforceForRenamedProperties, normalizedOptions = {
+				VariableDeclarator: {
+					array: !0,
+					object: !0
+				},
+				AssignmentExpression: {
+					array: !0,
+					object: !0
+				}
+			};
+			enabledTypes && (normalizedOptions = enabledTypes.array !== void 0 || enabledTypes.object !== void 0 ? {
+				VariableDeclarator: enabledTypes,
+				AssignmentExpression: enabledTypes
+			} : enabledTypes);
+			/**
+			* Checks if destructuring type should be checked.
+			* @param {string} nodeType "AssignmentExpression" or "VariableDeclarator"
+			* @param {string} destructuringType "array" or "object"
+			* @returns {boolean} `true` if the destructuring type should be checked for the given node
+			*/
+			function shouldCheck(nodeType, destructuringType) {
+				return normalizedOptions && normalizedOptions[nodeType] && normalizedOptions[nodeType][destructuringType];
+			}
+			/**
+			* Determines if the given node is accessing an array index
+			*
+			* This is used to differentiate array index access from object property
+			* access.
+			* @param {ASTNode} node the node to evaluate
+			* @returns {boolean} whether or not the node is an integer
+			*/
+			function isArrayIndexAccess(node) {
+				return Number.isInteger(node.property.value);
+			}
+			/**
+			* Report that the given node should use destructuring
+			* @param {ASTNode} reportNode the node to report
+			* @param {string} type the type of destructuring that should have been done
+			* @param {Function|null} fix the fix function or null to pass to context.report
+			* @returns {void}
+			*/
+			function report(reportNode, type, fix) {
+				context.report({
+					node: reportNode,
+					messageId: "preferDestructuring",
+					data: { type },
+					fix
+				});
+			}
+			/**
+			* Determines if a node should be fixed into object destructuring
+			*
+			* The fixer only fixes the simplest case of object destructuring,
+			* like: `let x = a.x`;
+			*
+			* Assignment expression is not fixed.
+			* Array destructuring is not fixed.
+			* Renamed property is not fixed.
+			* @param {ASTNode} node the node to evaluate
+			* @returns {boolean} whether or not the node should be fixed
+			*/
+			function shouldFix(node) {
+				return node.type === "VariableDeclarator" && node.id.type === "Identifier" && node.init.type === "MemberExpression" && !node.init.computed && node.init.property.type === "Identifier" && node.id.name === node.init.property.name;
+			}
+			/**
+			* Fix a node into object destructuring.
+			* This function only handles the simplest case of object destructuring,
+			* see {@link shouldFix}.
+			* @param {SourceCodeFixer} fixer the fixer object
+			* @param {ASTNode} node the node to be fixed.
+			* @returns {Object} a fix for the node
+			*/
+			function fixIntoObjectDestructuring(fixer, node) {
+				let rightNode = node.init, sourceCode = context.sourceCode;
+				if (sourceCode.getCommentsInside(node).length > sourceCode.getCommentsInside(rightNode.object).length) return null;
+				let objectText = sourceCode.getText(rightNode.object);
+				return astUtils.getPrecedence(rightNode.object) < PRECEDENCE_OF_ASSIGNMENT_EXPR && (objectText = `(${objectText})`), fixer.replaceText(node, `{${rightNode.property.name}} = ${objectText}`);
+			}
+			/**
+			* Check that the `prefer-destructuring` rules are followed based on the
+			* given left- and right-hand side of the assignment.
+			*
+			* Pulled out into a separate method so that VariableDeclarators and
+			* AssignmentExpressions can share the same verification logic.
+			* @param {ASTNode} leftNode the left-hand side of the assignment
+			* @param {ASTNode} rightNode the right-hand side of the assignment
+			* @param {ASTNode} reportNode the node to report the error on
+			* @returns {void}
+			*/
+			function performCheck(leftNode, rightNode, reportNode) {
+				if (rightNode.type !== "MemberExpression" || rightNode.object.type === "Super" || rightNode.property.type === "PrivateIdentifier") return;
+				if (isArrayIndexAccess(rightNode)) {
+					shouldCheck(reportNode.type, "array") && report(reportNode, "array", null);
+					return;
+				}
+				let fix = shouldFix(reportNode) ? (fixer) => fixIntoObjectDestructuring(fixer, reportNode) : null;
+				if (shouldCheck(reportNode.type, "object") && enforceForRenamedProperties) {
+					report(reportNode, "object", fix);
+					return;
+				}
+				if (shouldCheck(reportNode.type, "object")) {
+					let property = rightNode.property;
+					(property.type === "Literal" && leftNode.name === property.value || property.type === "Identifier" && leftNode.name === property.name && !rightNode.computed) && report(reportNode, "object", fix);
+				}
+			}
+			/**
+			* Check if a given variable declarator is coming from an property access
+			* that should be using destructuring instead
+			* @param {ASTNode} node the variable declarator to check
+			* @returns {void}
+			*/
+			function checkVariableDeclarator(node) {
+				node.init && (node.parent.kind === "using" || node.parent.kind === "await using" || node.init.type === "MemberExpression" && performCheck(node.id, node.init, node));
+			}
+			/**
+			* Run the `prefer-destructuring` check on an AssignmentExpression
+			* @param {ASTNode} node the AssignmentExpression node
+			* @returns {void}
+			*/
+			function checkAssignmentExpression(node) {
+				node.operator === "=" && performCheck(node.left, node.right, node);
+			}
+			return {
+				VariableDeclarator: checkVariableDeclarator,
+				AssignmentExpression: checkAssignmentExpression
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-destructuring.cjs
+module.exports = require_prefer_destructuring().create;
+//#endregion