oxlint-plugin-eslint 1.52.0

package/rules/comma-dangle.cjs

@@ -0,0 +1,274 @@
+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/comma-dangle.js
+/**
+* @fileoverview Rule to forbid or enforce dangling commas.
+* @author Ian Christian Myers
+* @deprecated in ESLint v8.53.0
+*/
+var require_comma_dangle = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), DEFAULT_OPTIONS = Object.freeze({
+		arrays: "never",
+		objects: "never",
+		imports: "never",
+		exports: "never",
+		functions: "never"
+	});
+	/**
+	* Checks whether or not a trailing comma is allowed in a given node.
+	* If the `lastItem` is `RestElement` or `RestProperty`, it disallows trailing commas.
+	* @param {ASTNode} lastItem The node of the last element in the given node.
+	* @returns {boolean} `true` if a trailing comma is allowed.
+	*/
+	function isTrailingCommaAllowed(lastItem) {
+		return !(lastItem.type === "RestElement" || lastItem.type === "RestProperty" || lastItem.type === "ExperimentalRestProperty");
+	}
+	/**
+	* Normalize option value.
+	* @param {string|Object|undefined} optionValue The 1st option value to normalize.
+	* @param {number} ecmaVersion The normalized ECMAScript version.
+	* @returns {Object} The normalized option value.
+	*/
+	function normalizeOptions(optionValue, ecmaVersion) {
+		return typeof optionValue == "string" ? {
+			arrays: optionValue,
+			objects: optionValue,
+			imports: optionValue,
+			exports: optionValue,
+			functions: ecmaVersion < 2017 ? "ignore" : optionValue
+		} : typeof optionValue == "object" && optionValue ? {
+			arrays: optionValue.arrays || DEFAULT_OPTIONS.arrays,
+			objects: optionValue.objects || DEFAULT_OPTIONS.objects,
+			imports: optionValue.imports || DEFAULT_OPTIONS.imports,
+			exports: optionValue.exports || DEFAULT_OPTIONS.exports,
+			functions: optionValue.functions || DEFAULT_OPTIONS.functions
+		} : DEFAULT_OPTIONS;
+	}
+	/** @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: "comma-dangle",
+						url: "https://eslint.style/rules/comma-dangle"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require or disallow trailing commas",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/comma-dangle"
+			},
+			fixable: "code",
+			schema: {
+				definitions: {
+					value: { enum: [
+						"always-multiline",
+						"always",
+						"never",
+						"only-multiline"
+					] },
+					valueWithIgnore: { enum: [
+						"always-multiline",
+						"always",
+						"ignore",
+						"never",
+						"only-multiline"
+					] }
+				},
+				type: "array",
+				items: [{ oneOf: [{ $ref: "#/definitions/value" }, {
+					type: "object",
+					properties: {
+						arrays: { $ref: "#/definitions/valueWithIgnore" },
+						objects: { $ref: "#/definitions/valueWithIgnore" },
+						imports: { $ref: "#/definitions/valueWithIgnore" },
+						exports: { $ref: "#/definitions/valueWithIgnore" },
+						functions: { $ref: "#/definitions/valueWithIgnore" }
+					},
+					additionalProperties: !1
+				}] }],
+				additionalItems: !1
+			},
+			messages: {
+				unexpected: "Unexpected trailing comma.",
+				missing: "Missing trailing comma."
+			}
+		},
+		create(context) {
+			let options = normalizeOptions(context.options[0], context.languageOptions.ecmaVersion), sourceCode = context.sourceCode;
+			/**
+			* Gets the last item of the given node.
+			* @param {ASTNode} node The node to get.
+			* @returns {ASTNode|null} The last node or null.
+			*/
+			function getLastItem(node) {
+				/**
+				* Returns the last element of an array
+				* @param {any[]} array The input array
+				* @returns {any} The last element
+				*/
+				function last(array) {
+					return array.at(-1);
+				}
+				switch (node.type) {
+					case "ObjectExpression":
+					case "ObjectPattern": return last(node.properties);
+					case "ArrayExpression":
+					case "ArrayPattern": return last(node.elements);
+					case "ImportDeclaration":
+					case "ExportNamedDeclaration": return last(node.specifiers);
+					case "FunctionDeclaration":
+					case "FunctionExpression":
+					case "ArrowFunctionExpression": return last(node.params);
+					case "CallExpression":
+					case "NewExpression": return last(node.arguments);
+					default: return null;
+				}
+			}
+			/**
+			* Gets the trailing comma token of the given node.
+			* If the trailing comma does not exist, this returns the token which is
+			* the insertion point of the trailing comma token.
+			* @param {ASTNode} node The node to get.
+			* @param {ASTNode} lastItem The last item of the node.
+			* @returns {Token} The trailing comma token or the insertion point.
+			*/
+			function getTrailingToken(node, lastItem) {
+				switch (node.type) {
+					case "ObjectExpression":
+					case "ArrayExpression":
+					case "CallExpression":
+					case "NewExpression": return sourceCode.getLastToken(node, 1);
+					default: {
+						let nextToken = sourceCode.getTokenAfter(lastItem);
+						return astUtils.isCommaToken(nextToken) ? nextToken : sourceCode.getLastToken(lastItem);
+					}
+				}
+			}
+			/**
+			* Checks whether or not a given node is multiline.
+			* This rule handles a given node as multiline when the closing parenthesis
+			* and the last element are not on the same line.
+			* @param {ASTNode} node A node to check.
+			* @returns {boolean} `true` if the node is multiline.
+			*/
+			function isMultiline(node) {
+				let lastItem = getLastItem(node);
+				if (!lastItem) return !1;
+				let penultimateToken = getTrailingToken(node, lastItem);
+				return sourceCode.getTokenAfter(penultimateToken).loc.end.line !== penultimateToken.loc.end.line;
+			}
+			/**
+			* Reports a trailing comma if it exists.
+			* @param {ASTNode} node A node to check. Its type is one of
+			*   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
+			*   ImportDeclaration, and ExportNamedDeclaration.
+			* @returns {void}
+			*/
+			function forbidTrailingComma(node) {
+				let lastItem = getLastItem(node);
+				if (!lastItem || node.type === "ImportDeclaration" && lastItem.type !== "ImportSpecifier") return;
+				let trailingToken = getTrailingToken(node, lastItem);
+				astUtils.isCommaToken(trailingToken) && context.report({
+					node: lastItem,
+					loc: trailingToken.loc,
+					messageId: "unexpected",
+					*fix(fixer) {
+						yield fixer.remove(trailingToken), yield fixer.insertTextBefore(sourceCode.getTokenBefore(trailingToken), ""), yield fixer.insertTextAfter(sourceCode.getTokenAfter(trailingToken), "");
+					}
+				});
+			}
+			/**
+			* Reports the last element of a given node if it does not have a trailing
+			* comma.
+			*
+			* If a given node is `ArrayPattern` which has `RestElement`, the trailing
+			* comma is disallowed, so report if it exists.
+			* @param {ASTNode} node A node to check. Its type is one of
+			*   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
+			*   ImportDeclaration, and ExportNamedDeclaration.
+			* @returns {void}
+			*/
+			function forceTrailingComma(node) {
+				let lastItem = getLastItem(node);
+				if (!lastItem || node.type === "ImportDeclaration" && lastItem.type !== "ImportSpecifier") return;
+				if (!isTrailingCommaAllowed(lastItem)) {
+					forbidTrailingComma(node);
+					return;
+				}
+				let trailingToken = getTrailingToken(node, lastItem);
+				trailingToken.value !== "," && context.report({
+					node: lastItem,
+					loc: {
+						start: trailingToken.loc.end,
+						end: astUtils.getNextLocation(sourceCode, trailingToken.loc.end)
+					},
+					messageId: "missing",
+					*fix(fixer) {
+						yield fixer.insertTextAfter(trailingToken, ","), yield fixer.insertTextBefore(trailingToken, ""), yield fixer.insertTextAfter(sourceCode.getTokenAfter(trailingToken), "");
+					}
+				});
+			}
+			/**
+			* If a given node is multiline, reports the last element of a given node
+			* when it does not have a trailing comma.
+			* Otherwise, reports a trailing comma if it exists.
+			* @param {ASTNode} node A node to check. Its type is one of
+			*   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
+			*   ImportDeclaration, and ExportNamedDeclaration.
+			* @returns {void}
+			*/
+			function forceTrailingCommaIfMultiline(node) {
+				isMultiline(node) ? forceTrailingComma(node) : forbidTrailingComma(node);
+			}
+			/**
+			* Only if a given node is not multiline, reports the last element of a given node
+			* when it does not have a trailing comma.
+			* Otherwise, reports a trailing comma if it exists.
+			* @param {ASTNode} node A node to check. Its type is one of
+			*   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
+			*   ImportDeclaration, and ExportNamedDeclaration.
+			* @returns {void}
+			*/
+			function allowTrailingCommaIfMultiline(node) {
+				isMultiline(node) || forbidTrailingComma(node);
+			}
+			let predicate = {
+				always: forceTrailingComma,
+				"always-multiline": forceTrailingCommaIfMultiline,
+				"only-multiline": allowTrailingCommaIfMultiline,
+				never: forbidTrailingComma,
+				ignore() {}
+			};
+			return {
+				ObjectExpression: predicate[options.objects],
+				ObjectPattern: predicate[options.objects],
+				ArrayExpression: predicate[options.arrays],
+				ArrayPattern: predicate[options.arrays],
+				ImportDeclaration: predicate[options.imports],
+				ExportNamedDeclaration: predicate[options.exports],
+				FunctionDeclaration: predicate[options.functions],
+				FunctionExpression: predicate[options.functions],
+				ArrowFunctionExpression: predicate[options.functions],
+				CallExpression: predicate[options.functions],
+				NewExpression: predicate[options.functions]
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/comma-dangle.cjs
+module.exports = require_comma_dangle().create;
+//#endregion

package/rules/comma-spacing.cjs

@@ -0,0 +1,111 @@
+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/comma-spacing.js
+/**
+* @fileoverview Comma spacing - validates spacing before and after comma
+* @author Vignesh Anand aka vegetableman.
+* @deprecated in ESLint v8.53.0
+*/
+var require_comma_spacing = /* @__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: "comma-spacing",
+						url: "https://eslint.style/rules/comma-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing before and after commas",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/comma-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: {
+					before: {
+						type: "boolean",
+						default: !1
+					},
+					after: {
+						type: "boolean",
+						default: !0
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				missing: "A space is required {{loc}} ','.",
+				unexpected: "There should be no space {{loc}} ','."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, tokensAndComments = sourceCode.tokensAndComments, options = {
+				before: context.options[0] ? context.options[0].before : !1,
+				after: context.options[0] ? context.options[0].after : !0
+			}, commaTokensToIgnore = [];
+			/**
+			* Reports a spacing error with an appropriate message.
+			* @param {ASTNode} node The binary expression node to report.
+			* @param {string} loc Is the error "before" or "after" the comma?
+			* @param {ASTNode} otherNode The node at the left or right of `node`
+			* @returns {void}
+			* @private
+			*/
+			function report(node, loc, otherNode) {
+				context.report({
+					node,
+					fix(fixer) {
+						if (options[loc]) return loc === "before" ? fixer.insertTextBefore(node, " ") : fixer.insertTextAfter(node, " ");
+						let start, end;
+						return loc === "before" ? (start = otherNode.range[1], end = node.range[0]) : (start = node.range[1], end = otherNode.range[0]), fixer.replaceTextRange([start, end], "");
+					},
+					messageId: options[loc] ? "missing" : "unexpected",
+					data: { loc }
+				});
+			}
+			/**
+			* Adds null elements of the given ArrayExpression or ArrayPattern node to the ignore list.
+			* @param {ASTNode} node An ArrayExpression or ArrayPattern node.
+			* @returns {void}
+			*/
+			function addNullElementsToIgnoreList(node) {
+				let previousToken = sourceCode.getFirstToken(node);
+				node.elements.forEach((element) => {
+					let token;
+					element === null ? (token = sourceCode.getTokenAfter(previousToken), astUtils.isCommaToken(token) && commaTokensToIgnore.push(token)) : token = sourceCode.getTokenAfter(element), previousToken = token;
+				});
+			}
+			return {
+				"Program:exit"() {
+					tokensAndComments.forEach((token, i) => {
+						if (!astUtils.isCommaToken(token)) return;
+						let previousToken = tokensAndComments[i - 1], nextToken = tokensAndComments[i + 1];
+						previousToken && !astUtils.isCommaToken(previousToken) && !commaTokensToIgnore.includes(token) && astUtils.isTokenOnSameLine(previousToken, token) && options.before !== sourceCode.isSpaceBetweenTokens(previousToken, token) && report(token, "before", previousToken), nextToken && !astUtils.isCommaToken(nextToken) && !astUtils.isClosingParenToken(nextToken) && !astUtils.isClosingBracketToken(nextToken) && !astUtils.isClosingBraceToken(nextToken) && !(!options.after && nextToken.type === "Line") && astUtils.isTokenOnSameLine(token, nextToken) && options.after !== sourceCode.isSpaceBetweenTokens(token, nextToken) && report(token, "after", nextToken);
+					});
+				},
+				ArrayExpression: addNullElementsToIgnoreList,
+				ArrayPattern: addNullElementsToIgnoreList
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/comma-spacing.cjs
+module.exports = require_comma_spacing().create;
+//#endregion

package/rules/comma-style.cjs

@@ -0,0 +1,180 @@
+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/comma-style.js
+/**
+* @fileoverview Comma style - enforces comma styles of two types: last and first
+* @author Vignesh Anand aka vegetableman
+* @deprecated in ESLint v8.53.0
+*/
+var require_comma_style = /* @__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: "comma-style",
+						url: "https://eslint.style/rules/comma-style"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent comma style",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/comma-style"
+			},
+			fixable: "code",
+			schema: [{ enum: ["first", "last"] }, {
+				type: "object",
+				properties: { exceptions: {
+					type: "object",
+					additionalProperties: { type: "boolean" }
+				} },
+				additionalProperties: !1
+			}],
+			messages: {
+				unexpectedLineBeforeAndAfterComma: "Bad line breaking before and after ','.",
+				expectedCommaFirst: "',' should be placed first.",
+				expectedCommaLast: "',' should be placed last."
+			}
+		},
+		create(context) {
+			let style = context.options[0] || "last", sourceCode = context.sourceCode, exceptions = {
+				ArrayPattern: !0,
+				ArrowFunctionExpression: !0,
+				CallExpression: !0,
+				FunctionDeclaration: !0,
+				FunctionExpression: !0,
+				ImportDeclaration: !0,
+				ObjectPattern: !0,
+				NewExpression: !0
+			};
+			if (context.options.length === 2 && Object.hasOwn(context.options[1], "exceptions")) {
+				let keys = Object.keys(context.options[1].exceptions);
+				for (let i = 0; i < keys.length; i++) exceptions[keys[i]] = context.options[1].exceptions[keys[i]];
+			}
+			/**
+			* Modified text based on the style
+			* @param {string} styleType Style type
+			* @param {string} text Source code text
+			* @returns {string} modified text
+			* @private
+			*/
+			function getReplacedText(styleType, text) {
+				switch (styleType) {
+					case "between": return `,${text.replace(astUtils.LINEBREAK_MATCHER, "")}`;
+					case "first": return `${text},`;
+					case "last": return `,${text}`;
+					default: return "";
+				}
+			}
+			/**
+			* Determines the fixer function for a given style.
+			* @param {string} styleType comma style
+			* @param {ASTNode} previousItemToken The token to check.
+			* @param {ASTNode} commaToken The token to check.
+			* @param {ASTNode} currentItemToken The token to check.
+			* @returns {Function} Fixer function
+			* @private
+			*/
+			function getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken) {
+				let text = sourceCode.text.slice(previousItemToken.range[1], commaToken.range[0]) + sourceCode.text.slice(commaToken.range[1], currentItemToken.range[0]), range = [previousItemToken.range[1], currentItemToken.range[0]];
+				return function(fixer) {
+					return fixer.replaceTextRange(range, getReplacedText(styleType, text));
+				};
+			}
+			/**
+			* Validates the spacing around single items in lists.
+			* @param {Token} previousItemToken The last token from the previous item.
+			* @param {Token} commaToken The token representing the comma.
+			* @param {Token} currentItemToken The first token of the current item.
+			* @param {Token} reportItem The item to use when reporting an error.
+			* @returns {void}
+			* @private
+			*/
+			function validateCommaItemSpacing(previousItemToken, commaToken, currentItemToken, reportItem) {
+				if (!(astUtils.isTokenOnSameLine(commaToken, currentItemToken) && astUtils.isTokenOnSameLine(previousItemToken, commaToken))) if (!astUtils.isTokenOnSameLine(commaToken, currentItemToken) && !astUtils.isTokenOnSameLine(previousItemToken, commaToken)) {
+					let comment = sourceCode.getCommentsAfter(commaToken)[0], styleType = comment && comment.type === "Block" && astUtils.isTokenOnSameLine(commaToken, comment) ? style : "between";
+					context.report({
+						node: reportItem,
+						loc: commaToken.loc,
+						messageId: "unexpectedLineBeforeAndAfterComma",
+						fix: getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken)
+					});
+				} else style === "first" && !astUtils.isTokenOnSameLine(commaToken, currentItemToken) ? context.report({
+					node: reportItem,
+					loc: commaToken.loc,
+					messageId: "expectedCommaFirst",
+					fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)
+				}) : style === "last" && astUtils.isTokenOnSameLine(commaToken, currentItemToken) && context.report({
+					node: reportItem,
+					loc: commaToken.loc,
+					messageId: "expectedCommaLast",
+					fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)
+				});
+			}
+			/**
+			* Checks the comma placement with regards to a declaration/property/element
+			* @param {ASTNode} node The binary expression node to check
+			* @param {string} property The property of the node containing child nodes.
+			* @private
+			* @returns {void}
+			*/
+			function validateComma(node, property) {
+				let items = node[property], arrayLiteral = node.type === "ArrayExpression" || node.type === "ArrayPattern";
+				if (items.length > 1 || arrayLiteral) {
+					let previousItemToken = sourceCode.getFirstToken(node);
+					if (items.forEach((item) => {
+						let commaToken = item ? sourceCode.getTokenBefore(item) : previousItemToken, currentItemToken = item ? sourceCode.getFirstToken(item) : sourceCode.getTokenAfter(commaToken), reportItem = item || currentItemToken;
+						if (astUtils.isCommaToken(commaToken) && validateCommaItemSpacing(previousItemToken, commaToken, currentItemToken, reportItem), item) {
+							let tokenAfterItem = sourceCode.getTokenAfter(item, astUtils.isNotClosingParenToken);
+							previousItemToken = tokenAfterItem ? sourceCode.getTokenBefore(tokenAfterItem) : sourceCode.ast.tokens.at(-1);
+						} else previousItemToken = currentItemToken;
+					}), arrayLiteral) {
+						let lastToken = sourceCode.getLastToken(node), nextToLastToken = sourceCode.getTokenBefore(lastToken);
+						astUtils.isCommaToken(nextToLastToken) && validateCommaItemSpacing(sourceCode.getTokenBefore(nextToLastToken), nextToLastToken, lastToken, lastToken);
+					}
+				}
+			}
+			let nodes = {};
+			return exceptions.VariableDeclaration || (nodes.VariableDeclaration = function(node) {
+				validateComma(node, "declarations");
+			}), exceptions.ObjectExpression || (nodes.ObjectExpression = function(node) {
+				validateComma(node, "properties");
+			}), exceptions.ObjectPattern || (nodes.ObjectPattern = function(node) {
+				validateComma(node, "properties");
+			}), exceptions.ArrayExpression || (nodes.ArrayExpression = function(node) {
+				validateComma(node, "elements");
+			}), exceptions.ArrayPattern || (nodes.ArrayPattern = function(node) {
+				validateComma(node, "elements");
+			}), exceptions.FunctionDeclaration || (nodes.FunctionDeclaration = function(node) {
+				validateComma(node, "params");
+			}), exceptions.FunctionExpression || (nodes.FunctionExpression = function(node) {
+				validateComma(node, "params");
+			}), exceptions.ArrowFunctionExpression || (nodes.ArrowFunctionExpression = function(node) {
+				validateComma(node, "params");
+			}), exceptions.CallExpression || (nodes.CallExpression = function(node) {
+				validateComma(node, "arguments");
+			}), exceptions.ImportDeclaration || (nodes.ImportDeclaration = function(node) {
+				validateComma(node, "specifiers");
+			}), exceptions.NewExpression || (nodes.NewExpression = function(node) {
+				validateComma(node, "arguments");
+			}), nodes;
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/comma-style.cjs
+module.exports = require_comma_style().create;
+//#endregion

package/rules/complexity.cjs

@@ -0,0 +1,100 @@
+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/complexity.js
+/**
+* @fileoverview Counts the cyclomatic complexity of each function of the script. See http://en.wikipedia.org/wiki/Cyclomatic_complexity.
+* Counts the number of if, conditional, for, while, try, switch/case,
+* @author Patrick Brosset
+*/
+var require_complexity = /* @__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",
+			defaultOptions: [20],
+			docs: {
+				description: "Enforce a maximum cyclomatic complexity allowed in a program",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/complexity"
+			},
+			schema: [{ oneOf: [{
+				type: "integer",
+				minimum: 0
+			}, {
+				type: "object",
+				properties: {
+					maximum: {
+						type: "integer",
+						minimum: 0
+					},
+					max: {
+						type: "integer",
+						minimum: 0
+					},
+					variant: { enum: ["classic", "modified"] }
+				},
+				additionalProperties: !1
+			}] }],
+			messages: { complex: "{{name}} has a complexity of {{complexity}}. Maximum allowed is {{max}}." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, option = context.options[0], threshold = 20, VARIANT = "classic";
+			typeof option == "object" ? ((Object.hasOwn(option, "maximum") || Object.hasOwn(option, "max")) && (threshold = option.maximum || option.max), Object.hasOwn(option, "variant") && (VARIANT = option.variant)) : typeof option == "number" && (threshold = option);
+			let IS_MODIFIED_COMPLEXITY = VARIANT === "modified", complexities = [];
+			/**
+			* Increase the complexity of the code path in context
+			* @returns {void}
+			* @private
+			*/
+			function increaseComplexity() {
+				complexities[complexities.length - 1]++;
+			}
+			return {
+				onCodePathStart() {
+					complexities.push(1);
+				},
+				CatchClause: increaseComplexity,
+				ConditionalExpression: increaseComplexity,
+				LogicalExpression: increaseComplexity,
+				ForStatement: increaseComplexity,
+				ForInStatement: increaseComplexity,
+				ForOfStatement: increaseComplexity,
+				IfStatement: increaseComplexity,
+				WhileStatement: increaseComplexity,
+				DoWhileStatement: increaseComplexity,
+				AssignmentPattern: increaseComplexity,
+				"SwitchCase[test]": () => IS_MODIFIED_COMPLEXITY || increaseComplexity(),
+				SwitchStatement: () => IS_MODIFIED_COMPLEXITY && increaseComplexity(),
+				AssignmentExpression(node) {
+					astUtils.isLogicalAssignmentOperator(node.operator) && increaseComplexity();
+				},
+				MemberExpression(node) {
+					node.optional === !0 && increaseComplexity();
+				},
+				CallExpression(node) {
+					node.optional === !0 && increaseComplexity();
+				},
+				onCodePathEnd(codePath, node) {
+					let complexity = complexities.pop();
+					if (!(codePath.origin !== "function" && codePath.origin !== "class-field-initializer" && codePath.origin !== "class-static-block") && complexity > threshold) {
+						let name, loc = node.loc;
+						codePath.origin === "class-field-initializer" ? name = "class field initializer" : codePath.origin === "class-static-block" ? (name = "class static block", loc = sourceCode.getFirstToken(node).loc) : (name = astUtils.getFunctionNameWithKind(node), loc = astUtils.getFunctionHeadLoc(node, sourceCode)), context.report({
+							node,
+							loc,
+							messageId: "complex",
+							data: {
+								name: upperCaseFirst(name),
+								complexity,
+								max: threshold
+							}
+						});
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/complexity.cjs
+module.exports = require_complexity().create;
+//#endregion