oxlint-plugin-eslint 1.52.0

package/rules/func-style.cjs

@@ -0,0 +1,103 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/func-style.js
+/**
+* @fileoverview Rule to enforce a particular function style
+* @author Nicholas C. Zakas
+*/
+var require_func_style = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			type: "suggestion",
+			defaultOptions: ["expression", {
+				allowArrowFunctions: !1,
+				allowTypeAnnotation: !1,
+				overrides: {}
+			}],
+			docs: {
+				description: "Enforce the consistent use of either `function` declarations or expressions assigned to variables",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/func-style"
+			},
+			schema: [{ enum: ["declaration", "expression"] }, {
+				type: "object",
+				properties: {
+					allowArrowFunctions: { type: "boolean" },
+					allowTypeAnnotation: { type: "boolean" },
+					overrides: {
+						type: "object",
+						properties: { namedExports: { enum: [
+							"declaration",
+							"expression",
+							"ignore"
+						] } },
+						additionalProperties: !1
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				expression: "Expected a function expression.",
+				declaration: "Expected a function declaration."
+			}
+		},
+		create(context) {
+			let [style, { allowArrowFunctions, allowTypeAnnotation, overrides }] = context.options, enforceDeclarations = style === "declaration", { namedExports: exportFunctionStyle } = overrides, stack = [];
+			/**
+			* Checks if a function declaration is part of an overloaded function
+			* @param {ASTNode} node The function declaration node to check
+			* @returns {boolean} True if the function is overloaded
+			*/
+			function isOverloadedFunction(node) {
+				let functionName = node.id.name;
+				return node.parent.type === "ExportNamedDeclaration" ? node.parent.parent.body.some((member) => member.type === "ExportNamedDeclaration" && member.declaration?.type === "TSDeclareFunction" && member.declaration.id.name === functionName) : node.parent.type === "SwitchCase" ? node.parent.parent.cases.some((switchCase) => switchCase.consequent.some((member) => member.type === "TSDeclareFunction" && member.id.name === functionName)) : Array.isArray(node.parent.body) && node.parent.body.some((member) => member.type === "TSDeclareFunction" && member.id.name === functionName);
+			}
+			let nodesToCheck = {
+				FunctionDeclaration(node) {
+					stack.push(!1), !enforceDeclarations && node.parent.type !== "ExportDefaultDeclaration" && (exportFunctionStyle === void 0 || node.parent.type !== "ExportNamedDeclaration") && !isOverloadedFunction(node) && context.report({
+						node,
+						messageId: "expression"
+					}), node.parent.type === "ExportNamedDeclaration" && exportFunctionStyle === "expression" && !isOverloadedFunction(node) && context.report({
+						node,
+						messageId: "expression"
+					});
+				},
+				"FunctionDeclaration:exit"() {
+					stack.pop();
+				},
+				FunctionExpression(node) {
+					stack.push(!1), enforceDeclarations && node.parent.type === "VariableDeclarator" && (exportFunctionStyle === void 0 || node.parent.parent.parent.type !== "ExportNamedDeclaration") && !(allowTypeAnnotation && node.parent.id.typeAnnotation) && context.report({
+						node: node.parent,
+						messageId: "declaration"
+					}), node.parent.type === "VariableDeclarator" && node.parent.parent.parent.type === "ExportNamedDeclaration" && exportFunctionStyle === "declaration" && !(allowTypeAnnotation && node.parent.id.typeAnnotation) && context.report({
+						node: node.parent,
+						messageId: "declaration"
+					});
+				},
+				"FunctionExpression:exit"() {
+					stack.pop();
+				},
+				"ThisExpression, Super"() {
+					stack.length > 0 && (stack[stack.length - 1] = !0);
+				}
+			};
+			return allowArrowFunctions || (nodesToCheck.ArrowFunctionExpression = function() {
+				stack.push(!1);
+			}, nodesToCheck["ArrowFunctionExpression:exit"] = function(node) {
+				!stack.pop() && node.parent.type === "VariableDeclarator" && (enforceDeclarations && (exportFunctionStyle === void 0 || node.parent.parent.parent.type !== "ExportNamedDeclaration") && !(allowTypeAnnotation && node.parent.id.typeAnnotation) && context.report({
+					node: node.parent,
+					messageId: "declaration"
+				}), node.parent.parent.parent.type === "ExportNamedDeclaration" && exportFunctionStyle === "declaration" && !(allowTypeAnnotation && node.parent.id.typeAnnotation) && context.report({
+					node: node.parent,
+					messageId: "declaration"
+				}));
+			}), nodesToCheck;
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/func-style.cjs
+module.exports = require_func_style().create;
+//#endregion

package/rules/function-call-argument-newline.cjs

@@ -0,0 +1,109 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/function-call-argument-newline.js
+/**
+* @fileoverview Rule to enforce line breaks between arguments of a function call
+* @author Alexey Gonchar <https://github.com/finico>
+* @deprecated in ESLint v8.53.0
+*/
+var require_function_call_argument_newline = /* @__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: "function-call-argument-newline",
+						url: "https://eslint.style/rules/function-call-argument-newline"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce line breaks between arguments of a function call",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/function-call-argument-newline"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: [
+				"always",
+				"never",
+				"consistent"
+			] }],
+			messages: {
+				unexpectedLineBreak: "There should be no line break here.",
+				missingLineBreak: "There should be a line break after this argument."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, checkers = {
+				unexpected: {
+					messageId: "unexpectedLineBreak",
+					check: (prevToken, currentToken) => prevToken.loc.end.line !== currentToken.loc.start.line,
+					createFix: (token, tokenBefore) => (fixer) => fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], " ")
+				},
+				missing: {
+					messageId: "missingLineBreak",
+					check: (prevToken, currentToken) => prevToken.loc.end.line === currentToken.loc.start.line,
+					createFix: (token, tokenBefore) => (fixer) => fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], "\n")
+				}
+			};
+			/**
+			* Check all arguments for line breaks in the CallExpression
+			* @param {CallExpression} node node to evaluate
+			* @param {{ messageId: string, check: Function }} checker selected checker
+			* @returns {void}
+			* @private
+			*/
+			function checkArguments(node, checker) {
+				for (let i = 1; i < node.arguments.length; i++) {
+					let prevArgToken = sourceCode.getLastToken(node.arguments[i - 1]), currentArgToken = sourceCode.getFirstToken(node.arguments[i]);
+					if (checker.check(prevArgToken, currentArgToken)) {
+						let tokenBefore = sourceCode.getTokenBefore(currentArgToken, { includeComments: !0 }), hasLineCommentBefore = tokenBefore.type === "Line";
+						context.report({
+							node,
+							loc: {
+								start: tokenBefore.loc.end,
+								end: currentArgToken.loc.start
+							},
+							messageId: checker.messageId,
+							fix: hasLineCommentBefore ? null : checker.createFix(currentArgToken, tokenBefore)
+						});
+					}
+				}
+			}
+			/**
+			* Check if open space is present in a function name
+			* @param {CallExpression} node node to evaluate
+			* @returns {void}
+			* @private
+			*/
+			function check(node) {
+				if (node.arguments.length < 2) return;
+				let option = context.options[0] || "always";
+				if (option === "never") checkArguments(node, checkers.unexpected);
+				else if (option === "always") checkArguments(node, checkers.missing);
+				else if (option === "consistent") {
+					let firstArgToken = sourceCode.getLastToken(node.arguments[0]), secondArgToken = sourceCode.getFirstToken(node.arguments[1]);
+					firstArgToken.loc.end.line === secondArgToken.loc.start.line ? checkArguments(node, checkers.unexpected) : checkArguments(node, checkers.missing);
+				}
+			}
+			return {
+				CallExpression: check,
+				NewExpression: check
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/function-call-argument-newline.cjs
+module.exports = require_function_call_argument_newline().create;
+//#endregion

package/rules/function-paren-newline.cjs

@@ -0,0 +1,173 @@
+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/function-paren-newline.js
+/**
+* @fileoverview enforce consistent line breaks inside function parentheses
+* @author Teddy Katz
+* @deprecated in ESLint v8.53.0
+*/
+var require_function_paren_newline = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Formatting rules are being moved out of ESLint core.",
+				url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+				deprecatedSince: "8.53.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style"
+					},
+					rule: {
+						name: "function-paren-newline",
+						url: "https://eslint.style/rules/function-paren-newline"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent line breaks inside function parentheses",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/function-paren-newline"
+			},
+			fixable: "whitespace",
+			schema: [{ oneOf: [{ enum: [
+				"always",
+				"never",
+				"consistent",
+				"multiline",
+				"multiline-arguments"
+			] }, {
+				type: "object",
+				properties: { minItems: {
+					type: "integer",
+					minimum: 0
+				} },
+				additionalProperties: !1
+			}] }],
+			messages: {
+				expectedBefore: "Expected newline before ')'.",
+				expectedAfter: "Expected newline after '('.",
+				expectedBetween: "Expected newline between arguments/params.",
+				unexpectedBefore: "Unexpected newline before ')'.",
+				unexpectedAfter: "Unexpected newline after '('."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, rawOption = context.options[0] || "multiline", multilineOption = rawOption === "multiline", multilineArgumentsOption = rawOption === "multiline-arguments", consistentOption = rawOption === "consistent", minItems;
+			minItems = typeof rawOption == "object" ? rawOption.minItems : rawOption === "always" ? 0 : rawOption === "never" ? Infinity : null;
+			/**
+			* Determines whether there should be newlines inside function parens
+			* @param {ASTNode[]} elements The arguments or parameters in the list
+			* @param {boolean} hasLeftNewline `true` if the left paren has a newline in the current code.
+			* @returns {boolean} `true` if there should be newlines inside the function parens
+			*/
+			function shouldHaveNewlines(elements, hasLeftNewline) {
+				return multilineArgumentsOption && elements.length === 1 ? hasLeftNewline : multilineOption || multilineArgumentsOption ? elements.some((element, index) => index !== elements.length - 1 && element.loc.end.line !== elements[index + 1].loc.start.line) : consistentOption ? hasLeftNewline : elements.length >= minItems;
+			}
+			/**
+			* Validates parens
+			* @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token
+			* @param {ASTNode[]} elements The arguments or parameters in the list
+			* @returns {void}
+			*/
+			function validateParens(parens, elements) {
+				let leftParen = parens.leftParen, rightParen = parens.rightParen, tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen), tokenBeforeRightParen = sourceCode.getTokenBefore(rightParen), hasLeftNewline = !astUtils.isTokenOnSameLine(leftParen, tokenAfterLeftParen), hasRightNewline = !astUtils.isTokenOnSameLine(tokenBeforeRightParen, rightParen), needsNewlines = shouldHaveNewlines(elements, hasLeftNewline);
+				hasLeftNewline && !needsNewlines ? context.report({
+					node: leftParen,
+					messageId: "unexpectedAfter",
+					fix(fixer) {
+						return sourceCode.getText().slice(leftParen.range[1], tokenAfterLeftParen.range[0]).trim() ? null : fixer.removeRange([leftParen.range[1], tokenAfterLeftParen.range[0]]);
+					}
+				}) : !hasLeftNewline && needsNewlines && context.report({
+					node: leftParen,
+					messageId: "expectedAfter",
+					fix: (fixer) => fixer.insertTextAfter(leftParen, "\n")
+				}), hasRightNewline && !needsNewlines ? context.report({
+					node: rightParen,
+					messageId: "unexpectedBefore",
+					fix(fixer) {
+						return sourceCode.getText().slice(tokenBeforeRightParen.range[1], rightParen.range[0]).trim() ? null : fixer.removeRange([tokenBeforeRightParen.range[1], rightParen.range[0]]);
+					}
+				}) : !hasRightNewline && needsNewlines && context.report({
+					node: rightParen,
+					messageId: "expectedBefore",
+					fix: (fixer) => fixer.insertTextBefore(rightParen, "\n")
+				});
+			}
+			/**
+			* Validates a list of arguments or parameters
+			* @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token
+			* @param {ASTNode[]} elements The arguments or parameters in the list
+			* @returns {void}
+			*/
+			function validateArguments(parens, elements) {
+				let leftParen = parens.leftParen, tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen), needsNewlines = shouldHaveNewlines(elements, !astUtils.isTokenOnSameLine(leftParen, tokenAfterLeftParen));
+				for (let i = 0; i <= elements.length - 2; i++) {
+					let currentElement = elements[i], nextElement = elements[i + 1];
+					currentElement.loc.end.line === nextElement.loc.start.line && needsNewlines && context.report({
+						node: currentElement,
+						messageId: "expectedBetween",
+						fix: (fixer) => fixer.insertTextBefore(nextElement, "\n")
+					});
+				}
+			}
+			/**
+			* Gets the left paren and right paren tokens of a node.
+			* @param {ASTNode} node The node with parens
+			* @throws {TypeError} Unexpected node type.
+			* @returns {Object} An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token.
+			* Can also return `null` if an expression has no parens (e.g. a NewExpression with no arguments, or an ArrowFunctionExpression
+			* with a single parameter)
+			*/
+			function getParenTokens(node) {
+				switch (node.type) {
+					case "NewExpression": if (!node.arguments.length && !(astUtils.isOpeningParenToken(sourceCode.getLastToken(node, { skip: 1 })) && astUtils.isClosingParenToken(sourceCode.getLastToken(node)) && node.callee.range[1] < node.range[1])) return null;
+					case "CallExpression": return {
+						leftParen: sourceCode.getTokenAfter(node.callee, astUtils.isOpeningParenToken),
+						rightParen: sourceCode.getLastToken(node)
+					};
+					case "FunctionDeclaration":
+					case "FunctionExpression": {
+						let leftParen = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken);
+						return {
+							leftParen,
+							rightParen: node.params.length ? sourceCode.getTokenAfter(node.params.at(-1), astUtils.isClosingParenToken) : sourceCode.getTokenAfter(leftParen)
+						};
+					}
+					case "ArrowFunctionExpression": {
+						let firstToken = sourceCode.getFirstToken(node, { skip: node.async ? 1 : 0 });
+						return astUtils.isOpeningParenToken(firstToken) ? {
+							leftParen: firstToken,
+							rightParen: node.params.length ? sourceCode.getTokenAfter(node.params.at(-1), astUtils.isClosingParenToken) : sourceCode.getTokenAfter(firstToken)
+						} : null;
+					}
+					case "ImportExpression": return {
+						leftParen: sourceCode.getFirstToken(node, 1),
+						rightParen: sourceCode.getLastToken(node)
+					};
+					default: throw TypeError(`unexpected node with type ${node.type}`);
+				}
+			}
+			return { [[
+				"ArrowFunctionExpression",
+				"CallExpression",
+				"FunctionDeclaration",
+				"FunctionExpression",
+				"ImportExpression",
+				"NewExpression"
+			]](node) {
+				let parens = getParenTokens(node), params;
+				params = node.type === "ImportExpression" ? [node.source] : astUtils.isFunction(node) ? node.params : node.arguments, parens && (validateParens(parens, params), multilineArgumentsOption && validateArguments(parens, params));
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/function-paren-newline.cjs
+module.exports = require_function_paren_newline().create;
+//#endregion

package/rules/generator-star-spacing.cjs

@@ -0,0 +1,174 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/generator-star-spacing.js
+/**
+* @fileoverview Rule to check the spacing around the * in generator functions.
+* @author Jamund Ferguson
+* @deprecated in ESLint v8.53.0
+*/
+var require_generator_star_spacing = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let OVERRIDE_SCHEMA = { oneOf: [{ enum: [
+		"before",
+		"after",
+		"both",
+		"neither"
+	] }, {
+		type: "object",
+		properties: {
+			before: { type: "boolean" },
+			after: { type: "boolean" }
+		},
+		additionalProperties: !1
+	}] };
+	/** @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: "generator-star-spacing",
+						url: "https://eslint.style/rules/generator-star-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing around `*` operators in generator functions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/generator-star-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{ oneOf: [{ enum: [
+				"before",
+				"after",
+				"both",
+				"neither"
+			] }, {
+				type: "object",
+				properties: {
+					before: { type: "boolean" },
+					after: { type: "boolean" },
+					named: OVERRIDE_SCHEMA,
+					anonymous: OVERRIDE_SCHEMA,
+					method: OVERRIDE_SCHEMA
+				},
+				additionalProperties: !1
+			}] }],
+			messages: {
+				missingBefore: "Missing space before *.",
+				missingAfter: "Missing space after *.",
+				unexpectedBefore: "Unexpected space before *.",
+				unexpectedAfter: "Unexpected space after *."
+			}
+		},
+		create(context) {
+			let optionDefinitions = {
+				before: {
+					before: !0,
+					after: !1
+				},
+				after: {
+					before: !1,
+					after: !0
+				},
+				both: {
+					before: !0,
+					after: !0
+				},
+				neither: {
+					before: !1,
+					after: !1
+				}
+			};
+			/**
+			* Returns resolved option definitions based on an option and defaults
+			* @param {any} option The option object or string value
+			* @param {Object} defaults The defaults to use if options are not present
+			* @returns {Object} the resolved object definition
+			*/
+			function optionToDefinition(option, defaults) {
+				return option ? typeof option == "string" ? optionDefinitions[option] : Object.assign({}, defaults, option) : defaults;
+			}
+			let modes = (function(option) {
+				let defaults = optionToDefinition(option, optionDefinitions.before);
+				return {
+					named: optionToDefinition(option.named, defaults),
+					anonymous: optionToDefinition(option.anonymous, defaults),
+					method: optionToDefinition(option.method, defaults)
+				};
+			})(context.options[0] || {}), sourceCode = context.sourceCode;
+			/**
+			* Checks if the given token is a star token or not.
+			* @param {Token} token The token to check.
+			* @returns {boolean} `true` if the token is a star token.
+			*/
+			function isStarToken(token) {
+				return token.value === "*" && token.type === "Punctuator";
+			}
+			/**
+			* Gets the generator star token of the given function node.
+			* @param {ASTNode} node The function node to get.
+			* @returns {Token} Found star token.
+			*/
+			function getStarToken(node) {
+				return sourceCode.getFirstToken(node.parent.method || node.parent.type === "MethodDefinition" ? node.parent : node, isStarToken);
+			}
+			/**
+			* capitalize a given string.
+			* @param {string} str the given string.
+			* @returns {string} the capitalized string.
+			*/
+			function capitalize(str) {
+				return str[0].toUpperCase() + str.slice(1);
+			}
+			/**
+			* Checks the spacing between two tokens before or after the star token.
+			* @param {string} kind Either "named", "anonymous", or "method"
+			* @param {string} side Either "before" or "after".
+			* @param {Token} leftToken `function` keyword token if side is "before", or
+			*     star token if side is "after".
+			* @param {Token} rightToken Star token if side is "before", or identifier
+			*     token if side is "after".
+			* @returns {void}
+			*/
+			function checkSpacing(kind, side, leftToken, rightToken) {
+				if (!!(rightToken.range[0] - leftToken.range[1]) !== modes[kind][side]) {
+					let after = leftToken.value === "*", spaceRequired = modes[kind][side], node = after ? leftToken : rightToken, messageId = `${spaceRequired ? "missing" : "unexpected"}${capitalize(side)}`;
+					context.report({
+						node,
+						messageId,
+						fix(fixer) {
+							return spaceRequired ? after ? fixer.insertTextAfter(node, " ") : fixer.insertTextBefore(node, " ") : fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
+						}
+					});
+				}
+			}
+			/**
+			* Enforces the spacing around the star if node is a generator function.
+			* @param {ASTNode} node A function expression or declaration node.
+			* @returns {void}
+			*/
+			function checkFunction(node) {
+				if (!node.generator) return;
+				let starToken = getStarToken(node), prevToken = sourceCode.getTokenBefore(starToken), nextToken = sourceCode.getTokenAfter(starToken), kind = "named";
+				node.parent.type === "MethodDefinition" || node.parent.type === "Property" && node.parent.method ? kind = "method" : node.id || (kind = "anonymous"), kind === "method" && starToken === sourceCode.getFirstToken(node.parent) || checkSpacing(kind, "before", prevToken, starToken), checkSpacing(kind, "after", starToken, nextToken);
+			}
+			return {
+				FunctionDeclaration: checkFunction,
+				FunctionExpression: checkFunction
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/generator-star-spacing.cjs
+module.exports = require_generator_star_spacing().create;
+//#endregion