oxlint-plugin-eslint 1.52.0

package/rules/prefer-exponentiation-operator.cjs

@@ -0,0 +1,100 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_eslint_utils$1 = require("../common/eslint-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/prefer-exponentiation-operator.js
+/**
+* @fileoverview Rule to disallow Math.pow in favor of the ** operator
+* @author Milos Djermanovic
+*/
+var require_prefer_exponentiation_operator = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), { CALL, ReferenceTracker } = require_eslint_utils$1.t(), PRECEDENCE_OF_EXPONENTIATION_EXPR = astUtils.getPrecedence({
+		type: "BinaryExpression",
+		operator: "**"
+	});
+	/**
+	* Determines whether the given node needs parens if used as the base in an exponentiation binary expression.
+	* @param {ASTNode} base The node to check.
+	* @returns {boolean} `true` if the node needs to be parenthesised.
+	*/
+	function doesBaseNeedParens(base) {
+		return astUtils.getPrecedence(base) <= PRECEDENCE_OF_EXPONENTIATION_EXPR || base.type === "AwaitExpression" || base.type === "UnaryExpression";
+	}
+	/**
+	* Determines whether the given node needs parens if used as the exponent in an exponentiation binary expression.
+	* @param {ASTNode} exponent The node to check.
+	* @returns {boolean} `true` if the node needs to be parenthesised.
+	*/
+	function doesExponentNeedParens(exponent) {
+		return astUtils.getPrecedence(exponent) < PRECEDENCE_OF_EXPONENTIATION_EXPR;
+	}
+	/**
+	* Determines whether an exponentiation binary expression at the place of the given node would need parens.
+	* @param {ASTNode} node A node that would be replaced by an exponentiation binary expression.
+	* @param {SourceCode} sourceCode A SourceCode object.
+	* @returns {boolean} `true` if the expression needs to be parenthesised.
+	*/
+	function doesExponentiationExpressionNeedParens(node, sourceCode) {
+		let parent = node.parent.type === "ChainExpression" ? node.parent.parent : node.parent, parentPrecedence = astUtils.getPrecedence(parent);
+		return (parent.type === "ClassDeclaration" || parent.type.endsWith("Expression") && (parentPrecedence === -1 || parentPrecedence >= PRECEDENCE_OF_EXPONENTIATION_EXPR) && !(parent.type === "BinaryExpression" && parent.operator === "**" && parent.right === node) && !((parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node)) && !(parent.type === "MemberExpression" && parent.computed && parent.property === node) && parent.type !== "ArrayExpression") && !astUtils.isParenthesised(sourceCode, node);
+	}
+	/**
+	* Optionally parenthesizes given text.
+	* @param {string} text The text to parenthesize.
+	* @param {boolean} shouldParenthesize If `true`, the text will be parenthesised.
+	* @returns {string} parenthesised or unchanged text.
+	*/
+	function parenthesizeIfShould(text, shouldParenthesize) {
+		return shouldParenthesize ? `(${text})` : text;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow the use of `Math.pow` in favor of the `**` operator",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/prefer-exponentiation-operator"
+			},
+			schema: [],
+			fixable: "code",
+			messages: { useExponentiation: "Use the '**' operator instead of 'Math.pow'." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Reports the given node.
+			* @param {ASTNode} node 'Math.pow()' node to report.
+			* @returns {void}
+			*/
+			function report(node) {
+				context.report({
+					node,
+					messageId: "useExponentiation",
+					fix(fixer) {
+						if (node.arguments.length !== 2 || node.arguments.some((arg) => arg.type === "SpreadElement") || sourceCode.getCommentsInside(node).length > 0) return null;
+						let base = node.arguments[0], exponent = node.arguments[1], baseText = sourceCode.getText(base), exponentText = sourceCode.getText(exponent), shouldParenthesizeBase = doesBaseNeedParens(base), shouldParenthesizeExponent = doesExponentNeedParens(exponent), shouldParenthesizeAll = doesExponentiationExpressionNeedParens(node, sourceCode), prefix = "", suffix = "";
+						if (!shouldParenthesizeAll) {
+							if (!shouldParenthesizeBase) {
+								let firstReplacementToken = sourceCode.getFirstToken(base), tokenBefore = sourceCode.getTokenBefore(node);
+								tokenBefore && tokenBefore.range[1] === node.range[0] && !astUtils.canTokensBeAdjacent(tokenBefore, firstReplacementToken) && (prefix = " ");
+							}
+							if (!shouldParenthesizeExponent) {
+								let lastReplacementToken = sourceCode.getLastToken(exponent), tokenAfter = sourceCode.getTokenAfter(node);
+								tokenAfter && node.range[1] === tokenAfter.range[0] && !astUtils.canTokensBeAdjacent(lastReplacementToken, tokenAfter) && (suffix = " ");
+							}
+						}
+						let replacement = parenthesizeIfShould(`${parenthesizeIfShould(baseText, shouldParenthesizeBase)}**${parenthesizeIfShould(exponentText, shouldParenthesizeExponent)}`, shouldParenthesizeAll);
+						return fixer.replaceText(node, `${prefix}${replacement}${suffix}`);
+					}
+				});
+			}
+			return { Program(node) {
+				let tracker = new ReferenceTracker(sourceCode.getScope(node)), trackMap = { Math: { pow: { [CALL]: !0 } } };
+				for (let { node: refNode } of tracker.iterateGlobalReferences(trackMap)) report(refNode);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-exponentiation-operator.cjs
+module.exports = require_prefer_exponentiation_operator().create;
+//#endregion

package/rules/prefer-named-capture-group.cjs

@@ -0,0 +1,111 @@
+const require_chunk = require("../common/chunk.cjs"), require_eslint_utils$1 = require("../common/eslint-utils.cjs"), require_regexpp$1 = require("../common/regexpp.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/prefer-named-capture-group.js
+/**
+* @fileoverview Rule to enforce requiring named capture groups in regular expression.
+* @author Pig Fang <https://github.com/g-plane>
+*/
+var require_prefer_named_capture_group = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require_eslint_utils$1.t(), regexpp = require_regexpp$1.t(), parser = new regexpp.RegExpParser();
+	/**
+	* Creates fixer suggestions for the regex, if statically determinable.
+	* @param {number} groupStart Starting index of the regex group.
+	* @param {string} pattern The regular expression pattern to be checked.
+	* @param {string} rawText Source text of the regexNode.
+	* @param {ASTNode} regexNode AST node which contains the regular expression.
+	* @returns {Array<SuggestedEdit>} Fixer suggestions for the regex, if statically determinable.
+	*/
+	function suggestIfPossible(groupStart, pattern, rawText, regexNode) {
+		switch (regexNode.type) {
+			case "Literal":
+				if (typeof regexNode.value == "string" && rawText.includes("\\")) return null;
+				break;
+			case "TemplateLiteral":
+				if (regexNode.expressions.length || rawText.slice(1, -1) !== pattern) return null;
+				break;
+			default: return null;
+		}
+		let start = regexNode.range[0] + groupStart + 2;
+		return [{
+			fix(fixer) {
+				let highestTempCount = (pattern.match(/temp\d+/gu) || []).reduce((previous, next) => Math.max(previous, Number(next.slice(4))), 0);
+				return fixer.insertTextBeforeRange([start, start], `?<temp${highestTempCount + 1}>`);
+			},
+			messageId: "addGroupName"
+		}, {
+			fix(fixer) {
+				return fixer.insertTextBeforeRange([start, start], "?:");
+			},
+			messageId: "addNonCapture"
+		}];
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce using named capture group in regular expression",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/prefer-named-capture-group"
+			},
+			hasSuggestions: !0,
+			schema: [],
+			messages: {
+				addGroupName: "Add name to capture group.",
+				addNonCapture: "Convert group to non-capturing.",
+				required: "Capture group '{{group}}' should be converted to a named or non-capturing group."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Function to check regular expression.
+			* @param {string} pattern The regular expression pattern to be checked.
+			* @param {ASTNode} node AST node which contains the regular expression or a call/new expression.
+			* @param {ASTNode} regexNode AST node which contains the regular expression.
+			* @param {string|null} flags The regular expression flags to be checked.
+			* @returns {void}
+			*/
+			function checkRegex(pattern, node, regexNode, flags) {
+				let ast;
+				try {
+					ast = parser.parsePattern(pattern, 0, pattern.length, {
+						unicode: !!(flags && flags.includes("u")),
+						unicodeSets: !!(flags && flags.includes("v"))
+					});
+				} catch {
+					return;
+				}
+				regexpp.visitRegExpAST(ast, { onCapturingGroupEnter(group) {
+					if (!group.name) {
+						let rawText = sourceCode.getText(regexNode), suggest = suggestIfPossible(group.start, pattern, rawText, regexNode);
+						context.report({
+							node,
+							messageId: "required",
+							data: { group: group.raw },
+							suggest
+						});
+					}
+				} });
+			}
+			return {
+				Literal(node) {
+					node.regex && checkRegex(node.regex.pattern, node, node, node.regex.flags);
+				},
+				Program(node) {
+					let tracker = new ReferenceTracker(sourceCode.getScope(node)), traceMap = { RegExp: {
+						[CALL]: !0,
+						[CONSTRUCT]: !0
+					} };
+					for (let { node: refNode } of tracker.iterateGlobalReferences(traceMap)) {
+						let regex = getStringIfConstant(refNode.arguments[0]), flags = getStringIfConstant(refNode.arguments[1]);
+						regex && checkRegex(regex, refNode, refNode.arguments[0], flags);
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-named-capture-group.cjs
+module.exports = require_prefer_named_capture_group().create;
+//#endregion

package/rules/prefer-numeric-literals.cjs

@@ -0,0 +1,75 @@
+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-numeric-literals.js
+/**
+* @fileoverview Rule to disallow `parseInt()` in favor of binary, octal, and hexadecimal literals
+* @author Annie Zhang, Henry Zhu
+*/
+var require_prefer_numeric_literals = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), radixMap = new Map([
+		[2, {
+			system: "binary",
+			literalPrefix: "0b"
+		}],
+		[8, {
+			system: "octal",
+			literalPrefix: "0o"
+		}],
+		[16, {
+			system: "hexadecimal",
+			literalPrefix: "0x"
+		}]
+	]);
+	/**
+	* Checks to see if a CallExpression's callee node is `parseInt` or
+	* `Number.parseInt`.
+	* @param {ASTNode} calleeNode The callee node to evaluate.
+	* @returns {boolean} True if the callee is `parseInt` or `Number.parseInt`,
+	* false otherwise.
+	*/
+	function isParseInt(calleeNode) {
+		return astUtils.isSpecificId(calleeNode, "parseInt") || astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt");
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/prefer-numeric-literals"
+			},
+			schema: [],
+			messages: { useLiteral: "Use {{system}} literals instead of {{functionName}}()." },
+			fixable: "code"
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { "CallExpression[arguments.length=2]"(node) {
+				let [strNode, radixNode] = node.arguments, str = astUtils.getStaticStringValue(strNode), radix = radixNode.value;
+				if (str !== null && astUtils.isStringLiteral(strNode) && radixNode.type === "Literal" && typeof radix == "number" && radixMap.has(radix) && isParseInt(node.callee)) {
+					let { system, literalPrefix } = radixMap.get(radix);
+					context.report({
+						node,
+						messageId: "useLiteral",
+						data: {
+							system,
+							functionName: sourceCode.getText(node.callee)
+						},
+						fix(fixer) {
+							if (sourceCode.getCommentsInside(node).length) return null;
+							let replacement = `${literalPrefix}${str}`;
+							if (+replacement !== parseInt(str, radix)) return null;
+							let tokenBefore = sourceCode.getTokenBefore(node), tokenAfter = sourceCode.getTokenAfter(node), prefix = "", suffix = "";
+							return tokenBefore && tokenBefore.range[1] === node.range[0] && !astUtils.canTokensBeAdjacent(tokenBefore, replacement) && (prefix = " "), tokenAfter && node.range[1] === tokenAfter.range[0] && !astUtils.canTokensBeAdjacent(replacement, tokenAfter) && (suffix = " "), fixer.replaceText(node, `${prefix}${replacement}${suffix}`);
+						}
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-numeric-literals.cjs
+module.exports = require_prefer_numeric_literals().create;
+//#endregion

package/rules/prefer-object-has-own.cjs

@@ -0,0 +1,54 @@
+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-object-has-own.js
+/**
+* @fileoverview Prefers Object.hasOwn() instead of Object.prototype.hasOwnProperty.call()
+* @author Nitin Kumar
+* @author Gautam Arora
+*/
+var require_prefer_object_has_own = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks if the given node is considered to be an access to a property of `Object.prototype`.
+	* @param {ASTNode} node `MemberExpression` node to evaluate.
+	* @returns {boolean} `true` if `node.object` is `Object`, `Object.prototype`, or `{}` (empty 'ObjectExpression' node).
+	*/
+	function hasLeftHandObject(node) {
+		if (node.object.type === "ObjectExpression" && node.object.properties.length === 0) return !0;
+		let objectNodeToCheck = node.object.type === "MemberExpression" && astUtils.getStaticPropertyName(node.object) === "prototype" ? node.object.object : node.object;
+		return objectNodeToCheck.type === "Identifier" && objectNodeToCheck.name === "Object";
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow use of `Object.prototype.hasOwnProperty.call()` and prefer use of `Object.hasOwn()`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/prefer-object-has-own"
+			},
+			schema: [],
+			messages: { useHasOwn: "Use 'Object.hasOwn()' instead of 'Object.prototype.hasOwnProperty.call()'." },
+			fixable: "code"
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { CallExpression(node) {
+				if (!(node.callee.type === "MemberExpression" && node.callee.object.type === "MemberExpression")) return;
+				let calleePropertyName = astUtils.getStaticPropertyName(node.callee), objectPropertyName = astUtils.getStaticPropertyName(node.callee.object), isObject = hasLeftHandObject(node.callee.object), scope = sourceCode.getScope(node), variable = astUtils.getVariableByName(scope, "Object");
+				calleePropertyName === "call" && objectPropertyName === "hasOwnProperty" && isObject && variable && variable.scope.type === "global" && context.report({
+					node,
+					messageId: "useHasOwn",
+					fix(fixer) {
+						if (sourceCode.getCommentsInside(node.callee).length > 0) return null;
+						let tokenJustBeforeNode = sourceCode.getTokenBefore(node.callee, { includeComments: !0 });
+						return tokenJustBeforeNode && tokenJustBeforeNode.range[1] === node.callee.range[0] && !astUtils.canTokensBeAdjacent(tokenJustBeforeNode, "Object.hasOwn") ? fixer.replaceText(node.callee, " Object.hasOwn") : fixer.replaceText(node.callee, "Object.hasOwn");
+					}
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-object-has-own.cjs
+module.exports = require_prefer_object_has_own().create;
+//#endregion

package/rules/prefer-object-spread.cjs

@@ -0,0 +1,170 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_eslint_utils$1 = require("../common/eslint-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/prefer-object-spread.js
+/**
+* @fileoverview Rule to disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead
+* @author Sharmila Jesupaul
+*/
+var require_prefer_object_spread = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { CALL, ReferenceTracker } = require_eslint_utils$1.t(), { isCommaToken, isOpeningParenToken, isClosingParenToken, isParenthesised } = require_ast_utils$1.t(), ANY_SPACE = /\s/u;
+	/**
+	* Helper that checks if the Object.assign call has array spread
+	* @param {ASTNode} node The node that the rule warns on
+	* @returns {boolean} - Returns true if the Object.assign call has array spread
+	*/
+	function hasArraySpread(node) {
+		return node.arguments.some((arg) => arg.type === "SpreadElement");
+	}
+	/**
+	* Determines whether the given node is an accessor property (getter/setter).
+	* @param {ASTNode} node Node to check.
+	* @returns {boolean} `true` if the node is a getter or a setter.
+	*/
+	function isAccessorProperty(node) {
+		return node.type === "Property" && (node.kind === "get" || node.kind === "set");
+	}
+	/**
+	* Determines whether the given object expression node has accessor properties (getters/setters).
+	* @param {ASTNode} node `ObjectExpression` node to check.
+	* @returns {boolean} `true` if the node has at least one getter/setter.
+	*/
+	function hasAccessors(node) {
+		return node.properties.some(isAccessorProperty);
+	}
+	/**
+	* Determines whether the given call expression node has object expression arguments with accessor properties (getters/setters).
+	* @param {ASTNode} node `CallExpression` node to check.
+	* @returns {boolean} `true` if the node has at least one argument that is an object expression with at least one getter/setter.
+	*/
+	function hasArgumentsWithAccessors(node) {
+		return node.arguments.filter((arg) => arg.type === "ObjectExpression").some(hasAccessors);
+	}
+	/**
+	* Helper that checks if the node needs parentheses to be valid JS.
+	* The default is to wrap the node in parentheses to avoid parsing errors.
+	* @param {ASTNode} node The node that the rule warns on
+	* @param {Object} sourceCode in context sourcecode object
+	* @returns {boolean} - Returns true if the node needs parentheses
+	*/
+	function needsParens(node, sourceCode) {
+		let parent = node.parent;
+		switch (parent.type) {
+			case "VariableDeclarator":
+			case "ArrayExpression":
+			case "ReturnStatement":
+			case "CallExpression":
+			case "Property": return !1;
+			case "AssignmentExpression": return parent.left === node && !isParenthesised(sourceCode, node);
+			default: return !isParenthesised(sourceCode, node);
+		}
+	}
+	/**
+	* Determines if an argument needs parentheses. The default is to not add parens.
+	* @param {ASTNode} node The node to be checked.
+	* @param {Object} sourceCode in context sourcecode object
+	* @returns {boolean} True if the node needs parentheses
+	*/
+	function argNeedsParens(node, sourceCode) {
+		switch (node.type) {
+			case "AssignmentExpression":
+			case "ArrowFunctionExpression":
+			case "ConditionalExpression": return !isParenthesised(sourceCode, node);
+			default: return !1;
+		}
+	}
+	/**
+	* Get the parenthesis tokens of a given ObjectExpression node.
+	* This includes the braces of the object literal and enclosing parentheses.
+	* @param {ASTNode} node The node to get.
+	* @param {Token} leftArgumentListParen The opening paren token of the argument list.
+	* @param {SourceCode} sourceCode The source code object to get tokens.
+	* @returns {Token[]} The parenthesis tokens of the node. This is sorted by the location.
+	*/
+	function getParenTokens(node, leftArgumentListParen, sourceCode) {
+		let parens = [sourceCode.getFirstToken(node), sourceCode.getLastToken(node)], leftNext = sourceCode.getTokenBefore(node), rightNext = sourceCode.getTokenAfter(node);
+		for (; leftNext && rightNext && leftNext.range[0] > leftArgumentListParen.range[0] && isOpeningParenToken(leftNext) && isClosingParenToken(rightNext);) parens.push(leftNext, rightNext), leftNext = sourceCode.getTokenBefore(leftNext), rightNext = sourceCode.getTokenAfter(rightNext);
+		return parens.sort((a, b) => a.range[0] - b.range[0]);
+	}
+	/**
+	* Get the range of a given token and around whitespaces.
+	* @param {Token} token The token to get range.
+	* @param {SourceCode} sourceCode The source code object to get tokens.
+	* @returns {number} The end of the range of the token and around whitespaces.
+	*/
+	function getStartWithSpaces(token, sourceCode) {
+		let text = sourceCode.text, start = token.range[0];
+		{
+			let prevToken = sourceCode.getTokenBefore(token, { includeComments: !0 });
+			if (prevToken && prevToken.type === "Line") return start;
+		}
+		for (; ANY_SPACE.test(text[start - 1] || "");) --start;
+		return start;
+	}
+	/**
+	* Get the range of a given token and around whitespaces.
+	* @param {Token} token The token to get range.
+	* @param {SourceCode} sourceCode The source code object to get tokens.
+	* @returns {number} The start of the range of the token and around whitespaces.
+	*/
+	function getEndWithSpaces(token, sourceCode) {
+		let text = sourceCode.text, end = token.range[1];
+		for (; ANY_SPACE.test(text[end] || "");) end += 1;
+		return end;
+	}
+	/**
+	* Autofixes the Object.assign call to use an object spread instead.
+	* @param {ASTNode|null} node The node that the rule warns on, i.e. the Object.assign call
+	* @param {string} sourceCode sourceCode of the Object.assign call
+	* @returns {Function} autofixer - replaces the Object.assign with a spread object.
+	*/
+	function defineFixer(node, sourceCode) {
+		return function* (fixer) {
+			let leftParen = sourceCode.getTokenAfter(node.callee, isOpeningParenToken), rightParen = sourceCode.getLastToken(node);
+			yield fixer.removeRange([node.range[0], leftParen.range[0]]), needsParens(node, sourceCode) ? (yield fixer.replaceText(leftParen, "({"), yield fixer.replaceText(rightParen, "})")) : (yield fixer.replaceText(leftParen, "{"), yield fixer.replaceText(rightParen, "}"));
+			for (let argNode of node.arguments) {
+				let innerParens = getParenTokens(argNode, leftParen, sourceCode), left = innerParens.shift(), right = innerParens.pop();
+				if (argNode.type === "ObjectExpression") {
+					let maybeTrailingComma = sourceCode.getLastToken(argNode, 1), maybeArgumentComma = sourceCode.getTokenAfter(right);
+					for (let innerParen of innerParens) yield fixer.remove(innerParen);
+					let leftRange = [left.range[0], getEndWithSpaces(left, sourceCode)], rightRange = [Math.max(getStartWithSpaces(right, sourceCode), leftRange[1]), right.range[1]];
+					yield fixer.removeRange(leftRange), yield fixer.removeRange(rightRange), (argNode.properties.length === 0 || isCommaToken(maybeTrailingComma)) && isCommaToken(maybeArgumentComma) && (yield fixer.remove(maybeArgumentComma));
+				} else argNeedsParens(argNode, sourceCode) ? (yield fixer.insertTextBefore(left, "...("), yield fixer.insertTextAfter(right, ")")) : yield fixer.insertTextBefore(left, "...");
+			}
+		};
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/prefer-object-spread"
+			},
+			schema: [],
+			fixable: "code",
+			messages: {
+				useSpreadMessage: "Use an object spread instead of `Object.assign` eg: `{ ...foo }`.",
+				useLiteralMessage: "Use an object literal instead of `Object.assign`. eg: `{ foo: bar }`."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { Program(node) {
+				let tracker = new ReferenceTracker(sourceCode.getScope(node)), trackMap = { Object: { assign: { [CALL]: !0 } } };
+				for (let { node: refNode } of tracker.iterateGlobalReferences(trackMap)) if (refNode.arguments.length >= 1 && refNode.arguments[0].type === "ObjectExpression" && !hasArraySpread(refNode) && !(refNode.arguments.length > 1 && hasArgumentsWithAccessors(refNode))) {
+					let messageId = refNode.arguments.length === 1 ? "useLiteralMessage" : "useSpreadMessage", fix = defineFixer(refNode, sourceCode);
+					context.report({
+						node: refNode,
+						messageId,
+						fix
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-object-spread.cjs
+module.exports = require_prefer_object_spread().create;
+//#endregion

package/rules/prefer-promise-reject-errors.cjs

@@ -0,0 +1,62 @@
+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-promise-reject-errors.js
+/**
+* @fileoverview restrict values that can be used as Promise rejection reasons
+* @author Teddy Katz
+*/
+var require_prefer_promise_reject_errors = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ allowEmptyReject: !1 }],
+			docs: {
+				description: "Require using Error objects as Promise rejection reasons",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/prefer-promise-reject-errors"
+			},
+			fixable: null,
+			schema: [{
+				type: "object",
+				properties: { allowEmptyReject: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: { rejectAnError: "Expected the Promise rejection reason to be an Error." }
+		},
+		create(context) {
+			let [{ allowEmptyReject }] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Checks the argument of a reject() or Promise.reject() CallExpression, and reports it if it can't be an Error
+			* @param {ASTNode} callExpression A CallExpression node which is used to reject a Promise
+			* @returns {void}
+			*/
+			function checkRejectCall(callExpression) {
+				!callExpression.arguments.length && allowEmptyReject || (!callExpression.arguments.length || !astUtils.couldBeError(callExpression.arguments[0]) || callExpression.arguments[0].type === "Identifier" && callExpression.arguments[0].name === "undefined") && context.report({
+					node: callExpression,
+					messageId: "rejectAnError"
+				});
+			}
+			/**
+			* Determines whether a function call is a Promise.reject() call
+			* @param {ASTNode} node A CallExpression node
+			* @returns {boolean} `true` if the call is a Promise.reject() call
+			*/
+			function isPromiseRejectCall(node) {
+				return astUtils.isSpecificMemberAccess(node.callee, "Promise", "reject");
+			}
+			return {
+				CallExpression(node) {
+					isPromiseRejectCall(node) && checkRejectCall(node);
+				},
+				"NewExpression:exit"(node) {
+					node.callee.type === "Identifier" && node.callee.name === "Promise" && node.arguments.length && astUtils.isFunction(node.arguments[0]) && node.arguments[0].params.length > 1 && node.arguments[0].params[1].type === "Identifier" && sourceCode.getDeclaredVariables(node.arguments[0]).find((variable) => variable.name === node.arguments[0].params[1].name).references.filter((ref) => ref.isRead()).filter((ref) => ref.identifier.parent.type === "CallExpression" && ref.identifier === ref.identifier.parent.callee).forEach((ref) => checkRejectCall(ref.identifier.parent));
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-promise-reject-errors.cjs
+module.exports = require_prefer_promise_reject_errors().create;
+//#endregion