oxlint-plugin-eslint 1.52.0

package/rules/radix.cjs

@@ -0,0 +1,124 @@
+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/radix.js
+/**
+* @fileoverview Rule to flag use of parseInt without a radix argument
+* @author James Allardice
+*/
+var require_radix = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), MODE_ALWAYS = "always", validRadixValues = new Set(Array.from({ length: 35 }, (_, index) => index + 2));
+	/**
+	* Checks whether a given variable is shadowed or not.
+	* @param {eslint-scope.Variable} variable A variable to check.
+	* @returns {boolean} `true` if the variable is shadowed.
+	*/
+	function isShadowed(variable) {
+		return variable.defs.length >= 1;
+	}
+	/**
+	* Checks whether a given node is a MemberExpression of `parseInt` method or not.
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if the node is a MemberExpression of `parseInt`
+	*      method.
+	*/
+	function isParseIntMethod(node) {
+		return node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier" && node.property.name === "parseInt";
+	}
+	/**
+	* Checks whether a given node is a valid value of radix or not.
+	*
+	* The following values are invalid.
+	*
+	* - A literal except integers between 2 and 36.
+	* - undefined.
+	* @param {ASTNode} radix A node of radix to check.
+	* @returns {boolean} `true` if the node is valid.
+	*/
+	function isValidRadix(radix) {
+		return !(radix.type === "Literal" && !validRadixValues.has(radix.value) || radix.type === "Identifier" && radix.name === "undefined");
+	}
+	/**
+	* Checks whether a given node is a default value of radix or not.
+	* @param {ASTNode} radix A node of radix to check.
+	* @returns {boolean} `true` if the node is the literal node of `10`.
+	*/
+	function isDefaultRadix(radix) {
+		return radix.type === "Literal" && radix.value === 10;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [MODE_ALWAYS],
+			docs: {
+				description: "Enforce the consistent use of the radix argument when using `parseInt()`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/radix"
+			},
+			hasSuggestions: !0,
+			schema: [{ enum: ["always", "as-needed"] }],
+			messages: {
+				missingParameters: "Missing parameters.",
+				redundantRadix: "Redundant radix parameter.",
+				missingRadix: "Missing radix parameter.",
+				invalidRadix: "Invalid radix parameter, must be an integer between 2 and 36.",
+				addRadixParameter10: "Add radix parameter `10` for parsing decimal numbers."
+			}
+		},
+		create(context) {
+			let [mode] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Checks the arguments of a given CallExpression node and reports it if it
+			* offends this rule.
+			* @param {ASTNode} node A CallExpression node to check.
+			* @returns {void}
+			*/
+			function checkArguments(node) {
+				let args = node.arguments;
+				switch (args.length) {
+					case 0:
+						context.report({
+							node,
+							messageId: "missingParameters"
+						});
+						break;
+					case 1:
+						mode === MODE_ALWAYS && context.report({
+							node,
+							messageId: "missingRadix",
+							suggest: [{
+								messageId: "addRadixParameter10",
+								fix(fixer) {
+									let tokens = sourceCode.getTokens(node), lastToken = tokens.at(-1), secondToLastToken = tokens.at(-2), hasTrailingComma = secondToLastToken.type === "Punctuator" && secondToLastToken.value === ",";
+									return fixer.insertTextBefore(lastToken, hasTrailingComma ? " 10," : ", 10");
+								}
+							}]
+						});
+						break;
+					default:
+						mode === "as-needed" && isDefaultRadix(args[1]) ? context.report({
+							node,
+							messageId: "redundantRadix"
+						}) : isValidRadix(args[1]) || context.report({
+							node,
+							messageId: "invalidRadix"
+						});
+						break;
+				}
+			}
+			return { "Program:exit"(node) {
+				let scope = sourceCode.getScope(node), variable;
+				variable = astUtils.getVariableByName(scope, "parseInt"), variable && !isShadowed(variable) && variable.references.forEach((reference) => {
+					let idNode = reference.identifier;
+					astUtils.isCallee(idNode) && checkArguments(idNode.parent);
+				}), variable = astUtils.getVariableByName(scope, "Number"), variable && !isShadowed(variable) && variable.references.forEach((reference) => {
+					let parentNode = reference.identifier.parent, maybeCallee = parentNode.parent.type === "ChainExpression" ? parentNode.parent : parentNode;
+					isParseIntMethod(parentNode) && astUtils.isCallee(maybeCallee) && checkArguments(maybeCallee.parent);
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/radix.cjs
+module.exports = require_radix().create;
+//#endregion

package/rules/require-atomic-updates.cjs

@@ -0,0 +1,197 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/require-atomic-updates.js
+/**
+* @fileoverview disallow assignments that can lead to race conditions due to usage of `await` or `yield`
+* @author Teddy Katz
+* @author Toru Nagashima
+*/
+var require_require_atomic_updates = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/**
+	* Make the map from identifiers to each reference.
+	* @param {escope.Scope} scope The scope to get references.
+	* @param {Map<Identifier, escope.Reference>} [outReferenceMap] The map from identifier nodes to each reference object.
+	* @returns {Map<Identifier, escope.Reference>} `referenceMap`.
+	*/
+	function createReferenceMap(scope, outReferenceMap = /* @__PURE__ */ new Map()) {
+		for (let reference of scope.references) reference.resolved !== null && outReferenceMap.set(reference.identifier, reference);
+		for (let childScope of scope.childScopes) childScope.type !== "function" && createReferenceMap(childScope, outReferenceMap);
+		return outReferenceMap;
+	}
+	/**
+	* Get `reference.writeExpr` of a given reference.
+	* If it's the read reference of MemberExpression in LHS, returns RHS in order to address `a.b = await a`
+	* @param {escope.Reference} reference The reference to get.
+	* @returns {Expression|null} The `reference.writeExpr`.
+	*/
+	function getWriteExpr(reference) {
+		if (reference.writeExpr) return reference.writeExpr;
+		let node = reference.identifier;
+		for (; node;) {
+			let t = node.parent.type;
+			if (t === "AssignmentExpression" && node.parent.left === node) return node.parent.right;
+			if (t === "MemberExpression" && node.parent.object === node) {
+				node = node.parent;
+				continue;
+			}
+			break;
+		}
+		return null;
+	}
+	/**
+	* Checks if an expression is a variable that can only be observed within the given function.
+	* @param {Variable|null} variable The variable to check
+	* @param {boolean} isMemberAccess If `true` then this is a member access.
+	* @returns {boolean} `true` if the variable is local to the given function, and is never referenced in a closure.
+	*/
+	function isLocalVariableWithoutEscape(variable, isMemberAccess) {
+		if (!variable || isMemberAccess && variable.defs.some((d) => d.type === "Parameter")) return !1;
+		let functionScope = variable.scope.variableScope;
+		return variable.references.every((reference) => reference.from.variableScope === functionScope);
+	}
+	/**
+	* Represents segment information.
+	*/
+	var SegmentInfo = class {
+		constructor() {
+			this.info = /* @__PURE__ */ new WeakMap();
+		}
+		/**
+		* Initialize the segment information.
+		* @param {PathSegment} segment The segment to initialize.
+		* @returns {void}
+		*/
+		initialize(segment) {
+			let outdatedReadVariables = /* @__PURE__ */ new Set(), freshReadVariables = /* @__PURE__ */ new Set();
+			for (let prevSegment of segment.prevSegments) {
+				let info = this.info.get(prevSegment);
+				info && (info.outdatedReadVariables.forEach(Set.prototype.add, outdatedReadVariables), info.freshReadVariables.forEach(Set.prototype.add, freshReadVariables));
+			}
+			this.info.set(segment, {
+				outdatedReadVariables,
+				freshReadVariables
+			});
+		}
+		/**
+		* Mark a given variable as read on given segments.
+		* @param {PathSegment[]} segments The segments that it read the variable on.
+		* @param {Variable} variable The variable to be read.
+		* @returns {void}
+		*/
+		markAsRead(segments, variable) {
+			for (let segment of segments) {
+				let info = this.info.get(segment);
+				info && (info.freshReadVariables.add(variable), info.outdatedReadVariables.delete(variable));
+			}
+		}
+		/**
+		* Move `freshReadVariables` to `outdatedReadVariables`.
+		* @param {PathSegment[]} segments The segments to process.
+		* @returns {void}
+		*/
+		makeOutdated(segments) {
+			for (let segment of segments) {
+				let info = this.info.get(segment);
+				info && (info.freshReadVariables.forEach(Set.prototype.add, info.outdatedReadVariables), info.freshReadVariables.clear());
+			}
+		}
+		/**
+		* Check if a given variable is outdated on the current segments.
+		* @param {PathSegment[]} segments The current segments.
+		* @param {Variable} variable The variable to check.
+		* @returns {boolean} `true` if the variable is outdated on the segments.
+		*/
+		isOutdated(segments, variable) {
+			for (let segment of segments) {
+				let info = this.info.get(segment);
+				if (info && info.outdatedReadVariables.has(variable)) return !0;
+			}
+			return !1;
+		}
+	};
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{ allowProperties: !1 }],
+			docs: {
+				description: "Disallow assignments that can lead to race conditions due to usage of `await` or `yield`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/require-atomic-updates"
+			},
+			fixable: null,
+			schema: [{
+				type: "object",
+				properties: { allowProperties: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: {
+				nonAtomicUpdate: "Possible race condition: `{{value}}` might be reassigned based on an outdated value of `{{value}}`.",
+				nonAtomicObjectUpdate: "Possible race condition: `{{value}}` might be assigned based on an outdated state of `{{object}}`."
+			}
+		},
+		create(context) {
+			let [{ allowProperties }] = context.options, sourceCode = context.sourceCode, assignmentReferences = /* @__PURE__ */ new Map(), segmentInfo = new SegmentInfo(), stack = null;
+			return {
+				onCodePathStart(codePath, node) {
+					let scope = sourceCode.getScope(node), shouldVerify = scope.type === "function" && (scope.block.async || scope.block.generator);
+					stack = {
+						upper: stack,
+						codePath,
+						referenceMap: shouldVerify ? createReferenceMap(scope) : null,
+						currentSegments: /* @__PURE__ */ new Set()
+					};
+				},
+				onCodePathEnd() {
+					stack = stack.upper;
+				},
+				onCodePathSegmentStart(segment) {
+					segmentInfo.initialize(segment), stack.currentSegments.add(segment);
+				},
+				onUnreachableCodePathSegmentStart(segment) {
+					stack.currentSegments.add(segment);
+				},
+				onUnreachableCodePathSegmentEnd(segment) {
+					stack.currentSegments.delete(segment);
+				},
+				onCodePathSegmentEnd(segment) {
+					stack.currentSegments.delete(segment);
+				},
+				Identifier(node) {
+					let { referenceMap } = stack, reference = referenceMap && referenceMap.get(node);
+					if (!reference) return;
+					let variable = reference.resolved, writeExpr = getWriteExpr(reference), isMemberAccess = reference.identifier.parent.type === "MemberExpression";
+					if (reference.isRead() && !(writeExpr && writeExpr.parent.operator === "=") && segmentInfo.markAsRead(stack.currentSegments, variable), writeExpr && writeExpr.parent.right === writeExpr && !isLocalVariableWithoutEscape(variable, isMemberAccess)) {
+						let refs = assignmentReferences.get(writeExpr);
+						refs || (refs = [], assignmentReferences.set(writeExpr, refs)), refs.push(reference);
+					}
+				},
+				":expression:exit"(node) {
+					if (!stack.referenceMap) return;
+					(node.type === "AwaitExpression" || node.type === "YieldExpression") && segmentInfo.makeOutdated(stack.currentSegments);
+					let references = assignmentReferences.get(node);
+					if (references) {
+						assignmentReferences.delete(node);
+						for (let reference of references) {
+							let variable = reference.resolved;
+							segmentInfo.isOutdated(stack.currentSegments, variable) && (node.parent.left === reference.identifier ? context.report({
+								node: node.parent,
+								messageId: "nonAtomicUpdate",
+								data: { value: variable.name }
+							}) : allowProperties || context.report({
+								node: node.parent,
+								messageId: "nonAtomicObjectUpdate",
+								data: {
+									value: sourceCode.getText(node.parent.left),
+									object: variable.name
+								}
+							}));
+						}
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/require-atomic-updates.cjs
+module.exports = require_require_atomic_updates().create;
+//#endregion

package/rules/require-await.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/require-await.js
+/**
+* @fileoverview Rule to disallow async functions which have no `await` expression.
+* @author Toru Nagashima
+*/
+var require_require_await = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Capitalize the 1st letter of the given text.
+	* @param {string} text The text to capitalize.
+	* @returns {string} The text that the 1st letter was capitalized.
+	*/
+	function capitalizeFirstLetter(text) {
+		return text[0].toUpperCase() + text.slice(1);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow async functions which have no `await` expression",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/require-await"
+			},
+			schema: [],
+			messages: {
+				missingAwait: "{{name}} has no 'await' expression.",
+				removeAsync: "Remove 'async'."
+			},
+			hasSuggestions: !0
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, scopeInfo = null;
+			/**
+			* Push the scope info object to the stack.
+			* @returns {void}
+			*/
+			function enterFunction() {
+				scopeInfo = {
+					upper: scopeInfo,
+					hasAwait: !1
+				};
+			}
+			/**
+			* Pop the top scope info object from the stack.
+			* Also, it reports the function if needed.
+			* @param {ASTNode} node The node to report.
+			* @returns {void}
+			*/
+			function exitFunction(node) {
+				if (!node.generator && node.async && !scopeInfo.hasAwait && !astUtils.isEmptyFunction(node)) {
+					let nodeWithAsyncKeyword = node.parent.type === "MethodDefinition" && node.parent.value === node || node.parent.type === "Property" && node.parent.method && node.parent.value === node ? node.parent : node, asyncToken = sourceCode.getFirstToken(nodeWithAsyncKeyword, (token) => token.value === "async"), asyncRange = [asyncToken.range[0], sourceCode.getTokenAfter(asyncToken, { includeComments: !0 }).range[0]], nextToken = sourceCode.getTokenAfter(asyncToken), addSemiColon = nextToken.type === "Punctuator" && (nextToken.value === "[" || nextToken.value === "(") && (nodeWithAsyncKeyword.type === "MethodDefinition" || astUtils.isStartOfExpressionStatement(nodeWithAsyncKeyword)) && astUtils.needsPrecedingSemicolon(sourceCode, nodeWithAsyncKeyword);
+					context.report({
+						node,
+						loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+						messageId: "missingAwait",
+						data: { name: capitalizeFirstLetter(astUtils.getFunctionNameWithKind(node)) },
+						suggest: [{
+							messageId: "removeAsync",
+							fix: (fixer) => fixer.replaceTextRange(asyncRange, addSemiColon ? ";" : "")
+						}]
+					});
+				}
+				scopeInfo = scopeInfo.upper;
+			}
+			return {
+				FunctionDeclaration: enterFunction,
+				FunctionExpression: enterFunction,
+				ArrowFunctionExpression: enterFunction,
+				"FunctionDeclaration:exit": exitFunction,
+				"FunctionExpression:exit": exitFunction,
+				"ArrowFunctionExpression:exit": exitFunction,
+				AwaitExpression() {
+					scopeInfo && (scopeInfo.hasAwait = !0);
+				},
+				ForOfStatement(node) {
+					scopeInfo && node.await && (scopeInfo.hasAwait = !0);
+				},
+				VariableDeclaration(node) {
+					scopeInfo && node.kind === "await using" && (scopeInfo.hasAwait = !0);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/require-await.cjs
+module.exports = require_require_await().create;
+//#endregion

package/rules/require-unicode-regexp.cjs

@@ -0,0 +1,101 @@
+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");
+require("../common/regexpp.cjs");
+const require_regular_expressions$1 = require("../common/regular-expressions.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/require-unicode-regexp.js
+/**
+* @fileoverview Rule to enforce the use of `u` or `v` flag on regular expressions.
+* @author Toru Nagashima
+*/
+var require_require_unicode_regexp = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require_eslint_utils$1.t(), astUtils = require_ast_utils$1.t(), { isValidWithUnicodeFlag } = require_regular_expressions$1.t();
+	/**
+	* Checks whether the flag configuration should be treated as a missing flag.
+	* @param {"u"|"v"|undefined} requireFlag A particular flag to require
+	* @param {string} flags The regex flags
+	* @returns {boolean} Whether the flag configuration results in a missing flag.
+	*/
+	function checkFlags(requireFlag, flags) {
+		let missingFlag;
+		return missingFlag = requireFlag === "v" ? !flags.includes("v") : requireFlag === "u" ? !flags.includes("u") : !flags.includes("u") && !flags.includes("v"), missingFlag;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{}],
+			docs: {
+				description: "Enforce the use of `u` or `v` flag on regular expressions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/require-unicode-regexp"
+			},
+			hasSuggestions: !0,
+			messages: {
+				addUFlag: "Add the 'u' flag.",
+				addVFlag: "Add the 'v' flag.",
+				requireUFlag: "Use the 'u' flag.",
+				requireVFlag: "Use the 'v' flag."
+			},
+			schema: [{
+				type: "object",
+				properties: { requireFlag: { enum: ["u", "v"] } },
+				additionalProperties: !1
+			}]
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, [{ requireFlag }] = context.options;
+			return {
+				"Literal[regex]"(node) {
+					checkFlags(requireFlag, node.regex.flags || "") && context.report({
+						messageId: requireFlag === "v" ? "requireVFlag" : "requireUFlag",
+						node,
+						suggest: isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern, requireFlag) ? [{
+							fix(fixer) {
+								let replaceFlag = requireFlag ?? "u", regex = sourceCode.getText(node), slashPos = regex.lastIndexOf("/");
+								if (requireFlag) {
+									let flag = requireFlag === "u" ? "v" : "u";
+									if (regex.includes(flag, slashPos)) return fixer.replaceText(node, regex.slice(0, slashPos) + regex.slice(slashPos).replace(flag, requireFlag));
+								}
+								return fixer.insertTextAfter(node, replaceFlag);
+							},
+							messageId: requireFlag === "v" ? "addVFlag" : "addUFlag"
+						}] : null
+					});
+				},
+				Program(node) {
+					let scope = sourceCode.getScope(node), tracker = new ReferenceTracker(scope), trackMap = { RegExp: {
+						[CALL]: !0,
+						[CONSTRUCT]: !0
+					} };
+					for (let { node: refNode } of tracker.iterateGlobalReferences(trackMap)) {
+						let [patternNode, flagsNode] = refNode.arguments;
+						if (patternNode && patternNode.type === "SpreadElement") continue;
+						let pattern = getStringIfConstant(patternNode, scope), flags = getStringIfConstant(flagsNode, scope), missingFlag = !flagsNode;
+						typeof flags == "string" && (missingFlag = checkFlags(requireFlag, flags)), missingFlag && context.report({
+							messageId: requireFlag === "v" ? "requireVFlag" : "requireUFlag",
+							node: refNode,
+							suggest: typeof pattern == "string" && isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern, requireFlag) ? [{
+								fix(fixer) {
+									let replaceFlag = requireFlag ?? "u";
+									if (flagsNode) {
+										if (flagsNode.type === "Literal" && typeof flagsNode.value == "string" || flagsNode.type === "TemplateLiteral") {
+											let flagsNodeText = sourceCode.getText(flagsNode), flag = requireFlag === "u" ? "v" : "u";
+											return flags.includes(flag) ? flagsNode.type === "Literal" && flagsNode.raw.includes("\\") || flagsNode.type === "TemplateLiteral" && (flagsNode.expressions.length || flagsNode.quasis.some(({ value: { raw } }) => raw.includes("\\"))) ? null : fixer.replaceText(flagsNode, flagsNodeText.replace(flag, replaceFlag)) : fixer.replaceText(flagsNode, [flagsNodeText.slice(0, flagsNodeText.length - 1), flagsNodeText.slice(flagsNodeText.length - 1)].join(replaceFlag));
+										}
+										return null;
+									}
+									let penultimateToken = sourceCode.getLastToken(refNode, { skip: 1 });
+									return fixer.insertTextAfter(penultimateToken, astUtils.isCommaToken(penultimateToken) ? ` "${replaceFlag}",` : `, "${replaceFlag}"`);
+								},
+								messageId: requireFlag === "v" ? "addVFlag" : "addUFlag"
+							}] : null
+						});
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/require-unicode-regexp.cjs
+module.exports = require_require_unicode_regexp().create;
+//#endregion

package/rules/require-yield.cjs

@@ -0,0 +1,56 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/require-yield.js
+/**
+* @fileoverview Rule to flag the generator functions that does not have yield.
+* @author Toru Nagashima
+*/
+var require_require_yield = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require generator functions to contain `yield`",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/require-yield"
+			},
+			schema: [],
+			messages: { missingYield: "This generator function does not have 'yield'." }
+		},
+		create(context) {
+			let stack = [];
+			/**
+			* If the node is a generator function, start counting `yield` keywords.
+			* @param {Node} node A function node to check.
+			* @returns {void}
+			*/
+			function beginChecking(node) {
+				node.generator && stack.push(0);
+			}
+			/**
+			* If the node is a generator function, end counting `yield` keywords, then
+			* reports result.
+			* @param {Node} node A function node to check.
+			* @returns {void}
+			*/
+			function endChecking(node) {
+				node.generator && stack.pop() === 0 && node.body.body.length > 0 && context.report({
+					node,
+					messageId: "missingYield"
+				});
+			}
+			return {
+				FunctionDeclaration: beginChecking,
+				"FunctionDeclaration:exit": endChecking,
+				FunctionExpression: beginChecking,
+				"FunctionExpression:exit": endChecking,
+				YieldExpression() {
+					stack.length > 0 && (stack[stack.length - 1] += 1);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/require-yield.cjs
+module.exports = require_require_yield().create;
+//#endregion

package/rules/rest-spread-spacing.cjs

@@ -0,0 +1,99 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/rest-spread-spacing.js
+/**
+* @fileoverview Enforce spacing between rest and spread operators and their expressions.
+* @author Kai Cataldo
+* @deprecated in ESLint v8.53.0
+*/
+var require_rest_spread_spacing = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @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: "rest-spread-spacing",
+						url: "https://eslint.style/rules/rest-spread-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce spacing between rest and spread operators and their expressions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/rest-spread-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["always", "never"] }],
+			messages: {
+				unexpectedWhitespace: "Unexpected whitespace after {{type}} operator.",
+				expectedWhitespace: "Expected whitespace after {{type}} operator."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, alwaysSpace = context.options[0] === "always";
+			/**
+			* Checks whitespace between rest/spread operators and their expressions
+			* @param {ASTNode} node The node to check
+			* @returns {void}
+			*/
+			function checkWhiteSpace(node) {
+				let operator = sourceCode.getFirstToken(node), nextToken = sourceCode.getTokenAfter(operator), hasWhitespace = sourceCode.isSpaceBetweenTokens(operator, nextToken), type;
+				switch (node.type) {
+					case "SpreadElement":
+						type = "spread", node.parent.type === "ObjectExpression" && (type += " property");
+						break;
+					case "RestElement":
+						type = "rest", node.parent.type === "ObjectPattern" && (type += " property");
+						break;
+					case "ExperimentalSpreadProperty":
+						type = "spread property";
+						break;
+					case "ExperimentalRestProperty":
+						type = "rest property";
+						break;
+					default: return;
+				}
+				alwaysSpace && !hasWhitespace ? context.report({
+					node,
+					loc: operator.loc,
+					messageId: "expectedWhitespace",
+					data: { type },
+					fix(fixer) {
+						return fixer.replaceTextRange([operator.range[1], nextToken.range[0]], " ");
+					}
+				}) : !alwaysSpace && hasWhitespace && context.report({
+					node,
+					loc: {
+						start: operator.loc.end,
+						end: nextToken.loc.start
+					},
+					messageId: "unexpectedWhitespace",
+					data: { type },
+					fix(fixer) {
+						return fixer.removeRange([operator.range[1], nextToken.range[0]]);
+					}
+				});
+			}
+			return {
+				SpreadElement: checkWhiteSpace,
+				RestElement: checkWhiteSpace,
+				ExperimentalSpreadProperty: checkWhiteSpace,
+				ExperimentalRestProperty: checkWhiteSpace
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/rest-spread-spacing.cjs
+module.exports = require_rest_spread_spacing().create;
+//#endregion