oxlint-plugin-eslint 1.52.0

package/rules/no-eval.cjs

@@ -0,0 +1,165 @@
+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-eval.js
+/**
+* @fileoverview Rule to flag use of eval() statement
+* @author Nicholas C. Zakas
+*/
+var require_no_eval = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), candidatesOfGlobalObject = Object.freeze([
+		"global",
+		"window",
+		"globalThis"
+	]);
+	/**
+	* Checks a given node is a MemberExpression node which has the specified name's
+	* property.
+	* @param {ASTNode} node A node to check.
+	* @param {string} name A name to check.
+	* @returns {boolean} `true` if the node is a MemberExpression node which has
+	*      the specified name's property
+	*/
+	function isMember(node, name) {
+		return astUtils.isSpecificMemberAccess(node, null, name);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ allowIndirect: !1 }],
+			docs: {
+				description: "Disallow the use of `eval()`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-eval"
+			},
+			schema: [{
+				type: "object",
+				properties: { allowIndirect: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: { unexpected: "eval can be harmful." }
+		},
+		create(context) {
+			let [{ allowIndirect }] = context.options, sourceCode = context.sourceCode, funcInfo = null;
+			/**
+			* Pushes a `this` scope (non-arrow function, class static block, or class field initializer) information to the stack.
+			* Top-level scopes are handled separately.
+			*
+			* This is used in order to check whether or not `this` binding is a
+			* reference to the global object.
+			* @param {ASTNode} node A node of the scope.
+			*      For functions, this is one of FunctionDeclaration, FunctionExpression.
+			*      For class static blocks, this is StaticBlock.
+			*      For class field initializers, this can be any node that is PropertyDefinition#value.
+			* @returns {void}
+			*/
+			function enterThisScope(node) {
+				let strict = sourceCode.getScope(node).isStrict;
+				funcInfo = {
+					upper: funcInfo,
+					node,
+					strict,
+					isTopLevelOfScript: !1,
+					defaultThis: !1,
+					initialized: strict
+				};
+			}
+			/**
+			* Pops a variable scope from the stack.
+			* @returns {void}
+			*/
+			function exitThisScope() {
+				funcInfo = funcInfo.upper;
+			}
+			/**
+			* Reports a given node.
+			*
+			* `node` is `Identifier` or `MemberExpression`.
+			* The parent of `node` might be `CallExpression`.
+			*
+			* The location of the report is always `eval` `Identifier` (or possibly
+			* `Literal`). The type of the report is `CallExpression` if the parent is
+			* `CallExpression`. Otherwise, it's the given node type.
+			* @param {ASTNode} node A node to report.
+			* @returns {void}
+			*/
+			function report(node) {
+				let parent = node.parent, locationNode = node.type === "MemberExpression" ? node.property : node, reportNode = parent.type === "CallExpression" && parent.callee === node ? parent : node;
+				context.report({
+					node: reportNode,
+					loc: locationNode.loc,
+					messageId: "unexpected"
+				});
+			}
+			/**
+			* Reports accesses of `eval` via the global object.
+			* @param {eslint-scope.Scope} globalScope The global scope.
+			* @returns {void}
+			*/
+			function reportAccessingEvalViaGlobalObject(globalScope) {
+				for (let i = 0; i < candidatesOfGlobalObject.length; ++i) {
+					let name = candidatesOfGlobalObject[i], variable = astUtils.getVariableByName(globalScope, name);
+					if (!variable) continue;
+					let references = variable.references;
+					for (let j = 0; j < references.length; ++j) {
+						let node = references[j].identifier.parent;
+						for (; isMember(node, name);) node = node.parent;
+						isMember(node, "eval") && report(node);
+					}
+				}
+			}
+			/**
+			* Reports all accesses of `eval` (excludes direct calls to eval).
+			* @param {eslint-scope.Scope} globalScope The global scope.
+			* @returns {void}
+			*/
+			function reportAccessingEval(globalScope) {
+				let variable = astUtils.getVariableByName(globalScope, "eval");
+				if (!variable) return;
+				let references = variable.references;
+				for (let i = 0; i < references.length; ++i) {
+					let id = references[i].identifier;
+					id.name === "eval" && !astUtils.isCallee(id) && report(id);
+				}
+			}
+			return allowIndirect ? { "CallExpression:exit"(node) {
+				let callee = node.callee;
+				!node.optional && astUtils.isSpecificId(callee, "eval") && report(callee);
+			} } : {
+				"CallExpression:exit"(node) {
+					let callee = node.callee;
+					astUtils.isSpecificId(callee, "eval") && report(callee);
+				},
+				Program(node) {
+					let scope = sourceCode.getScope(node), features = context.languageOptions.parserOptions.ecmaFeatures || {};
+					funcInfo = {
+						upper: null,
+						node,
+						strict: scope.isStrict || node.sourceType === "module" || features.globalReturn && scope.childScopes[0].isStrict,
+						isTopLevelOfScript: node.sourceType !== "module" && !features.globalReturn,
+						defaultThis: !0,
+						initialized: !0
+					};
+				},
+				"Program:exit"(node) {
+					let globalScope = sourceCode.getScope(node);
+					exitThisScope(), reportAccessingEval(globalScope), reportAccessingEvalViaGlobalObject(globalScope);
+				},
+				FunctionDeclaration: enterThisScope,
+				"FunctionDeclaration:exit": exitThisScope,
+				FunctionExpression: enterThisScope,
+				"FunctionExpression:exit": exitThisScope,
+				"PropertyDefinition > *.value": enterThisScope,
+				"PropertyDefinition > *.value:exit": exitThisScope,
+				StaticBlock: enterThisScope,
+				"StaticBlock:exit": exitThisScope,
+				ThisExpression(node) {
+					isMember(node.parent, "eval") && (funcInfo.initialized || (funcInfo.initialized = !0, funcInfo.defaultThis = astUtils.isDefaultThisBinding(funcInfo.node, sourceCode)), (funcInfo.isTopLevelOfScript || !funcInfo.strict && funcInfo.defaultThis) && report(node.parent));
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-eval.cjs
+module.exports = require_no_eval().create;
+//#endregion

package/rules/no-ex-assign.cjs

@@ -0,0 +1,45 @@
+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-ex-assign.js
+/**
+* @fileoverview Rule to flag assignment of the exception parameter
+* @author Stephen Murray <spmurrayzzz>
+*/
+var require_no_ex_assign = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow reassigning exceptions in `catch` clauses",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-ex-assign"
+			},
+			schema: [],
+			messages: { unexpected: "Do not assign to the exception parameter." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Finds and reports references that are non initializer and writable.
+			* @param {Variable} variable A variable to check.
+			* @returns {void}
+			*/
+			function checkVariable(variable) {
+				astUtils.getModifyingReferences(variable.references).forEach((reference) => {
+					context.report({
+						node: reference.identifier,
+						messageId: "unexpected"
+					});
+				});
+			}
+			return { CatchClause(node) {
+				sourceCode.getDeclaredVariables(node).forEach(checkVariable);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-ex-assign.cjs
+module.exports = require_no_ex_assign().create;
+//#endregion

package/rules/no-extend-native.cjs

@@ -0,0 +1,103 @@
+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-extend-native.js
+/**
+* @fileoverview Rule to flag adding properties to native object's prototypes.
+* @author David Nelson
+*/
+var require_no_extend_native = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ exceptions: [] }],
+			docs: {
+				description: "Disallow extending native types",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-extend-native"
+			},
+			schema: [{
+				type: "object",
+				properties: { exceptions: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: !0
+				} },
+				additionalProperties: !1
+			}],
+			messages: { unexpected: "{{builtin}} prototype is read only, properties should not be added." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, exceptions = new Set(context.options[0].exceptions), modifiedBuiltins = new Set(Object.keys(astUtils.ECMASCRIPT_GLOBALS).filter((builtin) => builtin[0].toUpperCase() === builtin[0]).filter((builtin) => !exceptions.has(builtin)));
+			/**
+			* Reports a lint error for the given node.
+			* @param {ASTNode} node The node to report.
+			* @param {string} builtin The name of the native builtin being extended.
+			* @returns {void}
+			*/
+			function reportNode(node, builtin) {
+				context.report({
+					node,
+					messageId: "unexpected",
+					data: { builtin }
+				});
+			}
+			/**
+			* Check to see if the `prototype` property of the given object
+			* identifier node is being accessed.
+			* @param {ASTNode} identifierNode The Identifier representing the object
+			* to check.
+			* @returns {boolean} True if the identifier is the object of a
+			* MemberExpression and its `prototype` property is being accessed,
+			* false otherwise.
+			*/
+			function isPrototypePropertyAccessed(identifierNode) {
+				return !!(identifierNode && identifierNode.parent && identifierNode.parent.type === "MemberExpression" && identifierNode.parent.object === identifierNode && astUtils.getStaticPropertyName(identifierNode.parent) === "prototype");
+			}
+			/**
+			* Check if it's an assignment to the property of the given node.
+			* Example: `*.prop = 0` // the `*` is the given node.
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} True if an assignment to the property of the node.
+			*/
+			function isAssigningToPropertyOf(node) {
+				return node.parent.type === "MemberExpression" && node.parent.object === node && node.parent.parent.type === "AssignmentExpression" && node.parent.parent.left === node.parent;
+			}
+			/**
+			* Checks if the given node is at the first argument of the method call of `Object.defineProperty()` or `Object.defineProperties()`.
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} True if the node is at the first argument of the method call of `Object.defineProperty()` or `Object.defineProperties()`.
+			*/
+			function isInDefinePropertyCall(node) {
+				return node.parent.type === "CallExpression" && node.parent.arguments[0] === node && astUtils.isSpecificMemberAccess(node.parent.callee, "Object", /^definePropert(?:y|ies)$/u);
+			}
+			/**
+			* Check to see if object prototype access is part of a prototype
+			* extension. There are three ways a prototype can be extended:
+			* 1. Assignment to prototype property (Object.prototype.foo = 1)
+			* 2. Object.defineProperty()/Object.defineProperties() on a prototype
+			* If prototype extension is detected, report the AssignmentExpression
+			* or CallExpression node.
+			* @param {ASTNode} identifierNode The Identifier representing the object
+			* which prototype is being accessed and possibly extended.
+			* @returns {void}
+			*/
+			function checkAndReportPrototypeExtension(identifierNode) {
+				if (!isPrototypePropertyAccessed(identifierNode)) return;
+				let prototypeNode = identifierNode.parent.parent.type === "ChainExpression" ? identifierNode.parent.parent : identifierNode.parent;
+				isAssigningToPropertyOf(prototypeNode) ? reportNode(prototypeNode.parent.parent, identifierNode.name) : isInDefinePropertyCall(prototypeNode) && reportNode(prototypeNode.parent, identifierNode.name);
+			}
+			return { "Program:exit"(node) {
+				let globalScope = sourceCode.getScope(node);
+				modifiedBuiltins.forEach((builtin) => {
+					let builtinVar = globalScope.set.get(builtin);
+					builtinVar && builtinVar.references && builtinVar.references.map((ref) => ref.identifier).forEach(checkAndReportPrototypeExtension);
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-extend-native.cjs
+module.exports = require_no_extend_native().create;
+//#endregion

package/rules/no-extra-bind.cjs

@@ -0,0 +1,127 @@
+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-extra-bind.js
+/**
+* @fileoverview Rule to flag unnecessary bind calls
+* @author Bence Dányi <bence@danyi.me>
+*/
+var require_no_extra_bind = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), SIDE_EFFECT_FREE_NODE_TYPES = new Set([
+		"Literal",
+		"Identifier",
+		"ThisExpression",
+		"FunctionExpression"
+	]);
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow unnecessary calls to `.bind()`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-extra-bind"
+			},
+			schema: [],
+			fixable: "code",
+			messages: { unexpected: "The function binding is unnecessary." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, scopeInfo = null;
+			/**
+			* Checks if a node is free of side effects.
+			*
+			* This check is stricter than it needs to be, in order to keep the implementation simple.
+			* @param {ASTNode} node A node to check.
+			* @returns {boolean} True if the node is known to be side-effect free, false otherwise.
+			*/
+			function isSideEffectFree(node) {
+				return SIDE_EFFECT_FREE_NODE_TYPES.has(node.type);
+			}
+			/**
+			* Reports a given function node.
+			* @param {ASTNode} node A node to report. This is a FunctionExpression or
+			*      an ArrowFunctionExpression.
+			* @returns {void}
+			*/
+			function report(node) {
+				let memberNode = node.parent, callNode = memberNode.parent.type === "ChainExpression" ? memberNode.parent.parent : memberNode.parent;
+				context.report({
+					node: callNode,
+					messageId: "unexpected",
+					loc: memberNode.property.loc,
+					fix(fixer) {
+						if (!isSideEffectFree(callNode.arguments[0])) return null;
+						let tokenPairs = [[sourceCode.getTokenAfter(memberNode.object, astUtils.isNotClosingParenToken), sourceCode.getLastToken(memberNode)], [sourceCode.getTokenAfter(memberNode, astUtils.isNotClosingParenToken), sourceCode.getLastToken(callNode)]], firstTokenToRemove = tokenPairs[0][0], lastTokenToRemove = tokenPairs[1][1];
+						return sourceCode.commentsExistBetween(firstTokenToRemove, lastTokenToRemove) ? null : tokenPairs.map(([start, end]) => fixer.removeRange([start.range[0], end.range[1]]));
+					}
+				});
+			}
+			/**
+			* Checks whether or not a given function node is the callee of `.bind()`
+			* method.
+			*
+			* e.g. `(function() {}.bind(foo))`
+			* @param {ASTNode} node A node to report. This is a FunctionExpression or
+			*      an ArrowFunctionExpression.
+			* @returns {boolean} `true` if the node is the callee of `.bind()` method.
+			*/
+			function isCalleeOfBindMethod(node) {
+				if (!astUtils.isSpecificMemberAccess(node.parent, null, "bind")) return !1;
+				let bindNode = node.parent.parent.type === "ChainExpression" ? node.parent.parent : node.parent;
+				return bindNode.parent.type === "CallExpression" && bindNode.parent.callee === bindNode && bindNode.parent.arguments.length === 1 && bindNode.parent.arguments[0].type !== "SpreadElement";
+			}
+			/**
+			* Adds a scope information object to the stack.
+			* @param {ASTNode} node A node to add. This node is a FunctionExpression
+			*      or a FunctionDeclaration node.
+			* @returns {void}
+			*/
+			function enterFunction(node) {
+				scopeInfo = {
+					isBound: isCalleeOfBindMethod(node),
+					thisFound: !1,
+					upper: scopeInfo
+				};
+			}
+			/**
+			* Removes the scope information object from the top of the stack.
+			* At the same time, this reports the function node if the function has
+			* `.bind()` and the `this` keywords found.
+			* @param {ASTNode} node A node to remove. This node is a
+			*      FunctionExpression or a FunctionDeclaration node.
+			* @returns {void}
+			*/
+			function exitFunction(node) {
+				scopeInfo.isBound && !scopeInfo.thisFound && report(node), scopeInfo = scopeInfo.upper;
+			}
+			/**
+			* Reports a given arrow function if the function is callee of `.bind()`
+			* method.
+			* @param {ASTNode} node A node to report. This node is an
+			*      ArrowFunctionExpression.
+			* @returns {void}
+			*/
+			function exitArrowFunction(node) {
+				isCalleeOfBindMethod(node) && report(node);
+			}
+			/**
+			* Set the mark as the `this` keyword was found in this scope.
+			* @returns {void}
+			*/
+			function markAsThisFound() {
+				scopeInfo && (scopeInfo.thisFound = !0);
+			}
+			return {
+				"ArrowFunctionExpression:exit": exitArrowFunction,
+				FunctionDeclaration: enterFunction,
+				"FunctionDeclaration:exit": exitFunction,
+				FunctionExpression: enterFunction,
+				"FunctionExpression:exit": exitFunction,
+				ThisExpression: markAsThisFound
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-extra-bind.cjs
+module.exports = require_no_extra_bind().create;
+//#endregion

package/rules/no-extra-boolean-cast.cjs

@@ -0,0 +1,159 @@
+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/no-extra-boolean-cast.js
+/**
+* @fileoverview Rule to flag unnecessary double negation in Boolean contexts
+* @author Brandon Mills
+*/
+var require_no_extra_boolean_cast = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), eslintUtils = require_eslint_utils$1.t(), precedence = astUtils.getPrecedence;
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{}],
+			docs: {
+				description: "Disallow unnecessary boolean casts",
+				recommended: !0,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-extra-boolean-cast"
+			},
+			schema: [{ anyOf: [{
+				type: "object",
+				properties: { enforceForInnerExpressions: { type: "boolean" } },
+				additionalProperties: !1
+			}, {
+				type: "object",
+				properties: { enforceForLogicalOperands: { type: "boolean" } },
+				additionalProperties: !1
+			}] }],
+			fixable: "code",
+			messages: {
+				unexpectedCall: "Redundant Boolean call.",
+				unexpectedNegation: "Redundant double negation."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, [{ enforceForLogicalOperands, enforceForInnerExpressions }] = context.options, BOOLEAN_NODE_TYPES = new Set([
+				"IfStatement",
+				"DoWhileStatement",
+				"WhileStatement",
+				"ConditionalExpression",
+				"ForStatement"
+			]);
+			/**
+			* Check if a node is a Boolean function or constructor.
+			* @param {ASTNode} node the node
+			* @returns {boolean} If the node is Boolean function or constructor
+			*/
+			function isBooleanFunctionOrConstructorCall(node) {
+				return (node.type === "CallExpression" || node.type === "NewExpression") && node.callee.type === "Identifier" && node.callee.name === "Boolean";
+			}
+			/**
+			* Check if a node is in a context where its value would be coerced to a boolean at runtime.
+			* @param {ASTNode} node The node
+			* @returns {boolean} If it is in a boolean context
+			*/
+			function isInBooleanContext(node) {
+				return isBooleanFunctionOrConstructorCall(node.parent) && node === node.parent.arguments[0] || BOOLEAN_NODE_TYPES.has(node.parent.type) && node === node.parent.test || node.parent.type === "UnaryExpression" && node.parent.operator === "!";
+			}
+			/**
+			* Checks whether the node is a context that should report an error
+			* Acts recursively if it is in a logical context
+			* @param {ASTNode} node the node
+			* @returns {boolean} If the node is in one of the flagged contexts
+			*/
+			function isInFlaggedContext(node) {
+				return node.parent.type === "ChainExpression" || (enforceForLogicalOperands || enforceForInnerExpressions) && node.parent.type === "LogicalExpression" && (node.parent.operator === "||" || node.parent.operator === "&&" || enforceForInnerExpressions && node.parent.operator === "??" && node.parent.right === node) || enforceForInnerExpressions && (node.parent.type === "ConditionalExpression" && (node.parent.consequent === node || node.parent.alternate === node) || node.parent.type === "SequenceExpression" && node.parent.expressions.at(-1) === node) ? isInFlaggedContext(node.parent) : isInBooleanContext(node);
+			}
+			/**
+			* Check if a node has comments inside.
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} `true` if it has comments inside.
+			*/
+			function hasCommentsInside(node) {
+				return !!sourceCode.getCommentsInside(node).length;
+			}
+			/**
+			* Checks if the given node is wrapped in grouping parentheses. Parentheses for constructs such as if() don't count.
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} `true` if the node is parenthesized.
+			* @private
+			*/
+			function isParenthesized(node) {
+				return eslintUtils.isParenthesized(1, node, sourceCode);
+			}
+			/**
+			* Determines whether the given node needs to be parenthesized when replacing the previous node.
+			* It assumes that `previousNode` is the node to be reported by this rule, so it has a limited list
+			* of possible parent node types. By the same assumption, the node's role in a particular parent is already known.
+			* @param {ASTNode} previousNode Previous node.
+			* @param {ASTNode} node The node to check.
+			* @throws {Error} (Unreachable.)
+			* @returns {boolean} `true` if the node needs to be parenthesized.
+			*/
+			function needsParens(previousNode, node) {
+				if (previousNode.parent.type === "ChainExpression") return needsParens(previousNode.parent, node);
+				if (isParenthesized(previousNode)) return !1;
+				let parent = previousNode.parent;
+				switch (parent.type) {
+					case "CallExpression":
+					case "NewExpression": return node.type === "SequenceExpression";
+					case "IfStatement":
+					case "DoWhileStatement":
+					case "WhileStatement":
+					case "ForStatement":
+					case "SequenceExpression": return !1;
+					case "ConditionalExpression":
+						if (previousNode === parent.test) return precedence(node) <= precedence(parent);
+						if (previousNode === parent.consequent || previousNode === parent.alternate) return precedence(node) < precedence({ type: "AssignmentExpression" });
+						/* c8 ignore next */
+						throw Error("Ternary child must be test, consequent, or alternate.");
+					case "UnaryExpression": return precedence(node) < precedence(parent);
+					case "LogicalExpression": return astUtils.isMixedLogicalAndCoalesceExpressions(node, parent) ? !0 : previousNode === parent.left ? precedence(node) < precedence(parent) : precedence(node) <= precedence(parent);
+					default: throw Error(`Unexpected parent type: ${parent.type}`);
+				}
+			}
+			return {
+				UnaryExpression(node) {
+					let parent = node.parent;
+					node.operator !== "!" || parent.type !== "UnaryExpression" || parent.operator !== "!" || isInFlaggedContext(parent) && context.report({
+						node: parent,
+						messageId: "unexpectedNegation",
+						fix(fixer) {
+							if (hasCommentsInside(parent)) return null;
+							if (needsParens(parent, node.argument)) return fixer.replaceText(parent, `(${sourceCode.getText(node.argument)})`);
+							let prefix = "", tokenBefore = sourceCode.getTokenBefore(parent), firstReplacementToken = sourceCode.getFirstToken(node.argument);
+							return tokenBefore && tokenBefore.range[1] === parent.range[0] && !astUtils.canTokensBeAdjacent(tokenBefore, firstReplacementToken) && (prefix = " "), fixer.replaceText(parent, prefix + sourceCode.getText(node.argument));
+						}
+					});
+				},
+				CallExpression(node) {
+					node.callee.type !== "Identifier" || node.callee.name !== "Boolean" || isInFlaggedContext(node) && context.report({
+						node,
+						messageId: "unexpectedCall",
+						fix(fixer) {
+							let parent = node.parent;
+							if (node.arguments.length === 0) {
+								if (parent.type === "UnaryExpression" && parent.operator === "!") {
+									if (hasCommentsInside(parent)) return null;
+									let replacement = "true", prefix = "", tokenBefore = sourceCode.getTokenBefore(parent);
+									return tokenBefore && tokenBefore.range[1] === parent.range[0] && !astUtils.canTokensBeAdjacent(tokenBefore, replacement) && (prefix = " "), fixer.replaceText(parent, prefix + replacement);
+								}
+								return hasCommentsInside(node) ? null : fixer.replaceText(node, "false");
+							}
+							if (node.arguments.length === 1) {
+								let argument = node.arguments[0];
+								return argument.type === "SpreadElement" || hasCommentsInside(node) ? null : needsParens(node, argument) ? fixer.replaceText(node, `(${sourceCode.getText(argument)})`) : fixer.replaceText(node, sourceCode.getText(argument));
+							}
+							return null;
+						}
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-extra-boolean-cast.cjs
+module.exports = require_no_extra_boolean_cast().create;
+//#endregion