oxlint-plugin-eslint 1.52.0

package/rules/sort-imports.cjs

@@ -0,0 +1,140 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/sort-imports.js
+/**
+* @fileoverview Rule to enforce sorted `import` declarations within modules
+* @author Christian Schuller
+*/
+var require_sort_imports = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{
+				allowSeparatedGroups: !1,
+				ignoreCase: !1,
+				ignoreDeclarationSort: !1,
+				ignoreMemberSort: !1,
+				memberSyntaxSortOrder: [
+					"none",
+					"all",
+					"multiple",
+					"single"
+				]
+			}],
+			docs: {
+				description: "Enforce sorted `import` declarations within modules",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/sort-imports"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					ignoreCase: { type: "boolean" },
+					memberSyntaxSortOrder: {
+						type: "array",
+						items: { enum: [
+							"none",
+							"all",
+							"multiple",
+							"single"
+						] },
+						uniqueItems: !0,
+						minItems: 4,
+						maxItems: 4
+					},
+					ignoreDeclarationSort: { type: "boolean" },
+					ignoreMemberSort: { type: "boolean" },
+					allowSeparatedGroups: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			fixable: "code",
+			messages: {
+				sortImportsAlphabetically: "Imports should be sorted alphabetically.",
+				sortMembersAlphabetically: "Member '{{memberName}}' of the import declaration should be sorted alphabetically.",
+				unexpectedSyntaxOrder: "Expected '{{syntaxA}}' syntax before '{{syntaxB}}' syntax."
+			}
+		},
+		create(context) {
+			let [{ ignoreCase, ignoreDeclarationSort, ignoreMemberSort, memberSyntaxSortOrder, allowSeparatedGroups }] = context.options, sourceCode = context.sourceCode, previousDeclaration = null;
+			/**
+			* Gets the used member syntax style.
+			*
+			* import "my-module.js" --> none
+			* import * as myModule from "my-module.js" --> all
+			* import {myMember} from "my-module.js" --> single
+			* import {foo, bar} from  "my-module.js" --> multiple
+			* @param {ASTNode} node the ImportDeclaration node.
+			* @returns {string} used member parameter style, ["all", "multiple", "single"]
+			*/
+			function usedMemberSyntax(node) {
+				return node.specifiers.length === 0 ? "none" : node.specifiers[0].type === "ImportNamespaceSpecifier" ? "all" : node.specifiers.length === 1 ? "single" : "multiple";
+			}
+			/**
+			* Gets the group by member parameter index for given declaration.
+			* @param {ASTNode} node the ImportDeclaration node.
+			* @returns {number} the declaration group by member index.
+			*/
+			function getMemberParameterGroupIndex(node) {
+				return memberSyntaxSortOrder.indexOf(usedMemberSyntax(node));
+			}
+			/**
+			* Gets the local name of the first imported module.
+			* @param {ASTNode} node the ImportDeclaration node.
+			* @returns {?string} the local name of the first imported module.
+			*/
+			function getFirstLocalMemberName(node) {
+				return node.specifiers[0] ? node.specifiers[0].local.name : null;
+			}
+			/**
+			* Calculates number of lines between two nodes. It is assumed that the given `left` node appears before
+			* the given `right` node in the source code. Lines are counted from the end of the `left` node till the
+			* start of the `right` node. If the given nodes are on the same line, it returns `0`, same as if they were
+			* on two consecutive lines.
+			* @param {ASTNode} left node that appears before the given `right` node.
+			* @param {ASTNode} right node that appears after the given `left` node.
+			* @returns {number} number of lines between nodes.
+			*/
+			function getNumberOfLinesBetween(left, right) {
+				return Math.max(right.loc.start.line - left.loc.end.line - 1, 0);
+			}
+			return { ImportDeclaration(node) {
+				if (!ignoreDeclarationSort) {
+					if (previousDeclaration && allowSeparatedGroups && getNumberOfLinesBetween(previousDeclaration, node) > 0 && (previousDeclaration = null), previousDeclaration) {
+						let currentMemberSyntaxGroupIndex = getMemberParameterGroupIndex(node), previousMemberSyntaxGroupIndex = getMemberParameterGroupIndex(previousDeclaration), currentLocalMemberName = getFirstLocalMemberName(node), previousLocalMemberName = getFirstLocalMemberName(previousDeclaration);
+						ignoreCase && (previousLocalMemberName &&= previousLocalMemberName.toLowerCase(), currentLocalMemberName &&= currentLocalMemberName.toLowerCase()), currentMemberSyntaxGroupIndex === previousMemberSyntaxGroupIndex ? previousLocalMemberName && currentLocalMemberName && currentLocalMemberName < previousLocalMemberName && context.report({
+							node,
+							messageId: "sortImportsAlphabetically"
+						}) : currentMemberSyntaxGroupIndex < previousMemberSyntaxGroupIndex && context.report({
+							node,
+							messageId: "unexpectedSyntaxOrder",
+							data: {
+								syntaxA: memberSyntaxSortOrder[currentMemberSyntaxGroupIndex],
+								syntaxB: memberSyntaxSortOrder[previousMemberSyntaxGroupIndex]
+							}
+						});
+					}
+					previousDeclaration = node;
+				}
+				if (!ignoreMemberSort) {
+					let importSpecifiers = node.specifiers.filter((specifier) => specifier.type === "ImportSpecifier"), getSortableName = ignoreCase ? (specifier) => specifier.local.name.toLowerCase() : (specifier) => specifier.local.name, firstUnsortedIndex = importSpecifiers.map(getSortableName).findIndex((name, index, array) => array[index - 1] > name);
+					firstUnsortedIndex !== -1 && context.report({
+						node: importSpecifiers[firstUnsortedIndex],
+						messageId: "sortMembersAlphabetically",
+						data: { memberName: importSpecifiers[firstUnsortedIndex].local.name },
+						fix(fixer) {
+							return importSpecifiers.some((specifier) => sourceCode.getCommentsBefore(specifier).length || sourceCode.getCommentsAfter(specifier).length) ? null : fixer.replaceTextRange([importSpecifiers[0].range[0], importSpecifiers.at(-1).range[1]], importSpecifiers.slice().sort((specifierA, specifierB) => getSortableName(specifierA) > getSortableName(specifierB) ? 1 : -1).reduce((sourceText, specifier, index) => {
+								let textAfterSpecifier = index === importSpecifiers.length - 1 ? "" : sourceCode.getText().slice(importSpecifiers[index].range[1], importSpecifiers[index + 1].range[0]);
+								return sourceText + sourceCode.getText(specifier) + textAfterSpecifier;
+							}, ""));
+						}
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/sort-imports.cjs
+module.exports = require_sort_imports().create;
+//#endregion

package/rules/sort-keys.cjs

@@ -0,0 +1,165 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs");
+//#region ../../node_modules/.pnpm/natural-compare@1.4.0/node_modules/natural-compare/index.js
+var require_natural_compare = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	/*
+	* @version    1.4.0
+	* @date       2015-10-26
+	* @stability  3 - Stable
+	* @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)
+	* @license    MIT License
+	*/
+	var naturalCompare = function(a, b) {
+		var i, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
+		function getCode(str, pos, code) {
+			if (code) {
+				for (i = pos; code = getCode(str, i), code < 76 && code > 65;) ++i;
+				return +str.slice(pos - 1, i);
+			}
+			return code = alphabet && alphabet.indexOf(str.charAt(pos)), code > -1 ? code + 76 : (code = str.charCodeAt(pos) || 0, code < 45 || code > 127 ? code : code < 46 ? 65 : code < 48 ? code - 1 : code < 58 ? code + 18 : code < 65 ? code - 11 : code < 91 ? code + 11 : code < 97 ? code - 37 : code < 123 ? code + 5 : code - 63);
+		}
+		if ((a += "") != (b += "")) {
+			for (; codeB;) if (codeA = getCode(a, posA++), codeB = getCode(b, posB++), codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66 && (codeA = getCode(a, posA, posA), codeB = getCode(b, posB, posA = i), posB = i), codeA != codeB) return codeA < codeB ? -1 : 1;
+		}
+		return 0;
+	};
+	try {
+		module.exports = naturalCompare;
+	} catch {
+		String.naturalCompare = naturalCompare;
+	}
+})), require_sort_keys = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), naturalCompare = require_natural_compare();
+	/**
+	* Gets the property name of the given `Property` node.
+	*
+	* - If the property's key is an `Identifier` node, this returns the key's name
+	*   whether it's a computed property or not.
+	* - If the property has a static name, this returns the static name.
+	* - Otherwise, this returns null.
+	* @param {ASTNode} node The `Property` node to get.
+	* @returns {string|null} The property name or null.
+	* @private
+	*/
+	function getPropertyName(node) {
+		let staticName = astUtils.getStaticPropertyName(node);
+		return staticName === null ? node.key.name || null : staticName;
+	}
+	/**
+	* Functions which check that the given 2 names are in specific order.
+	*
+	* Postfix `I` is meant insensitive.
+	* Postfix `N` is meant natural.
+	* @private
+	*/
+	let isValidOrders = {
+		asc(a, b) {
+			return a <= b;
+		},
+		ascI(a, b) {
+			return a.toLowerCase() <= b.toLowerCase();
+		},
+		ascN(a, b) {
+			return naturalCompare(a, b) <= 0;
+		},
+		ascIN(a, b) {
+			return naturalCompare(a.toLowerCase(), b.toLowerCase()) <= 0;
+		},
+		desc(a, b) {
+			return isValidOrders.asc(b, a);
+		},
+		descI(a, b) {
+			return isValidOrders.ascI(b, a);
+		},
+		descN(a, b) {
+			return isValidOrders.ascN(b, a);
+		},
+		descIN(a, b) {
+			return isValidOrders.ascIN(b, a);
+		}
+	};
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: ["asc", {
+				allowLineSeparatedGroups: !1,
+				caseSensitive: !0,
+				ignoreComputedKeys: !1,
+				minKeys: 2,
+				natural: !1
+			}],
+			docs: {
+				description: "Require object keys to be sorted",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/sort-keys"
+			},
+			schema: [{ enum: ["asc", "desc"] }, {
+				type: "object",
+				properties: {
+					caseSensitive: { type: "boolean" },
+					natural: { type: "boolean" },
+					minKeys: {
+						type: "integer",
+						minimum: 2
+					},
+					allowLineSeparatedGroups: { type: "boolean" },
+					ignoreComputedKeys: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: { sortKeys: "Expected object keys to be in {{natural}}{{insensitive}}{{order}}ending order. '{{thisName}}' should be before '{{prevName}}'." }
+		},
+		create(context) {
+			let [order, { caseSensitive, natural, minKeys, allowLineSeparatedGroups, ignoreComputedKeys }] = context.options, insensitive = !caseSensitive, isValidOrder = isValidOrders[order + (insensitive ? "I" : "") + (natural ? "N" : "")], stack = null, sourceCode = context.sourceCode;
+			return {
+				ObjectExpression(node) {
+					stack = {
+						upper: stack,
+						prevNode: null,
+						prevBlankLine: !1,
+						prevName: null,
+						numKeys: node.properties.length
+					};
+				},
+				"ObjectExpression:exit"() {
+					stack = stack.upper;
+				},
+				SpreadElement(node) {
+					node.parent.type === "ObjectExpression" && (stack.prevName = null);
+				},
+				Property(node) {
+					if (node.parent.type === "ObjectPattern") return;
+					if (ignoreComputedKeys && node.computed) {
+						stack.prevName = null;
+						return;
+					}
+					let prevName = stack.prevName, numKeys = stack.numKeys, thisName = getPropertyName(node), tokens = stack.prevNode && sourceCode.getTokensBetween(stack.prevNode, node, { includeComments: !0 }), isBlankLineBetweenNodes = stack.prevBlankLine;
+					if (tokens && (tokens.forEach((token, index) => {
+						let previousToken = tokens[index - 1];
+						previousToken && token.loc.start.line - previousToken.loc.end.line > 1 && (isBlankLineBetweenNodes = !0);
+					}), !isBlankLineBetweenNodes && node.loc.start.line - tokens.at(-1).loc.end.line > 1 && (isBlankLineBetweenNodes = !0), !isBlankLineBetweenNodes && tokens[0].loc.start.line - stack.prevNode.loc.end.line > 1 && (isBlankLineBetweenNodes = !0)), stack.prevNode = node, thisName !== null && (stack.prevName = thisName), allowLineSeparatedGroups && isBlankLineBetweenNodes) {
+						stack.prevBlankLine = thisName === null;
+						return;
+					}
+					prevName === null || thisName === null || numKeys < minKeys || isValidOrder(prevName, thisName) || context.report({
+						node,
+						loc: node.key.loc,
+						messageId: "sortKeys",
+						data: {
+							thisName,
+							prevName,
+							order,
+							insensitive: insensitive ? "insensitive " : "",
+							natural: natural ? "natural " : ""
+						}
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/sort-keys.cjs
+module.exports = require_sort_keys().create;
+//#endregion

package/rules/sort-vars.cjs

@@ -0,0 +1,50 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/sort-vars.js
+/**
+* @fileoverview Rule to require sorting of variables within a single Variable Declaration block
+* @author Ilya Volodin
+*/
+var require_sort_vars = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ ignoreCase: !1 }],
+			docs: {
+				description: "Require variables within the same declaration block to be sorted",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/sort-vars"
+			},
+			schema: [{
+				type: "object",
+				properties: { ignoreCase: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			fixable: "code",
+			messages: { sortVars: "Variables within the same declaration block should be sorted alphabetically." }
+		},
+		create(context) {
+			let [{ ignoreCase }] = context.options, sourceCode = context.sourceCode;
+			return { VariableDeclaration(node) {
+				let idDeclarations = node.declarations.filter((decl) => decl.id.type === "Identifier"), getSortableName = ignoreCase ? (decl) => decl.id.name.toLowerCase() : (decl) => decl.id.name, unfixable = idDeclarations.some((decl) => decl.init !== null && decl.init.type !== "Literal"), fixed = !1;
+				idDeclarations.slice(1).reduce((memo, decl) => {
+					let lastVariableName = getSortableName(memo);
+					return getSortableName(decl) < lastVariableName ? (context.report({
+						node: decl,
+						messageId: "sortVars",
+						fix(fixer) {
+							return unfixable || fixed ? null : fixer.replaceTextRange([idDeclarations[0].range[0], idDeclarations.at(-1).range[1]], idDeclarations.slice().sort((declA, declB) => getSortableName(declA) > getSortableName(declB) ? 1 : -1).reduce((sourceText, identifier, index) => {
+								let textAfterIdentifier = index === idDeclarations.length - 1 ? "" : sourceCode.getText().slice(idDeclarations[index].range[1], idDeclarations[index + 1].range[0]);
+								return sourceText + sourceCode.getText(identifier) + textAfterIdentifier;
+							}, ""));
+						}
+					}), fixed = !0, memo) : decl;
+				}, idDeclarations[0]);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/sort-vars.cjs
+module.exports = require_sort_vars().create;
+//#endregion

package/rules/space-before-blocks.cjs

@@ -0,0 +1,132 @@
+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/space-before-blocks.js
+/**
+* @fileoverview A rule to ensure whitespace before blocks.
+* @author Mathias Schreck <https://github.com/lo1tuma>
+* @deprecated in ESLint v8.53.0
+*/
+var require_space_before_blocks = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether the given node represents the body of a function.
+	* @param {ASTNode} node the node to check.
+	* @returns {boolean} `true` if the node is function body.
+	*/
+	function isFunctionBody(node) {
+		let parent = node.parent;
+		return node.type === "BlockStatement" && astUtils.isFunction(parent) && parent.body === node;
+	}
+	/** @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: "space-before-blocks",
+						url: "https://eslint.style/rules/space-before-blocks"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing before blocks",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/space-before-blocks"
+			},
+			fixable: "whitespace",
+			schema: [{ oneOf: [{ enum: ["always", "never"] }, {
+				type: "object",
+				properties: {
+					keywords: { enum: [
+						"always",
+						"never",
+						"off"
+					] },
+					functions: { enum: [
+						"always",
+						"never",
+						"off"
+					] },
+					classes: { enum: [
+						"always",
+						"never",
+						"off"
+					] }
+				},
+				additionalProperties: !1
+			}] }],
+			messages: {
+				unexpectedSpace: "Unexpected space before opening brace.",
+				missingSpace: "Missing space before opening brace."
+			}
+		},
+		create(context) {
+			let config = context.options[0], sourceCode = context.sourceCode, alwaysFunctions = !0, alwaysKeywords = !0, alwaysClasses = !0, neverFunctions = !1, neverKeywords = !1, neverClasses = !1;
+			typeof config == "object" ? (alwaysFunctions = config.functions === "always", alwaysKeywords = config.keywords === "always", alwaysClasses = config.classes === "always", neverFunctions = config.functions === "never", neverKeywords = config.keywords === "never", neverClasses = config.classes === "never") : config === "never" && (alwaysFunctions = !1, alwaysKeywords = !1, alwaysClasses = !1, neverFunctions = !0, neverKeywords = !0, neverClasses = !0);
+			/**
+			* Checks whether the spacing before the given block is already controlled by another rule:
+			* - `arrow-spacing` checks spaces after `=>`.
+			* - `keyword-spacing` checks spaces after keywords in certain contexts.
+			* - `switch-colon-spacing` checks spaces after `:` of switch cases.
+			* @param {Token} precedingToken first token before the block.
+			* @param {ASTNode|Token} node `BlockStatement` node or `{` token of a `SwitchStatement` node.
+			* @returns {boolean} `true` if requiring or disallowing spaces before the given block could produce conflicts with other rules.
+			*/
+			function isConflicted(precedingToken, node) {
+				return astUtils.isArrowToken(precedingToken) || astUtils.isKeywordToken(precedingToken) && !isFunctionBody(node) || astUtils.isColonToken(precedingToken) && node.parent && node.parent.type === "SwitchCase" && precedingToken === astUtils.getSwitchCaseColonToken(node.parent, sourceCode);
+			}
+			/**
+			* Checks the given BlockStatement node has a preceding space if it doesn’t start on a new line.
+			* @param {ASTNode|Token} node The AST node of a BlockStatement.
+			* @returns {void} undefined.
+			*/
+			function checkPrecedingSpace(node) {
+				let precedingToken = sourceCode.getTokenBefore(node);
+				if (precedingToken && !isConflicted(precedingToken, node) && astUtils.isTokenOnSameLine(precedingToken, node)) {
+					let hasSpace = sourceCode.isSpaceBetweenTokens(precedingToken, node), requireSpace, requireNoSpace;
+					isFunctionBody(node) ? (requireSpace = alwaysFunctions, requireNoSpace = neverFunctions) : node.type === "ClassBody" ? (requireSpace = alwaysClasses, requireNoSpace = neverClasses) : (requireSpace = alwaysKeywords, requireNoSpace = neverKeywords), requireSpace && !hasSpace ? context.report({
+						node,
+						messageId: "missingSpace",
+						fix(fixer) {
+							return fixer.insertTextBefore(node, " ");
+						}
+					}) : requireNoSpace && hasSpace && context.report({
+						node,
+						messageId: "unexpectedSpace",
+						fix(fixer) {
+							return fixer.removeRange([precedingToken.range[1], node.range[0]]);
+						}
+					});
+				}
+			}
+			/**
+			* Checks if the CaseBlock of an given SwitchStatement node has a preceding space.
+			* @param {ASTNode} node The node of a SwitchStatement.
+			* @returns {void} undefined.
+			*/
+			function checkSpaceBeforeCaseBlock(node) {
+				let cases = node.cases, openingBrace;
+				openingBrace = cases.length > 0 ? sourceCode.getTokenBefore(cases[0]) : sourceCode.getLastToken(node, 1), checkPrecedingSpace(openingBrace);
+			}
+			return {
+				BlockStatement: checkPrecedingSpace,
+				ClassBody: checkPrecedingSpace,
+				SwitchStatement: checkSpaceBeforeCaseBlock
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/space-before-blocks.cjs
+module.exports = require_space_before_blocks().create;
+//#endregion

package/rules/space-before-function-paren.cjs

@@ -0,0 +1,126 @@
+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/space-before-function-paren.js
+/**
+* @fileoverview Rule to validate spacing before function paren.
+* @author Mathias Schreck <https://github.com/lo1tuma>
+* @deprecated in ESLint v8.53.0
+*/
+var require_space_before_function_paren = /* @__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: "space-before-function-paren",
+						url: "https://eslint.style/rules/space-before-function-paren"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing before `function` definition opening parenthesis",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/space-before-function-paren"
+			},
+			fixable: "whitespace",
+			schema: [{ oneOf: [{ enum: ["always", "never"] }, {
+				type: "object",
+				properties: {
+					anonymous: { enum: [
+						"always",
+						"never",
+						"ignore"
+					] },
+					named: { enum: [
+						"always",
+						"never",
+						"ignore"
+					] },
+					asyncArrow: { enum: [
+						"always",
+						"never",
+						"ignore"
+					] }
+				},
+				additionalProperties: !1
+			}] }],
+			messages: {
+				unexpectedSpace: "Unexpected space before function parentheses.",
+				missingSpace: "Missing space before function parentheses."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, baseConfig = typeof context.options[0] == "string" ? context.options[0] : "always", overrideConfig = typeof context.options[0] == "object" ? context.options[0] : {};
+			/**
+			* Determines whether a function has a name.
+			* @param {ASTNode} node The function node.
+			* @returns {boolean} Whether the function has a name.
+			*/
+			function isNamedFunction(node) {
+				if (node.id) return !0;
+				let parent = node.parent;
+				return parent.type === "MethodDefinition" || parent.type === "Property" && (parent.kind === "get" || parent.kind === "set" || parent.method);
+			}
+			/**
+			* Gets the config for a given function
+			* @param {ASTNode} node The function node
+			* @returns {string} "always", "never", or "ignore"
+			*/
+			function getConfigForFunction(node) {
+				if (node.type === "ArrowFunctionExpression") {
+					if (node.async && astUtils.isOpeningParenToken(sourceCode.getFirstToken(node, { skip: 1 }))) return overrideConfig.asyncArrow || baseConfig;
+				} else if (isNamedFunction(node)) return overrideConfig.named || baseConfig;
+				else if (!node.generator) return overrideConfig.anonymous || baseConfig;
+				return "ignore";
+			}
+			/**
+			* Checks the parens of a function node
+			* @param {ASTNode} node A function node
+			* @returns {void}
+			*/
+			function checkFunction(node) {
+				let functionConfig = getConfigForFunction(node);
+				if (functionConfig === "ignore") return;
+				let rightToken = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken), leftToken = sourceCode.getTokenBefore(rightToken), hasSpacing = sourceCode.isSpaceBetweenTokens(leftToken, rightToken);
+				hasSpacing && functionConfig === "never" ? context.report({
+					node,
+					loc: {
+						start: leftToken.loc.end,
+						end: rightToken.loc.start
+					},
+					messageId: "unexpectedSpace",
+					fix(fixer) {
+						let comments = sourceCode.getCommentsBefore(rightToken);
+						return comments.some((comment) => comment.type === "Line") ? null : fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], comments.reduce((text, comment) => text + sourceCode.getText(comment), ""));
+					}
+				}) : !hasSpacing && functionConfig === "always" && context.report({
+					node,
+					loc: rightToken.loc,
+					messageId: "missingSpace",
+					fix: (fixer) => fixer.insertTextAfter(leftToken, " ")
+				});
+			}
+			return {
+				ArrowFunctionExpression: checkFunction,
+				FunctionDeclaration: checkFunction,
+				FunctionExpression: checkFunction
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/space-before-function-paren.cjs
+module.exports = require_space_before_function_paren().create;
+//#endregion