oxlint-plugin-eslint 1.52.0

package/rules/no-use-before-define.cjs

@@ -0,0 +1,245 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-use-before-define.js
+/**
+* @fileoverview Rule to flag use of variables before they are defined
+* @author Ilya Volodin
+*/
+var require_no_use_before_define = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let SENTINEL_TYPE = /^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/u, FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;
+	/**
+	* Parses a given value as options.
+	* @param {any} options A value to parse.
+	* @returns {Object} The parsed options.
+	*/
+	function parseOptions(options) {
+		return typeof options == "object" && options ? options : {
+			functions: typeof options == "string" ? options !== "nofunc" : !0,
+			classes: !0,
+			variables: !0,
+			allowNamedExports: !1,
+			enums: !0,
+			typedefs: !0,
+			ignoreTypeReferences: !0
+		};
+	}
+	/**
+	* Checks whether or not a given location is inside of the range of a given node.
+	* @param {ASTNode} node An node to check.
+	* @param {number} location A location to check.
+	* @returns {boolean} `true` if the location is inside of the range of the node.
+	*/
+	function isInRange(node, location) {
+		return node && node.range[0] <= location && location <= node.range[1];
+	}
+	/**
+	* Checks whether or not a given location is inside of the range of a class static initializer.
+	* Static initializers are static blocks and initializers of static fields.
+	* @param {ASTNode} node `ClassBody` node to check static initializers.
+	* @param {number} location A location to check.
+	* @returns {boolean} `true` if the location is inside of a class static initializer.
+	*/
+	function isInClassStaticInitializerRange(node, location) {
+		return node.body.some((classMember) => classMember.type === "StaticBlock" && isInRange(classMember, location) || classMember.type === "PropertyDefinition" && classMember.static && classMember.value && isInRange(classMember.value, location));
+	}
+	/**
+	* Checks whether a given scope is the scope of a class static initializer.
+	* Static initializers are static blocks and initializers of static fields.
+	* @param {eslint-scope.Scope} scope A scope to check.
+	* @returns {boolean} `true` if the scope is a class static initializer scope.
+	*/
+	function isClassStaticInitializerScope(scope) {
+		return scope.type === "class-static-block" ? !0 : scope.type === "class-field-initializer" ? scope.block.parent.static : !1;
+	}
+	/**
+	* Checks whether a given reference is evaluated in an execution context
+	* that isn't the one where the variable it refers to is defined.
+	* Execution contexts are:
+	* - top-level
+	* - functions
+	* - class field initializers (implicit functions)
+	* - class static blocks (implicit functions)
+	* Static class field initializers and class static blocks are automatically run during the class definition evaluation,
+	* and therefore we'll consider them as a part of the parent execution context.
+	* Example:
+	*
+	*   const x = 1;
+	*
+	*   x; // returns `false`
+	*   () => x; // returns `true`
+	*
+	*   class C {
+	*       field = x; // returns `true`
+	*       static field = x; // returns `false`
+	*
+	*       method() {
+	*           x; // returns `true`
+	*       }
+	*
+	*       static method() {
+	*           x; // returns `true`
+	*       }
+	*
+	*       static {
+	*           x; // returns `false`
+	*       }
+	*   }
+	* @param {eslint-scope.Reference} reference A reference to check.
+	* @returns {boolean} `true` if the reference is from a separate execution context.
+	*/
+	function isFromSeparateExecutionContext(reference) {
+		let variable = reference.resolved, scope = reference.from;
+		for (; variable.scope.variableScope !== scope.variableScope;) if (isClassStaticInitializerScope(scope.variableScope)) scope = scope.variableScope.upper;
+		else return !0;
+		return !1;
+	}
+	/**
+	* Checks whether or not a given reference is evaluated during the initialization of its variable.
+	*
+	* This returns `true` in the following cases:
+	*
+	*     var a = a
+	*     var [a = a] = list
+	*     var {a = a} = obj
+	*     for (var a in a) {}
+	*     for (var a of a) {}
+	*     var C = class { [C]; };
+	*     var C = class { static foo = C; };
+	*     var C = class { static { foo = C; } };
+	*     class C extends C {}
+	*     class C extends (class { static foo = C; }) {}
+	*     class C { [C]; }
+	* @param {Reference} reference A reference to check.
+	* @returns {boolean} `true` if the reference is evaluated during the initialization.
+	*/
+	function isEvaluatedDuringInitialization(reference) {
+		if (isFromSeparateExecutionContext(reference)) return !1;
+		let location = reference.identifier.range[1], definition = reference.resolved.defs[0];
+		if (definition.type === "ClassName") {
+			let classDefinition = definition.node;
+			return isInRange(classDefinition, location) && !isInClassStaticInitializerRange(classDefinition.body, location);
+		}
+		let node = definition.name.parent;
+		for (; node;) {
+			if (node.type === "VariableDeclarator") {
+				if (isInRange(node.init, location) || FOR_IN_OF_TYPE.test(node.parent.parent.type) && isInRange(node.parent.parent.right, location)) return !0;
+				break;
+			} else if (node.type === "AssignmentPattern") {
+				if (isInRange(node.right, location)) return !0;
+			} else if (SENTINEL_TYPE.test(node.type)) break;
+			node = node.parent;
+		}
+		return !1;
+	}
+	/**
+	* check whether the reference contains a type query.
+	* @param {ASTNode} node Identifier node to check.
+	* @returns {boolean} true if reference contains type query.
+	*/
+	function referenceContainsTypeQuery(node) {
+		switch (node.type) {
+			case "TSTypeQuery": return !0;
+			case "TSQualifiedName":
+			case "Identifier": return referenceContainsTypeQuery(node.parent);
+			default: return !1;
+		}
+	}
+	/**
+	* Decorators are transpiled such that the decorator is placed after the class declaration
+	* So it is considered safe
+	* @param {Variable} variable The variable to check.
+	* @param {Reference} reference The reference to check.
+	* @returns {boolean} `true` if the reference is in a class decorator.
+	*/
+	function isClassRefInClassDecorator(variable, reference) {
+		if (variable.defs[0].type !== "ClassName" || !variable.defs[0].node.decorators || variable.defs[0].node.decorators.length === 0) return !1;
+		for (let deco of variable.defs[0].node.decorators) if (reference.identifier.range[0] >= deco.range[0] && reference.identifier.range[1] <= deco.range[1]) return !0;
+		return !1;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			type: "problem",
+			docs: {
+				description: "Disallow the use of variables before they are defined",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-use-before-define"
+			},
+			schema: [{ oneOf: [{ enum: ["nofunc"] }, {
+				type: "object",
+				properties: {
+					functions: { type: "boolean" },
+					classes: { type: "boolean" },
+					variables: { type: "boolean" },
+					allowNamedExports: { type: "boolean" },
+					enums: { type: "boolean" },
+					typedefs: { type: "boolean" },
+					ignoreTypeReferences: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}] }],
+			defaultOptions: [{
+				classes: !0,
+				functions: !0,
+				variables: !0,
+				allowNamedExports: !1,
+				enums: !0,
+				typedefs: !0,
+				ignoreTypeReferences: !0
+			}],
+			messages: { usedBeforeDefined: "'{{name}}' was used before it was defined." }
+		},
+		create(context) {
+			let options = parseOptions(context.options[0]), sourceCode = context.sourceCode;
+			/**
+			* Determines whether a given reference should be checked.
+			*
+			* Returns `false` if the reference is:
+			* - initialization's (e.g., `let a = 1`).
+			* - referring to an undefined variable (i.e., if it's an unresolved reference).
+			* - referring to a variable that is defined, but not in the given source code
+			*   (e.g., global environment variable or `arguments` in functions).
+			* - allowed by options.
+			* @param {eslint-scope.Reference} reference The reference
+			* @returns {boolean} `true` if the reference should be checked
+			*/
+			function shouldCheck(reference) {
+				if (reference.init) return !1;
+				let { identifier } = reference;
+				if (options.allowNamedExports && identifier.parent.type === "ExportSpecifier" && identifier.parent.local === identifier) return !1;
+				let variable = reference.resolved;
+				if (!variable || variable.defs.length === 0) return !1;
+				let definitionType = variable.defs[0].type;
+				if (!options.functions && definitionType === "FunctionName" || (!options.variables && definitionType === "Variable" || !options.classes && definitionType === "ClassName") && isFromSeparateExecutionContext(reference) || !options.enums && definitionType === "TSEnumName" || !options.typedefs && definitionType === "Type" || options.ignoreTypeReferences && (referenceContainsTypeQuery(identifier) || identifier.parent.type === "TSTypeReference")) return !1;
+				if (identifier.parent.type === "TSQualifiedName") {
+					let currentNode = identifier.parent;
+					for (; currentNode.type === "TSQualifiedName";) currentNode = currentNode.left;
+					return currentNode === identifier;
+				}
+				return !isClassRefInClassDecorator(variable, reference);
+			}
+			/**
+			* Finds and validates all references in a given scope and its child scopes.
+			* @param {eslint-scope.Scope} scope The scope object.
+			* @returns {void}
+			*/
+			function checkReferencesInScope(scope) {
+				scope.references.filter(shouldCheck).forEach((reference) => {
+					let definitionIdentifier = reference.resolved.defs[0].name;
+					(reference.identifier.range[1] < definitionIdentifier.range[1] || isEvaluatedDuringInitialization(reference) && reference.identifier.parent.type !== "TSTypeReference") && context.report({
+						node: reference.identifier,
+						messageId: "usedBeforeDefined",
+						data: reference.identifier
+					});
+				}), scope.childScopes.forEach(checkReferencesInScope);
+			}
+			return { Program(node) {
+				checkReferencesInScope(sourceCode.getScope(node));
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-use-before-define.cjs
+module.exports = require_no_use_before_define().create;
+//#endregion

package/rules/no-useless-assignment.cjs

@@ -0,0 +1,250 @@
+const require_chunk = require("../common/chunk.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-useless-assignment.js
+/**
+* @fileoverview A rule to disallow unnecessary assignments`.
+* @author Yosuke Ota
+*/
+var require_no_useless_assignment = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { findVariable } = require_eslint_utils$1.t();
+	/** @typedef {import("estree").Node} ASTNode */
+	/** @typedef {import("estree").Pattern} Pattern */
+	/** @typedef {import("estree").Identifier} Identifier */
+	/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
+	/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
+	/** @typedef {import("estree").UpdateExpression} UpdateExpression */
+	/** @typedef {import("estree").Expression} Expression */
+	/** @typedef {import("eslint-scope").Scope} Scope */
+	/** @typedef {import("eslint-scope").Variable} Variable */
+	/** @typedef {import("../linter/code-path-analysis/code-path")} CodePath */
+	/** @typedef {import("../linter/code-path-analysis/code-path-segment")} CodePathSegment */
+	/**
+	* Extract identifier from the given pattern node used on the left-hand side of the assignment.
+	* @param {Pattern} pattern The pattern node to extract identifier
+	* @returns {Iterable<Identifier>} The extracted identifier
+	*/
+	function* extractIdentifiersFromPattern(pattern) {
+		switch (pattern.type) {
+			case "Identifier":
+				yield pattern;
+				return;
+			case "ObjectPattern":
+				for (let property of pattern.properties) yield* extractIdentifiersFromPattern(property.type === "Property" ? property.value : property);
+				return;
+			case "ArrayPattern":
+				for (let element of pattern.elements) element && (yield* extractIdentifiersFromPattern(element));
+				return;
+			case "RestElement":
+				yield* extractIdentifiersFromPattern(pattern.argument);
+				return;
+			case "AssignmentPattern": yield* extractIdentifiersFromPattern(pattern.left);
+		}
+	}
+	/**
+	* Checks whether the given identifier node is evaluated after the assignment identifier.
+	* @param {AssignmentInfo} assignment The assignment info.
+	* @param {Identifier} identifier The identifier to check.
+	* @returns {boolean} `true` if the given identifier node is evaluated after the assignment identifier.
+	*/
+	function isIdentifierEvaluatedAfterAssignment(assignment, identifier) {
+		return !(identifier.range[0] < assignment.identifier.range[1] || assignment.expression && assignment.expression.range[0] <= identifier.range[0] && identifier.range[1] <= assignment.expression.range[1]);
+	}
+	/**
+	* Checks whether the given identifier node is used between the assigned identifier and the equal sign.
+	*
+	* e.g. let { x, y = x } = obj;
+	*                   ^   identifier to check
+	*            ^          assigned identifier
+	* @param {AssignmentInfo} assignment The assignment info.
+	* @param {Identifier} identifier The identifier to check.
+	* @returns {boolean} `true` if the given identifier node is used between the assigned identifier and the equal sign.
+	*/
+	function isIdentifierUsedBetweenAssignedAndEqualSign(assignment, identifier) {
+		return assignment.expression ? assignment.identifier.range[1] <= identifier.range[0] && identifier.range[1] <= assignment.expression.range[0] : !1;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow variable assignments when the value is not used",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-useless-assignment"
+			},
+			schema: [],
+			messages: { unnecessaryAssignment: "This assigned value is not used in subsequent statements." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, scopeStack = null, codePathStartScopes = /* @__PURE__ */ new Set();
+			/**
+			* Gets the scope of code path start from given scope
+			* @param {Scope} scope The initial scope
+			* @returns {Scope} The scope of code path start
+			* @throws {Error} Unexpected error
+			*/
+			function getCodePathStartScope(scope) {
+				let target = scope;
+				for (; target;) {
+					if (codePathStartScopes.has(target)) return target;
+					target = target.upper;
+				}
+				return null;
+			}
+			/**
+			* Verify the given scope stack.
+			* @param {ScopeStack} target The scope stack to verify.
+			* @returns {void}
+			*/
+			function verify(target) {
+				/**
+				* Checks whether the given identifier is used in the segment.
+				* @param {CodePathSegment} segment The code path segment.
+				* @param {Identifier} identifier The identifier to check.
+				* @returns {boolean} `true` if the identifier is used in the segment.
+				*/
+				function isIdentifierUsedInSegment(segment, identifier) {
+					let segmentInfo = target.segments[segment.id];
+					return segmentInfo.first && segmentInfo.last && segmentInfo.first.range[0] <= identifier.range[0] && identifier.range[1] <= segmentInfo.last.range[1];
+				}
+				/**
+				* Verifies whether the given assignment info is an used assignment.
+				* Report if it is an unused assignment.
+				* @param {AssignmentInfo} targetAssignment The assignment info to verify.
+				* @param {AssignmentInfo[]} allAssignments The list of all assignment info for variables.
+				* @returns {void}
+				*/
+				function verifyAssignmentIsUsed(targetAssignment, allAssignments) {
+					if (target.tryStatementBlocks.some((tryBlock) => tryBlock.range[0] <= targetAssignment.identifier.range[0] && targetAssignment.identifier.range[1] <= tryBlock.range[1])) return;
+					/**
+					* @typedef {Object} SubsequentSegmentData
+					* @property {CodePathSegment} segment The code path segment
+					* @property {AssignmentInfo} [assignment] The first occurrence of the assignment within the segment.
+					* There is no need to check if the variable is used after this assignment,
+					* as the value it was assigned will be used.
+					*/
+					/**
+					* Information used in `getSubsequentSegments()`.
+					* To avoid unnecessary iterations, cache information that has already been iterated over,
+					* and if additional iterations are needed, start iterating from the retained position.
+					*/
+					let subsequentSegmentData = {
+						results: [],
+						subsequentSegments: /* @__PURE__ */ new Set(),
+						queueSegments: targetAssignment.segments.flatMap((segment) => segment.nextSegments)
+					};
+					/**
+					* Gets the subsequent segments from the segment of
+					* the assignment currently being validated (targetAssignment).
+					* @returns {Iterable<SubsequentSegmentData>} the subsequent segments
+					*/
+					function* getSubsequentSegments() {
+						for (yield* subsequentSegmentData.results; subsequentSegmentData.queueSegments.length > 0;) {
+							let nextSegment = subsequentSegmentData.queueSegments.shift();
+							if (subsequentSegmentData.subsequentSegments.has(nextSegment)) continue;
+							subsequentSegmentData.subsequentSegments.add(nextSegment);
+							let assignmentInSegment = allAssignments.find((otherAssignment) => otherAssignment.segments.includes(nextSegment) && !isIdentifierUsedBetweenAssignedAndEqualSign(otherAssignment, targetAssignment.identifier));
+							assignmentInSegment || subsequentSegmentData.queueSegments.push(...nextSegment.nextSegments);
+							/** @type {SubsequentSegmentData} */
+							let result = {
+								segment: nextSegment,
+								assignment: assignmentInSegment
+							};
+							subsequentSegmentData.results.push(result), yield result;
+						}
+					}
+					if (targetAssignment.variable.references.some((ref) => ref.identifier.type !== "Identifier"))
+ /**
+					* Skip checking for a variable that has at least one non-identifier reference.
+					* It's generated by plugins and cannot be handled reliably in the core rule.
+					*/
+					return;
+					let readReferences = targetAssignment.variable.references.filter((reference) => reference.isRead());
+					if (!readReferences.length) return;
+					/**
+					* Other assignment on the current segment and after current assignment.
+					*/
+					let otherAssignmentAfterTargetAssignment = allAssignments.find((assignment) => assignment === targetAssignment || assignment.segments.length && assignment.segments.every((segment) => !targetAssignment.segments.includes(segment)) ? !1 : !!(isIdentifierEvaluatedAfterAssignment(targetAssignment, assignment.identifier) || assignment.expression && assignment.expression.range[0] <= targetAssignment.identifier.range[0] && targetAssignment.identifier.range[1] <= assignment.expression.range[1]));
+					for (let reference of readReferences) {
+						if (target.scope !== getCodePathStartScope(reference.from)) return;
+						if (isIdentifierEvaluatedAfterAssignment(targetAssignment, reference.identifier) && (isIdentifierUsedBetweenAssignedAndEqualSign(targetAssignment, reference.identifier) || targetAssignment.segments.some((segment) => isIdentifierUsedInSegment(segment, reference.identifier)))) {
+							if (otherAssignmentAfterTargetAssignment && isIdentifierEvaluatedAfterAssignment(otherAssignmentAfterTargetAssignment, reference.identifier)) continue;
+							return;
+						}
+						if (!otherAssignmentAfterTargetAssignment) {
+							for (let subsequentSegment of getSubsequentSegments()) if (isIdentifierUsedInSegment(subsequentSegment.segment, reference.identifier)) {
+								if (subsequentSegment.assignment && isIdentifierEvaluatedAfterAssignment(subsequentSegment.assignment, reference.identifier)) continue;
+								return;
+							}
+						}
+					}
+					context.report({
+						node: targetAssignment.identifier,
+						messageId: "unnecessaryAssignment"
+					});
+				}
+				for (let assignments of target.assignments.values()) {
+					assignments.sort((a, b) => a.identifier.range[0] - b.identifier.range[0]);
+					for (let assignment of assignments) verifyAssignmentIsUsed(assignment, assignments);
+				}
+			}
+			return {
+				onCodePathStart(codePath, node) {
+					let scope = sourceCode.getScope(node);
+					scopeStack = {
+						upper: scopeStack,
+						codePath,
+						scope,
+						segments: Object.create(null),
+						currentSegments: /* @__PURE__ */ new Set(),
+						assignments: /* @__PURE__ */ new Map(),
+						tryStatementBlocks: []
+					}, codePathStartScopes.add(scopeStack.scope);
+				},
+				onCodePathEnd() {
+					verify(scopeStack), scopeStack = scopeStack.upper;
+				},
+				onCodePathSegmentStart(segment) {
+					let segmentInfo = {
+						segment,
+						first: null,
+						last: null
+					};
+					scopeStack.segments[segment.id] = segmentInfo, scopeStack.currentSegments.add(segment);
+				},
+				onCodePathSegmentEnd(segment) {
+					scopeStack.currentSegments.delete(segment);
+				},
+				TryStatement(node) {
+					scopeStack.tryStatementBlocks.push(node.block);
+				},
+				Identifier(node) {
+					for (let segment of scopeStack.currentSegments) {
+						let segmentInfo = scopeStack.segments[segment.id];
+						segmentInfo.first ||= node, segmentInfo.last = node;
+					}
+				},
+				":matches(VariableDeclarator[init!=null], AssignmentExpression, UpdateExpression):exit"(node) {
+					if (scopeStack.currentSegments.size === 0) return;
+					let assignments = scopeStack.assignments, pattern, expression = null;
+					node.type === "VariableDeclarator" ? (pattern = node.id, expression = node.init) : node.type === "AssignmentExpression" ? (pattern = node.left, expression = node.right) : pattern = node.argument;
+					for (let identifier of extractIdentifiersFromPattern(pattern)) {
+						/** @type {Variable} */
+						let variable = findVariable(sourceCode.getScope(identifier), identifier);
+						if (!variable || variable.scope.type === "global" && variable.defs.length === 0 || scopeStack.scope !== getCodePathStartScope(variable.scope) || variable.eslintUsed || variable.scope.type === "module" && (variable.defs.some((def) => def.type === "Variable" && def.parent.parent.type === "ExportNamedDeclaration" || def.type === "FunctionName" && (def.node.parent.type === "ExportNamedDeclaration" || def.node.parent.type === "ExportDefaultDeclaration") || def.type === "ClassName" && (def.node.parent.type === "ExportNamedDeclaration" || def.node.parent.type === "ExportDefaultDeclaration")) || variable.references.some((reference) => reference.identifier.parent.type === "ExportSpecifier"))) continue;
+						let list = assignments.get(variable);
+						list || (list = [], assignments.set(variable, list)), list.push({
+							variable,
+							identifier,
+							node,
+							expression,
+							segments: [...scopeStack.currentSegments]
+						});
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-useless-assignment.cjs
+module.exports = require_no_useless_assignment().create;
+//#endregion

package/rules/no-useless-backreference.cjs

@@ -0,0 +1,137 @@
+const require_chunk = require("../common/chunk.cjs"), require_eslint_utils$1 = require("../common/eslint-utils.cjs"), require_regexpp$1 = require("../common/regexpp.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-useless-backreference.js
+/**
+* @fileoverview Rule to disallow useless backreferences in regular expressions
+* @author Milos Djermanovic
+*/
+var require_no_useless_backreference = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require_eslint_utils$1.t(), { RegExpParser, visitRegExpAST } = require_regexpp$1.t(), parser = new RegExpParser();
+	/**
+	* Finds the path from the given `regexpp` AST node to the root node.
+	* @param {regexpp.Node} node Node.
+	* @returns {regexpp.Node[]} Array that starts with the given node and ends with the root node.
+	*/
+	function getPathToRoot(node) {
+		let path = [], current = node;
+		do
+			path.push(current), current = current.parent;
+		while (current);
+		return path;
+	}
+	/**
+	* Determines whether the given `regexpp` AST node is a lookaround node.
+	* @param {regexpp.Node} node Node.
+	* @returns {boolean} `true` if it is a lookaround node.
+	*/
+	function isLookaround(node) {
+		return node.type === "Assertion" && (node.kind === "lookahead" || node.kind === "lookbehind");
+	}
+	/**
+	* Determines whether the given `regexpp` AST node is a negative lookaround node.
+	* @param {regexpp.Node} node Node.
+	* @returns {boolean} `true` if it is a negative lookaround node.
+	*/
+	function isNegativeLookaround(node) {
+		return isLookaround(node) && node.negate;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow useless backreferences in regular expressions",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-useless-backreference"
+			},
+			schema: [],
+			messages: {
+				nested: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} from within that group.",
+				forward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears later in the pattern.",
+				backward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears before in the same lookbehind.",
+				disjunctive: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in another alternative.",
+				intoNegativeLookaround: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in a negative lookaround."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Checks and reports useless backreferences in the given regular expression.
+			* @param {ASTNode} node Node that represents regular expression. A regex literal or RegExp constructor call.
+			* @param {string} pattern Regular expression pattern.
+			* @param {string} flags Regular expression flags.
+			* @returns {void}
+			*/
+			function checkRegex(node, pattern, flags) {
+				let regExpAST;
+				try {
+					regExpAST = parser.parsePattern(pattern, 0, pattern.length, {
+						unicode: flags.includes("u"),
+						unicodeSets: flags.includes("v")
+					});
+				} catch {
+					return;
+				}
+				visitRegExpAST(regExpAST, { onBackreferenceEnter(bref) {
+					let groups = [bref.resolved].flat(), brefPath = getPathToRoot(bref), problems = groups.map((group) => {
+						let groupPath = getPathToRoot(group);
+						if (brefPath.includes(group)) return {
+							messageId: "nested",
+							group
+						};
+						let i = brefPath.length - 1, j = groupPath.length - 1;
+						do
+							i--, j--;
+						while (brefPath[i] === groupPath[j]);
+						let indexOfLowestCommonAncestor = j + 1, groupCut = groupPath.slice(0, indexOfLowestCommonAncestor), lowestCommonLookaround = groupPath.slice(indexOfLowestCommonAncestor).find(isLookaround), isMatchingBackward = lowestCommonLookaround && lowestCommonLookaround.kind === "lookbehind";
+						return groupCut.at(-1).type === "Alternative" ? {
+							messageId: "disjunctive",
+							group
+						} : !isMatchingBackward && bref.end <= group.start ? {
+							messageId: "forward",
+							group
+						} : isMatchingBackward && group.end <= bref.start ? {
+							messageId: "backward",
+							group
+						} : groupCut.some(isNegativeLookaround) ? {
+							messageId: "intoNegativeLookaround",
+							group
+						} : null;
+					});
+					if (problems.length === 0 || problems.some((problem) => !problem)) return;
+					let problemsToReport, problemsInSameDisjunction = problems.filter((problem) => problem.messageId !== "disjunctive");
+					problemsToReport = problemsInSameDisjunction.length ? problemsInSameDisjunction : problems;
+					let [{ messageId, group }, ...other] = problemsToReport, otherGroups = "";
+					other.length === 1 ? otherGroups = " and another group" : other.length > 1 && (otherGroups = ` and other ${other.length} groups`), context.report({
+						node,
+						messageId,
+						data: {
+							bref: bref.raw,
+							group: group.raw,
+							otherGroups
+						}
+					});
+				} });
+			}
+			return {
+				"Literal[regex]"(node) {
+					let { pattern, flags } = node.regex;
+					checkRegex(node, pattern, flags);
+				},
+				Program(node) {
+					let scope = sourceCode.getScope(node), tracker = new ReferenceTracker(scope), traceMap = { RegExp: {
+						[CALL]: !0,
+						[CONSTRUCT]: !0
+					} };
+					for (let { node: refNode } of tracker.iterateGlobalReferences(traceMap)) {
+						let [patternNode, flagsNode] = refNode.arguments, pattern = getStringIfConstant(patternNode, scope), flags = getStringIfConstant(flagsNode, scope);
+						typeof pattern == "string" && checkRegex(refNode, pattern, flags || "");
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-useless-backreference.cjs
+module.exports = require_no_useless_backreference().create;
+//#endregion