oxlint-plugin-eslint 1.52.0

package/rules/eqeqeq.cjs

@@ -0,0 +1,127 @@
+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/eqeqeq.js
+/**
+* @fileoverview Rule to flag statements that use != and == instead of !== and ===
+* @author Nicholas C. Zakas
+*/
+var require_eqeqeq = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			hasSuggestions: !0,
+			docs: {
+				description: "Require the use of `===` and `!==`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/eqeqeq"
+			},
+			schema: { anyOf: [{
+				type: "array",
+				items: [{ enum: ["always"] }, {
+					type: "object",
+					properties: { null: { enum: [
+						"always",
+						"never",
+						"ignore"
+					] } },
+					additionalProperties: !1
+				}],
+				additionalItems: !1
+			}, {
+				type: "array",
+				items: [{ enum: ["smart", "allow-null"] }],
+				additionalItems: !1
+			}] },
+			fixable: "code",
+			messages: {
+				unexpected: "Expected '{{expectedOperator}}' and instead saw '{{actualOperator}}'.",
+				replaceOperator: "Use '{{expectedOperator}}' instead of '{{actualOperator}}'."
+			}
+		},
+		create(context) {
+			let config = context.options[0] || "always", options = context.options[1] || {}, sourceCode = context.sourceCode, nullOption = config === "always" ? options.null || "always" : "ignore", enforceRuleForNull = nullOption === "always", enforceInverseRuleForNull = nullOption === "never";
+			/**
+			* Checks if an expression is a typeof expression
+			* @param {ASTNode} node The node to check
+			* @returns {boolean} if the node is a typeof expression
+			*/
+			function isTypeOf(node) {
+				return node.type === "UnaryExpression" && node.operator === "typeof";
+			}
+			/**
+			* Checks if either operand of a binary expression is a typeof operation
+			* @param {ASTNode} node The node to check
+			* @returns {boolean} if one of the operands is typeof
+			* @private
+			*/
+			function isTypeOfBinary(node) {
+				return isTypeOf(node.left) || isTypeOf(node.right);
+			}
+			/**
+			* Checks if operands are literals of the same type (via typeof)
+			* @param {ASTNode} node The node to check
+			* @returns {boolean} if operands are of same type
+			* @private
+			*/
+			function areLiteralsAndSameType(node) {
+				return node.left.type === "Literal" && node.right.type === "Literal" && typeof node.left.value == typeof node.right.value;
+			}
+			/**
+			* Checks if one of the operands is a literal null
+			* @param {ASTNode} node The node to check
+			* @returns {boolean} if operands are null
+			* @private
+			*/
+			function isNullCheck(node) {
+				return astUtils.isNullLiteral(node.right) || astUtils.isNullLiteral(node.left);
+			}
+			/**
+			* Reports a message for this rule.
+			* @param {ASTNode} node The binary expression node that was checked
+			* @param {string} expectedOperator The operator that was expected (either '==', '!=', '===', or '!==')
+			* @returns {void}
+			* @private
+			*/
+			function report(node, expectedOperator) {
+				let operatorToken = sourceCode.getFirstTokenBetween(node.left, node.right, (token) => token.value === node.operator), commonReportParams = {
+					node,
+					loc: operatorToken.loc,
+					messageId: "unexpected",
+					data: {
+						expectedOperator,
+						actualOperator: node.operator
+					}
+				};
+				isTypeOfBinary(node) || areLiteralsAndSameType(node) ? context.report({
+					...commonReportParams,
+					fix(fixer) {
+						return fixer.replaceText(operatorToken, expectedOperator);
+					}
+				}) : context.report({
+					...commonReportParams,
+					suggest: [{
+						messageId: "replaceOperator",
+						data: {
+							expectedOperator,
+							actualOperator: node.operator
+						},
+						fix: (fixer) => fixer.replaceText(operatorToken, expectedOperator)
+					}]
+				});
+			}
+			return { BinaryExpression(node) {
+				let isNull = isNullCheck(node);
+				if (node.operator !== "==" && node.operator !== "!=") {
+					enforceInverseRuleForNull && isNull && report(node, node.operator.slice(0, -1));
+					return;
+				}
+				config === "smart" && (isTypeOfBinary(node) || areLiteralsAndSameType(node) || isNull) || !enforceRuleForNull && isNull || report(node, `${node.operator}=`);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/eqeqeq.cjs
+module.exports = require_eqeqeq().create;
+//#endregion

package/rules/for-direction.cjs

@@ -0,0 +1,94 @@
+const require_chunk = require("../common/chunk.cjs"), require_eslint_utils$1 = require("../common/eslint-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/for-direction.js
+/**
+* @fileoverview enforce `for` loop update clause moving the counter in the right direction.(for-direction)
+* @author Aladdin-ADD<hh_2013@foxmail.com>
+*/
+var require_for_direction = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { getStaticValue } = require_eslint_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Enforce `for` loop update clause moving the counter in the right direction",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/for-direction"
+			},
+			fixable: null,
+			schema: [],
+			messages: { incorrectDirection: "The update clause in this loop moves the variable in the wrong direction." }
+		},
+		create(context) {
+			let { sourceCode } = context;
+			/**
+			* report an error.
+			* @param {ASTNode} node the node to report.
+			* @returns {void}
+			*/
+			function report(node) {
+				context.report({
+					loc: {
+						start: node.loc.start,
+						end: sourceCode.getTokenBefore(node.body).loc.end
+					},
+					messageId: "incorrectDirection"
+				});
+			}
+			/**
+			* check the right side of the assignment
+			* @param {ASTNode} update UpdateExpression to check
+			* @param {number} dir expected direction that could either be turned around or invalidated
+			* @returns {number} return dir, the negated dir, or zero if the counter does not change or the direction is not clear
+			*/
+			function getRightDirection(update, dir) {
+				let staticValue = getStaticValue(update.right, sourceCode.getScope(update));
+				return staticValue && [
+					"bigint",
+					"boolean",
+					"number"
+				].includes(typeof staticValue.value) ? dir * (Math.sign(Number(staticValue.value)) || 0) : 0;
+			}
+			/**
+			* check UpdateExpression add/sub the counter
+			* @param {ASTNode} update UpdateExpression to check
+			* @param {string} counter variable name to check
+			* @returns {number} if add return 1, if sub return -1, if nochange, return 0
+			*/
+			function getUpdateDirection(update, counter) {
+				if (update.argument.type === "Identifier" && update.argument.name === counter) {
+					if (update.operator === "++") return 1;
+					if (update.operator === "--") return -1;
+				}
+				return 0;
+			}
+			/**
+			* check AssignmentExpression add/sub the counter
+			* @param {ASTNode} update AssignmentExpression to check
+			* @param {string} counter variable name to check
+			* @returns {number} if add return 1, if sub return -1, if nochange, return 0
+			*/
+			function getAssignmentDirection(update, counter) {
+				if (update.left.name === counter) {
+					if (update.operator === "+=") return getRightDirection(update, 1);
+					if (update.operator === "-=") return getRightDirection(update, -1);
+				}
+				return 0;
+			}
+			return { ForStatement(node) {
+				if (node.test && node.test.type === "BinaryExpression" && node.update) for (let counterPosition of ["left", "right"]) {
+					if (node.test[counterPosition].type !== "Identifier") continue;
+					let counter = node.test[counterPosition].name, operator = node.test.operator, update = node.update, wrongDirection;
+					if (operator === "<" || operator === "<=") wrongDirection = counterPosition === "left" ? -1 : 1;
+					else if (operator === ">" || operator === ">=") wrongDirection = counterPosition === "left" ? 1 : -1;
+					else return;
+					update.type === "UpdateExpression" ? getUpdateDirection(update, counter) === wrongDirection && report(node) : update.type === "AssignmentExpression" && getAssignmentDirection(update, counter) === wrongDirection && report(node);
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/for-direction.cjs
+module.exports = require_for_direction().create;
+//#endregion

package/rules/func-call-spacing.cjs

@@ -0,0 +1,127 @@
+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/func-call-spacing.js
+/**
+* @fileoverview Rule to control spacing within function calls
+* @author Matt DuVall <http://www.mattduvall.com>
+* @deprecated in ESLint v8.53.0
+*/
+var require_func_call_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: "function-call-spacing",
+						url: "https://eslint.style/rules/function-call-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require or disallow spacing between function identifiers and their invocations",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/func-call-spacing"
+			},
+			fixable: "whitespace",
+			schema: { anyOf: [{
+				type: "array",
+				items: [{ enum: ["never"] }],
+				minItems: 0,
+				maxItems: 1
+			}, {
+				type: "array",
+				items: [{ enum: ["always"] }, {
+					type: "object",
+					properties: { allowNewlines: { type: "boolean" } },
+					additionalProperties: !1
+				}],
+				minItems: 0,
+				maxItems: 2
+			}] },
+			messages: {
+				unexpectedWhitespace: "Unexpected whitespace between function name and paren.",
+				unexpectedNewline: "Unexpected newline between function name and paren.",
+				missing: "Missing space between function name and paren."
+			}
+		},
+		create(context) {
+			let never = context.options[0] !== "always", allowNewlines = !never && context.options[1] && context.options[1].allowNewlines, sourceCode = context.sourceCode, text = sourceCode.getText();
+			/**
+			* Check if open space is present in a function name
+			* @param {ASTNode} node node to evaluate
+			* @param {Token} leftToken The last token of the callee. This may be the closing parenthesis that encloses the callee.
+			* @param {Token} rightToken The first token of the arguments. this is the opening parenthesis that encloses the arguments.
+			* @returns {void}
+			* @private
+			*/
+			function checkSpacing(node, leftToken, rightToken) {
+				let textBetweenTokens = text.slice(leftToken.range[1], rightToken.range[0]).replace(/\/\*.*?\*\//gu, ""), hasWhitespace = /\s/u.test(textBetweenTokens), hasNewline = hasWhitespace && astUtils.LINEBREAK_MATCHER.test(textBetweenTokens);
+				never && hasWhitespace ? context.report({
+					node,
+					loc: {
+						start: leftToken.loc.end,
+						end: {
+							line: rightToken.loc.start.line,
+							column: rightToken.loc.start.column - 1
+						}
+					},
+					messageId: "unexpectedWhitespace",
+					fix(fixer) {
+						return sourceCode.commentsExistBetween(leftToken, rightToken) ? null : node.optional ? fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], "?.") : hasNewline ? null : fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
+					}
+				}) : !never && !hasWhitespace ? context.report({
+					node,
+					loc: {
+						start: {
+							line: leftToken.loc.end.line,
+							column: leftToken.loc.end.column - 1
+						},
+						end: rightToken.loc.start
+					},
+					messageId: "missing",
+					fix(fixer) {
+						return node.optional ? null : fixer.insertTextBefore(rightToken, " ");
+					}
+				}) : !never && !allowNewlines && hasNewline && context.report({
+					node,
+					loc: {
+						start: leftToken.loc.end,
+						end: rightToken.loc.start
+					},
+					messageId: "unexpectedNewline",
+					fix(fixer) {
+						if (!node.optional || sourceCode.commentsExistBetween(leftToken, rightToken)) return null;
+						let range = [leftToken.range[1], rightToken.range[0]], qdToken = sourceCode.getTokenAfter(leftToken);
+						return qdToken.range[0] === leftToken.range[1] ? fixer.replaceTextRange(range, "?. ") : qdToken.range[1] === rightToken.range[0] ? fixer.replaceTextRange(range, " ?.") : fixer.replaceTextRange(range, " ?. ");
+					}
+				});
+			}
+			return {
+				"CallExpression, NewExpression"(node) {
+					let lastToken = sourceCode.getLastToken(node), lastCalleeToken = sourceCode.getLastToken(node.callee), parenToken = sourceCode.getFirstTokenBetween(lastCalleeToken, lastToken, astUtils.isOpeningParenToken), prevToken = parenToken && sourceCode.getTokenBefore(parenToken, astUtils.isNotQuestionDotToken);
+					parenToken && parenToken.range[1] < node.range[1] && checkSpacing(node, prevToken, parenToken);
+				},
+				ImportExpression(node) {
+					let leftToken = sourceCode.getFirstToken(node);
+					checkSpacing(node, leftToken, sourceCode.getTokenAfter(leftToken));
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/func-call-spacing.cjs
+module.exports = require_func_call_spacing().create;
+//#endregion

package/rules/func-name-matching.cjs

@@ -0,0 +1,138 @@
+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/func-name-matching.js
+/**
+* @fileoverview Rule to require function names to match the name of the variable or property to which they are assigned.
+* @author Annie Zhang, Pavel Strashkin
+*/
+var require_func_name_matching = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), esutils = require_ast_utils$1.i();
+	/**
+	* Determines if a pattern is `module.exports` or `module["exports"]`
+	* @param {ASTNode} pattern The left side of the AssignmentExpression
+	* @returns {boolean} True if the pattern is `module.exports` or `module["exports"]`
+	*/
+	function isModuleExports(pattern) {
+		return pattern.type === "MemberExpression" && pattern.object.type === "Identifier" && pattern.object.name === "module" && (pattern.property.type === "Identifier" && pattern.property.name === "exports" || pattern.property.type === "Literal" && pattern.property.value === "exports");
+	}
+	/**
+	* Determines if a string name is a valid identifier
+	* @param {string} name The string to be checked
+	* @param {number} ecmaVersion The ECMAScript version if specified in the parserOptions config
+	* @returns {boolean} True if the string is a valid identifier
+	*/
+	function isIdentifier(name, ecmaVersion) {
+		return ecmaVersion >= 2015 ? esutils.keyword.isIdentifierES6(name) : esutils.keyword.isIdentifierES5(name);
+	}
+	let alwaysOrNever = { enum: ["always", "never"] }, optionsObject = {
+		type: "object",
+		properties: {
+			considerPropertyDescriptor: { type: "boolean" },
+			includeCommonJSModuleExports: { type: "boolean" }
+		},
+		additionalProperties: !1
+	};
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require function names to match the name of the variable or property to which they are assigned",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/func-name-matching"
+			},
+			schema: { anyOf: [{
+				type: "array",
+				additionalItems: !1,
+				items: [alwaysOrNever, optionsObject]
+			}, {
+				type: "array",
+				additionalItems: !1,
+				items: [optionsObject]
+			}] },
+			messages: {
+				matchProperty: "Function name `{{funcName}}` should match property name `{{name}}`.",
+				matchVariable: "Function name `{{funcName}}` should match variable name `{{name}}`.",
+				notMatchProperty: "Function name `{{funcName}}` should not match property name `{{name}}`.",
+				notMatchVariable: "Function name `{{funcName}}` should not match variable name `{{name}}`."
+			}
+		},
+		create(context) {
+			let options = (typeof context.options[0] == "object" ? context.options[0] : context.options[1]) || {}, nameMatches = typeof context.options[0] == "string" ? context.options[0] : "always", considerPropertyDescriptor = options.considerPropertyDescriptor, includeModuleExports = options.includeCommonJSModuleExports, ecmaVersion = context.languageOptions.ecmaVersion;
+			/**
+			* Check whether node is a certain CallExpression.
+			* @param {string} objName object name
+			* @param {string} funcName function name
+			* @param {ASTNode} node The node to check
+			* @returns {boolean} `true` if node matches CallExpression
+			*/
+			function isPropertyCall(objName, funcName, node) {
+				return node ? node.type === "CallExpression" && astUtils.isSpecificMemberAccess(node.callee, objName, funcName) : !1;
+			}
+			/**
+			* Compares identifiers based on the nameMatches option
+			* @param {string} x the first identifier
+			* @param {string} y the second identifier
+			* @returns {boolean} whether the two identifiers should warn.
+			*/
+			function shouldWarn(x, y) {
+				return nameMatches === "always" && x !== y || nameMatches === "never" && x === y;
+			}
+			/**
+			* Reports
+			* @param {ASTNode} node The node to report
+			* @param {string} name The variable or property name
+			* @param {string} funcName The function name
+			* @param {boolean} isProp True if the reported node is a property assignment
+			* @returns {void}
+			*/
+			function report(node, name, funcName, isProp) {
+				let messageId;
+				messageId = nameMatches === "always" && isProp ? "matchProperty" : nameMatches === "always" ? "matchVariable" : isProp ? "notMatchProperty" : "notMatchVariable", context.report({
+					node,
+					messageId,
+					data: {
+						name,
+						funcName
+					}
+				});
+			}
+			/**
+			* Determines whether a given node is a string literal
+			* @param {ASTNode} node The node to check
+			* @returns {boolean} `true` if the node is a string literal
+			*/
+			function isStringLiteral(node) {
+				return node.type === "Literal" && typeof node.value == "string";
+			}
+			return {
+				VariableDeclarator(node) {
+					!node.init || node.init.type !== "FunctionExpression" || node.id.type !== "Identifier" || node.init.id && shouldWarn(node.id.name, node.init.id.name) && report(node, node.id.name, node.init.id.name, !1);
+				},
+				AssignmentExpression(node) {
+					if (node.right.type !== "FunctionExpression" || node.left.computed && node.left.property.type !== "Literal" || !includeModuleExports && isModuleExports(node.left) || node.left.type !== "Identifier" && node.left.type !== "MemberExpression") return;
+					let isProp = node.left.type === "MemberExpression", name = isProp ? astUtils.getStaticPropertyName(node.left) : node.left.name;
+					node.right.id && name && isIdentifier(name) && shouldWarn(name, node.right.id.name) && report(node, name, node.right.id.name, isProp);
+				},
+				"Property, PropertyDefinition[value]"(node) {
+					if (node.value.type === "FunctionExpression" && node.value.id) {
+						if (node.key.type === "Identifier" && !node.computed) {
+							let functionName = node.value.id.name, propertyName = node.key.name;
+							if (considerPropertyDescriptor && propertyName === "value" && node.parent.type === "ObjectExpression") if (isPropertyCall("Object", "defineProperty", node.parent.parent) || isPropertyCall("Reflect", "defineProperty", node.parent.parent)) {
+								let property = node.parent.parent.arguments[1];
+								isStringLiteral(property) && shouldWarn(property.value, functionName) && report(node, property.value, functionName, !0);
+							} else isPropertyCall("Object", "defineProperties", node.parent.parent.parent.parent) || isPropertyCall("Object", "create", node.parent.parent.parent.parent) ? (propertyName = node.parent.parent.key.name, !node.parent.parent.computed && shouldWarn(propertyName, functionName) && report(node, propertyName, functionName, !0)) : shouldWarn(propertyName, functionName) && report(node, propertyName, functionName, !0);
+							else shouldWarn(propertyName, functionName) && report(node, propertyName, functionName, !0);
+							return;
+						}
+						isStringLiteral(node.key) && isIdentifier(node.key.value, ecmaVersion) && shouldWarn(node.key.value, node.value.id.name) && report(node, node.key.value, node.value.id.name, !0);
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/func-name-matching.cjs
+module.exports = require_func_name_matching().create;
+//#endregion

package/rules/func-names.cjs

@@ -0,0 +1,121 @@
+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/func-names.js
+/**
+* @fileoverview Rule to warn when a function expression does not have a name.
+* @author Kyle T. Nunery
+*/
+var require_func_names = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether or not a given variable is a function name.
+	* @param {eslint-scope.Variable} variable A variable to check.
+	* @returns {boolean} `true` if the variable is a function name.
+	*/
+	function isFunctionName(variable) {
+		return variable && variable.defs[0].type === "FunctionName";
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: ["always", {}],
+			docs: {
+				description: "Require or disallow named `function` expressions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/func-names"
+			},
+			schema: {
+				definitions: { value: { enum: [
+					"always",
+					"as-needed",
+					"never"
+				] } },
+				items: [{ $ref: "#/definitions/value" }, {
+					type: "object",
+					properties: { generators: { $ref: "#/definitions/value" } },
+					additionalProperties: !1
+				}]
+			},
+			messages: {
+				unnamed: "Unexpected unnamed {{name}}.",
+				named: "Unexpected named {{name}}."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Returns the config option for the given node.
+			* @param {ASTNode} node A node to get the config for.
+			* @returns {string} The config option.
+			*/
+			function getConfigForNode(node) {
+				return node.generator && context.options[1].generators ? context.options[1].generators : context.options[0];
+			}
+			/**
+			* Determines whether the current FunctionExpression node is a get, set, or
+			* shorthand method in an object literal or a class.
+			* @param {ASTNode} node A node to check.
+			* @returns {boolean} True if the node is a get, set, or shorthand method.
+			*/
+			function isObjectOrClassMethod(node) {
+				let parent = node.parent;
+				return parent.type === "MethodDefinition" || parent.type === "Property" && (parent.method || parent.kind === "get" || parent.kind === "set");
+			}
+			/**
+			* Determines whether the current FunctionExpression node has a name that would be
+			* inferred from context in a conforming ES6 environment.
+			* @param {ASTNode} node A node to check.
+			* @returns {boolean} True if the node would have a name assigned automatically.
+			*/
+			function hasInferredName(node) {
+				let parent = node.parent;
+				return isObjectOrClassMethod(node) || parent.type === "VariableDeclarator" && parent.id.type === "Identifier" && parent.init === node || parent.type === "Property" && parent.value === node || parent.type === "PropertyDefinition" && parent.value === node || parent.type === "AssignmentExpression" && parent.left.type === "Identifier" && parent.right === node || parent.type === "AssignmentPattern" && parent.left.type === "Identifier" && parent.right === node;
+			}
+			/**
+			* Reports that an unnamed function should be named
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @returns {void}
+			*/
+			function reportUnexpectedUnnamedFunction(node) {
+				context.report({
+					node,
+					messageId: "unnamed",
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					data: { name: astUtils.getFunctionNameWithKind(node) }
+				});
+			}
+			/**
+			* Reports that a named function should be unnamed
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @returns {void}
+			*/
+			function reportUnexpectedNamedFunction(node) {
+				context.report({
+					node,
+					messageId: "named",
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					data: { name: astUtils.getFunctionNameWithKind(node) }
+				});
+			}
+			/**
+			* The listener for function nodes.
+			* @param {ASTNode} node function node
+			* @returns {void}
+			*/
+			function handleFunction(node) {
+				let nameVar = sourceCode.getDeclaredVariables(node)[0];
+				if (isFunctionName(nameVar) && nameVar.references.length > 0) return;
+				let hasName = !!(node.id && node.id.name), config = getConfigForNode(node);
+				config === "never" ? hasName && node.type !== "FunctionDeclaration" && reportUnexpectedNamedFunction(node) : config === "as-needed" ? !hasName && !hasInferredName(node) && reportUnexpectedUnnamedFunction(node) : !hasName && !isObjectOrClassMethod(node) && reportUnexpectedUnnamedFunction(node);
+			}
+			return {
+				"FunctionExpression:exit": handleFunction,
+				"ExportDefaultDeclaration > FunctionDeclaration": handleFunction
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/func-names.cjs
+module.exports = require_func_names().create;
+//#endregion