oxlint-plugin-eslint 1.52.0

package/rules/no-octal.cjs

@@ -0,0 +1,32 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-octal.js
+/**
+* @fileoverview Rule to flag when initializing octal literal
+* @author Ilya Volodin
+*/
+var require_no_octal = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow octal literals",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-octal"
+			},
+			schema: [],
+			messages: { noOctal: "Octal literals should not be used." }
+		},
+		create(context) {
+			return { Literal(node) {
+				typeof node.value == "number" && /^0\d/u.test(node.raw) && context.report({
+					node,
+					messageId: "noOctal"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-octal.cjs
+module.exports = require_no_octal().create;
+//#endregion

package/rules/no-param-reassign.cjs

@@ -0,0 +1,135 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-param-reassign.js
+/**
+* @fileoverview Disallow reassigning function parameters.
+* @author Nat Burns
+*/
+var require_no_param_reassign = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let stopNodePattern = /(?:Statement|Declaration|Function(?:Expression)?|Program)$/u;
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow reassigning function parameters",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-param-reassign"
+			},
+			schema: [{ oneOf: [{
+				type: "object",
+				properties: { props: { enum: [!1] } },
+				additionalProperties: !1
+			}, {
+				type: "object",
+				properties: {
+					props: { enum: [!0] },
+					ignorePropertyModificationsFor: {
+						type: "array",
+						items: { type: "string" },
+						uniqueItems: !0
+					},
+					ignorePropertyModificationsForRegex: {
+						type: "array",
+						items: { type: "string" },
+						uniqueItems: !0
+					}
+				},
+				additionalProperties: !1
+			}] }],
+			messages: {
+				assignmentToFunctionParam: "Assignment to function parameter '{{name}}'.",
+				assignmentToFunctionParamProp: "Assignment to property of function parameter '{{name}}'."
+			}
+		},
+		create(context) {
+			let props = context.options[0] && context.options[0].props, ignoredPropertyAssignmentsFor = context.options[0] && context.options[0].ignorePropertyModificationsFor || [], ignoredPropertyAssignmentsForRegex = context.options[0] && context.options[0].ignorePropertyModificationsForRegex || [], sourceCode = context.sourceCode;
+			/**
+			* Checks whether or not the reference modifies properties of its variable.
+			* @param {Reference} reference A reference to check.
+			* @returns {boolean} Whether or not the reference modifies properties of its variable.
+			*/
+			function isModifyingProp(reference) {
+				let node = reference.identifier, parent = node.parent;
+				for (; parent && (!stopNodePattern.test(parent.type) || parent.type === "ForInStatement" || parent.type === "ForOfStatement");) {
+					switch (parent.type) {
+						case "AssignmentExpression": return parent.left === node;
+						case "UpdateExpression": return !0;
+						case "UnaryExpression":
+							if (parent.operator === "delete") return !0;
+							break;
+						case "ForInStatement":
+						case "ForOfStatement": return parent.left === node;
+						case "CallExpression":
+							if (parent.callee !== node) return !1;
+							break;
+						case "MemberExpression":
+							if (parent.property === node) return !1;
+							break;
+						case "Property":
+							if (parent.key === node) return !1;
+							break;
+						case "ConditionalExpression":
+							if (parent.test === node) return !1;
+							break;
+					}
+					node = parent, parent = node.parent;
+				}
+				return !1;
+			}
+			/**
+			* Tests that an identifier name matches any of the ignored property assignments.
+			* First we test strings in ignoredPropertyAssignmentsFor.
+			* Then we instantiate and test RegExp objects from ignoredPropertyAssignmentsForRegex strings.
+			* @param {string} identifierName A string that describes the name of an identifier to
+			* ignore property assignments for.
+			* @returns {boolean} Whether the string matches an ignored property assignment regular expression or not.
+			*/
+			function isIgnoredPropertyAssignment(identifierName) {
+				return ignoredPropertyAssignmentsFor.includes(identifierName) || ignoredPropertyAssignmentsForRegex.some((ignored) => new RegExp(ignored, "u").test(identifierName));
+			}
+			/**
+			* Reports a reference if is non initializer and writable.
+			* @param {Reference} reference A reference to check.
+			* @param {number} index The index of the reference in the references.
+			* @param {Reference[]} references The array that the reference belongs to.
+			* @returns {void}
+			*/
+			function checkReference(reference, index, references) {
+				let identifier = reference.identifier;
+				identifier && !reference.init && (index === 0 || references[index - 1].identifier !== identifier) && (reference.isWrite() ? context.report({
+					node: identifier,
+					messageId: "assignmentToFunctionParam",
+					data: { name: identifier.name }
+				}) : props && isModifyingProp(reference) && !isIgnoredPropertyAssignment(identifier.name) && context.report({
+					node: identifier,
+					messageId: "assignmentToFunctionParamProp",
+					data: { name: identifier.name }
+				}));
+			}
+			/**
+			* Finds and reports references that are non initializer and writable.
+			* @param {Variable} variable A variable to check.
+			* @returns {void}
+			*/
+			function checkVariable(variable) {
+				variable.defs[0].type === "Parameter" && variable.references.forEach(checkReference);
+			}
+			/**
+			* Checks parameters of a given function node.
+			* @param {ASTNode} node A function node to check.
+			* @returns {void}
+			*/
+			function checkForFunction(node) {
+				sourceCode.getDeclaredVariables(node).forEach(checkVariable);
+			}
+			return {
+				"FunctionDeclaration:exit": checkForFunction,
+				"FunctionExpression:exit": checkForFunction,
+				"ArrowFunctionExpression:exit": checkForFunction
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-param-reassign.cjs
+module.exports = require_no_param_reassign().create;
+//#endregion

package/rules/no-path-concat.cjs

@@ -0,0 +1,52 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-path-concat.js
+/**
+* @fileoverview Disallow string concatenation when using __dirname and __filename
+* @author Nicholas C. Zakas
+* @deprecated in ESLint v7.0.0
+*/
+var require_no_path_concat = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Node.js rules were moved out of ESLint core.",
+				url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
+				deprecatedSince: "7.0.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "eslint-plugin-n now maintains deprecated Node.js-related rules.",
+					plugin: {
+						name: "eslint-plugin-n",
+						url: "https://github.com/eslint-community/eslint-plugin-n"
+					},
+					rule: {
+						name: "no-path-concat",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-path-concat.md"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Disallow string concatenation with `__dirname` and `__filename`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-path-concat"
+			},
+			schema: [],
+			messages: { usePathFunctions: "Use path.join() or path.resolve() instead of + to create paths." }
+		},
+		create(context) {
+			let MATCHER = /^__(?:dir|file)name$/u;
+			return { BinaryExpression(node) {
+				let left = node.left, right = node.right;
+				node.operator === "+" && (left.type === "Identifier" && MATCHER.test(left.name) || right.type === "Identifier" && MATCHER.test(right.name)) && context.report({
+					node,
+					messageId: "usePathFunctions"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-path-concat.cjs
+module.exports = require_no_path_concat().create;
+//#endregion

package/rules/no-plusplus.cjs

@@ -0,0 +1,64 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-plusplus.js
+/**
+* @fileoverview Rule to flag use of unary increment and decrement operators.
+* @author Ian Christian Myers
+* @author Brody McKee (github.com/mrmckeb)
+*/
+var require_no_plusplus = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/**
+	* Determines whether the given node is the update node of a `ForStatement`.
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} `true` if the node is `ForStatement` update.
+	*/
+	function isForStatementUpdate(node) {
+		let parent = node.parent;
+		return parent.type === "ForStatement" && parent.update === node;
+	}
+	/**
+	* Determines whether the given node is considered to be a for loop "afterthought" by the logic of this rule.
+	* In particular, it returns `true` if the given node is either:
+	*   - The update node of a `ForStatement`: for (;; i++) {}
+	*   - An operand of a sequence expression that is the update node: for (;; foo(), i++) {}
+	*   - An operand of a sequence expression that is child of another sequence expression, etc.,
+	*     up to the sequence expression that is the update node: for (;; foo(), (bar(), (baz(), i++))) {}
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} `true` if the node is a for loop afterthought.
+	*/
+	function isForLoopAfterthought(node) {
+		let parent = node.parent;
+		return parent.type === "SequenceExpression" ? isForLoopAfterthought(parent) : isForStatementUpdate(node);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ allowForLoopAfterthoughts: !1 }],
+			docs: {
+				description: "Disallow the unary operators `++` and `--`",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-plusplus"
+			},
+			schema: [{
+				type: "object",
+				properties: { allowForLoopAfterthoughts: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: { unexpectedUnaryOp: "Unary operator '{{operator}}' used." }
+		},
+		create(context) {
+			let [{ allowForLoopAfterthoughts }] = context.options;
+			return { UpdateExpression(node) {
+				allowForLoopAfterthoughts && isForLoopAfterthought(node) || context.report({
+					node,
+					messageId: "unexpectedUnaryOp",
+					data: { operator: node.operator }
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-plusplus.cjs
+module.exports = require_no_plusplus().create;
+//#endregion

package/rules/no-process-env.cjs

@@ -0,0 +1,51 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-process-env.js
+/**
+* @fileoverview Disallow the use of process.env()
+* @author Vignesh Anand
+* @deprecated in ESLint v7.0.0
+*/
+var require_no_process_env = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Node.js rules were moved out of ESLint core.",
+				url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
+				deprecatedSince: "7.0.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "eslint-plugin-n now maintains deprecated Node.js-related rules.",
+					plugin: {
+						name: "eslint-plugin-n",
+						url: "https://github.com/eslint-community/eslint-plugin-n"
+					},
+					rule: {
+						name: "no-process-env",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-process-env.md"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Disallow the use of `process.env`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-process-env"
+			},
+			schema: [],
+			messages: { unexpectedProcessEnv: "Unexpected use of process.env." }
+		},
+		create(context) {
+			return { MemberExpression(node) {
+				let objectName = node.object.name, propertyName = node.property.name;
+				objectName === "process" && !node.computed && propertyName && propertyName === "env" && context.report({
+					node,
+					messageId: "unexpectedProcessEnv"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-process-env.cjs
+module.exports = require_no_process_env().create;
+//#endregion

package/rules/no-process-exit.cjs

@@ -0,0 +1,50 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-process-exit.js
+/**
+* @fileoverview Disallow the use of process.exit()
+* @author Nicholas C. Zakas
+* @deprecated in ESLint v7.0.0
+*/
+var require_no_process_exit = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Node.js rules were moved out of ESLint core.",
+				url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
+				deprecatedSince: "7.0.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "eslint-plugin-n now maintains deprecated Node.js-related rules.",
+					plugin: {
+						name: "eslint-plugin-n",
+						url: "https://github.com/eslint-community/eslint-plugin-n"
+					},
+					rule: {
+						name: "no-process-exit",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-process-exit.md"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Disallow the use of `process.exit()`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-process-exit"
+			},
+			schema: [],
+			messages: { noProcessExit: "Don't use process.exit(); throw an error instead." }
+		},
+		create(context) {
+			return { "CallExpression > MemberExpression.callee[object.name = 'process'][property.name = 'exit']"(node) {
+				context.report({
+					node: node.parent,
+					messageId: "noProcessExit"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-process-exit.cjs
+module.exports = require_no_process_exit().create;
+//#endregion

package/rules/no-promise-executor-return.cjs

@@ -0,0 +1,131 @@
+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/no-promise-executor-return.js
+/**
+* @fileoverview Rule to disallow returning values from Promise executor functions
+* @author Milos Djermanovic
+*/
+var require_no_promise_executor_return = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), functionTypesToCheck = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
+	/**
+	* Determines whether the given function node is used as a Promise executor.
+	* @param {ASTNode} node The node to check.
+	* @param {SourceCode} sourceCode Source code to which the node belongs.
+	* @returns {boolean} `true` if the node is a Promise executor.
+	*/
+	function isPromiseExecutor(node, sourceCode) {
+		let parent = node.parent;
+		return parent.type === "NewExpression" && parent.arguments[0] === node && parent.callee.type === "Identifier" && parent.callee.name === "Promise" && sourceCode.isGlobalReference(parent.callee);
+	}
+	/**
+	* Checks if the given node is a void expression.
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} - `true` if the node is a void expression
+	*/
+	function expressionIsVoid(node) {
+		return node.type === "UnaryExpression" && node.operator === "void";
+	}
+	/**
+	* Fixes the linting error by prepending "void " to the given node
+	* @param {Object} sourceCode context given by context.sourceCode
+	* @param {ASTNode} node The node to fix.
+	* @param {Object} fixer The fixer object provided by ESLint.
+	* @returns {Array<Object>} - An array of fix objects to apply to the node.
+	*/
+	function voidPrependFixer(sourceCode, node, fixer) {
+		let requiresParens = astUtils.getPrecedence(node) < astUtils.getPrecedence({
+			type: "UnaryExpression",
+			operator: "void"
+		}) && !astUtils.isParenthesised(sourceCode, node), returnOrArrowToken = sourceCode.getTokenBefore(node, node.parent.type === "ArrowFunctionExpression" ? astUtils.isArrowToken : (token) => token.type === "Keyword" && token.value === "return"), firstToken = sourceCode.getTokenAfter(returnOrArrowToken), prependSpace = returnOrArrowToken.value === "return" && returnOrArrowToken.range[1] === firstToken.range[0];
+		return [fixer.insertTextBefore(firstToken, `${prependSpace ? " " : ""}void ${requiresParens ? "(" : ""}`), fixer.insertTextAfter(node, requiresParens ? ")" : "")];
+	}
+	/**
+	* Fixes the linting error by `wrapping {}` around the given node's body.
+	* @param {Object} sourceCode context given by context.sourceCode
+	* @param {ASTNode} node The node to fix.
+	* @param {Object} fixer The fixer object provided by ESLint.
+	* @returns {Array<Object>} - An array of fix objects to apply to the node.
+	*/
+	function curlyWrapFixer(sourceCode, node, fixer) {
+		let arrowToken = sourceCode.getTokenBefore(node.body, astUtils.isArrowToken), firstToken = sourceCode.getTokenAfter(arrowToken), lastToken = sourceCode.getLastToken(node);
+		return [fixer.insertTextBefore(firstToken, "{"), fixer.insertTextAfter(lastToken, "}")];
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{ allowVoid: !1 }],
+			docs: {
+				description: "Disallow returning values from Promise executor functions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-promise-executor-return"
+			},
+			hasSuggestions: !0,
+			schema: [{
+				type: "object",
+				properties: { allowVoid: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: {
+				returnsValue: "Return values from promise executor functions cannot be read.",
+				prependVoid: "Prepend `void` to the expression.",
+				wrapBraces: "Wrap the expression in `{}`."
+			}
+		},
+		create(context) {
+			let funcInfo = null, sourceCode = context.sourceCode, [{ allowVoid }] = context.options;
+			return {
+				onCodePathStart(_, node) {
+					if (funcInfo = {
+						upper: funcInfo,
+						shouldCheck: functionTypesToCheck.has(node.type) && isPromiseExecutor(node, sourceCode)
+					}, funcInfo.shouldCheck && node.type === "ArrowFunctionExpression" && node.expression && !(allowVoid && expressionIsVoid(node.body))) {
+						let suggest = [];
+						allowVoid && suggest.push({
+							messageId: "prependVoid",
+							fix(fixer) {
+								return voidPrependFixer(sourceCode, node.body, fixer);
+							}
+						}), node.body.type === "FunctionExpression" && !node.body.id || suggest.push({
+							messageId: "wrapBraces",
+							fix(fixer) {
+								return curlyWrapFixer(sourceCode, node, fixer);
+							}
+						}), context.report({
+							node: node.body,
+							messageId: "returnsValue",
+							suggest
+						});
+					}
+				},
+				onCodePathEnd() {
+					funcInfo = funcInfo.upper;
+				},
+				ReturnStatement(node) {
+					if (funcInfo.shouldCheck && node.argument) {
+						if (!allowVoid) {
+							context.report({
+								node,
+								messageId: "returnsValue"
+							});
+							return;
+						}
+						expressionIsVoid(node.argument) || context.report({
+							node,
+							messageId: "returnsValue",
+							suggest: [{
+								messageId: "prependVoid",
+								fix(fixer) {
+									return voidPrependFixer(sourceCode, node.argument, fixer);
+								}
+							}]
+						});
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-promise-executor-return.cjs
+module.exports = require_no_promise_executor_return().create;
+//#endregion

package/rules/no-proto.cjs

@@ -0,0 +1,34 @@
+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/no-proto.js
+/**
+* @fileoverview Rule to flag usage of __proto__ property
+* @author Ilya Volodin
+*/
+var require_no_proto = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { getStaticPropertyName } = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow the use of the `__proto__` property",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-proto"
+			},
+			schema: [],
+			messages: { unexpectedProto: "The '__proto__' property is deprecated." }
+		},
+		create(context) {
+			return { MemberExpression(node) {
+				getStaticPropertyName(node) === "__proto__" && context.report({
+					node,
+					messageId: "unexpectedProto"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-proto.cjs
+module.exports = require_no_proto().create;
+//#endregion

package/rules/no-prototype-builtins.cjs

@@ -0,0 +1,85 @@
+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/no-prototype-builtins.js
+/**
+* @fileoverview Rule to disallow use of Object.prototype builtins on objects
+* @author Andrew Levine
+*/
+var require_no_prototype_builtins = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Returns true if the node or any of the objects
+	* to the left of it in the member/call chain is optional.
+	*
+	* e.g. `a?.b`, `a?.b.c`, `a?.()`, `a()?.()`
+	* @param {ASTNode} node The expression to check
+	* @returns {boolean} `true` if there is a short-circuiting optional `?.`
+	* in the same option chain to the left of this call or member expression,
+	* or the node itself is an optional call or member `?.`.
+	*/
+	function isAfterOptional(node) {
+		let leftNode;
+		if (node.type === "MemberExpression") leftNode = node.object;
+		else if (node.type === "CallExpression") leftNode = node.callee;
+		else return !1;
+		return node.optional ? !0 : isAfterOptional(leftNode);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow calling some `Object.prototype` methods directly on objects",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-prototype-builtins"
+			},
+			hasSuggestions: !0,
+			schema: [],
+			messages: {
+				prototypeBuildIn: "Do not access Object.prototype method '{{prop}}' from target object.",
+				callObjectPrototype: "Call Object.prototype.{{prop}} explicitly."
+			}
+		},
+		create(context) {
+			let DISALLOWED_PROPS = new Set([
+				"hasOwnProperty",
+				"isPrototypeOf",
+				"propertyIsEnumerable"
+			]);
+			/**
+			* Reports if a disallowed property is used in a CallExpression
+			* @param {ASTNode} node The CallExpression node.
+			* @returns {void}
+			*/
+			function disallowBuiltIns(node) {
+				let callee = astUtils.skipChainExpression(node.callee);
+				if (callee.type !== "MemberExpression") return;
+				let propName = astUtils.getStaticPropertyName(callee);
+				propName !== null && DISALLOWED_PROPS.has(propName) && context.report({
+					messageId: "prototypeBuildIn",
+					loc: callee.property.loc,
+					data: { prop: propName },
+					node,
+					suggest: [{
+						messageId: "callObjectPrototype",
+						data: { prop: propName },
+						fix(fixer) {
+							let sourceCode = context.sourceCode;
+							if (isAfterOptional(node) || node.callee.type === "ChainExpression") return null;
+							let objectVariable = astUtils.getVariableByName(sourceCode.getScope(node), "Object");
+							if (!objectVariable || objectVariable.scope.type !== "global" || objectVariable.defs.length > 0) return null;
+							let objectText = sourceCode.getText(callee.object);
+							astUtils.getPrecedence(callee.object) <= astUtils.getPrecedence({ type: "SequenceExpression" }) && (objectText = `(${objectText})`);
+							let openParenToken = sourceCode.getTokenAfter(node.callee, astUtils.isOpeningParenToken), delim = node.arguments.length === 0 ? "" : ", ";
+							return [fixer.replaceText(callee, `Object.prototype.${propName}.call`), fixer.insertTextAfter(openParenToken, objectText + delim)];
+						}
+					}]
+				});
+			}
+			return { CallExpression: disallowBuiltIns };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-prototype-builtins.cjs
+module.exports = require_no_prototype_builtins().create;
+//#endregion