oxlint-plugin-eslint 1.52.0

package/rules/no-restricted-properties.cjs

@@ -0,0 +1,123 @@
+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/no-restricted-properties.js
+/**
+* @fileoverview Rule to disallow certain object properties
+* @author Will Klein & Eli White
+*/
+var require_no_restricted_properties = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow certain properties on certain objects",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-restricted-properties"
+			},
+			schema: {
+				type: "array",
+				items: {
+					type: "object",
+					properties: {
+						object: { type: "string" },
+						property: { type: "string" },
+						allowObjects: {
+							type: "array",
+							items: { type: "string" },
+							uniqueItems: !0
+						},
+						allowProperties: {
+							type: "array",
+							items: { type: "string" },
+							uniqueItems: !0
+						},
+						message: { type: "string" }
+					},
+					anyOf: [{ required: ["object"] }, { required: ["property"] }],
+					not: { anyOf: [{ required: ["allowObjects", "object"] }, { required: ["allowProperties", "property"] }] },
+					additionalProperties: !1
+				},
+				uniqueItems: !0
+			},
+			messages: {
+				restrictedObjectProperty: "'{{objectName}}.{{propertyName}}' is restricted from being used.{{allowedPropertiesMessage}}{{message}}",
+				restrictedProperty: "'{{propertyName}}' is restricted from being used.{{allowedObjectsMessage}}{{message}}"
+			}
+		},
+		create(context) {
+			let restrictedCalls = context.options;
+			if (restrictedCalls.length === 0) return {};
+			let restrictedProperties = /* @__PURE__ */ new Map(), globallyRestrictedObjects = /* @__PURE__ */ new Map(), globallyRestrictedProperties = /* @__PURE__ */ new Map();
+			restrictedCalls.forEach((option) => {
+				let objectName = option.object, propertyName = option.property;
+				objectName === void 0 ? globallyRestrictedProperties.set(propertyName, {
+					allowObjects: option.allowObjects,
+					message: option.message
+				}) : propertyName === void 0 ? globallyRestrictedObjects.set(objectName, {
+					allowProperties: option.allowProperties,
+					message: option.message
+				}) : (restrictedProperties.has(objectName) || restrictedProperties.set(objectName, /* @__PURE__ */ new Map()), restrictedProperties.get(objectName).set(propertyName, { message: option.message }));
+			});
+			/**
+			* Checks if a name is in the allowed list.
+			* @param {string} name The name to check
+			* @param {string[]} [allowedList] The list of allowed names
+			* @returns {boolean} True if the name is allowed, false otherwise
+			*/
+			function isAllowed(name, allowedList) {
+				return allowedList ? allowedList.includes(name) : !1;
+			}
+			/**
+			* Checks to see whether a property access is restricted, and reports it if so.
+			* @param {ASTNode} node The node to report
+			* @param {string} objectName The name of the object
+			* @param {string} propertyName The name of the property
+			* @returns {undefined}
+			*/
+			function checkPropertyAccess(node, objectName, propertyName) {
+				if (propertyName === null) return;
+				let matchedObject = restrictedProperties.get(objectName), matchedObjectProperty = matchedObject ? matchedObject.get(propertyName) : globallyRestrictedObjects.get(objectName), globalMatchedProperty = globallyRestrictedProperties.get(propertyName);
+				if (matchedObjectProperty && !isAllowed(propertyName, matchedObjectProperty.allowProperties)) {
+					let message = matchedObjectProperty.message ? ` ${matchedObjectProperty.message}` : "", allowedPropertiesMessage = matchedObjectProperty.allowProperties ? ` Only these properties are allowed: ${matchedObjectProperty.allowProperties.join(", ")}.` : "";
+					context.report({
+						node,
+						messageId: "restrictedObjectProperty",
+						data: {
+							objectName,
+							propertyName,
+							message,
+							allowedPropertiesMessage
+						}
+					});
+				} else if (globalMatchedProperty && !isAllowed(objectName, globalMatchedProperty.allowObjects)) {
+					let message = globalMatchedProperty.message ? ` ${globalMatchedProperty.message}` : "", allowedObjectsMessage = globalMatchedProperty.allowObjects ? ` Property '${propertyName}' is only allowed on these objects: ${globalMatchedProperty.allowObjects.join(", ")}.` : "";
+					context.report({
+						node,
+						messageId: "restrictedProperty",
+						data: {
+							propertyName,
+							message,
+							allowedObjectsMessage
+						}
+					});
+				}
+			}
+			return {
+				MemberExpression(node) {
+					checkPropertyAccess(node, node.object && node.object.name, astUtils.getStaticPropertyName(node));
+				},
+				ObjectPattern(node) {
+					let objectName = null;
+					node.parent.type === "VariableDeclarator" ? node.parent.init && node.parent.init.type === "Identifier" && (objectName = node.parent.init.name) : (node.parent.type === "AssignmentExpression" || node.parent.type === "AssignmentPattern") && node.parent.right.type === "Identifier" && (objectName = node.parent.right.name), node.properties.forEach((property) => {
+						checkPropertyAccess(node, objectName, astUtils.getStaticPropertyName(property));
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-restricted-properties.cjs
+module.exports = require_no_restricted_properties().create;
+//#endregion

package/rules/no-restricted-syntax.cjs

@@ -0,0 +1,49 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-restricted-syntax.js
+/**
+* @fileoverview Rule to flag use of certain node types
+* @author Burak Yigit Kaya
+*/
+var require_no_restricted_syntax = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow specified syntax",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-restricted-syntax"
+			},
+			schema: {
+				type: "array",
+				items: { oneOf: [{ type: "string" }, {
+					type: "object",
+					properties: {
+						selector: { type: "string" },
+						message: { type: "string" }
+					},
+					required: ["selector"],
+					additionalProperties: !1
+				}] },
+				uniqueItems: !0,
+				minItems: 0
+			},
+			messages: { restrictedSyntax: "{{message}}" }
+		},
+		create(context) {
+			return context.options.reduce((result, selectorOrObject) => {
+				let isStringFormat = typeof selectorOrObject == "string", hasCustomMessage = !isStringFormat && !!selectorOrObject.message, selector = isStringFormat ? selectorOrObject : selectorOrObject.selector, message = hasCustomMessage ? selectorOrObject.message : `Using '${selector}' is not allowed.`;
+				return Object.assign(result, { [selector](node) {
+					context.report({
+						node,
+						messageId: "restrictedSyntax",
+						data: { message }
+					});
+				} });
+			}, {});
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-restricted-syntax.cjs
+module.exports = require_no_restricted_syntax().create;
+//#endregion

package/rules/no-return-assign.cjs

@@ -0,0 +1,45 @@
+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/no-return-assign.js
+/**
+* @fileoverview Rule to flag when return statement contains assignment
+* @author Ilya Volodin
+*/
+var require_no_return_assign = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), SENTINEL_TYPE = /^(?:[a-zA-Z]+?Statement|ArrowFunctionExpression|FunctionExpression|ClassExpression)$/u;
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: ["except-parens"],
+			docs: {
+				description: "Disallow assignment operators in `return` statements",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-return-assign"
+			},
+			schema: [{ enum: ["except-parens", "always"] }],
+			messages: {
+				returnAssignment: "Return statement should not contain assignment.",
+				arrowAssignment: "Arrow function should not return assignment."
+			}
+		},
+		create(context) {
+			let always = context.options[0] !== "except-parens", sourceCode = context.sourceCode;
+			return { AssignmentExpression(node) {
+				if (!always && astUtils.isParenthesised(sourceCode, node)) return;
+				let currentChild = node, parent = currentChild.parent;
+				for (; parent && !SENTINEL_TYPE.test(parent.type);) currentChild = parent, parent = parent.parent;
+				parent && parent.type === "ReturnStatement" ? context.report({
+					node: parent,
+					messageId: "returnAssignment"
+				}) : parent && parent.type === "ArrowFunctionExpression" && parent.body === currentChild && context.report({
+					node: parent,
+					messageId: "arrowAssignment"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-return-assign.cjs
+module.exports = require_no_return_assign().create;
+//#endregion

package/rules/no-return-await.cjs

@@ -0,0 +1,88 @@
+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/no-return-await.js
+/**
+* @fileoverview Disallows unnecessary `return await`
+* @author Jordan Harband
+* @deprecated in ESLint v8.46.0
+*/
+var require_no_return_await = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			hasSuggestions: !0,
+			type: "suggestion",
+			docs: {
+				description: "Disallow unnecessary `return await`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-return-await"
+			},
+			fixable: null,
+			deprecated: {
+				message: "The original assumption of the rule no longer holds true because of engine optimization.",
+				deprecatedSince: "8.46.0",
+				availableUntil: null,
+				replacedBy: []
+			},
+			schema: [],
+			messages: {
+				removeAwait: "Remove redundant `await`.",
+				redundantUseOfAwait: "Redundant use of `await` on a return value."
+			}
+		},
+		create(context) {
+			/**
+			* Reports a found unnecessary `await` expression.
+			* @param {ASTNode} node The node representing the `await` expression to report
+			* @returns {void}
+			*/
+			function reportUnnecessaryAwait(node) {
+				context.report({
+					node: context.sourceCode.getFirstToken(node),
+					loc: node.loc,
+					messageId: "redundantUseOfAwait",
+					suggest: [{
+						messageId: "removeAwait",
+						fix(fixer) {
+							let sourceCode = context.sourceCode, [awaitToken, tokenAfterAwait] = sourceCode.getFirstTokens(node, 2);
+							if (awaitToken.loc.start.line !== tokenAfterAwait.loc.start.line) return null;
+							let [startOfAwait, endOfAwait] = awaitToken.range, range = [startOfAwait, endOfAwait + (sourceCode.text[endOfAwait] === " " ? 1 : 0)];
+							return fixer.removeRange(range);
+						}
+					}]
+				});
+			}
+			/**
+			* Determines whether a thrown error from this node will be caught/handled within this function rather than immediately halting
+			* this function. For example, a statement in a `try` block will always have an error handler. A statement in
+			* a `catch` block will only have an error handler if there is also a `finally` block.
+			* @param {ASTNode} node A node representing a location where an could be thrown
+			* @returns {boolean} `true` if a thrown error will be caught/handled in this function
+			*/
+			function hasErrorHandler(node) {
+				let ancestor = node;
+				for (; !astUtils.isFunction(ancestor) && ancestor.type !== "Program";) {
+					if (ancestor.parent.type === "TryStatement" && (ancestor === ancestor.parent.block || ancestor === ancestor.parent.handler && ancestor.parent.finalizer)) return !0;
+					ancestor = ancestor.parent;
+				}
+				return !1;
+			}
+			/**
+			* Checks if a node is placed in tail call position. Once `return` arguments (or arrow function expressions) can be a complex expression,
+			* an `await` expression could or could not be unnecessary by the definition of this rule. So we're looking for `await` expressions that are in tail position.
+			* @param {ASTNode} node A node representing the `await` expression to check
+			* @returns {boolean} The checking result
+			*/
+			function isInTailCallPosition(node) {
+				return node.parent.type === "ArrowFunctionExpression" ? !0 : node.parent.type === "ReturnStatement" ? !hasErrorHandler(node.parent) : node.parent.type === "ConditionalExpression" && (node === node.parent.consequent || node === node.parent.alternate) || node.parent.type === "LogicalExpression" && node === node.parent.right || node.parent.type === "SequenceExpression" && node === node.parent.expressions.at(-1) ? isInTailCallPosition(node.parent) : !1;
+			}
+			return { AwaitExpression(node) {
+				isInTailCallPosition(node) && !hasErrorHandler(node) && reportUnnecessaryAwait(node);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-return-await.cjs
+module.exports = require_no_return_await().create;
+//#endregion

package/rules/no-script-url.cjs

@@ -0,0 +1,49 @@
+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/no-script-url.js
+/**
+* @fileoverview Rule to disallow `javascript:` URLs
+* @author Ilya Volodin
+*/
+var require_no_script_url = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow `javascript:` URLs",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-script-url"
+			},
+			schema: [],
+			messages: { unexpectedScriptURL: "Script URL is a form of eval." }
+		},
+		create(context) {
+			/**
+			* Check whether a node's static value starts with `javascript:` or not.
+			* And report an error for unexpected script URL.
+			* @param {ASTNode} node node to check
+			* @returns {void}
+			*/
+			function check(node) {
+				let value = astUtils.getStaticStringValue(node);
+				typeof value == "string" && value.toLowerCase().indexOf("javascript:") === 0 && context.report({
+					node,
+					messageId: "unexpectedScriptURL"
+				});
+			}
+			return {
+				Literal(node) {
+					node.value && typeof node.value == "string" && check(node);
+				},
+				TemplateLiteral(node) {
+					node.parent && node.parent.type === "TaggedTemplateExpression" || check(node);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-script-url.cjs
+module.exports = require_no_script_url().create;
+//#endregion

package/rules/no-self-assign.cjs

@@ -0,0 +1,88 @@
+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/no-self-assign.js
+/**
+* @fileoverview Rule to disallow assignments where both sides are exactly the same
+* @author Toru Nagashima
+*/
+var require_no_self_assign = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), SPACES = /\s+/gu;
+	/**
+	* Traverses 2 Pattern nodes in parallel, then reports self-assignments.
+	* @param {ASTNode|null} left A left node to traverse. This is a Pattern or
+	*      a Property.
+	* @param {ASTNode|null} right A right node to traverse. This is a Pattern or
+	*      a Property.
+	* @param {boolean} props The flag to check member expressions as well.
+	* @param {Function} report A callback function to report.
+	* @returns {void}
+	*/
+	function eachSelfAssignment(left, right, props, report) {
+		if (!(!left || !right)) if (left.type === "Identifier" && right.type === "Identifier" && left.name === right.name) report(right);
+		else if (left.type === "ArrayPattern" && right.type === "ArrayExpression") {
+			let end = Math.min(left.elements.length, right.elements.length);
+			for (let i = 0; i < end; ++i) {
+				let leftElement = left.elements[i], rightElement = right.elements[i];
+				if (leftElement && leftElement.type === "RestElement" && i < right.elements.length - 1 || (eachSelfAssignment(leftElement, rightElement, props, report), rightElement && rightElement.type === "SpreadElement")) break;
+			}
+		} else if (left.type === "RestElement" && right.type === "SpreadElement") eachSelfAssignment(left.argument, right.argument, props, report);
+		else if (left.type === "ObjectPattern" && right.type === "ObjectExpression" && right.properties.length >= 1) {
+			let startJ = 0;
+			for (let i = right.properties.length - 1; i >= 0; --i) {
+				let propType = right.properties[i].type;
+				if (propType === "SpreadElement" || propType === "ExperimentalSpreadProperty") {
+					startJ = i + 1;
+					break;
+				}
+			}
+			for (let i = 0; i < left.properties.length; ++i) for (let j = startJ; j < right.properties.length; ++j) eachSelfAssignment(left.properties[i], right.properties[j], props, report);
+		} else if (left.type === "Property" && right.type === "Property" && right.kind === "init" && !right.method) {
+			let leftName = astUtils.getStaticPropertyName(left);
+			leftName !== null && leftName === astUtils.getStaticPropertyName(right) && eachSelfAssignment(left.value, right.value, props, report);
+		} else props && astUtils.skipChainExpression(left).type === "MemberExpression" && astUtils.skipChainExpression(right).type === "MemberExpression" && astUtils.isSameReference(left, right) && report(right);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{ props: !0 }],
+			docs: {
+				description: "Disallow assignments where both sides are exactly the same",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-self-assign"
+			},
+			schema: [{
+				type: "object",
+				properties: { props: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: { selfAssignment: "'{{name}}' is assigned to itself." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, [{ props }] = context.options;
+			/**
+			* Reports a given node as self assignments.
+			* @param {ASTNode} node A node to report. This is an Identifier node.
+			* @returns {void}
+			*/
+			function report(node) {
+				context.report({
+					node,
+					messageId: "selfAssignment",
+					data: { name: sourceCode.getText(node).replace(SPACES, "") }
+				});
+			}
+			return { AssignmentExpression(node) {
+				[
+					"=",
+					"&&=",
+					"||=",
+					"??="
+				].includes(node.operator) && eachSelfAssignment(node.left, node.right, props, report);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-self-assign.cjs
+module.exports = require_no_self_assign().create;
+//#endregion

package/rules/no-self-compare.cjs

@@ -0,0 +1,53 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-self-compare.js
+/**
+* @fileoverview Rule to flag comparison where left part is the same as the right
+* part.
+* @author Ilya Volodin
+*/
+var require_no_self_compare = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow comparisons where both sides are exactly the same",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-self-compare"
+			},
+			schema: [],
+			messages: { comparingToSelf: "Comparing to itself is potentially pointless." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Determines whether two nodes are composed of the same tokens.
+			* @param {ASTNode} nodeA The first node
+			* @param {ASTNode} nodeB The second node
+			* @returns {boolean} true if the nodes have identical token representations
+			*/
+			function hasSameTokens(nodeA, nodeB) {
+				let tokensA = sourceCode.getTokens(nodeA), tokensB = sourceCode.getTokens(nodeB);
+				return tokensA.length === tokensB.length && tokensA.every((token, index) => token.type === tokensB[index].type && token.value === tokensB[index].value);
+			}
+			return { BinaryExpression(node) {
+				new Set([
+					"===",
+					"==",
+					"!==",
+					"!=",
+					">",
+					"<",
+					">=",
+					"<="
+				]).has(node.operator) && hasSameTokens(node.left, node.right) && context.report({
+					node,
+					messageId: "comparingToSelf"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-self-compare.cjs
+module.exports = require_no_self_compare().create;
+//#endregion

package/rules/no-sequences.cjs

@@ -0,0 +1,81 @@
+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/no-sequences.js
+/**
+* @fileoverview Rule to flag use of comma operator
+* @author Brandon Mills
+*/
+var require_no_sequences = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow comma operators",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-sequences"
+			},
+			schema: [{
+				type: "object",
+				properties: { allowInParentheses: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			defaultOptions: [{ allowInParentheses: !0 }],
+			messages: { unexpectedCommaExpression: "Unexpected use of comma operator." }
+		},
+		create(context) {
+			let [{ allowInParentheses }] = context.options, sourceCode = context.sourceCode, parenthesized = {
+				DoWhileStatement: "test",
+				IfStatement: "test",
+				SwitchStatement: "discriminant",
+				WhileStatement: "test",
+				WithStatement: "object",
+				ArrowFunctionExpression: "body"
+			};
+			/**
+			* Determines whether a node is required by the grammar to be wrapped in
+			* parens, e.g. the test of an if statement.
+			* @param {ASTNode} node The AST node
+			* @returns {boolean} True if parens around node belong to parent node.
+			*/
+			function requiresExtraParens(node) {
+				return node.parent && parenthesized[node.parent.type] && node === node.parent[parenthesized[node.parent.type]];
+			}
+			/**
+			* Check if a node is wrapped in parens.
+			* @param {ASTNode} node The AST node
+			* @returns {boolean} True if the node has a paren on each side.
+			*/
+			function isParenthesised(node) {
+				return astUtils.isParenthesised(sourceCode, node);
+			}
+			/**
+			* Check if a node is wrapped in two levels of parens.
+			* @param {ASTNode} node The AST node
+			* @returns {boolean} True if two parens surround the node on each side.
+			*/
+			function isParenthesisedTwice(node) {
+				let previousToken = sourceCode.getTokenBefore(node, 1), nextToken = sourceCode.getTokenAfter(node, 1);
+				return isParenthesised(node) && previousToken && nextToken && astUtils.isOpeningParenToken(previousToken) && previousToken.range[1] <= node.range[0] && astUtils.isClosingParenToken(nextToken) && nextToken.range[0] >= node.range[1];
+			}
+			return { SequenceExpression(node) {
+				if (node.parent.type === "ForStatement" && (node === node.parent.init || node === node.parent.update)) return;
+				if (allowInParentheses) {
+					if (requiresExtraParens(node)) {
+						if (isParenthesisedTwice(node)) return;
+					} else if (isParenthesised(node)) return;
+				}
+				let firstCommaToken = sourceCode.getTokenAfter(node.expressions[0], astUtils.isCommaToken);
+				context.report({
+					node,
+					loc: firstCommaToken.loc,
+					messageId: "unexpectedCommaExpression"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-sequences.cjs
+module.exports = require_no_sequences().create;
+//#endregion