oxlint-plugin-eslint 1.52.0

package/rules/max-len.cjs

@@ -0,0 +1,256 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/max-len.js
+/**
+* @fileoverview Rule to check for max length on a line.
+* @author Matt DuVall <http://www.mattduvall.com>
+* @deprecated in ESLint v8.53.0
+*/
+var require_max_len = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let OPTIONS_SCHEMA = {
+		type: "object",
+		properties: {
+			code: {
+				type: "integer",
+				minimum: 0
+			},
+			comments: {
+				type: "integer",
+				minimum: 0
+			},
+			tabWidth: {
+				type: "integer",
+				minimum: 0
+			},
+			ignorePattern: { type: "string" },
+			ignoreComments: { type: "boolean" },
+			ignoreStrings: { type: "boolean" },
+			ignoreUrls: { type: "boolean" },
+			ignoreTemplateLiterals: { type: "boolean" },
+			ignoreRegExpLiterals: { type: "boolean" },
+			ignoreTrailingComments: { type: "boolean" }
+		},
+		additionalProperties: !1
+	}, OPTIONS_OR_INTEGER_SCHEMA = { anyOf: [OPTIONS_SCHEMA, {
+		type: "integer",
+		minimum: 0
+	}] };
+	/** @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: "max-len",
+						url: "https://eslint.style/rules/max-len"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce a maximum line length",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/max-len"
+			},
+			schema: [
+				OPTIONS_OR_INTEGER_SCHEMA,
+				OPTIONS_OR_INTEGER_SCHEMA,
+				OPTIONS_SCHEMA
+			],
+			messages: {
+				max: "This line has a length of {{lineLength}}. Maximum allowed is {{maxLength}}.",
+				maxComment: "This line has a comment length of {{lineLength}}. Maximum allowed is {{maxCommentLength}}."
+			}
+		},
+		create(context) {
+			let URL_REGEXP = /[^:/?#]:\/\/[^?#]/u, sourceCode = context.sourceCode;
+			/**
+			* Computes the length of a line that may contain tabs. The width of each
+			* tab will be the number of spaces to the next tab stop.
+			* @param {string} line The line.
+			* @param {number} tabWidth The width of each tab stop in spaces.
+			* @returns {number} The computed line length.
+			* @private
+			*/
+			function computeLineLength(line, tabWidth) {
+				let extraCharacterCount = 0;
+				return line.replace(/\t/gu, (match, offset) => {
+					let totalOffset = offset + extraCharacterCount, spaceCount = tabWidth - (tabWidth ? totalOffset % tabWidth : 0);
+					extraCharacterCount += spaceCount - 1;
+				}), Array.from(line).length + extraCharacterCount;
+			}
+			let options = Object.assign({}, context.options.at(-1));
+			typeof context.options[0] == "number" && (options.code = context.options[0]), typeof context.options[1] == "number" && (options.tabWidth = context.options[1]);
+			let maxLength = typeof options.code == "number" ? options.code : 80, tabWidth = typeof options.tabWidth == "number" ? options.tabWidth : 4, ignoreComments = !!options.ignoreComments, ignoreStrings = !!options.ignoreStrings, ignoreTemplateLiterals = !!options.ignoreTemplateLiterals, ignoreRegExpLiterals = !!options.ignoreRegExpLiterals, ignoreTrailingComments = !!options.ignoreTrailingComments || !!options.ignoreComments, ignoreUrls = !!options.ignoreUrls, maxCommentLength = options.comments, ignorePattern = options.ignorePattern || null;
+			ignorePattern &&= new RegExp(ignorePattern, "u");
+			/**
+			* Tells if a given comment is trailing: it starts on the current line and
+			* extends to or past the end of the current line.
+			* @param {string} line The source line we want to check for a trailing comment on
+			* @param {number} lineNumber The one-indexed line number for line
+			* @param {ASTNode} comment The comment to inspect
+			* @returns {boolean} If the comment is trailing on the given line
+			*/
+			function isTrailingComment(line, lineNumber, comment) {
+				return comment && comment.loc.start.line === lineNumber && lineNumber <= comment.loc.end.line && (comment.loc.end.line > lineNumber || comment.loc.end.column === line.length);
+			}
+			/**
+			* Tells if a comment encompasses the entire line.
+			* @param {string} line The source line with a trailing comment
+			* @param {number} lineNumber The one-indexed line number this is on
+			* @param {ASTNode} comment The comment to remove
+			* @returns {boolean} If the comment covers the entire line
+			*/
+			function isFullLineComment(line, lineNumber, comment) {
+				let start = comment.loc.start, end = comment.loc.end, isFirstTokenOnLine = !line.slice(0, comment.loc.start.column).trim();
+				return comment && (start.line < lineNumber || start.line === lineNumber && isFirstTokenOnLine) && (end.line > lineNumber || end.line === lineNumber && end.column === line.length);
+			}
+			/**
+			* Check if a node is a JSXEmptyExpression contained in a single line JSXExpressionContainer.
+			* @param {ASTNode} node A node to check.
+			* @returns {boolean} True if the node is a JSXEmptyExpression contained in a single line JSXExpressionContainer.
+			*/
+			function isJSXEmptyExpressionInSingleLineContainer(node) {
+				if (!node || !node.parent || node.type !== "JSXEmptyExpression" || node.parent.type !== "JSXExpressionContainer") return !1;
+				let parent = node.parent;
+				return parent.loc.start.line === parent.loc.end.line;
+			}
+			/**
+			* Gets the line after the comment and any remaining trailing whitespace is
+			* stripped.
+			* @param {string} line The source line with a trailing comment
+			* @param {ASTNode} comment The comment to remove
+			* @returns {string} Line without comment and trailing whitespace
+			*/
+			function stripTrailingComment(line, comment) {
+				return line.slice(0, comment.loc.start.column).replace(/\s+$/u, "");
+			}
+			/**
+			* Ensure that an array exists at [key] on `object`, and add `value` to it.
+			* @param {Object} object the object to mutate
+			* @param {string} key the object's key
+			* @param {any} value the value to add
+			* @returns {void}
+			* @private
+			*/
+			function ensureArrayAndPush(object, key, value) {
+				Array.isArray(object[key]) || (object[key] = []), object[key].push(value);
+			}
+			/**
+			* Retrieves an array containing all strings (" or ') in the source code.
+			* @returns {ASTNode[]} An array of string nodes.
+			*/
+			function getAllStrings() {
+				return sourceCode.ast.tokens.filter((token) => token.type === "String" || token.type === "JSXText" && sourceCode.getNodeByRangeIndex(token.range[0] - 1).type === "JSXAttribute");
+			}
+			/**
+			* Retrieves an array containing all template literals in the source code.
+			* @returns {ASTNode[]} An array of template literal nodes.
+			*/
+			function getAllTemplateLiterals() {
+				return sourceCode.ast.tokens.filter((token) => token.type === "Template");
+			}
+			/**
+			* Retrieves an array containing all RegExp literals in the source code.
+			* @returns {ASTNode[]} An array of RegExp literal nodes.
+			*/
+			function getAllRegExpLiterals() {
+				return sourceCode.ast.tokens.filter((token) => token.type === "RegularExpression");
+			}
+			/**
+			*
+			* reduce an array of AST nodes by line number, both start and end.
+			* @param {ASTNode[]} arr array of AST nodes
+			* @returns {Object} accululated AST nodes
+			*/
+			function groupArrayByLineNumber(arr) {
+				let obj = {};
+				for (let i = 0; i < arr.length; i++) {
+					let node = arr[i];
+					for (let j = node.loc.start.line; j <= node.loc.end.line; ++j) ensureArrayAndPush(obj, j, node);
+				}
+				return obj;
+			}
+			/**
+			* Returns an array of all comments in the source code.
+			* If the element in the array is a JSXEmptyExpression contained with a single line JSXExpressionContainer,
+			* the element is changed with JSXExpressionContainer node.
+			* @returns {ASTNode[]} An array of comment nodes
+			*/
+			function getAllComments() {
+				let comments = [];
+				return sourceCode.getAllComments().forEach((commentNode) => {
+					let containingNode = sourceCode.getNodeByRangeIndex(commentNode.range[0]);
+					isJSXEmptyExpressionInSingleLineContainer(containingNode) ? comments.at(-1) !== containingNode.parent && comments.push(containingNode.parent) : comments.push(commentNode);
+				}), comments;
+			}
+			/**
+			* Check the program for max length
+			* @param {ASTNode} node Node to examine
+			* @returns {void}
+			* @private
+			*/
+			function checkProgramForMaxLength(node) {
+				let lines = sourceCode.lines, comments = ignoreComments || maxCommentLength || ignoreTrailingComments ? getAllComments() : [], commentsIndex = 0, stringsByLine = groupArrayByLineNumber(getAllStrings()), templateLiteralsByLine = groupArrayByLineNumber(getAllTemplateLiterals()), regExpLiteralsByLine = groupArrayByLineNumber(getAllRegExpLiterals());
+				lines.forEach((line, i) => {
+					let lineNumber = i + 1, lineIsComment = !1, textToMeasure;
+					if (commentsIndex < comments.length) {
+						let comment;
+						do
+							comment = comments[++commentsIndex];
+						while (comment && comment.loc.start.line <= lineNumber);
+						if (comment = comments[--commentsIndex], isFullLineComment(line, lineNumber, comment)) lineIsComment = !0, textToMeasure = line;
+						else if (ignoreTrailingComments && isTrailingComment(line, lineNumber, comment)) {
+							textToMeasure = stripTrailingComment(line, comment);
+							let lastIndex = commentsIndex;
+							for (; isTrailingComment(textToMeasure, lineNumber, comments[--lastIndex]);) textToMeasure = stripTrailingComment(textToMeasure, comments[lastIndex]);
+						} else textToMeasure = line;
+					} else textToMeasure = line;
+					if (ignorePattern && ignorePattern.test(textToMeasure) || ignoreUrls && URL_REGEXP.test(textToMeasure) || ignoreStrings && stringsByLine[lineNumber] || ignoreTemplateLiterals && templateLiteralsByLine[lineNumber] || ignoreRegExpLiterals && regExpLiteralsByLine[lineNumber]) return;
+					let lineLength = computeLineLength(textToMeasure, tabWidth), commentLengthApplies = lineIsComment && maxCommentLength;
+					if (lineIsComment && ignoreComments) return;
+					let loc = {
+						start: {
+							line: lineNumber,
+							column: 0
+						},
+						end: {
+							line: lineNumber,
+							column: textToMeasure.length
+						}
+					};
+					commentLengthApplies ? lineLength > maxCommentLength && context.report({
+						node,
+						loc,
+						messageId: "maxComment",
+						data: {
+							lineLength,
+							maxCommentLength
+						}
+					}) : lineLength > maxLength && context.report({
+						node,
+						loc,
+						messageId: "max",
+						data: {
+							lineLength,
+							maxLength
+						}
+					});
+				});
+			}
+			return { Program: checkProgramForMaxLength };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/max-len.cjs
+module.exports = require_max_len().create;
+//#endregion

package/rules/max-lines-per-function.cjs

@@ -0,0 +1,116 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_string_utils$1 = require("../common/string-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/max-lines-per-function.js
+/**
+* @fileoverview A rule to set the maximum number of line of code in a function.
+* @author Pete Ward <peteward44@gmail.com>
+*/
+var require_max_lines_per_function = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), { upperCaseFirst } = require_string_utils$1.t(), OPTIONS_OR_INTEGER_SCHEMA = { oneOf: [{
+		type: "object",
+		properties: {
+			max: {
+				type: "integer",
+				minimum: 0
+			},
+			skipComments: { type: "boolean" },
+			skipBlankLines: { type: "boolean" },
+			IIFEs: { type: "boolean" }
+		},
+		additionalProperties: !1
+	}, {
+		type: "integer",
+		minimum: 1
+	}] };
+	/**
+	* Given a list of comment nodes, return a map with numeric keys (source code line numbers) and comment token values.
+	* @param {Array} comments An array of comment nodes.
+	* @returns {Map<string, Node>} A map with numeric keys (source code line numbers) and comment token values.
+	*/
+	function getCommentLineNumbers(comments) {
+		let map = /* @__PURE__ */ new Map();
+		return comments.forEach((comment) => {
+			for (let i = comment.loc.start.line; i <= comment.loc.end.line; i++) map.set(i, comment);
+		}), map;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce a maximum number of lines of code in a function",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/max-lines-per-function"
+			},
+			schema: [OPTIONS_OR_INTEGER_SCHEMA],
+			messages: { exceed: "{{name}} has too many lines ({{lineCount}}). Maximum allowed is {{maxLines}}." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, lines = sourceCode.lines, option = context.options[0], maxLines = 50, skipComments = !1, skipBlankLines = !1, IIFEs = !1;
+			typeof option == "object" ? (maxLines = typeof option.max == "number" ? option.max : 50, skipComments = !!option.skipComments, skipBlankLines = !!option.skipBlankLines, IIFEs = !!option.IIFEs) : typeof option == "number" && (maxLines = option);
+			let commentLineNumbers = getCommentLineNumbers(sourceCode.getAllComments());
+			/**
+			* Tells if a comment encompasses the entire line.
+			* @param {string} line The source line with a trailing comment
+			* @param {number} lineNumber The one-indexed line number this is on
+			* @param {ASTNode} comment The comment to remove
+			* @returns {boolean} If the comment covers the entire line
+			*/
+			function isFullLineComment(line, lineNumber, comment) {
+				let start = comment.loc.start, end = comment.loc.end, isFirstTokenOnLine = start.line === lineNumber && !line.slice(0, start.column).trim(), isLastTokenOnLine = end.line === lineNumber && !line.slice(end.column).trim();
+				return comment && (start.line < lineNumber || isFirstTokenOnLine) && (end.line > lineNumber || isLastTokenOnLine);
+			}
+			/**
+			* Identifies is a node is a FunctionExpression which is part of an IIFE
+			* @param {ASTNode} node Node to test
+			* @returns {boolean} True if it's an IIFE
+			*/
+			function isIIFE(node) {
+				return (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && node.parent && node.parent.type === "CallExpression" && node.parent.callee === node;
+			}
+			/**
+			* Identifies is a node is a FunctionExpression which is embedded within a MethodDefinition or Property
+			* @param {ASTNode} node Node to test
+			* @returns {boolean} True if it's a FunctionExpression embedded within a MethodDefinition or Property
+			*/
+			function isEmbedded(node) {
+				return !node.parent || node !== node.parent.value ? !1 : node.parent.type === "MethodDefinition" ? !0 : node.parent.type === "Property" ? node.parent.method === !0 || node.parent.kind === "get" || node.parent.kind === "set" : !1;
+			}
+			/**
+			* Count the lines in the function
+			* @param {ASTNode} funcNode Function AST node
+			* @returns {void}
+			* @private
+			*/
+			function processFunction(funcNode) {
+				let node = isEmbedded(funcNode) ? funcNode.parent : funcNode;
+				if (!IIFEs && isIIFE(node)) return;
+				let lineCount = 0;
+				for (let i = node.loc.start.line - 1; i < node.loc.end.line; ++i) {
+					let line = lines[i];
+					skipComments && commentLineNumbers.has(i + 1) && isFullLineComment(line, i + 1, commentLineNumbers.get(i + 1)) || skipBlankLines && line.match(/^\s*$/u) || lineCount++;
+				}
+				if (lineCount > maxLines) {
+					let name = upperCaseFirst(astUtils.getFunctionNameWithKind(funcNode));
+					context.report({
+						node,
+						messageId: "exceed",
+						data: {
+							name,
+							lineCount,
+							maxLines
+						}
+					});
+				}
+			}
+			return {
+				FunctionDeclaration: processFunction,
+				FunctionExpression: processFunction,
+				ArrowFunctionExpression: processFunction
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/max-lines-per-function.cjs
+module.exports = require_max_lines_per_function().create;
+//#endregion

package/rules/max-lines.cjs

@@ -0,0 +1,109 @@
+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/max-lines.js
+/**
+* @fileoverview enforce a maximum file length
+* @author Alberto Rodríguez
+*/
+var require_max_lines = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Creates an array of numbers from `start` up to, but not including, `end`
+	* @param {number} start The start of the range
+	* @param {number} end The end of the range
+	* @returns {number[]} The range of numbers
+	*/
+	function range(start, end) {
+		return [...Array(end - start).keys()].map((x) => x + start);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce a maximum number of lines per file",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/max-lines"
+			},
+			schema: [{ oneOf: [{
+				type: "integer",
+				minimum: 0
+			}, {
+				type: "object",
+				properties: {
+					max: {
+						type: "integer",
+						minimum: 0
+					},
+					skipComments: { type: "boolean" },
+					skipBlankLines: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}] }],
+			messages: { exceed: "File has too many lines ({{actual}}). Maximum allowed is {{max}}." }
+		},
+		create(context) {
+			let option = context.options[0], max = 300;
+			typeof option == "object" && Object.hasOwn(option, "max") ? max = option.max : typeof option == "number" && (max = option);
+			let skipComments = option && option.skipComments, skipBlankLines = option && option.skipBlankLines, sourceCode = context.sourceCode;
+			/**
+			* Returns whether or not a token is a comment node type
+			* @param {Token} token The token to check
+			* @returns {boolean} True if the token is a comment node
+			*/
+			function isCommentNodeType(token) {
+				return token && (token.type === "Block" || token.type === "Line");
+			}
+			/**
+			* Returns the line numbers of a comment that don't have any code on the same line
+			* @param {Node} comment The comment node to check
+			* @returns {number[]} The line numbers
+			*/
+			function getLinesWithoutCode(comment) {
+				let start = comment.loc.start.line, end = comment.loc.end.line, token;
+				token = comment;
+				do
+					token = sourceCode.getTokenBefore(token, { includeComments: !0 });
+				while (isCommentNodeType(token));
+				token && astUtils.isTokenOnSameLine(token, comment) && (start += 1), token = comment;
+				do
+					token = sourceCode.getTokenAfter(token, { includeComments: !0 });
+				while (isCommentNodeType(token));
+				return token && astUtils.isTokenOnSameLine(comment, token) && --end, start <= end ? range(start, end + 1) : [];
+			}
+			return { "Program:exit"() {
+				let lines = sourceCode.lines.map((text, i) => ({
+					lineNumber: i + 1,
+					text
+				}));
+				if (lines.length > 1 && lines.at(-1).text === "" && lines.pop(), skipBlankLines && (lines = lines.filter((l) => l.text.trim() !== "")), skipComments) {
+					let comments = sourceCode.getAllComments(), commentLines = new Set(comments.flatMap(getLinesWithoutCode));
+					lines = lines.filter((l) => !commentLines.has(l.lineNumber));
+				}
+				if (lines.length > max) {
+					let loc = {
+						start: {
+							line: lines[max].lineNumber,
+							column: 0
+						},
+						end: {
+							line: sourceCode.lines.length,
+							column: sourceCode.lines.at(-1).length
+						}
+					};
+					context.report({
+						loc,
+						messageId: "exceed",
+						data: {
+							max,
+							actual: lines.length
+						}
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/max-lines.cjs
+module.exports = require_max_lines().create;
+//#endregion

package/rules/max-nested-callbacks.cjs

@@ -0,0 +1,78 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/max-nested-callbacks.js
+/**
+* @fileoverview Rule to enforce a maximum number of nested callbacks.
+* @author Ian Christian Myers
+*/
+var require_max_nested_callbacks = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce a maximum depth that callbacks can be nested",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/max-nested-callbacks"
+			},
+			schema: [{ oneOf: [{
+				type: "integer",
+				minimum: 0
+			}, {
+				type: "object",
+				properties: {
+					maximum: {
+						type: "integer",
+						minimum: 0
+					},
+					max: {
+						type: "integer",
+						minimum: 0
+					}
+				},
+				additionalProperties: !1
+			}] }],
+			messages: { exceed: "Too many nested callbacks ({{num}}). Maximum allowed is {{max}}." }
+		},
+		create(context) {
+			let option = context.options[0], THRESHOLD = 10;
+			typeof option == "object" && (Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max")) ? THRESHOLD = option.maximum || option.max : typeof option == "number" && (THRESHOLD = option);
+			let callbackStack = [];
+			/**
+			* Checks a given function node for too many callbacks.
+			* @param {ASTNode} node The node to check.
+			* @returns {void}
+			* @private
+			*/
+			function checkFunction(node) {
+				if (node.parent.type === "CallExpression" && callbackStack.push(node), callbackStack.length > THRESHOLD) {
+					let opts = {
+						num: callbackStack.length,
+						max: THRESHOLD
+					};
+					context.report({
+						node,
+						messageId: "exceed",
+						data: opts
+					});
+				}
+			}
+			/**
+			* Pops the call stack.
+			* @returns {void}
+			* @private
+			*/
+			function popStack() {
+				callbackStack.pop();
+			}
+			return {
+				ArrowFunctionExpression: checkFunction,
+				"ArrowFunctionExpression:exit": popStack,
+				FunctionExpression: checkFunction,
+				"FunctionExpression:exit": popStack
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/max-nested-callbacks.cjs
+module.exports = require_max_nested_callbacks().create;
+//#endregion

package/rules/max-params.cjs

@@ -0,0 +1,78 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_string_utils$1 = require("../common/string-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/max-params.js
+/**
+* @fileoverview Rule to flag when a function has too many parameters
+* @author Ilya Volodin
+*/
+var require_max_params = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), { upperCaseFirst } = require_string_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			dialects: ["typescript", "javascript"],
+			language: "javascript",
+			docs: {
+				description: "Enforce a maximum number of parameters in function definitions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/max-params"
+			},
+			schema: [{ oneOf: [{
+				type: "integer",
+				minimum: 0
+			}, {
+				type: "object",
+				properties: {
+					maximum: {
+						type: "integer",
+						minimum: 0
+					},
+					max: {
+						type: "integer",
+						minimum: 0
+					},
+					countVoidThis: {
+						type: "boolean",
+						description: "Whether to count a `this` declaration when the type is `void`."
+					}
+				},
+				additionalProperties: !1
+			}] }],
+			messages: { exceed: "{{name}} has too many parameters ({{count}}). Maximum allowed is {{max}}." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, option = context.options[0], numParams = 3, countVoidThis = !1;
+			typeof option == "object" && ((Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max")) && (numParams = option.maximum || option.max), countVoidThis = option.countVoidThis), typeof option == "number" && (numParams = option);
+			/**
+			* Checks a function to see if it has too many parameters.
+			* @param {ASTNode} node The node to check.
+			* @returns {void}
+			* @private
+			*/
+			function checkFunction(node) {
+				let effectiveParamCount = node.params.length > 0 && node.params[0].type === "Identifier" && node.params[0].name === "this" && node.params[0].typeAnnotation?.typeAnnotation.type === "TSVoidKeyword" && !countVoidThis ? node.params.length - 1 : node.params.length;
+				effectiveParamCount > numParams && context.report({
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					node,
+					messageId: "exceed",
+					data: {
+						name: upperCaseFirst(astUtils.getFunctionNameWithKind(node)),
+						count: effectiveParamCount,
+						max: numParams
+					}
+				});
+			}
+			return {
+				FunctionDeclaration: checkFunction,
+				ArrowFunctionExpression: checkFunction,
+				FunctionExpression: checkFunction,
+				TSDeclareFunction: checkFunction,
+				TSFunctionType: checkFunction
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/max-params.cjs
+module.exports = require_max_params().create;
+//#endregion