oxlint-plugin-eslint 1.52.0

package/rules/no-useless-call.cjs

@@ -0,0 +1,57 @@
+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-useless-call.js
+/**
+* @fileoverview A rule to disallow unnecessary `.call()` and `.apply()`.
+* @author Toru Nagashima
+*/
+var require_no_useless_call = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether or not a node is a `.call()`/`.apply()`.
+	* @param {ASTNode} node A CallExpression node to check.
+	* @returns {boolean} Whether or not the node is a `.call()`/`.apply()`.
+	*/
+	function isCallOrNonVariadicApply(node) {
+		let callee = astUtils.skipChainExpression(node.callee);
+		return callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.computed === !1 && (callee.property.name === "call" && node.arguments.length >= 1 || callee.property.name === "apply" && node.arguments.length === 2 && node.arguments[1].type === "ArrayExpression");
+	}
+	/**
+	* Checks whether or not `thisArg` is not changed by `.call()`/`.apply()`.
+	* @param {ASTNode|null} expectedThis The node that is the owner of the applied function.
+	* @param {ASTNode} thisArg The node that is given to the first argument of the `.call()`/`.apply()`.
+	* @param {SourceCode} sourceCode The ESLint source code object.
+	* @returns {boolean} Whether or not `thisArg` is not changed by `.call()`/`.apply()`.
+	*/
+	function isValidThisArg(expectedThis, thisArg, sourceCode) {
+		return expectedThis ? astUtils.equalTokens(expectedThis, thisArg, sourceCode) : astUtils.isNullOrUndefined(thisArg);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow unnecessary calls to `.call()` and `.apply()`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-useless-call"
+			},
+			schema: [],
+			messages: { unnecessaryCall: "Unnecessary '.{{name}}()'." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { CallExpression(node) {
+				if (!isCallOrNonVariadicApply(node)) return;
+				let callee = astUtils.skipChainExpression(node.callee), applied = astUtils.skipChainExpression(callee.object), expectedThis = applied.type === "MemberExpression" ? applied.object : null, thisArg = node.arguments[0];
+				isValidThisArg(expectedThis, thisArg, sourceCode) && context.report({
+					node,
+					messageId: "unnecessaryCall",
+					data: { name: callee.property.name }
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-useless-call.cjs
+module.exports = require_no_useless_call().create;
+//#endregion

package/rules/no-useless-catch.cjs

@@ -0,0 +1,38 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-useless-catch.js
+/**
+* @fileoverview Reports useless `catch` clauses that just rethrow their error.
+* @author Teddy Katz
+*/
+var require_no_useless_catch = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow unnecessary `catch` clauses",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-useless-catch"
+			},
+			schema: [],
+			messages: {
+				unnecessaryCatchClause: "Unnecessary catch clause.",
+				unnecessaryCatch: "Unnecessary try/catch wrapper."
+			}
+		},
+		create(context) {
+			return { CatchClause(node) {
+				node.param && node.param.type === "Identifier" && node.body.body.length && node.body.body[0].type === "ThrowStatement" && node.body.body[0].argument.type === "Identifier" && node.body.body[0].argument.name === node.param.name && (node.parent.finalizer ? context.report({
+					node,
+					messageId: "unnecessaryCatchClause"
+				}) : context.report({
+					node: node.parent,
+					messageId: "unnecessaryCatch"
+				}));
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-useless-catch.cjs
+module.exports = require_no_useless_catch().create;
+//#endregion

package/rules/no-useless-computed-key.cjs

@@ -0,0 +1,106 @@
+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-useless-computed-key.js
+/**
+* @fileoverview Rule to disallow unnecessary computed property keys in object literals
+* @author Burak Yigit Kaya
+*/
+var require_no_useless_computed_key = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Determines whether the computed key syntax is unnecessarily used for the given node.
+	* In particular, it determines whether removing the square brackets and using the content between them
+	* directly as the key (e.g. ['foo'] -> 'foo') would produce valid syntax and preserve the same behavior.
+	* Valid non-computed keys are only: identifiers, number literals and string literals.
+	* Only literals can preserve the same behavior, with a few exceptions for specific node types:
+	* Property
+	*   - { ["__proto__"]: foo } defines a property named "__proto__"
+	*     { "__proto__": foo } defines object's prototype
+	* PropertyDefinition
+	*   - class C { ["constructor"]; } defines an instance field named "constructor"
+	*     class C { "constructor"; } produces a parsing error
+	*   - class C { static ["constructor"]; } defines a static field named "constructor"
+	*     class C { static "constructor"; } produces a parsing error
+	*   - class C { static ["prototype"]; } produces a runtime error (doesn't break the whole script)
+	*     class C { static "prototype"; } produces a parsing error (breaks the whole script)
+	* MethodDefinition
+	*   - class C { ["constructor"]() {} } defines a prototype method named "constructor"
+	*     class C { "constructor"() {} } defines the constructor
+	*   - class C { static ["prototype"]() {} } produces a runtime error (doesn't break the whole script)
+	*     class C { static "prototype"() {} } produces a parsing error (breaks the whole script)
+	* @param {ASTNode} node The node to check. It can be `Property`, `PropertyDefinition` or `MethodDefinition`.
+	* @throws {Error} (Unreachable.)
+	* @returns {void} `true` if the node has useless computed key.
+	*/
+	function hasUselessComputedKey(node) {
+		if (!node.computed) return !1;
+		let { key } = node;
+		if (key.type !== "Literal") return !1;
+		let { value } = key;
+		if (typeof value != "number" && typeof value != "string") return !1;
+		switch (node.type) {
+			case "Property": return node.parent.type === "ObjectExpression" ? value !== "__proto__" : !0;
+			case "PropertyDefinition": return node.static ? value !== "constructor" && value !== "prototype" : value !== "constructor";
+			case "MethodDefinition": return node.static ? value !== "prototype" : value !== "constructor";
+			default: throw Error(`Unexpected node type: ${node.type}`);
+		}
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ enforceForClassMembers: !0 }],
+			docs: {
+				description: "Disallow unnecessary computed property keys in objects and classes",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-useless-computed-key"
+			},
+			schema: [{
+				type: "object",
+				properties: { enforceForClassMembers: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			fixable: "code",
+			messages: { unnecessarilyComputedProperty: "Unnecessarily computed property [{{property}}] found." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, [{ enforceForClassMembers }] = context.options;
+			/**
+			* Reports a given node if it violated this rule.
+			* @param {ASTNode} node The node to check.
+			* @returns {void}
+			*/
+			function check(node) {
+				if (hasUselessComputedKey(node)) {
+					let { key } = node;
+					context.report({
+						node,
+						messageId: "unnecessarilyComputedProperty",
+						data: { property: sourceCode.getText(key) },
+						fix(fixer) {
+							let leftSquareBracket = sourceCode.getTokenBefore(key, astUtils.isOpeningBracketToken), rightSquareBracket = sourceCode.getTokenAfter(key, astUtils.isClosingBracketToken);
+							if (sourceCode.commentsExistBetween(leftSquareBracket, rightSquareBracket)) return null;
+							let tokenBeforeLeftBracket = sourceCode.getTokenBefore(leftSquareBracket), replacementKey = (tokenBeforeLeftBracket.range[1] === leftSquareBracket.range[0] && !astUtils.canTokensBeAdjacent(tokenBeforeLeftBracket, sourceCode.getFirstToken(key)) ? " " : "") + key.raw;
+							return fixer.replaceTextRange([leftSquareBracket.range[0], rightSquareBracket.range[1]], replacementKey);
+						}
+					});
+				}
+			}
+			/**
+			* A no-op function to act as placeholder for checking a node when the `enforceForClassMembers` option is `false`.
+			* @returns {void}
+			* @private
+			*/
+			function noop() {}
+			return {
+				Property: check,
+				MethodDefinition: enforceForClassMembers ? check : noop,
+				PropertyDefinition: enforceForClassMembers ? check : noop
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-useless-computed-key.cjs
+module.exports = require_no_useless_computed_key().create;
+//#endregion

package/rules/no-useless-concat.cjs

@@ -0,0 +1,78 @@
+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-useless-concat.js
+/**
+* @fileoverview disallow unnecessary concatenation of template strings
+* @author Henry Zhu
+*/
+var require_no_useless_concat = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether or not a given node is a concatenation.
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if the node is a concatenation.
+	*/
+	function isConcatenation(node) {
+		return node.type === "BinaryExpression" && node.operator === "+";
+	}
+	/**
+	* Checks if the given token is a `+` token or not.
+	* @param {Token} token The token to check.
+	* @returns {boolean} `true` if the token is a `+` token.
+	*/
+	function isConcatOperatorToken(token) {
+		return token.value === "+" && token.type === "Punctuator";
+	}
+	/**
+	* Get's the right most node on the left side of a BinaryExpression with + operator.
+	* @param {ASTNode} node A BinaryExpression node to check.
+	* @returns {ASTNode} node
+	*/
+	function getLeft(node) {
+		let left = node.left;
+		for (; isConcatenation(left);) left = left.right;
+		return left;
+	}
+	/**
+	* Get's the left most node on the right side of a BinaryExpression with + operator.
+	* @param {ASTNode} node A BinaryExpression node to check.
+	* @returns {ASTNode} node
+	*/
+	function getRight(node) {
+		let right = node.right;
+		for (; isConcatenation(right);) right = right.left;
+		return right;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow unnecessary concatenation of literals or template literals",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-useless-concat"
+			},
+			schema: [],
+			messages: { unexpectedConcat: "Unexpected string concatenation of literals." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { BinaryExpression(node) {
+				if (node.operator !== "+") return;
+				let left = getLeft(node), right = getRight(node);
+				if (astUtils.isStringLiteral(left) && astUtils.isStringLiteral(right) && astUtils.isTokenOnSameLine(left, right)) {
+					let operatorToken = sourceCode.getFirstTokenBetween(left, right, isConcatOperatorToken);
+					context.report({
+						node,
+						loc: operatorToken.loc,
+						messageId: "unexpectedConcat"
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-useless-concat.cjs
+module.exports = require_no_useless_concat().create;
+//#endregion

package/rules/no-useless-constructor.cjs

@@ -0,0 +1,152 @@
+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-useless-constructor.js
+/**
+* @fileoverview Rule to flag the use of redundant constructors in classes.
+* @author Alberto Rodríguez
+*/
+var require_no_useless_constructor = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether any of a method's parameters have a decorator or are a parameter property.
+	* @param {ASTNode} node A method definition node.
+	* @returns {boolean} `true` if any parameter had a decorator or is a parameter property.
+	*/
+	function hasDecoratorsOrParameterProperty(node) {
+		return node.value.params.some((param) => param.decorators?.length || param.type === "TSParameterProperty");
+	}
+	/**
+	* Checks whether a node's accessibility makes it not useless.
+	* @param {ASTNode} node A method definition node.
+	* @returns {boolean} `true` if the node has a useful accessibility.
+	*/
+	function hasUsefulAccessibility(node) {
+		switch (node.accessibility) {
+			case "protected":
+			case "private": return !0;
+			case "public": return !!node.parent.parent.superClass;
+			default: return !1;
+		}
+	}
+	/**
+	* Checks whether a given array of statements is a single call of `super`.
+	* @param {ASTNode[]} body An array of statements to check.
+	* @returns {boolean} `true` if the body is a single call of `super`.
+	*/
+	function isSingleSuperCall(body) {
+		return body.length === 1 && body[0].type === "ExpressionStatement" && body[0].expression.type === "CallExpression" && body[0].expression.callee.type === "Super";
+	}
+	/**
+	* Checks whether a given node is a pattern which doesn't have any side effects.
+	* Default parameters and Destructuring parameters can have side effects.
+	* @param {ASTNode} node A pattern node.
+	* @returns {boolean} `true` if the node doesn't have any side effects.
+	*/
+	function isSimple(node) {
+		return node.type === "Identifier" || node.type === "RestElement";
+	}
+	/**
+	* Checks whether a given array of expressions is `...arguments` or not.
+	* `super(...arguments)` passes all arguments through.
+	* @param {ASTNode[]} superArgs An array of expressions to check.
+	* @returns {boolean} `true` if the superArgs is `...arguments`.
+	*/
+	function isSpreadArguments(superArgs) {
+		return superArgs.length === 1 && superArgs[0].type === "SpreadElement" && superArgs[0].argument.type === "Identifier" && superArgs[0].argument.name === "arguments";
+	}
+	/**
+	* Checks whether given 2 nodes are identifiers which have the same name or not.
+	* @param {ASTNode} ctorParam A node to check.
+	* @param {ASTNode} superArg A node to check.
+	* @returns {boolean} `true` if the nodes are identifiers which have the same
+	*      name.
+	*/
+	function isValidIdentifierPair(ctorParam, superArg) {
+		return ctorParam.type === "Identifier" && superArg.type === "Identifier" && ctorParam.name === superArg.name;
+	}
+	/**
+	* Checks whether given 2 nodes are a rest/spread pair which has the same values.
+	* @param {ASTNode} ctorParam A node to check.
+	* @param {ASTNode} superArg A node to check.
+	* @returns {boolean} `true` if the nodes are a rest/spread pair which has the
+	*      same values.
+	*/
+	function isValidRestSpreadPair(ctorParam, superArg) {
+		return ctorParam.type === "RestElement" && superArg.type === "SpreadElement" && isValidIdentifierPair(ctorParam.argument, superArg.argument);
+	}
+	/**
+	* Checks whether given 2 nodes have the same value or not.
+	* @param {ASTNode} ctorParam A node to check.
+	* @param {ASTNode} superArg A node to check.
+	* @returns {boolean} `true` if the nodes have the same value or not.
+	*/
+	function isValidPair(ctorParam, superArg) {
+		return isValidIdentifierPair(ctorParam, superArg) || isValidRestSpreadPair(ctorParam, superArg);
+	}
+	/**
+	* Checks whether the parameters of a constructor and the arguments of `super()`
+	* have the same values or not.
+	* @param {ASTNode} ctorParams The parameters of a constructor to check.
+	* @param {ASTNode} superArgs The arguments of `super()` to check.
+	* @returns {boolean} `true` if those have the same values.
+	*/
+	function isPassingThrough(ctorParams, superArgs) {
+		if (ctorParams.length !== superArgs.length) return !1;
+		for (let i = 0; i < ctorParams.length; ++i) if (!isValidPair(ctorParams[i], superArgs[i])) return !1;
+		return !0;
+	}
+	/**
+	* Checks whether the constructor body is a redundant super call.
+	* @param {Array} body constructor body content.
+	* @param {Array} ctorParams The params to check against super call.
+	* @returns {boolean} true if the constructor body is redundant
+	*/
+	function isRedundantSuperCall(body, ctorParams) {
+		return isSingleSuperCall(body) && ctorParams.every(isSimple) && (isSpreadArguments(body[0].expression.arguments) || isPassingThrough(ctorParams, body[0].expression.arguments));
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			type: "suggestion",
+			docs: {
+				description: "Disallow unnecessary constructors",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-useless-constructor"
+			},
+			hasSuggestions: !0,
+			schema: [],
+			messages: {
+				noUselessConstructor: "Useless constructor.",
+				removeConstructor: "Remove the constructor."
+			}
+		},
+		create(context) {
+			/**
+			* Checks whether a node is a redundant constructor
+			* @param {ASTNode} node node to check
+			* @returns {void}
+			*/
+			function checkForConstructor(node) {
+				if (node.kind !== "constructor" || node.value.type !== "FunctionExpression" || hasDecoratorsOrParameterProperty(node) || hasUsefulAccessibility(node) || !node.value.body) return;
+				let body = node.value.body.body, ctorParams = node.value.params;
+				(node.parent.parent.superClass ? isRedundantSuperCall(body, ctorParams) : body.length === 0) && context.report({
+					node,
+					messageId: "noUselessConstructor",
+					suggest: [{
+						messageId: "removeConstructor",
+						*fix(fixer) {
+							let nextToken = context.sourceCode.getTokenAfter(node), addSemiColon = nextToken.type === "Punctuator" && nextToken.value === "[" && astUtils.needsPrecedingSemicolon(context.sourceCode, node);
+							yield fixer.replaceText(node, addSemiColon ? ";" : "");
+						}
+					}]
+				});
+			}
+			return { MethodDefinition: checkForConstructor };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-useless-constructor.cjs
+module.exports = require_no_useless_constructor().create;
+//#endregion

package/rules/no-useless-escape.cjs

@@ -0,0 +1,164 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-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/no-useless-escape.js
+/**
+* @fileoverview Look for useless escapes in strings and regexes
+* @author Onur Temizkan
+*/
+var require_no_useless_escape = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), { RegExpParser, visitRegExpAST } = require_regexpp$1.t();
+	/**
+	* @typedef {import('@eslint-community/regexpp').AST.CharacterClass} CharacterClass
+	* @typedef {import('@eslint-community/regexpp').AST.ExpressionCharacterClass} ExpressionCharacterClass
+	*/
+	/**
+	* Returns the union of two sets.
+	* @param {Set} setA The first set
+	* @param {Set} setB The second set
+	* @returns {Set} The union of the two sets
+	*/
+	function union(setA, setB) {
+		return new Set((function* () {
+			yield* setA, yield* setB;
+		})());
+	}
+	let VALID_STRING_ESCAPES = union(/* @__PURE__ */ new Set("\\nrvtbfux"), astUtils.LINEBREAKS), REGEX_GENERAL_ESCAPES = /* @__PURE__ */ new Set("\\bcdDfnpPrsStvwWxu0123456789]"), REGEX_NON_CHARCLASS_ESCAPES = union(REGEX_GENERAL_ESCAPES, /* @__PURE__ */ new Set("^/.$*+?[{}|()Bk")), REGEX_CLASSSET_CHARACTER_ESCAPES = union(REGEX_GENERAL_ESCAPES, /* @__PURE__ */ new Set("q/[{}|()-")), REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR = /* @__PURE__ */ new Set("!#$%&*+,.:;<=>?@^`~");
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ allowRegexCharacters: [] }],
+			docs: {
+				description: "Disallow unnecessary escape characters",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-useless-escape"
+			},
+			hasSuggestions: !0,
+			messages: {
+				unnecessaryEscape: "Unnecessary escape character: \\{{character}}.",
+				removeEscape: "Remove the `\\`. This maintains the current functionality.",
+				removeEscapeDoNotKeepSemantics: "Remove the `\\` if it was inserted by mistake.",
+				escapeBackslash: "Replace the `\\` with `\\\\` to include the actual backslash character."
+			},
+			schema: [{
+				type: "object",
+				properties: { allowRegexCharacters: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: !0
+				} },
+				additionalProperties: !1
+			}]
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, [{ allowRegexCharacters }] = context.options, parser = new RegExpParser();
+			/**
+			* Reports a node
+			* @param {ASTNode} node The node to report
+			* @param {number} startOffset The backslash's offset from the start of the node
+			* @param {string} character The uselessly escaped character (not including the backslash)
+			* @param {boolean} [disableEscapeBackslashSuggest] `true` if escapeBackslash suggestion should be turned off.
+			* @returns {void}
+			*/
+			function report(node, startOffset, character, disableEscapeBackslashSuggest) {
+				let rangeStart = node.range[0] + startOffset, range = [rangeStart, rangeStart + 1], start = sourceCode.getLocFromIndex(rangeStart);
+				context.report({
+					node,
+					loc: {
+						start,
+						end: {
+							line: start.line,
+							column: start.column + 1
+						}
+					},
+					messageId: "unnecessaryEscape",
+					data: { character },
+					suggest: [{
+						messageId: astUtils.isDirective(node.parent) ? "removeEscapeDoNotKeepSemantics" : "removeEscape",
+						fix(fixer) {
+							return fixer.removeRange(range);
+						}
+					}, ...disableEscapeBackslashSuggest ? [] : [{
+						messageId: "escapeBackslash",
+						fix(fixer) {
+							return fixer.insertTextBeforeRange(range, "\\");
+						}
+					}]]
+				});
+			}
+			/**
+			* Checks if the escape character in given string slice is unnecessary.
+			* @private
+			* @param {ASTNode} node node to validate.
+			* @param {string} match string slice to validate.
+			* @returns {void}
+			*/
+			function validateString(node, match) {
+				let isTemplateElement = node.type === "TemplateElement", escapedChar = match[0][1], isUnnecessaryEscape = !VALID_STRING_ESCAPES.has(escapedChar), isQuoteEscape;
+				isTemplateElement ? (isQuoteEscape = escapedChar === "`", escapedChar === "$" ? isUnnecessaryEscape = match.input[match.index + 2] !== "{" : escapedChar === "{" && (isUnnecessaryEscape = match.input[match.index - 1] !== "$")) : isQuoteEscape = escapedChar === node.raw[0], isUnnecessaryEscape && !isQuoteEscape && report(node, match.index, match[0].slice(1));
+			}
+			/**
+			* Checks if the escape character in given regexp is unnecessary.
+			* @private
+			* @param {ASTNode} node node to validate.
+			* @returns {void}
+			*/
+			function validateRegExp(node) {
+				let { pattern, flags } = node.regex, patternNode, unicode = flags.includes("u"), unicodeSets = flags.includes("v");
+				try {
+					patternNode = parser.parsePattern(pattern, 0, pattern.length, {
+						unicode,
+						unicodeSets
+					});
+				} catch {
+					return;
+				}
+				/** @type {(CharacterClass | ExpressionCharacterClass)[]} */
+				let characterClassStack = [];
+				visitRegExpAST(patternNode, {
+					onCharacterClassEnter: (characterClassNode) => characterClassStack.unshift(characterClassNode),
+					onCharacterClassLeave: () => characterClassStack.shift(),
+					onExpressionCharacterClassEnter: (characterClassNode) => characterClassStack.unshift(characterClassNode),
+					onExpressionCharacterClassLeave: () => characterClassStack.shift(),
+					onCharacterEnter(characterNode) {
+						if (!characterNode.raw.startsWith("\\")) return;
+						let escapedChar = characterNode.raw.slice(1);
+						if (escapedChar !== String.fromCodePoint(characterNode.value) || allowRegexCharacters.includes(escapedChar)) return;
+						let allowedEscapes;
+						if (allowedEscapes = characterClassStack.length ? unicodeSets ? REGEX_CLASSSET_CHARACTER_ESCAPES : REGEX_GENERAL_ESCAPES : REGEX_NON_CHARCLASS_ESCAPES, allowedEscapes.has(escapedChar)) return;
+						let reportedIndex = characterNode.start + 1, disableEscapeBackslashSuggest = !1;
+						if (characterClassStack.length) {
+							let characterClassNode = characterClassStack[0];
+							if (escapedChar === "^" && characterClassNode.start + 1 === characterNode.start) return;
+							if (unicodeSets) {
+								if (REGEX_CLASS_SET_RESERVED_DOUBLE_PUNCTUATOR.has(escapedChar) && (pattern[characterNode.end] === escapedChar || pattern[characterNode.start - 1] === escapedChar && (escapedChar !== "^" || !characterClassNode.negate || characterClassNode.start + 1 < characterNode.start - 1))) return;
+								(characterNode.parent.type === "ClassIntersection" || characterNode.parent.type === "ClassSubtraction") && (disableEscapeBackslashSuggest = !0);
+							} else if (escapedChar === "-" && characterClassNode.start + 1 !== characterNode.start && characterNode.end !== characterClassNode.end - 1) return;
+						}
+						report(node, reportedIndex, escapedChar, disableEscapeBackslashSuggest);
+					}
+				});
+			}
+			/**
+			* Checks if a node has an escape.
+			* @param {ASTNode} node node to check.
+			* @returns {void}
+			*/
+			function check(node) {
+				let isTemplateElement = node.type === "TemplateElement";
+				if (!(isTemplateElement && node.parent && node.parent.parent && node.parent.parent.type === "TaggedTemplateExpression" && node.parent === node.parent.parent.quasi)) if (typeof node.value == "string" || isTemplateElement) {
+					if (node.parent.type === "JSXAttribute" || node.parent.type === "JSXElement" || node.parent.type === "JSXFragment") return;
+					let value = isTemplateElement ? sourceCode.getText(node) : node.raw, pattern = /\\\D/gu, match;
+					for (; match = pattern.exec(value);) validateString(node, match);
+				} else node.regex && validateRegExp(node);
+			}
+			return {
+				Literal: check,
+				TemplateElement: check
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-useless-escape.cjs
+module.exports = require_no_useless_escape().create;
+//#endregion