oxlint-plugin-eslint 1.52.0

package/rules/callback-return.cjs

@@ -0,0 +1,117 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/callback-return.js
+/**
+* @fileoverview Enforce return after a callback.
+* @author Jamund Ferguson
+* @deprecated in ESLint v7.0.0
+*/
+var require_callback_return = /* @__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: "callback-return",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/callback-return.md"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Require `return` statements after callbacks",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/callback-return"
+			},
+			schema: [{
+				type: "array",
+				items: { type: "string" }
+			}],
+			messages: { missingReturn: "Expected return with your callback function." }
+		},
+		create(context) {
+			let callbacks = context.options[0] || [
+				"callback",
+				"cb",
+				"next"
+			], sourceCode = context.sourceCode;
+			/**
+			* Find the closest parent matching a list of types.
+			* @param {ASTNode} node The node whose parents we are searching
+			* @param {Array} types The node types to match
+			* @returns {ASTNode} The matched node or undefined.
+			*/
+			function findClosestParentOfType(node, types) {
+				return node.parent ? types.includes(node.parent.type) ? node.parent : findClosestParentOfType(node.parent, types) : null;
+			}
+			/**
+			* Check to see if a node contains only identifiers
+			* @param {ASTNode} node The node to check
+			* @returns {boolean} Whether or not the node contains only identifiers
+			*/
+			function containsOnlyIdentifiers(node) {
+				if (node.type === "Identifier") return !0;
+				if (node.type === "MemberExpression") {
+					if (node.object.type === "Identifier") return !0;
+					if (node.object.type === "MemberExpression") return containsOnlyIdentifiers(node.object);
+				}
+				return !1;
+			}
+			/**
+			* Check to see if a CallExpression is in our callback list.
+			* @param {ASTNode} node The node to check against our callback names list.
+			* @returns {boolean} Whether or not this function matches our callback name.
+			*/
+			function isCallback(node) {
+				return containsOnlyIdentifiers(node.callee) && callbacks.includes(sourceCode.getText(node.callee));
+			}
+			/**
+			* Determines whether or not the callback is part of a callback expression.
+			* @param {ASTNode} node The callback node
+			* @param {ASTNode} parentNode The expression node
+			* @returns {boolean} Whether or not this is part of a callback expression
+			*/
+			function isCallbackExpression(node, parentNode) {
+				return !parentNode || parentNode.type !== "ExpressionStatement" ? !1 : parentNode.expression === node || (parentNode.expression.type === "BinaryExpression" || parentNode.expression.type === "LogicalExpression") && parentNode.expression.right === node;
+			}
+			return { CallExpression(node) {
+				if (!isCallback(node)) return;
+				let closestBlock = findClosestParentOfType(node, [
+					"BlockStatement",
+					"ReturnStatement",
+					"ArrowFunctionExpression"
+				]) || {};
+				if (closestBlock.type !== "ReturnStatement" && closestBlock.type !== "ArrowFunctionExpression") {
+					if (closestBlock.type === "BlockStatement") {
+						let lastItem = closestBlock.body.at(-1);
+						if (isCallbackExpression(node, lastItem)) {
+							let parentType = closestBlock.parent.type;
+							if (parentType === "FunctionExpression" || parentType === "FunctionDeclaration" || parentType === "ArrowFunctionExpression") return;
+						}
+						if (lastItem.type === "ReturnStatement" && isCallbackExpression(node, closestBlock.body.at(-2))) return;
+					}
+					findClosestParentOfType(node, [
+						"FunctionDeclaration",
+						"FunctionExpression",
+						"ArrowFunctionExpression"
+					]) && context.report({
+						node,
+						messageId: "missingReturn"
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/callback-return.cjs
+module.exports = require_callback_return().create;
+//#endregion

package/rules/camelcase.cjs

@@ -0,0 +1,194 @@
+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/camelcase.js
+/**
+* @fileoverview Rule to flag non-camelcased identifiers
+* @author Nicholas C. Zakas
+*/
+var require_camelcase = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{
+				allow: [],
+				ignoreDestructuring: !1,
+				ignoreGlobals: !1,
+				ignoreImports: !1,
+				properties: "always"
+			}],
+			docs: {
+				description: "Enforce camelcase naming convention",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/camelcase"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					ignoreDestructuring: { type: "boolean" },
+					ignoreImports: { type: "boolean" },
+					ignoreGlobals: { type: "boolean" },
+					properties: { enum: ["always", "never"] },
+					allow: {
+						type: "array",
+						items: { type: "string" },
+						minItems: 0,
+						uniqueItems: !0
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				notCamelCase: "Identifier '{{name}}' is not in camel case.",
+				notCamelCasePrivate: "#{{name}} is not in camel case."
+			}
+		},
+		create(context) {
+			let [{ allow, ignoreDestructuring, ignoreGlobals, ignoreImports, properties }] = context.options, sourceCode = context.sourceCode, reported = /* @__PURE__ */ new Set();
+			/**
+			* Checks if a string contains an underscore and isn't all upper-case
+			* @param {string} name The string to check.
+			* @returns {boolean} if the string is underscored
+			* @private
+			*/
+			function isUnderscored(name) {
+				let nameBody = name.replace(/^_+|_+$/gu, "");
+				return nameBody.includes("_") && nameBody !== nameBody.toUpperCase();
+			}
+			/**
+			* Checks if a string match the ignore list
+			* @param {string} name The string to check.
+			* @returns {boolean} if the string is ignored
+			* @private
+			*/
+			function isAllowed(name) {
+				return allow.some((entry) => name === entry || name.match(new RegExp(entry, "u")));
+			}
+			/**
+			* Checks if a given name is good or not.
+			* @param {string} name The name to check.
+			* @returns {boolean} `true` if the name is good.
+			* @private
+			*/
+			function isGoodName(name) {
+				return !isUnderscored(name) || isAllowed(name);
+			}
+			/**
+			* Checks if a given identifier reference or member expression is an assignment
+			* target.
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} `true` if the node is an assignment target.
+			*/
+			function isAssignmentTarget(node) {
+				let parent = node.parent;
+				switch (parent.type) {
+					case "AssignmentExpression":
+					case "AssignmentPattern": return parent.left === node;
+					case "Property": return parent.parent.type === "ObjectPattern" && parent.value === node;
+					case "ArrayPattern":
+					case "RestElement": return !0;
+					default: return !1;
+				}
+			}
+			/**
+			* Checks if a given binding identifier uses the original name as-is.
+			* - If it's in object destructuring or object expression, the original name is its property name.
+			* - If it's in import declaration, the original name is its exported name.
+			* @param {ASTNode} node The `Identifier` node to check.
+			* @returns {boolean} `true` if the identifier uses the original name as-is.
+			*/
+			function equalsToOriginalName(node) {
+				let localName = node.name, valueNode = node.parent.type === "AssignmentPattern" ? node.parent : node, parent = valueNode.parent;
+				switch (parent.type) {
+					case "Property": return (parent.parent.type === "ObjectPattern" || parent.parent.type === "ObjectExpression") && parent.value === valueNode && !parent.computed && parent.key.type === "Identifier" && parent.key.name === localName;
+					case "ImportSpecifier": return parent.local === node && astUtils.getModuleExportName(parent.imported) === localName;
+					default: return !1;
+				}
+			}
+			/**
+			* Reports an AST node as a rule violation.
+			* @param {ASTNode} node The node to report.
+			* @returns {void}
+			* @private
+			*/
+			function report(node) {
+				reported.has(node.range[0]) || (reported.add(node.range[0]), context.report({
+					node,
+					messageId: node.type === "PrivateIdentifier" ? "notCamelCasePrivate" : "notCamelCase",
+					data: { name: node.name }
+				}));
+			}
+			/**
+			* Reports an identifier reference or a binding identifier.
+			* @param {ASTNode} node The `Identifier` node to report.
+			* @returns {void}
+			*/
+			function reportReferenceId(node) {
+				node.parent.type === "CallExpression" || node.parent.type === "NewExpression" || node.parent.type === "AssignmentPattern" && node.parent.right === node || ignoreDestructuring && equalsToOriginalName(node) || astUtils.isImportAttributeKey(node) || report(node);
+			}
+			return {
+				Program(node) {
+					let scope = sourceCode.getScope(node);
+					if (!ignoreGlobals) {
+						for (let variable of scope.variables) if (!(variable.identifiers.length > 0 || isGoodName(variable.name))) for (let reference of variable.references) reportReferenceId(reference.identifier);
+					}
+					for (let reference of scope.through) {
+						let id = reference.identifier;
+						isGoodName(id.name) || astUtils.isImportAttributeKey(id) || reportReferenceId(id);
+					}
+				},
+				[[
+					"VariableDeclaration",
+					"FunctionDeclaration",
+					"FunctionExpression",
+					"ArrowFunctionExpression",
+					"ClassDeclaration",
+					"ClassExpression",
+					"CatchClause"
+				]](node) {
+					for (let variable of sourceCode.getDeclaredVariables(node)) {
+						if (isGoodName(variable.name)) continue;
+						let id = variable.identifiers[0];
+						ignoreDestructuring && equalsToOriginalName(id) || report(id);
+						for (let reference of variable.references) reference.init || reportReferenceId(reference.identifier);
+					}
+				},
+				[[
+					"ObjectExpression > Property[computed!=true] > Identifier.key",
+					"MethodDefinition[computed!=true] > Identifier.key",
+					"PropertyDefinition[computed!=true] > Identifier.key",
+					"MethodDefinition > PrivateIdentifier.key",
+					"PropertyDefinition > PrivateIdentifier.key"
+				]](node) {
+					properties === "never" || astUtils.isImportAttributeKey(node) || isGoodName(node.name) || report(node);
+				},
+				"MemberExpression[computed!=true] > Identifier.property"(node) {
+					properties === "never" || !isAssignmentTarget(node.parent) || isGoodName(node.name) || report(node);
+				},
+				ImportDeclaration(node) {
+					for (let variable of sourceCode.getDeclaredVariables(node)) {
+						if (isGoodName(variable.name)) continue;
+						let id = variable.identifiers[0];
+						ignoreImports && equalsToOriginalName(id) || report(id);
+						for (let reference of variable.references) reportReferenceId(reference.identifier);
+					}
+				},
+				[["ExportAllDeclaration > Identifier.exported", "ExportSpecifier > Identifier.exported"]](node) {
+					isGoodName(node.name) || report(node);
+				},
+				[[
+					"LabeledStatement > Identifier.label",
+					"BreakStatement > Identifier.label",
+					"ContinueStatement > Identifier.label"
+				]](node) {
+					isGoodName(node.name) || report(node);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/camelcase.cjs
+module.exports = require_camelcase().create;
+//#endregion

package/rules/capitalized-comments.cjs

@@ -0,0 +1,168 @@
+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/capitalized-comments.js
+/**
+* @fileoverview enforce or disallow capitalization of the first letter of a comment
+* @author Kevin Partington
+*/
+var require_capitalized_comments = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let DEFAULT_IGNORE_PATTERN = require_ast_utils$1.t().COMMENTS_IGNORE_PATTERN, WHITESPACE = /\s/gu, MAYBE_URL = /^\s*[^:/?#\s]+:\/\/[^?#]/u, LETTER_PATTERN = /\p{L}/u, SCHEMA_BODY = {
+		type: "object",
+		properties: {
+			ignorePattern: { type: "string" },
+			ignoreInlineComments: { type: "boolean" },
+			ignoreConsecutiveComments: { type: "boolean" }
+		},
+		additionalProperties: !1
+	}, DEFAULTS = {
+		ignorePattern: "",
+		ignoreInlineComments: !1,
+		ignoreConsecutiveComments: !1
+	};
+	/**
+	* Get normalized options for either block or line comments from the given
+	* user-provided options.
+	* - If the user-provided options is just a string, returns a normalized
+	*   set of options using default values for all other options.
+	* - If the user-provided options is an object, then a normalized option
+	*   set is returned. Options specified in overrides will take priority
+	*   over options specified in the main options object, which will in
+	*   turn take priority over the rule's defaults.
+	* @param {Object|string} rawOptions The user-provided options.
+	* @param {string} which Either "line" or "block".
+	* @returns {Object} The normalized options.
+	*/
+	function getNormalizedOptions(rawOptions, which) {
+		return Object.assign({}, DEFAULTS, rawOptions[which] || rawOptions);
+	}
+	/**
+	* Get normalized options for block and line comments.
+	* @param {Object|string} rawOptions The user-provided options.
+	* @returns {Object} An object with "Line" and "Block" keys and corresponding
+	* normalized options objects.
+	*/
+	function getAllNormalizedOptions(rawOptions = {}) {
+		return {
+			Line: getNormalizedOptions(rawOptions, "line"),
+			Block: getNormalizedOptions(rawOptions, "block")
+		};
+	}
+	/**
+	* Creates a regular expression for each ignorePattern defined in the rule
+	* options.
+	*
+	* This is done in order to avoid invoking the RegExp constructor repeatedly.
+	* @param {Object} normalizedOptions The normalized rule options.
+	* @returns {void}
+	*/
+	function createRegExpForIgnorePatterns(normalizedOptions) {
+		Object.keys(normalizedOptions).forEach((key) => {
+			let ignorePatternStr = normalizedOptions[key].ignorePattern;
+			if (ignorePatternStr) {
+				let regExp = RegExp(`^\\s*(?:${ignorePatternStr})`, "u");
+				normalizedOptions[key].ignorePatternRegExp = regExp;
+			}
+		});
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce or disallow capitalization of the first letter of a comment",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/capitalized-comments"
+			},
+			fixable: "code",
+			schema: [{ enum: ["always", "never"] }, { oneOf: [SCHEMA_BODY, {
+				type: "object",
+				properties: {
+					line: SCHEMA_BODY,
+					block: SCHEMA_BODY
+				},
+				additionalProperties: !1
+			}] }],
+			messages: {
+				unexpectedLowercaseComment: "Comments should not begin with a lowercase character.",
+				unexpectedUppercaseComment: "Comments should not begin with an uppercase character."
+			}
+		},
+		create(context) {
+			let capitalize = context.options[0] || "always", normalizedOptions = getAllNormalizedOptions(context.options[1]), sourceCode = context.sourceCode;
+			createRegExpForIgnorePatterns(normalizedOptions);
+			/**
+			* Checks whether a comment is an inline comment.
+			*
+			* For the purpose of this rule, a comment is inline if:
+			* 1. The comment is preceded by a token on the same line; and
+			* 2. The command is followed by a token on the same line.
+			*
+			* Note that the comment itself need not be single-line!
+			*
+			* Also, it follows from this definition that only block comments can
+			* be considered as possibly inline. This is because line comments
+			* would consume any following tokens on the same line as the comment.
+			* @param {ASTNode} comment The comment node to check.
+			* @returns {boolean} True if the comment is an inline comment, false
+			* otherwise.
+			*/
+			function isInlineComment(comment) {
+				let previousToken = sourceCode.getTokenBefore(comment, { includeComments: !0 }), nextToken = sourceCode.getTokenAfter(comment, { includeComments: !0 });
+				return !!(previousToken && nextToken && comment.loc.start.line === previousToken.loc.end.line && comment.loc.end.line === nextToken.loc.start.line);
+			}
+			/**
+			* Determine if a comment follows another comment.
+			* @param {ASTNode} comment The comment to check.
+			* @returns {boolean} True if the comment follows a valid comment.
+			*/
+			function isConsecutiveComment(comment) {
+				let previousTokenOrComment = sourceCode.getTokenBefore(comment, { includeComments: !0 });
+				return !!(previousTokenOrComment && ["Block", "Line"].includes(previousTokenOrComment.type));
+			}
+			/**
+			* Check a comment to determine if it is valid for this rule.
+			* @param {ASTNode} comment The comment node to process.
+			* @param {Object} options The options for checking this comment.
+			* @returns {boolean} True if the comment is valid, false otherwise.
+			*/
+			function isCommentValid(comment, options) {
+				if (DEFAULT_IGNORE_PATTERN.test(comment.value)) return !0;
+				let commentWithoutAsterisks = comment.value.replace(/\*/gu, "");
+				if (options.ignorePatternRegExp && options.ignorePatternRegExp.test(commentWithoutAsterisks) || options.ignoreInlineComments && isInlineComment(comment) || options.ignoreConsecutiveComments && isConsecutiveComment(comment) || MAYBE_URL.test(commentWithoutAsterisks)) return !0;
+				let commentWordCharsOnly = commentWithoutAsterisks.replace(WHITESPACE, "");
+				if (commentWordCharsOnly.length === 0) return !0;
+				let [firstWordChar] = commentWordCharsOnly;
+				if (!LETTER_PATTERN.test(firstWordChar)) return !0;
+				let isUppercase = firstWordChar !== firstWordChar.toLocaleLowerCase(), isLowercase = firstWordChar !== firstWordChar.toLocaleUpperCase();
+				return !(capitalize === "always" && isLowercase || capitalize === "never" && isUppercase);
+			}
+			/**
+			* Process a comment to determine if it needs to be reported.
+			* @param {ASTNode} comment The comment node to process.
+			* @returns {void}
+			*/
+			function processComment(comment) {
+				let options = normalizedOptions[comment.type];
+				if (!isCommentValid(comment, options)) {
+					let messageId = capitalize === "always" ? "unexpectedLowercaseComment" : "unexpectedUppercaseComment";
+					context.report({
+						node: null,
+						loc: comment.loc,
+						messageId,
+						fix(fixer) {
+							let match = comment.value.match(LETTER_PATTERN), char = match[0], charIndex = comment.range[0] + match.index + 2;
+							return fixer.replaceTextRange([charIndex, charIndex + char.length], capitalize === "always" ? char.toLocaleUpperCase() : char.toLocaleLowerCase());
+						}
+					});
+				}
+			}
+			return { Program() {
+				sourceCode.getAllComments().filter((token) => token.type !== "Shebang").forEach(processComment);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/capitalized-comments.cjs
+module.exports = require_capitalized_comments().create;
+//#endregion

package/rules/class-methods-use-this.cjs

@@ -0,0 +1,155 @@
+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/class-methods-use-this.js
+/**
+* @fileoverview Rule to enforce that all class methods use 'this'.
+* @author Patrick Williams
+*/
+var require_class_methods_use_this = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			type: "suggestion",
+			defaultOptions: [{
+				enforceForClassFields: !0,
+				exceptMethods: [],
+				ignoreOverrideMethods: !1
+			}],
+			docs: {
+				description: "Enforce that class methods utilize `this`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/class-methods-use-this"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					exceptMethods: {
+						type: "array",
+						items: { type: "string" }
+					},
+					enforceForClassFields: { type: "boolean" },
+					ignoreOverrideMethods: { type: "boolean" },
+					ignoreClassesWithImplements: { enum: ["all", "public-fields"] }
+				},
+				additionalProperties: !1
+			}],
+			messages: { missingThis: "Expected 'this' to be used by class {{name}}." }
+		},
+		create(context) {
+			let [options] = context.options, { enforceForClassFields, ignoreOverrideMethods, ignoreClassesWithImplements } = options, exceptMethods = new Set(options.exceptMethods), stack = [];
+			/**
+			* Push `this` used flag initialized with `false` onto the stack.
+			* @returns {void}
+			*/
+			function pushContext() {
+				stack.push(!1);
+			}
+			/**
+			* Pop `this` used flag from the stack.
+			* @returns {boolean | undefined} `this` used flag
+			*/
+			function popContext() {
+				return stack.pop();
+			}
+			/**
+			* Initializes the current context to false and pushes it onto the stack.
+			* These booleans represent whether 'this' has been used in the context.
+			* @returns {void}
+			* @private
+			*/
+			function enterFunction() {
+				pushContext();
+			}
+			/**
+			* Check if the node is an instance method
+			* @param {ASTNode} node node to check
+			* @returns {boolean} True if its an instance method
+			* @private
+			*/
+			function isInstanceMethod(node) {
+				switch (node.type) {
+					case "MethodDefinition": return !node.static && node.kind !== "constructor";
+					case "AccessorProperty":
+					case "PropertyDefinition": return !node.static && enforceForClassFields;
+					default: return !1;
+				}
+			}
+			/**
+			* Check if the node's parent class implements any interfaces
+			* @param {ASTNode} node node to check
+			* @returns {boolean} True if parent class implements interfaces
+			* @private
+			*/
+			function hasImplements(node) {
+				let classNode = node.parent.parent;
+				return classNode?.type === "ClassDeclaration" && classNode.implements?.length > 0;
+			}
+			/**
+			* Check if the node is an instance method not excluded by config
+			* @param {ASTNode} node node to check
+			* @returns {boolean} True if it is an instance method, and not excluded by config
+			* @private
+			*/
+			function isIncludedInstanceMethod(node) {
+				if (isInstanceMethod(node)) {
+					if (node.computed) return !0;
+					if (ignoreOverrideMethods && node.override || ignoreClassesWithImplements && hasImplements(node) && (ignoreClassesWithImplements === "all" || ignoreClassesWithImplements === "public-fields" && node.key.type !== "PrivateIdentifier" && (!node.accessibility || node.accessibility === "public"))) return !1;
+					let hashIfNeeded = node.key.type === "PrivateIdentifier" ? "#" : "", name = node.key.type === "Literal" ? astUtils.getStaticStringValue(node.key) : node.key.name || "";
+					return !exceptMethods.has(hashIfNeeded + name);
+				}
+				return !1;
+			}
+			/**
+			* Checks if we are leaving a function that is a method, and reports if 'this' has not been used.
+			* Static methods and the constructor are exempt.
+			* Then pops the context off the stack.
+			* @param {ASTNode} node A function node that was entered.
+			* @returns {void}
+			* @private
+			*/
+			function exitFunction(node) {
+				let methodUsesThis = popContext();
+				isIncludedInstanceMethod(node.parent) && !methodUsesThis && context.report({
+					node,
+					loc: astUtils.getFunctionHeadLoc(node, context.sourceCode),
+					messageId: "missingThis",
+					data: { name: astUtils.getFunctionNameWithKind(node) }
+				});
+			}
+			/**
+			* Mark the current context as having used 'this'.
+			* @returns {void}
+			* @private
+			*/
+			function markThisUsed() {
+				stack.length && (stack[stack.length - 1] = !0);
+			}
+			return {
+				FunctionDeclaration: enterFunction,
+				"FunctionDeclaration:exit": exitFunction,
+				FunctionExpression: enterFunction,
+				"FunctionExpression:exit": exitFunction,
+				"AccessorProperty > *.key:exit": pushContext,
+				"AccessorProperty:exit": popContext,
+				"PropertyDefinition > *.key:exit": pushContext,
+				"PropertyDefinition:exit": popContext,
+				StaticBlock: pushContext,
+				"StaticBlock:exit": popContext,
+				ThisExpression: markThisUsed,
+				Super: markThisUsed,
+				...enforceForClassFields && {
+					"AccessorProperty > ArrowFunctionExpression.value": enterFunction,
+					"AccessorProperty > ArrowFunctionExpression.value:exit": exitFunction,
+					"PropertyDefinition > ArrowFunctionExpression.value": enterFunction,
+					"PropertyDefinition > ArrowFunctionExpression.value:exit": exitFunction
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/class-methods-use-this.cjs
+module.exports = require_class_methods_use_this().create;
+//#endregion