oxlint-plugin-eslint 1.52.0

package/rules/no-extra-semi.cjs

@@ -0,0 +1,103 @@
+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/no-extra-semi.js
+/**
+* @fileoverview Rule to flag use of unnecessary semicolons
+* @author Nicholas C. Zakas
+* @deprecated in ESLint v8.53.0
+*/
+var require_no_extra_semi = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let FixTracker = require_fix_tracker$1.t(), astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Formatting rules are being moved out of ESLint core.",
+				url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+				deprecatedSince: "8.53.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style"
+					},
+					rule: {
+						name: "no-extra-semi",
+						url: "https://eslint.style/rules/no-extra-semi"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Disallow unnecessary semicolons",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-extra-semi"
+			},
+			fixable: "code",
+			schema: [],
+			messages: { unexpected: "Unnecessary semicolon." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Checks if a node or token is fixable.
+			* A node is fixable if it can be removed without turning a subsequent statement into a directive after fixing other nodes.
+			* @param {Token} nodeOrToken The node or token to check.
+			* @returns {boolean} Whether or not the node is fixable.
+			*/
+			function isFixable(nodeOrToken) {
+				let nextToken = sourceCode.getTokenAfter(nodeOrToken);
+				if (!nextToken || nextToken.type !== "String") return !0;
+				let stringNode = sourceCode.getNodeByRangeIndex(nextToken.range[0]);
+				return !astUtils.isTopLevelExpressionStatement(stringNode.parent);
+			}
+			/**
+			* Reports an unnecessary semicolon error.
+			* @param {Node|Token} nodeOrToken A node or a token to be reported.
+			* @returns {void}
+			*/
+			function report(nodeOrToken) {
+				context.report({
+					node: nodeOrToken,
+					messageId: "unexpected",
+					fix: isFixable(nodeOrToken) ? (fixer) => new FixTracker(fixer, context.sourceCode).retainSurroundingTokens(nodeOrToken).remove(nodeOrToken) : null
+				});
+			}
+			/**
+			* Checks for a part of a class body.
+			* This checks tokens from a specified token to a next MethodDefinition or the end of class body.
+			* @param {Token} firstToken The first token to check.
+			* @returns {void}
+			*/
+			function checkForPartOfClassBody(firstToken) {
+				for (let token = firstToken; token.type === "Punctuator" && !astUtils.isClosingBraceToken(token); token = sourceCode.getTokenAfter(token)) astUtils.isSemicolonToken(token) && report(token);
+			}
+			return {
+				EmptyStatement(node) {
+					let parent = node.parent;
+					[
+						"ForStatement",
+						"ForInStatement",
+						"ForOfStatement",
+						"WhileStatement",
+						"DoWhileStatement",
+						"IfStatement",
+						"LabeledStatement",
+						"WithStatement"
+					].includes(parent.type) || report(node);
+				},
+				ClassBody(node) {
+					checkForPartOfClassBody(sourceCode.getFirstToken(node, 1));
+				},
+				"MethodDefinition, PropertyDefinition, StaticBlock"(node) {
+					checkForPartOfClassBody(sourceCode.getTokenAfter(node));
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-extra-semi.cjs
+module.exports = require_no_extra_semi().create;
+//#endregion

package/rules/no-fallthrough.cjs

@@ -0,0 +1,136 @@
+const require_chunk = require("../common/chunk.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/shared/directives.js
+/**
+* @fileoverview Common utils for directives.
+*
+* This file contains only shared items for directives.
+* If you make a utility for rules, please see `../rules/utils/ast-utils.js`.
+*
+* @author gfyoung <https://github.com/gfyoung>
+*/
+var require_directives = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	module.exports = { directivesPattern: /^(eslint(?:-env|-enable|-disable(?:(?:-next)?-line)?)?|exported|globals?)(?:\s|$)/u };
+})), require_no_fallthrough = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { directivesPattern } = require_directives(), DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/iu;
+	/**
+	* Checks all segments in a set and returns true if any are reachable.
+	* @param {Set<CodePathSegment>} segments The segments to check.
+	* @returns {boolean} True if any segment is reachable; false otherwise.
+	*/
+	function isAnySegmentReachable(segments) {
+		for (let segment of segments) if (segment.reachable) return !0;
+		return !1;
+	}
+	/**
+	* Checks whether or not a given comment string is really a fallthrough comment and not an ESLint directive.
+	* @param {string} comment The comment string to check.
+	* @param {RegExp} fallthroughCommentPattern The regular expression used for checking for fallthrough comments.
+	* @returns {boolean} `true` if the comment string is truly a fallthrough comment.
+	*/
+	function isFallThroughComment(comment, fallthroughCommentPattern) {
+		return fallthroughCommentPattern.test(comment) && !directivesPattern.test(comment.trim());
+	}
+	/**
+	* Checks whether or not a given case has a fallthrough comment.
+	* @param {ASTNode} caseWhichFallsThrough SwitchCase node which falls through.
+	* @param {ASTNode} subsequentCase The case after caseWhichFallsThrough.
+	* @param {RuleContext} context A rule context which stores comments.
+	* @param {RegExp} fallthroughCommentPattern A pattern to match comment to.
+	* @returns {null | object} the comment if the case has a valid fallthrough comment, otherwise null
+	*/
+	function getFallthroughComment(caseWhichFallsThrough, subsequentCase, context, fallthroughCommentPattern) {
+		let sourceCode = context.sourceCode;
+		if (caseWhichFallsThrough.consequent.length === 1 && caseWhichFallsThrough.consequent[0].type === "BlockStatement") {
+			let trailingCloseBrace = sourceCode.getLastToken(caseWhichFallsThrough.consequent[0]), commentInBlock = sourceCode.getCommentsBefore(trailingCloseBrace).pop();
+			if (commentInBlock && isFallThroughComment(commentInBlock.value, fallthroughCommentPattern)) return commentInBlock;
+		}
+		let comment = sourceCode.getCommentsBefore(subsequentCase).pop();
+		return comment && isFallThroughComment(comment.value, fallthroughCommentPattern) ? comment : null;
+	}
+	/**
+	* Checks whether a node and a token are separated by blank lines
+	* @param {ASTNode} node The node to check
+	* @param {Token} token The token to compare against
+	* @returns {boolean} `true` if there are blank lines between node and token
+	*/
+	function hasBlankLinesBetween(node, token) {
+		return token.loc.start.line > node.loc.end.line + 1;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{
+				allowEmptyCase: !1,
+				reportUnusedFallthroughComment: !1
+			}],
+			docs: {
+				description: "Disallow fallthrough of `case` statements",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-fallthrough"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					commentPattern: { type: "string" },
+					allowEmptyCase: { type: "boolean" },
+					reportUnusedFallthroughComment: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				unusedFallthroughComment: "Found a comment that would permit fallthrough, but case cannot fall through.",
+				case: "Expected a 'break' statement before 'case'.",
+				default: "Expected a 'break' statement before 'default'."
+			}
+		},
+		create(context) {
+			let codePathSegments = [], currentCodePathSegments = /* @__PURE__ */ new Set(), sourceCode = context.sourceCode, [{ allowEmptyCase, commentPattern, reportUnusedFallthroughComment }] = context.options, fallthroughCommentPattern = commentPattern ? new RegExp(commentPattern, "u") : DEFAULT_FALLTHROUGH_COMMENT, previousCase = null;
+			return {
+				onCodePathStart() {
+					codePathSegments.push(currentCodePathSegments), currentCodePathSegments = /* @__PURE__ */ new Set();
+				},
+				onCodePathEnd() {
+					currentCodePathSegments = codePathSegments.pop();
+				},
+				onUnreachableCodePathSegmentStart(segment) {
+					currentCodePathSegments.add(segment);
+				},
+				onUnreachableCodePathSegmentEnd(segment) {
+					currentCodePathSegments.delete(segment);
+				},
+				onCodePathSegmentStart(segment) {
+					currentCodePathSegments.add(segment);
+				},
+				onCodePathSegmentEnd(segment) {
+					currentCodePathSegments.delete(segment);
+				},
+				SwitchCase(node) {
+					if (previousCase && previousCase.node.parent === node.parent) {
+						let previousCaseFallthroughComment = getFallthroughComment(previousCase.node, node, context, fallthroughCommentPattern);
+						previousCase.isFallthrough && !previousCaseFallthroughComment ? context.report({
+							messageId: node.test ? "case" : "default",
+							node
+						}) : reportUnusedFallthroughComment && !previousCase.isSwitchExitReachable && previousCaseFallthroughComment && context.report({
+							messageId: "unusedFallthroughComment",
+							node: previousCaseFallthroughComment
+						});
+					}
+					previousCase = null;
+				},
+				"SwitchCase:exit"(node) {
+					let nextToken = sourceCode.getTokenAfter(node), isSwitchExitReachable = isAnySegmentReachable(currentCodePathSegments);
+					previousCase = {
+						node,
+						isSwitchExitReachable,
+						isFallthrough: isSwitchExitReachable && (node.consequent.length > 0 || !allowEmptyCase && hasBlankLinesBetween(node, nextToken)) && node.parent.cases.at(-1) !== node
+					};
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-fallthrough.cjs
+module.exports = require_no_fallthrough().create;
+//#endregion

package/rules/no-floating-decimal.cjs

@@ -0,0 +1,66 @@
+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-floating-decimal.js
+/**
+* @fileoverview Rule to flag use of a leading/trailing decimal point in a numeric literal
+* @author James Allardice
+* @deprecated in ESLint v8.53.0
+*/
+var require_no_floating_decimal = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Formatting rules are being moved out of ESLint core.",
+				url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+				deprecatedSince: "8.53.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style"
+					},
+					rule: {
+						name: "no-floating-decimal",
+						url: "https://eslint.style/rules/no-floating-decimal"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Disallow leading or trailing decimal points in numeric literals",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-floating-decimal"
+			},
+			schema: [],
+			fixable: "code",
+			messages: {
+				leading: "A leading decimal point can be confused with a dot.",
+				trailing: "A trailing decimal point can be confused with a dot."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { Literal(node) {
+				typeof node.value == "number" && (node.raw.startsWith(".") && context.report({
+					node,
+					messageId: "leading",
+					fix(fixer) {
+						let tokenBefore = sourceCode.getTokenBefore(node), needsSpaceBefore = tokenBefore && tokenBefore.range[1] === node.range[0] && !astUtils.canTokensBeAdjacent(tokenBefore, `0${node.raw}`);
+						return fixer.insertTextBefore(node, needsSpaceBefore ? " 0" : "0");
+					}
+				}), node.raw.indexOf(".") === node.raw.length - 1 && context.report({
+					node,
+					messageId: "trailing",
+					fix: (fixer) => fixer.insertTextAfter(node, "0")
+				}));
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-floating-decimal.cjs
+module.exports = require_no_floating_decimal().create;
+//#endregion

package/rules/no-func-assign.cjs

@@ -0,0 +1,63 @@
+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-func-assign.js
+/**
+* @fileoverview Rule to flag use of function declaration identifiers as variables.
+* @author Ian Christian Myers
+*/
+var require_no_func_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 `function` declarations",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-func-assign"
+			},
+			schema: [],
+			messages: { isAFunction: "'{{name}}' is a function." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Reports a reference if is non initializer and writable.
+			* @param {References} references Collection of reference to check.
+			* @returns {void}
+			*/
+			function checkReference(references) {
+				astUtils.getModifyingReferences(references).forEach((reference) => {
+					context.report({
+						node: reference.identifier,
+						messageId: "isAFunction",
+						data: { name: reference.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 === "FunctionName" && checkReference(variable.references);
+			}
+			/**
+			* 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: checkForFunction,
+				FunctionExpression: checkForFunction
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-func-assign.cjs
+module.exports = require_no_func_assign().create;
+//#endregion

package/rules/no-global-assign.cjs

@@ -0,0 +1,62 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-global-assign.js
+/**
+* @fileoverview Rule to disallow assignments to native objects or read-only global variables
+* @author Ilya Volodin
+*/
+var require_no_global_assign = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ exceptions: [] }],
+			docs: {
+				description: "Disallow assignments to native objects or read-only global variables",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-global-assign"
+			},
+			schema: [{
+				type: "object",
+				properties: { exceptions: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: !0
+				} },
+				additionalProperties: !1
+			}],
+			messages: { globalShouldNotBeModified: "Read-only global '{{name}}' should not be modified." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, [{ exceptions }] = context.options;
+			/**
+			* Reports write references.
+			* @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;
+				reference.init === !1 && reference.isWrite() && (index === 0 || references[index - 1].identifier !== identifier) && context.report({
+					node: identifier,
+					messageId: "globalShouldNotBeModified",
+					data: { name: identifier.name }
+				});
+			}
+			/**
+			* Reports write references if a given variable is read-only builtin.
+			* @param {Variable} variable A variable to check.
+			* @returns {void}
+			*/
+			function checkVariable(variable) {
+				variable.writeable === !1 && !exceptions.includes(variable.name) && variable.references.forEach(checkReference);
+			}
+			return { Program(node) {
+				sourceCode.getScope(node).variables.forEach(checkVariable);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-global-assign.cjs
+module.exports = require_no_global_assign().create;
+//#endregion

package/rules/no-implicit-coercion.cjs

@@ -0,0 +1,219 @@
+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-implicit-coercion.js
+/**
+* @fileoverview A rule to disallow the type conversions with shorter notations.
+* @author Toru Nagashima
+*/
+var require_no_implicit_coercion = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), INDEX_OF_PATTERN = /^(?:i|lastI)ndexOf$/u, ALLOWABLE_OPERATORS = [
+		"~",
+		"!!",
+		"+",
+		"- -",
+		"-",
+		"*"
+	];
+	/**
+	* Checks whether or not a node is a double logical negating.
+	* @param {ASTNode} node An UnaryExpression node to check.
+	* @returns {boolean} Whether or not the node is a double logical negating.
+	*/
+	function isDoubleLogicalNegating(node) {
+		return node.operator === "!" && node.argument.type === "UnaryExpression" && node.argument.operator === "!";
+	}
+	/**
+	* Checks whether or not a node is a binary negating of `.indexOf()` method calling.
+	* @param {ASTNode} node An UnaryExpression node to check.
+	* @returns {boolean} Whether or not the node is a binary negating of `.indexOf()` method calling.
+	*/
+	function isBinaryNegatingOfIndexOf(node) {
+		if (node.operator !== "~") return !1;
+		let callNode = astUtils.skipChainExpression(node.argument);
+		return callNode.type === "CallExpression" && astUtils.isSpecificMemberAccess(callNode.callee, null, INDEX_OF_PATTERN);
+	}
+	/**
+	* Checks whether or not a node is a multiplying by one.
+	* @param {BinaryExpression} node A BinaryExpression node to check.
+	* @returns {boolean} Whether or not the node is a multiplying by one.
+	*/
+	function isMultiplyByOne(node) {
+		return node.operator === "*" && (node.left.type === "Literal" && node.left.value === 1 || node.right.type === "Literal" && node.right.value === 1);
+	}
+	/**
+	* Checks whether the given node logically represents multiplication by a fraction of `1`.
+	* For example, `a * 1` in `a * 1 / b` is technically multiplication by `1`, but the
+	* whole expression can be logically interpreted as `a * (1 / b)` rather than `(a * 1) / b`.
+	* @param {BinaryExpression} node A BinaryExpression node to check.
+	* @param {SourceCode} sourceCode The source code object.
+	* @returns {boolean} Whether or not the node is a multiplying by a fraction of `1`.
+	*/
+	function isMultiplyByFractionOfOne(node, sourceCode) {
+		return node.type === "BinaryExpression" && node.operator === "*" && node.right.type === "Literal" && node.right.value === 1 && node.parent.type === "BinaryExpression" && node.parent.operator === "/" && node.parent.left === node && !astUtils.isParenthesised(sourceCode, node);
+	}
+	/**
+	* Checks whether the result of a node is numeric or not
+	* @param {ASTNode} node The node to test
+	* @returns {boolean} true if the node is a number literal or a `Number()`, `parseInt` or `parseFloat` call
+	*/
+	function isNumeric(node) {
+		return node.type === "Literal" && typeof node.value == "number" || node.type === "CallExpression" && (node.callee.name === "Number" || node.callee.name === "parseInt" || node.callee.name === "parseFloat");
+	}
+	/**
+	* Returns the first non-numeric operand in a BinaryExpression. Designed to be
+	* used from bottom to up since it walks up the BinaryExpression trees using
+	* node.parent to find the result.
+	* @param {BinaryExpression} node The BinaryExpression node to be walked up on
+	* @returns {ASTNode|null} The first non-numeric item in the BinaryExpression tree or null
+	*/
+	function getNonNumericOperand(node) {
+		let left = node.left, right = node.right;
+		return right.type !== "BinaryExpression" && !isNumeric(right) ? right : left.type !== "BinaryExpression" && !isNumeric(left) ? left : null;
+	}
+	/**
+	* Checks whether an expression evaluates to a string.
+	* @param {ASTNode} node node that represents the expression to check.
+	* @returns {boolean} Whether or not the expression evaluates to a string.
+	*/
+	function isStringType(node) {
+		return astUtils.isStringLiteral(node) || node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "String";
+	}
+	/**
+	* Checks whether a node is an empty string literal or not.
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} Whether or not the passed in node is an
+	* empty string literal or not.
+	*/
+	function isEmptyString(node) {
+		return astUtils.isStringLiteral(node) && (node.value === "" || node.type === "TemplateLiteral" && node.quasis.length === 1 && node.quasis[0].value.cooked === "");
+	}
+	/**
+	* Checks whether or not a node is a concatenating with an empty string.
+	* @param {ASTNode} node A BinaryExpression node to check.
+	* @returns {boolean} Whether or not the node is a concatenating with an empty string.
+	*/
+	function isConcatWithEmptyString(node) {
+		return node.operator === "+" && (isEmptyString(node.left) && !isStringType(node.right) || isEmptyString(node.right) && !isStringType(node.left));
+	}
+	/**
+	* Checks whether or not a node is appended with an empty string.
+	* @param {ASTNode} node An AssignmentExpression node to check.
+	* @returns {boolean} Whether or not the node is appended with an empty string.
+	*/
+	function isAppendEmptyString(node) {
+		return node.operator === "+=" && isEmptyString(node.right);
+	}
+	/**
+	* Returns the operand that is not an empty string from a flagged BinaryExpression.
+	* @param {ASTNode} node The flagged BinaryExpression node to check.
+	* @returns {ASTNode} The operand that is not an empty string from a flagged BinaryExpression.
+	*/
+	function getNonEmptyOperand(node) {
+		return isEmptyString(node.left) ? node.right : node.left;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			hasSuggestions: !0,
+			type: "suggestion",
+			docs: {
+				description: "Disallow shorthand type conversions",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-implicit-coercion"
+			},
+			fixable: "code",
+			schema: [{
+				type: "object",
+				properties: {
+					boolean: { type: "boolean" },
+					number: { type: "boolean" },
+					string: { type: "boolean" },
+					disallowTemplateShorthand: { type: "boolean" },
+					allow: {
+						type: "array",
+						items: { enum: ALLOWABLE_OPERATORS },
+						uniqueItems: !0
+					}
+				},
+				additionalProperties: !1
+			}],
+			defaultOptions: [{
+				allow: [],
+				boolean: !0,
+				disallowTemplateShorthand: !1,
+				number: !0,
+				string: !0
+			}],
+			messages: {
+				implicitCoercion: "Unexpected implicit coercion encountered. Use `{{recommendation}}` instead.",
+				useRecommendation: "Use `{{recommendation}}` instead."
+			}
+		},
+		create(context) {
+			let [options] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Reports an error and autofixes the node
+			* @param {ASTNode} node An ast node to report the error on.
+			* @param {string} recommendation The recommended code for the issue
+			* @param {bool} shouldSuggest Whether this report should offer a suggestion
+			* @param {bool} shouldFix Whether this report should fix the node
+			* @returns {void}
+			*/
+			function report(node, recommendation, shouldSuggest, shouldFix) {
+				/**
+				* Fix function
+				* @param {RuleFixer} fixer The fixer to fix.
+				* @returns {Fix} The fix object.
+				*/
+				function fix(fixer) {
+					let tokenBefore = sourceCode.getTokenBefore(node);
+					return tokenBefore?.range[1] === node.range[0] && !astUtils.canTokensBeAdjacent(tokenBefore, recommendation) ? fixer.replaceText(node, ` ${recommendation}`) : fixer.replaceText(node, recommendation);
+				}
+				context.report({
+					node,
+					messageId: "implicitCoercion",
+					data: { recommendation },
+					fix(fixer) {
+						return shouldFix ? fix(fixer) : null;
+					},
+					suggest: [{
+						messageId: "useRecommendation",
+						data: { recommendation },
+						fix(fixer) {
+							return shouldFix || !shouldSuggest ? null : fix(fixer);
+						}
+					}]
+				});
+			}
+			return {
+				UnaryExpression(node) {
+					let operatorAllowed;
+					if (operatorAllowed = options.allow.includes("!!"), !operatorAllowed && options.boolean && isDoubleLogicalNegating(node) && report(node, `Boolean(${sourceCode.getText(node.argument.argument)})`, !0, astUtils.getVariableByName(sourceCode.getScope(node), "Boolean")?.identifiers.length === 0), operatorAllowed = options.allow.includes("~"), !operatorAllowed && options.boolean && isBinaryNegatingOfIndexOf(node)) {
+						let comparison = node.argument.type === "ChainExpression" ? ">= 0" : "!== -1";
+						report(node, `${sourceCode.getText(node.argument)} ${comparison}`, !1, !1);
+					}
+					operatorAllowed = options.allow.includes("+"), !operatorAllowed && options.number && node.operator === "+" && !isNumeric(node.argument) && report(node, `Number(${sourceCode.getText(node.argument)})`, !0, !1), operatorAllowed = options.allow.includes("- -"), !operatorAllowed && options.number && node.operator === "-" && node.argument.type === "UnaryExpression" && node.argument.operator === "-" && !isNumeric(node.argument.argument) && report(node, `Number(${sourceCode.getText(node.argument.argument)})`, !0, !1);
+				},
+				"BinaryExpression:exit"(node) {
+					let operatorAllowed;
+					operatorAllowed = options.allow.includes("*");
+					let nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && !isMultiplyByFractionOfOne(node, sourceCode) && getNonNumericOperand(node);
+					nonNumericOperand && report(node, `Number(${sourceCode.getText(nonNumericOperand)})`, !0, !1), operatorAllowed = options.allow.includes("-"), !operatorAllowed && options.number && node.operator === "-" && node.right.type === "Literal" && node.right.value === 0 && !isNumeric(node.left) && report(node, `Number(${sourceCode.getText(node.left)})`, !0, !1), operatorAllowed = options.allow.includes("+"), !operatorAllowed && options.string && isConcatWithEmptyString(node) && report(node, `String(${sourceCode.getText(getNonEmptyOperand(node))})`, !0, !1);
+				},
+				AssignmentExpression(node) {
+					if (!options.allow.includes("+") && options.string && isAppendEmptyString(node)) {
+						let code = sourceCode.getText(getNonEmptyOperand(node));
+						report(node, `${code} = String(${code})`, !0, !1);
+					}
+				},
+				TemplateLiteral(node) {
+					options.disallowTemplateShorthand && node.parent.type !== "TaggedTemplateExpression" && node.expressions.length === 1 && node.quasis[0].value.cooked === "" && node.quasis[1].value.cooked === "" && (isStringType(node.expressions[0]) || report(node, `String(${sourceCode.getText(node.expressions[0])})`, !0, !1));
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-implicit-coercion.cjs
+module.exports = require_no_implicit_coercion().create;
+//#endregion