oxlint-plugin-eslint 1.52.0

package/rules/no-implicit-globals.cjs

@@ -0,0 +1,77 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-implicit-globals.js
+/**
+* @fileoverview Rule to check for implicit global variables, functions and classes.
+* @author Joshua Peek
+*/
+var require_no_implicit_globals = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let ASSIGNMENT_NODES = new Set([
+		"AssignmentExpression",
+		"ForInStatement",
+		"ForOfStatement"
+	]);
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ lexicalBindings: !1 }],
+			docs: {
+				description: "Disallow declarations in the global scope",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-implicit-globals"
+			},
+			schema: [{
+				type: "object",
+				properties: { lexicalBindings: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: {
+				globalNonLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable.",
+				globalLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in a block or in an IIFE.",
+				globalVariableLeak: "Global variable leak, declare the variable if it is intended to be local.",
+				assignmentToReadonlyGlobal: "Unexpected assignment to read-only global variable.",
+				redeclarationOfReadonlyGlobal: "Unexpected redeclaration of read-only global variable."
+			}
+		},
+		create(context) {
+			let [{ lexicalBindings: checkLexicalBindings }] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Reports the node.
+			* @param {ASTNode} node Node to report.
+			* @param {string} messageId Id of the message to report.
+			* @param {string|undefined} kind Declaration kind, can be 'var', 'const', 'let', function or class.
+			* @returns {void}
+			*/
+			function report(node, messageId, kind) {
+				context.report({
+					node,
+					messageId,
+					data: { kind }
+				});
+			}
+			return { Program(node) {
+				let scope = sourceCode.getScope(node);
+				scope.variables.forEach((variable) => {
+					let isReadonlyEslintGlobalVariable = variable.writeable === !1;
+					variable.writeable !== !0 && (variable.eslintExported || (variable.defs.forEach((def) => {
+						let defNode = def.node;
+						(def.type === "FunctionName" || def.type === "Variable" && def.parent.kind === "var") && (isReadonlyEslintGlobalVariable ? report(defNode, "redeclarationOfReadonlyGlobal") : report(defNode, "globalNonLexicalBinding", def.type === "FunctionName" ? "function" : `'${def.parent.kind}'`)), checkLexicalBindings && (def.type === "ClassName" || def.type === "Variable" && (def.parent.kind === "let" || def.parent.kind === "const")) && (isReadonlyEslintGlobalVariable ? report(defNode, "redeclarationOfReadonlyGlobal") : report(defNode, "globalLexicalBinding", def.type === "ClassName" ? "class" : `'${def.parent.kind}'`));
+					}), isReadonlyEslintGlobalVariable && variable.defs.length === 0 && variable.references.forEach((reference) => {
+						if (reference.isWrite() && !reference.isRead()) {
+							let assignmentParent = reference.identifier.parent;
+							for (; assignmentParent && !ASSIGNMENT_NODES.has(assignmentParent.type);) assignmentParent = assignmentParent.parent;
+							report(assignmentParent ?? reference.identifier, "assignmentToReadonlyGlobal");
+						}
+					})));
+				}), scope.implicit.variables.forEach((variable) => {
+					variable.defs.forEach((def) => {
+						report(def.node, "globalVariableLeak");
+					});
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-implicit-globals.cjs
+module.exports = require_no_implicit_globals().create;
+//#endregion

package/rules/no-implied-eval.cjs

@@ -0,0 +1,87 @@
+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-implied-eval.js
+/**
+* @fileoverview Rule to flag use of implied eval via setTimeout and setInterval
+* @author James Allardice
+*/
+var require_no_implied_eval = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), { getStaticValue } = require_eslint_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow the use of `eval()`-like methods",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-implied-eval"
+			},
+			schema: [],
+			messages: {
+				impliedEval: "Implied eval. Consider passing a function instead of a string.",
+				execScript: "Implied eval. Do not use execScript()."
+			}
+		},
+		create(context) {
+			let GLOBAL_CANDIDATES = Object.freeze([
+				"global",
+				"window",
+				"globalThis"
+			]), EVAL_LIKE_FUNC_PATTERN = /^(?:set(?:Interval|Timeout)|execScript)$/u, sourceCode = context.sourceCode;
+			/**
+			* Checks whether a node is evaluated as a string or not.
+			* @param {ASTNode} node A node to check.
+			* @returns {boolean} True if the node is evaluated as a string.
+			*/
+			function isEvaluatedString(node) {
+				return node.type === "Literal" && typeof node.value == "string" || node.type === "TemplateLiteral" ? !0 : node.type === "BinaryExpression" && node.operator === "+" ? isEvaluatedString(node.left) || isEvaluatedString(node.right) : !1;
+			}
+			/**
+			* Reports if the `CallExpression` node has evaluated argument.
+			* @param {ASTNode} node A CallExpression to check.
+			* @returns {void}
+			*/
+			function reportImpliedEvalCallExpression(node) {
+				let [firstArgument] = node.arguments;
+				if (firstArgument) {
+					let staticValue = getStaticValue(firstArgument, sourceCode.getScope(node));
+					if (staticValue && typeof staticValue.value == "string" || isEvaluatedString(firstArgument)) {
+						let isExecScript = (node.callee.type === "Identifier" ? node.callee.name : astUtils.getStaticPropertyName(node.callee)) === "execScript";
+						context.report({
+							node,
+							messageId: isExecScript ? "execScript" : "impliedEval"
+						});
+					}
+				}
+			}
+			/**
+			* Reports calls of `implied eval` via the global references.
+			* @param {Variable} globalVar A global variable to check.
+			* @returns {void}
+			*/
+			function reportImpliedEvalViaGlobal(globalVar) {
+				let { references, name } = globalVar;
+				references.forEach((ref) => {
+					let node = ref.identifier.parent;
+					for (; astUtils.isSpecificMemberAccess(node, null, name);) node = node.parent;
+					if (astUtils.isSpecificMemberAccess(node, null, EVAL_LIKE_FUNC_PATTERN)) {
+						let calleeNode = node.parent.type === "ChainExpression" ? node.parent : node, parent = calleeNode.parent;
+						parent.type === "CallExpression" && parent.callee === calleeNode && reportImpliedEvalCallExpression(parent);
+					}
+				});
+			}
+			return {
+				CallExpression(node) {
+					astUtils.isSpecificId(node.callee, EVAL_LIKE_FUNC_PATTERN) && sourceCode.isGlobalReference(node.callee) && reportImpliedEvalCallExpression(node);
+				},
+				"Program:exit"(node) {
+					let globalScope = sourceCode.getScope(node);
+					GLOBAL_CANDIDATES.map((candidate) => astUtils.getVariableByName(globalScope, candidate)).filter((globalVar) => !!globalVar && globalVar.defs.length === 0).forEach(reportImpliedEvalViaGlobal);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-implied-eval.cjs
+module.exports = require_no_implied_eval().create;
+//#endregion

package/rules/no-import-assign.cjs

@@ -0,0 +1,123 @@
+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-import-assign.js
+/**
+* @fileoverview Rule to flag updates of imported bindings.
+* @author Toru Nagashima <https://github.com/mysticatea>
+*/
+var require_no_import_assign = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { findVariable } = require_eslint_utils$1.t(), astUtils = require_ast_utils$1.t(), WellKnownMutationFunctions = {
+		Object: /^(?:assign|definePropert(?:y|ies)|freeze|setPrototypeOf)$/u,
+		Reflect: /^(?:(?:define|delete)Property|set(?:PrototypeOf)?)$/u
+	};
+	/**
+	* Check if a given node is LHS of an assignment node.
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} `true` if the node is LHS.
+	*/
+	function isAssignmentLeft(node) {
+		let { parent } = node;
+		return parent.type === "AssignmentExpression" && parent.left === node || parent.type === "ArrayPattern" || parent.type === "Property" && parent.value === node && parent.parent.type === "ObjectPattern" || parent.type === "RestElement" || parent.type === "AssignmentPattern" && parent.left === node;
+	}
+	/**
+	* Check if a given node is the operand of mutation unary operator.
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} `true` if the node is the operand of mutation unary operator.
+	*/
+	function isOperandOfMutationUnaryOperator(node) {
+		let argumentNode = node.parent.type === "ChainExpression" ? node.parent : node, { parent } = argumentNode;
+		return parent.type === "UpdateExpression" && parent.argument === argumentNode || parent.type === "UnaryExpression" && parent.operator === "delete" && parent.argument === argumentNode;
+	}
+	/**
+	* Check if a given node is the iteration variable of `for-in`/`for-of` syntax.
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} `true` if the node is the iteration variable.
+	*/
+	function isIterationVariable(node) {
+		let { parent } = node;
+		return parent.type === "ForInStatement" && parent.left === node || parent.type === "ForOfStatement" && parent.left === node;
+	}
+	/**
+	* Check if a given node is at the first argument of a well-known mutation function.
+	* - `Object.assign`
+	* - `Object.defineProperty`
+	* - `Object.defineProperties`
+	* - `Object.freeze`
+	* - `Object.setPrototypeOf`
+	* - `Reflect.defineProperty`
+	* - `Reflect.deleteProperty`
+	* - `Reflect.set`
+	* - `Reflect.setPrototypeOf`
+	* @param {ASTNode} node The node to check.
+	* @param {Scope} scope A `escope.Scope` object to find variable (whichever).
+	* @returns {boolean} `true` if the node is at the first argument of a well-known mutation function.
+	*/
+	function isArgumentOfWellKnownMutationFunction(node, scope) {
+		let { parent } = node;
+		if (parent.type !== "CallExpression" || parent.arguments[0] !== node) return !1;
+		let callee = astUtils.skipChainExpression(parent.callee);
+		if (!astUtils.isSpecificMemberAccess(callee, "Object", WellKnownMutationFunctions.Object) && !astUtils.isSpecificMemberAccess(callee, "Reflect", WellKnownMutationFunctions.Reflect)) return !1;
+		let variable = findVariable(scope, callee.object);
+		return variable !== null && variable.scope.type === "global";
+	}
+	/**
+	* Check if the identifier node is placed at to update members.
+	* @param {ASTNode} id The Identifier node to check.
+	* @param {Scope} scope A `escope.Scope` object to find variable (whichever).
+	* @returns {boolean} `true` if the member of `id` was updated.
+	*/
+	function isMemberWrite(id, scope) {
+		let { parent } = id;
+		return parent.type === "MemberExpression" && parent.object === id && (isAssignmentLeft(parent) || isOperandOfMutationUnaryOperator(parent) || isIterationVariable(parent)) || isArgumentOfWellKnownMutationFunction(id, scope);
+	}
+	/**
+	* Get the mutation node.
+	* @param {ASTNode} id The Identifier node to get.
+	* @returns {ASTNode} The mutation node.
+	*/
+	function getWriteNode(id) {
+		let node = id.parent;
+		for (; node && node.type !== "AssignmentExpression" && node.type !== "UpdateExpression" && node.type !== "UnaryExpression" && node.type !== "CallExpression" && node.type !== "ForInStatement" && node.type !== "ForOfStatement";) node = node.parent;
+		return node || id;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow assigning to imported bindings",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-import-assign"
+			},
+			schema: [],
+			messages: {
+				readonly: "'{{name}}' is read-only.",
+				readonlyMember: "The members of '{{name}}' are read-only."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { ImportDeclaration(node) {
+				let scope = sourceCode.getScope(node);
+				for (let variable of sourceCode.getDeclaredVariables(node)) {
+					let shouldCheckMembers = variable.defs.some((d) => d.node.type === "ImportNamespaceSpecifier"), prevIdNode = null;
+					for (let reference of variable.references) {
+						let idNode = reference.identifier;
+						idNode !== prevIdNode && (prevIdNode = idNode, reference.isWrite() ? context.report({
+							node: getWriteNode(idNode),
+							messageId: "readonly",
+							data: { name: idNode.name }
+						}) : shouldCheckMembers && isMemberWrite(idNode, scope) && context.report({
+							node: getWriteNode(idNode),
+							messageId: "readonlyMember",
+							data: { name: idNode.name }
+						}));
+					}
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-import-assign.cjs
+module.exports = require_no_import_assign().create;
+//#endregion

package/rules/no-inline-comments.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-inline-comments.js
+/**
+* @fileoverview Enforces or disallows inline comments.
+* @author Greg Cochard
+*/
+var require_no_inline_comments = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{}],
+			docs: {
+				description: "Disallow inline comments after code",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-inline-comments"
+			},
+			schema: [{
+				type: "object",
+				properties: { ignorePattern: { type: "string" } },
+				additionalProperties: !1
+			}],
+			messages: { unexpectedInlineComment: "Unexpected comment inline with code." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, [{ ignorePattern }] = context.options, customIgnoreRegExp = ignorePattern && new RegExp(ignorePattern, "u");
+			/**
+			* Will check that comments are not on lines starting with or ending with code
+			* @param {ASTNode} node The comment node to check
+			* @private
+			* @returns {void}
+			*/
+			function testCodeAroundComment(node) {
+				let startLine = String(sourceCode.lines[node.loc.start.line - 1]), endLine = String(sourceCode.lines[node.loc.end.line - 1]), preamble = startLine.slice(0, node.loc.start.column).trim(), postamble = endLine.slice(node.loc.end.column).trim(), isPreambleEmpty = !preamble, isPostambleEmpty = !postamble;
+				if (!(isPreambleEmpty && isPostambleEmpty) && !(customIgnoreRegExp && customIgnoreRegExp.test(node.value))) {
+					if ((isPreambleEmpty || preamble === "{") && (isPostambleEmpty || postamble === "}")) {
+						let enclosingNode = sourceCode.getNodeByRangeIndex(node.range[0]);
+						if (enclosingNode && enclosingNode.type === "JSXEmptyExpression") return;
+					}
+					astUtils.isDirectiveComment(node) || context.report({
+						node,
+						messageId: "unexpectedInlineComment"
+					});
+				}
+			}
+			return { Program() {
+				sourceCode.getAllComments().filter((token) => token.type !== "Shebang").forEach(testCodeAroundComment);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-inline-comments.cjs
+module.exports = require_no_inline_comments().create;
+//#endregion

package/rules/no-inner-declarations.cjs

@@ -0,0 +1,82 @@
+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-inner-declarations.js
+/**
+* @fileoverview Rule to enforce declarations in program or function body root.
+* @author Brandon Mills
+*/
+var require_no_inner_declarations = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), validParent = new Set([
+		"Program",
+		"StaticBlock",
+		"ExportNamedDeclaration",
+		"ExportDefaultDeclaration"
+	]), validBlockStatementParent = new Set([
+		"FunctionDeclaration",
+		"FunctionExpression",
+		"ArrowFunctionExpression"
+	]);
+	/**
+	* Finds the nearest enclosing context where this rule allows declarations and returns its description.
+	* @param {ASTNode} node Node to search from.
+	* @returns {string} Description. One of "program", "function body", "class static block body".
+	*/
+	function getAllowedBodyDescription(node) {
+		let { parent } = node;
+		for (; parent;) {
+			if (parent.type === "StaticBlock") return "class static block body";
+			if (astUtils.isFunction(parent)) return "function body";
+			({parent} = parent);
+		}
+		return "program";
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: ["functions", { blockScopedFunctions: "allow" }],
+			docs: {
+				description: "Disallow variable or `function` declarations in nested blocks",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-inner-declarations"
+			},
+			schema: [{ enum: ["functions", "both"] }, {
+				type: "object",
+				properties: { blockScopedFunctions: { enum: ["allow", "disallow"] } },
+				additionalProperties: !1
+			}],
+			messages: { moveDeclToRoot: "Move {{type}} declaration to {{body}} root." }
+		},
+		create(context) {
+			let both = context.options[0] === "both", { blockScopedFunctions } = context.options[1], sourceCode = context.sourceCode, ecmaVersion = context.languageOptions.ecmaVersion;
+			/**
+			* Ensure that a given node is at a program or function body's root.
+			* @param {ASTNode} node Declaration node to check.
+			* @returns {void}
+			*/
+			function check(node) {
+				let parent = node.parent;
+				parent.type === "BlockStatement" && validBlockStatementParent.has(parent.parent.type) || validParent.has(parent.type) || context.report({
+					node,
+					messageId: "moveDeclToRoot",
+					data: {
+						type: node.type === "FunctionDeclaration" ? "function" : "variable",
+						body: getAllowedBodyDescription(node)
+					}
+				});
+			}
+			return {
+				FunctionDeclaration(node) {
+					let isInStrictCode = sourceCode.getScope(node).upper.isStrict;
+					blockScopedFunctions === "allow" && ecmaVersion >= 2015 && isInStrictCode || check(node);
+				},
+				VariableDeclaration(node) {
+					both && node.kind === "var" && check(node);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-inner-declarations.cjs
+module.exports = require_no_inner_declarations().create;
+//#endregion

package/rules/no-invalid-regexp.cjs

@@ -0,0 +1,130 @@
+const require_chunk = require("../common/chunk.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-invalid-regexp.js
+/**
+* @fileoverview Validate strings passed to the RegExp constructor
+* @author Michael Ficarra
+*/
+var require_no_invalid_regexp = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let RegExpValidator = require_regexpp$1.t().RegExpValidator, validator = new RegExpValidator(), validFlags = "dgimsuvy";
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{}],
+			docs: {
+				description: "Disallow invalid regular expression strings in `RegExp` constructors",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-invalid-regexp"
+			},
+			schema: [{
+				type: "object",
+				properties: { allowConstructorFlags: {
+					type: "array",
+					items: { type: "string" }
+				} },
+				additionalProperties: !1
+			}],
+			messages: { regexMessage: "{{message}}." }
+		},
+		create(context) {
+			let [{ allowConstructorFlags }] = context.options, allowedFlags = [];
+			if (allowConstructorFlags) {
+				let temp = allowConstructorFlags.join("").replace(RegExp(`[${validFlags}]`, "gu"), "");
+				temp && (allowedFlags = [...new Set(temp)]);
+			}
+			/**
+			* Reports error with the provided message.
+			* @param {ASTNode} node The node holding the invalid RegExp
+			* @param {string} message The message to report.
+			* @returns {void}
+			*/
+			function report(node, message) {
+				context.report({
+					node,
+					messageId: "regexMessage",
+					data: { message }
+				});
+			}
+			/**
+			* Check if node is a string
+			* @param {ASTNode} node node to evaluate
+			* @returns {boolean} True if its a string
+			* @private
+			*/
+			function isString(node) {
+				return node && node.type === "Literal" && typeof node.value == "string";
+			}
+			/**
+			* Gets flags of a regular expression created by the given `RegExp()` or `new RegExp()` call
+			* Examples:
+			*     new RegExp(".")         // => ""
+			*     new RegExp(".", "gu")   // => "gu"
+			*     new RegExp(".", flags)  // => null
+			* @param {ASTNode} node `CallExpression` or `NewExpression` node
+			* @returns {string|null} flags if they can be determined, `null` otherwise
+			* @private
+			*/
+			function getFlags(node) {
+				return node.arguments.length < 2 ? "" : isString(node.arguments[1]) ? node.arguments[1].value : null;
+			}
+			/**
+			* Check syntax error in a given pattern.
+			* @param {string} pattern The RegExp pattern to validate.
+			* @param {Object} flags The RegExp flags to validate.
+			* @param {boolean} [flags.unicode] The Unicode flag.
+			* @param {boolean} [flags.unicodeSets] The UnicodeSets flag.
+			* @returns {string|null} The syntax error.
+			*/
+			function validateRegExpPattern(pattern, flags) {
+				try {
+					return validator.validatePattern(pattern, void 0, void 0, flags), null;
+				} catch (err) {
+					return err.message;
+				}
+			}
+			/**
+			* Check syntax error in a given flags.
+			* @param {string|null} flags The RegExp flags to validate.
+			* @param {string|null} flagsToCheck The RegExp invalid flags.
+			* @param {string} allFlags all valid and allowed flags.
+			* @returns {string|null} The syntax error.
+			*/
+			function validateRegExpFlags(flags, flagsToCheck, allFlags) {
+				let duplicateFlags = [];
+				if (typeof flagsToCheck == "string") for (let flag of flagsToCheck) allFlags.includes(flag) && duplicateFlags.push(flag);
+				return flags && flags.includes("u") && flags.includes("v") ? "Regex 'u' and 'v' flags cannot be used together" : duplicateFlags.length > 0 ? `Duplicate flags ('${duplicateFlags.join("")}') supplied to RegExp constructor` : flagsToCheck ? `Invalid flags supplied to RegExp constructor '${flagsToCheck}'` : null;
+			}
+			return { "CallExpression, NewExpression"(node) {
+				if (node.callee.type !== "Identifier" || node.callee.name !== "RegExp") return;
+				let flags = getFlags(node), flagsToCheck = flags, allFlags = allowedFlags.length > 0 ? validFlags.split("").concat(allowedFlags) : validFlags.split("");
+				flags && allFlags.forEach((flag) => {
+					flagsToCheck = flagsToCheck.replace(flag, "");
+				});
+				let message = validateRegExpFlags(flags, flagsToCheck, allFlags);
+				if (message) {
+					report(node, message);
+					return;
+				}
+				if (!isString(node.arguments[0])) return;
+				let pattern = node.arguments[0].value;
+				message = flags === null ? validateRegExpPattern(pattern, {
+					unicode: !0,
+					unicodeSets: !1
+				}) && validateRegExpPattern(pattern, {
+					unicode: !1,
+					unicodeSets: !0
+				}) && validateRegExpPattern(pattern, {
+					unicode: !1,
+					unicodeSets: !1
+				}) : validateRegExpPattern(pattern, {
+					unicode: flags.includes("u"),
+					unicodeSets: flags.includes("v")
+				}), message && report(node, message);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-invalid-regexp.cjs
+module.exports = require_no_invalid_regexp().create;
+//#endregion

package/rules/no-invalid-this.cjs

@@ -0,0 +1,90 @@
+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-invalid-this.js
+/**
+* @fileoverview A rule to disallow `this` keywords in contexts where the value of `this` is `undefined`.
+* @author Toru Nagashima
+*/
+var require_no_invalid_this = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Determines if the given code path is a code path with lexical `this` binding.
+	* That is, if `this` within the code path refers to `this` of surrounding code path.
+	* @param {CodePath} codePath Code path.
+	* @param {ASTNode} node Node that started the code path.
+	* @returns {boolean} `true` if it is a code path with lexical `this` binding.
+	*/
+	function isCodePathWithLexicalThis(codePath, node) {
+		return codePath.origin === "function" && node.type === "ArrowFunctionExpression";
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			type: "suggestion",
+			defaultOptions: [{ capIsConstructor: !0 }],
+			docs: {
+				description: "Disallow use of `this` in contexts where the value of `this` is `undefined`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-invalid-this"
+			},
+			schema: [{
+				type: "object",
+				properties: { capIsConstructor: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: { unexpectedThis: "Unexpected 'this'." }
+		},
+		create(context) {
+			let [{ capIsConstructor }] = context.options, stack = [], sourceCode = context.sourceCode;
+			return stack.getCurrent = function() {
+				let current = this.at(-1);
+				return current.init || (current.init = !0, current.valid = !astUtils.isDefaultThisBinding(current.node, sourceCode, { capIsConstructor })), current;
+			}, {
+				onCodePathStart(codePath, node) {
+					if (!isCodePathWithLexicalThis(codePath, node)) {
+						if (codePath.origin === "program") {
+							let scope = sourceCode.getScope(node), features = context.languageOptions.parserOptions.ecmaFeatures || {};
+							stack.push({
+								init: !0,
+								node,
+								valid: !(node.sourceType === "module" || features.globalReturn && scope.childScopes[0].isStrict)
+							});
+							return;
+						}
+						stack.push({
+							init: !sourceCode.getScope(node).isStrict,
+							node,
+							valid: !0
+						});
+					}
+				},
+				onCodePathEnd(codePath, node) {
+					isCodePathWithLexicalThis(codePath, node) || stack.pop();
+				},
+				"AccessorProperty > *.value"(node) {
+					stack.push({
+						init: !0,
+						node,
+						valid: !0
+					});
+				},
+				"AccessorProperty:exit"() {
+					stack.pop();
+				},
+				ThisExpression(node) {
+					if (node.parent.type === "AccessorProperty" && node.parent.value === node) return;
+					let current = stack.getCurrent();
+					current && !current.valid && context.report({
+						node,
+						messageId: "unexpectedThis"
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-invalid-this.cjs
+module.exports = require_no_invalid_this().create;
+//#endregion