oxlint-plugin-eslint 1.52.0

package/rules/newline-per-chained-call.cjs

@@ -0,0 +1,100 @@
+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/newline-per-chained-call.js
+/**
+* @fileoverview Rule to ensure newline per method call when chaining calls
+* @author Rajendra Patil
+* @author Burak Yigit Kaya
+* @deprecated in ESLint v8.53.0
+*/
+var require_newline_per_chained_call = /* @__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: "newline-per-chained-call",
+						url: "https://eslint.style/rules/newline-per-chained-call"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require a newline after each call in a method chain",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/newline-per-chained-call"
+			},
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: { ignoreChainWithDepth: {
+					type: "integer",
+					minimum: 1,
+					maximum: 10,
+					default: 2
+				} },
+				additionalProperties: !1
+			}],
+			messages: { expected: "Expected line break before `{{callee}}`." }
+		},
+		create(context) {
+			let ignoreChainWithDepth = (context.options[0] || {}).ignoreChainWithDepth || 2, sourceCode = context.sourceCode;
+			/**
+			* Get the prefix of a given MemberExpression node.
+			* If the MemberExpression node is a computed value it returns a
+			* left bracket. If not it returns a period.
+			* @param {ASTNode} node A MemberExpression node to get
+			* @returns {string} The prefix of the node.
+			*/
+			function getPrefix(node) {
+				return node.computed ? node.optional ? "?.[" : "[" : node.optional ? "?." : ".";
+			}
+			/**
+			* Gets the property text of a given MemberExpression node.
+			* If the text is multiline, this returns only the first line.
+			* @param {ASTNode} node A MemberExpression node to get.
+			* @returns {string} The property text of the node.
+			*/
+			function getPropertyText(node) {
+				let prefix = getPrefix(node), lines = sourceCode.getText(node.property).split(astUtils.LINEBREAK_MATCHER), suffix = node.computed && lines.length === 1 ? "]" : "";
+				return prefix + lines[0] + suffix;
+			}
+			return { "CallExpression:exit"(node) {
+				let callee = astUtils.skipChainExpression(node.callee);
+				if (callee.type !== "MemberExpression") return;
+				let parent = astUtils.skipChainExpression(callee.object), depth = 1;
+				for (; parent && parent.callee;) depth += 1, parent = astUtils.skipChainExpression(astUtils.skipChainExpression(parent.callee).object);
+				if (depth > ignoreChainWithDepth && astUtils.isTokenOnSameLine(callee.object, callee.property)) {
+					let firstTokenAfterObject = sourceCode.getTokenAfter(callee.object, astUtils.isNotClosingParenToken);
+					context.report({
+						node: callee.property,
+						loc: {
+							start: firstTokenAfterObject.loc.start,
+							end: callee.loc.end
+						},
+						messageId: "expected",
+						data: { callee: getPropertyText(callee) },
+						fix(fixer) {
+							return fixer.insertTextBefore(firstTokenAfterObject, "\n");
+						}
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/newline-per-chained-call.cjs
+module.exports = require_newline_per_chained_call().create;
+//#endregion

package/rules/no-alert.cjs

@@ -0,0 +1,84 @@
+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-alert.js
+/**
+* @fileoverview Rule to flag use of alert, confirm, prompt
+* @author Nicholas C. Zakas
+*/
+var require_no_alert = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { getStaticPropertyName: getPropertyName, getVariableByName, skipChainExpression } = require_ast_utils$1.t();
+	/**
+	* Checks if the given name is a prohibited identifier.
+	* @param {string} name The name to check
+	* @returns {boolean} Whether or not the name is prohibited.
+	*/
+	function isProhibitedIdentifier(name) {
+		return /^(?:alert|confirm|prompt)$/u.test(name);
+	}
+	/**
+	* Finds the eslint-scope reference in the given scope.
+	* @param {Object} scope The scope to search.
+	* @param {ASTNode} node The identifier node.
+	* @returns {Reference|null} Returns the found reference or null if none were found.
+	*/
+	function findReference(scope, node) {
+		let references = scope.references.filter((reference) => reference.identifier.range[0] === node.range[0] && reference.identifier.range[1] === node.range[1]);
+		return references.length === 1 ? references[0] : null;
+	}
+	/**
+	* Checks if the given identifier node is shadowed in the given scope.
+	* @param {Object} scope The current scope.
+	* @param {string} node The identifier node to check
+	* @returns {boolean} Whether or not the name is shadowed.
+	*/
+	function isShadowed(scope, node) {
+		let reference = findReference(scope, node);
+		return reference && reference.resolved && reference.resolved.defs.length > 0;
+	}
+	/**
+	* Checks if the given identifier node is a ThisExpression in the global scope or the global window property.
+	* @param {Object} scope The current scope.
+	* @param {string} node The identifier node to check
+	* @returns {boolean} Whether or not the node is a reference to the global object.
+	*/
+	function isGlobalThisReferenceOrGlobalWindow(scope, node) {
+		return scope.type === "global" && node.type === "ThisExpression" ? !0 : node.type === "Identifier" && (node.name === "window" || node.name === "globalThis" && getVariableByName(scope, "globalThis")) ? !isShadowed(scope, node) : !1;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow the use of `alert`, `confirm`, and `prompt`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-alert"
+			},
+			schema: [],
+			messages: { unexpected: "Unexpected {{name}}." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { CallExpression(node) {
+				let callee = skipChainExpression(node.callee), currentScope = sourceCode.getScope(node);
+				if (callee.type === "Identifier") {
+					let name = callee.name;
+					!isShadowed(currentScope, callee) && isProhibitedIdentifier(callee.name) && context.report({
+						node,
+						messageId: "unexpected",
+						data: { name }
+					});
+				} else if (callee.type === "MemberExpression" && isGlobalThisReferenceOrGlobalWindow(currentScope, callee.object)) {
+					let name = getPropertyName(callee);
+					isProhibitedIdentifier(name) && context.report({
+						node,
+						messageId: "unexpected",
+						data: { name }
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-alert.cjs
+module.exports = require_no_alert().create;
+//#endregion

package/rules/no-array-constructor.cjs

@@ -0,0 +1,91 @@
+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-array-constructor.js
+/**
+* @fileoverview Disallow construction of dense arrays using the Array constructor
+* @author Matt DuVall <http://www.mattduvall.com/>
+*/
+var require_no_array_constructor = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { getVariableByName, isClosingParenToken, isOpeningParenToken, isStartOfExpressionStatement, needsPrecedingSemicolon } = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			type: "suggestion",
+			docs: {
+				description: "Disallow `Array` constructors",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-array-constructor"
+			},
+			fixable: "code",
+			hasSuggestions: !0,
+			schema: [],
+			messages: {
+				preferLiteral: "The array literal notation [] is preferable.",
+				useLiteral: "Replace with an array literal.",
+				useLiteralAfterSemicolon: "Replace with an array literal, add preceding semicolon."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Checks if there are comments in Array constructor expressions.
+			* @param {ASTNode} node A CallExpression or NewExpression node.
+			* @returns {boolean} True if there are comments, false otherwise.
+			*/
+			function hasCommentsInArrayConstructor(node) {
+				let firstToken = sourceCode.getFirstToken(node), lastToken = sourceCode.getLastToken(node), lastRelevantToken = sourceCode.getLastToken(node.callee);
+				for (; lastRelevantToken !== lastToken && !isOpeningParenToken(lastRelevantToken);) lastRelevantToken = sourceCode.getTokenAfter(lastRelevantToken);
+				return sourceCode.commentsExistBetween(firstToken, lastRelevantToken);
+			}
+			/**
+			* Gets the text between the calling parentheses of a CallExpression or NewExpression.
+			* @param {ASTNode} node A CallExpression or NewExpression node.
+			* @returns {string} The text between the calling parentheses, or an empty string if there are none.
+			*/
+			function getArgumentsText(node) {
+				let lastToken = sourceCode.getLastToken(node);
+				if (!isClosingParenToken(lastToken)) return "";
+				let firstToken = node.callee;
+				do
+					if (firstToken = sourceCode.getTokenAfter(firstToken), !firstToken || firstToken === lastToken) return "";
+				while (!isOpeningParenToken(firstToken));
+				return sourceCode.text.slice(firstToken.range[1], lastToken.range[0]);
+			}
+			/**
+			* Disallow construction of dense arrays using the Array constructor
+			* @param {ASTNode} node node to evaluate
+			* @returns {void}
+			* @private
+			*/
+			function check(node) {
+				if (node.callee.type !== "Identifier" || node.callee.name !== "Array" || node.typeArguments || node.arguments.length === 1 && node.arguments[0].type !== "SpreadElement") return;
+				let variable = getVariableByName(sourceCode.getScope(node), "Array");
+				if (variable && variable.identifiers.length === 0) {
+					let argsText = getArgumentsText(node), fixText, messageId, nonSpreadCount = node.arguments.reduce((count, arg) => arg.type === "SpreadElement" ? count : count + 1, 0), shouldSuggest = node.optional || node.arguments.length > 0 && nonSpreadCount < 2 || hasCommentsInArrayConstructor(node);
+					isStartOfExpressionStatement(node) && needsPrecedingSemicolon(sourceCode, node) ? (fixText = `;[${argsText}]`, messageId = "useLiteralAfterSemicolon") : (fixText = `[${argsText}]`, messageId = "useLiteral"), context.report({
+						node,
+						messageId: "preferLiteral",
+						fix(fixer) {
+							return shouldSuggest ? null : fixer.replaceText(node, fixText);
+						},
+						suggest: [{
+							messageId,
+							fix(fixer) {
+								return shouldSuggest ? fixer.replaceText(node, fixText) : null;
+							}
+						}]
+					});
+				}
+			}
+			return {
+				CallExpression: check,
+				NewExpression: check
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-array-constructor.cjs
+module.exports = require_no_array_constructor().create;
+//#endregion

package/rules/no-async-promise-executor.cjs

@@ -0,0 +1,33 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-async-promise-executor.js
+/**
+* @fileoverview disallow using an async function as a Promise executor
+* @author Teddy Katz
+*/
+var require_no_async_promise_executor = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow using an async function as a Promise executor",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-async-promise-executor"
+			},
+			fixable: null,
+			schema: [],
+			messages: { async: "Promise executor functions should not be async." }
+		},
+		create(context) {
+			return { "NewExpression[callee.name='Promise'][arguments.0.async=true]"(node) {
+				context.report({
+					node: context.sourceCode.getFirstToken(node.arguments[0], (token) => token.value === "async"),
+					messageId: "async"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-async-promise-executor.cjs
+module.exports = require_no_async_promise_executor().create;
+//#endregion

package/rules/no-await-in-loop.cjs

@@ -0,0 +1,75 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-await-in-loop.js
+/**
+* @fileoverview Rule to disallow uses of await inside of loops.
+* @author Nat Mote (nmote)
+*/
+var require_no_await_in_loop = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/**
+	* Check whether it should stop traversing ancestors at the given node.
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if it should stop traversing.
+	*/
+	function isBoundary(node) {
+		let t = node.type;
+		return t === "FunctionDeclaration" || t === "FunctionExpression" || t === "ArrowFunctionExpression" || t === "ForOfStatement" && node.await === !0;
+	}
+	/**
+	* Check whether the given node is in loop.
+	* @param {ASTNode} node A node to check.
+	* @param {ASTNode} parent A parent node to check.
+	* @returns {boolean} `true` if the node is in loop.
+	*/
+	function isLooped(node, parent) {
+		switch (parent.type) {
+			case "ForStatement": return node === parent.test || node === parent.update || node === parent.body;
+			case "ForOfStatement":
+			case "ForInStatement": return node === parent.body || node === parent.left && node.kind === "await using";
+			case "WhileStatement":
+			case "DoWhileStatement": return node === parent.test || node === parent.body;
+			default: return !1;
+		}
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow `await` inside of loops",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-await-in-loop"
+			},
+			schema: [],
+			messages: { unexpectedAwait: "Unexpected `await` inside a loop." }
+		},
+		create(context) {
+			/**
+			* Validate an await expression.
+			* @param {ASTNode} awaitNode An AwaitExpression or ForOfStatement node to validate.
+			* @returns {void}
+			*/
+			function validate(awaitNode) {
+				if (awaitNode.type === "VariableDeclaration" && awaitNode.kind !== "await using" || awaitNode.type === "ForOfStatement" && !awaitNode.await) return;
+				let node = awaitNode, parent = node.parent;
+				for (; parent && !isBoundary(parent);) {
+					if (isLooped(node, parent)) {
+						context.report({
+							node: awaitNode,
+							messageId: "unexpectedAwait"
+						});
+						return;
+					}
+					node = parent, parent = parent.parent;
+				}
+			}
+			return {
+				AwaitExpression: validate,
+				ForOfStatement: validate,
+				VariableDeclaration: validate
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-await-in-loop.cjs
+module.exports = require_no_await_in_loop().create;
+//#endregion

package/rules/no-bitwise.cjs

@@ -0,0 +1,106 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-bitwise.js
+/**
+* @fileoverview Rule to flag bitwise identifiers
+* @author Nicholas C. Zakas
+*/
+var require_no_bitwise = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let BITWISE_OPERATORS = [
+		"^",
+		"|",
+		"&",
+		"<<",
+		">>",
+		">>>",
+		"^=",
+		"|=",
+		"&=",
+		"<<=",
+		">>=",
+		">>>=",
+		"~"
+	];
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{
+				allow: [],
+				int32Hint: !1
+			}],
+			docs: {
+				description: "Disallow bitwise operators",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-bitwise"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					allow: {
+						type: "array",
+						items: { enum: BITWISE_OPERATORS },
+						uniqueItems: !0
+					},
+					int32Hint: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: { unexpected: "Unexpected use of '{{operator}}'." }
+		},
+		create(context) {
+			let [{ allow: allowed, int32Hint }] = context.options;
+			/**
+			* Reports an unexpected use of a bitwise operator.
+			* @param {ASTNode} node Node which contains the bitwise operator.
+			* @returns {void}
+			*/
+			function report(node) {
+				context.report({
+					node,
+					messageId: "unexpected",
+					data: { operator: node.operator }
+				});
+			}
+			/**
+			* Checks if the given node has a bitwise operator.
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} Whether or not the node has a bitwise operator.
+			*/
+			function hasBitwiseOperator(node) {
+				return BITWISE_OPERATORS.includes(node.operator);
+			}
+			/**
+			* Checks if exceptions were provided, e.g. `{ allow: ['~', '|'] }`.
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} Whether or not the node has a bitwise operator.
+			*/
+			function allowedOperator(node) {
+				return allowed.includes(node.operator);
+			}
+			/**
+			* Checks if the given bitwise operator is used for integer typecasting, i.e. "|0"
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} whether the node is used in integer typecasting.
+			*/
+			function isInt32Hint(node) {
+				return int32Hint && node.operator === "|" && node.right && node.right.type === "Literal" && node.right.value === 0;
+			}
+			/**
+			* Report if the given node contains a bitwise operator.
+			* @param {ASTNode} node The node to check.
+			* @returns {void}
+			*/
+			function checkNodeForBitwiseOperator(node) {
+				hasBitwiseOperator(node) && !allowedOperator(node) && !isInt32Hint(node) && report(node);
+			}
+			return {
+				AssignmentExpression: checkNodeForBitwiseOperator,
+				BinaryExpression: checkNodeForBitwiseOperator,
+				UnaryExpression: checkNodeForBitwiseOperator
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-bitwise.cjs
+module.exports = require_no_bitwise().create;
+//#endregion

package/rules/no-buffer-constructor.cjs

@@ -0,0 +1,51 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-buffer-constructor.js
+/**
+* @fileoverview disallow use of the Buffer() constructor
+* @author Teddy Katz
+* @deprecated in ESLint v7.0.0
+*/
+var require_no_buffer_constructor = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Node.js rules were moved out of ESLint core.",
+				url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
+				deprecatedSince: "7.0.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "eslint-plugin-n now maintains deprecated Node.js-related rules.",
+					plugin: {
+						name: "eslint-plugin-n",
+						url: "https://github.com/eslint-community/eslint-plugin-n"
+					},
+					rule: {
+						name: "no-deprecated-api",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-deprecated-api.md"
+					}
+				}]
+			},
+			type: "problem",
+			docs: {
+				description: "Disallow use of the `Buffer()` constructor",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-buffer-constructor"
+			},
+			schema: [],
+			messages: { deprecated: "{{expr}} is deprecated. Use Buffer.from(), Buffer.alloc(), or Buffer.allocUnsafe() instead." }
+		},
+		create(context) {
+			return { "CallExpression[callee.name='Buffer'], NewExpression[callee.name='Buffer']"(node) {
+				context.report({
+					node,
+					messageId: "deprecated",
+					data: { expr: node.type === "CallExpression" ? "Buffer()" : "new Buffer()" }
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-buffer-constructor.cjs
+module.exports = require_no_buffer_constructor().create;
+//#endregion

package/rules/no-caller.cjs

@@ -0,0 +1,34 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-caller.js
+/**
+* @fileoverview Rule to flag use of arguments.callee and arguments.caller.
+* @author Nicholas C. Zakas
+*/
+var require_no_caller = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow the use of `arguments.caller` or `arguments.callee`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-caller"
+			},
+			schema: [],
+			messages: { unexpected: "Avoid arguments.{{prop}}." }
+		},
+		create(context) {
+			return { MemberExpression(node) {
+				let objectName = node.object.name, propertyName = node.property.name;
+				objectName === "arguments" && !node.computed && propertyName && propertyName.match(/^calle[er]$/u) && context.report({
+					node,
+					messageId: "unexpected",
+					data: { prop: propertyName }
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-caller.cjs
+module.exports = require_no_caller().create;
+//#endregion

package/rules/no-case-declarations.cjs

@@ -0,0 +1,56 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-case-declarations.js
+/**
+* @fileoverview Rule to flag use of an lexical declarations inside a case clause
+* @author Erik Arvidsson
+*/
+var require_no_case_declarations = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow lexical declarations in case clauses",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-case-declarations"
+			},
+			hasSuggestions: !0,
+			schema: [],
+			messages: {
+				addBrackets: "Add {} brackets around the case block.",
+				unexpected: "Unexpected lexical declaration in case block."
+			}
+		},
+		create(context) {
+			/**
+			* Checks whether or not a node is a lexical declaration.
+			* @param {ASTNode} node A direct child statement of a switch case.
+			* @returns {boolean} Whether or not the node is a lexical declaration.
+			*/
+			function isLexicalDeclaration(node) {
+				switch (node.type) {
+					case "FunctionDeclaration":
+					case "ClassDeclaration": return !0;
+					case "VariableDeclaration": return node.kind !== "var";
+					default: return !1;
+				}
+			}
+			return { SwitchCase(node) {
+				for (let i = 0; i < node.consequent.length; i++) {
+					let statement = node.consequent[i];
+					isLexicalDeclaration(statement) && context.report({
+						node: statement,
+						messageId: "unexpected",
+						suggest: [{
+							messageId: "addBrackets",
+							fix: (fixer) => [fixer.insertTextBefore(node.consequent[0], "{ "), fixer.insertTextAfter(node.consequent.at(-1), " }")]
+						}]
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-case-declarations.cjs
+module.exports = require_no_case_declarations().create;
+//#endregion