oxlint-plugin-eslint 1.52.0

package/rules/spaced-comment.cjs

@@ -0,0 +1,233 @@
+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/spaced-comment.js
+/**
+* @fileoverview Source code for spaced-comments rule
+* @author Gyandeep Singh
+* @deprecated in ESLint v8.53.0
+*/
+var require_spaced_comment = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let escapeRegExp = require_ast_utils$1.n(), astUtils = require_ast_utils$1.t();
+	/**
+	* Escapes the control characters of a given string.
+	* @param {string} s A string to escape.
+	* @returns {string} An escaped string.
+	*/
+	function escape(s) {
+		return `(?:${escapeRegExp(s)})`;
+	}
+	/**
+	* Escapes the control characters of a given string.
+	* And adds a repeat flag.
+	* @param {string} s A string to escape.
+	* @returns {string} An escaped string.
+	*/
+	function escapeAndRepeat(s) {
+		return `${escape(s)}+`;
+	}
+	/**
+	* Parses `markers` option.
+	* If markers don't include `"*"`, this adds `"*"` to allow JSDoc comments.
+	* @param {string[]} [markers] A marker list.
+	* @returns {string[]} A marker list.
+	*/
+	function parseMarkersOption(markers) {
+		return markers.includes("*") ? markers : markers.concat("*");
+	}
+	/**
+	* Creates string pattern for exceptions.
+	* Generated pattern:
+	*
+	* 1. A space or an exception pattern sequence.
+	* @param {string[]} exceptions An exception pattern list.
+	* @returns {string} A regular expression string for exceptions.
+	*/
+	function createExceptionsPattern(exceptions) {
+		let pattern = "";
+		return exceptions.length === 0 ? pattern += "\\s" : (pattern += "(?:\\s|", exceptions.length === 1 ? pattern += escapeAndRepeat(exceptions[0]) : (pattern += "(?:", pattern += exceptions.map(escapeAndRepeat).join("|"), pattern += ")"), pattern += `(?:$|[${Array.from(astUtils.LINEBREAKS).join("")}]))`), pattern;
+	}
+	/**
+	* Creates RegExp object for `always` mode.
+	* Generated pattern for beginning of comment:
+	*
+	* 1. First, a marker or nothing.
+	* 2. Next, a space or an exception pattern sequence.
+	* @param {string[]} markers A marker list.
+	* @param {string[]} exceptions An exception pattern list.
+	* @returns {RegExp} A RegExp object for the beginning of a comment in `always` mode.
+	*/
+	function createAlwaysStylePattern(markers, exceptions) {
+		let pattern = "^";
+		return markers.length === 1 ? pattern += escape(markers[0]) : (pattern += "(?:", pattern += markers.map(escape).join("|"), pattern += ")"), pattern += "?", pattern += createExceptionsPattern(exceptions), new RegExp(pattern, "u");
+	}
+	/**
+	* Creates RegExp object for `never` mode.
+	* Generated pattern for beginning of comment:
+	*
+	* 1. First, a marker or nothing (captured).
+	* 2. Next, a space or a tab.
+	* @param {string[]} markers A marker list.
+	* @returns {RegExp} A RegExp object for `never` mode.
+	*/
+	function createNeverStylePattern(markers) {
+		let pattern = `^(${markers.map(escape).join("|")})?[ \t]+`;
+		return new RegExp(pattern, "u");
+	}
+	/** @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: "spaced-comment",
+						url: "https://eslint.style/rules/spaced-comment"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Enforce consistent spacing after the `//` or `/*` in a comment",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/spaced-comment"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["always", "never"] }, {
+				type: "object",
+				properties: {
+					exceptions: {
+						type: "array",
+						items: { type: "string" }
+					},
+					markers: {
+						type: "array",
+						items: { type: "string" }
+					},
+					line: {
+						type: "object",
+						properties: {
+							exceptions: {
+								type: "array",
+								items: { type: "string" }
+							},
+							markers: {
+								type: "array",
+								items: { type: "string" }
+							}
+						},
+						additionalProperties: !1
+					},
+					block: {
+						type: "object",
+						properties: {
+							exceptions: {
+								type: "array",
+								items: { type: "string" }
+							},
+							markers: {
+								type: "array",
+								items: { type: "string" }
+							},
+							balanced: {
+								type: "boolean",
+								default: !1
+							}
+						},
+						additionalProperties: !1
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				unexpectedSpaceAfterMarker: "Unexpected space or tab after marker ({{refChar}}) in comment.",
+				expectedExceptionAfter: "Expected exception block, space or tab after '{{refChar}}' in comment.",
+				unexpectedSpaceBefore: "Unexpected space or tab before '*/' in comment.",
+				unexpectedSpaceAfter: "Unexpected space or tab after '{{refChar}}' in comment.",
+				expectedSpaceBefore: "Expected space or tab before '*/' in comment.",
+				expectedSpaceAfter: "Expected space or tab after '{{refChar}}' in comment."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, requireSpace = context.options[0] !== "never", config = context.options[1] || {}, balanced = config.block && config.block.balanced, styleRules = ["block", "line"].reduce((rule, type) => {
+				let markers = parseMarkersOption(config[type] && config[type].markers || config.markers || []), exceptions = config[type] && config[type].exceptions || config.exceptions || [];
+				return rule[type] = {
+					beginRegex: requireSpace ? createAlwaysStylePattern(markers, exceptions) : createNeverStylePattern(markers),
+					endRegex: balanced && requireSpace ? RegExp(`${createExceptionsPattern(exceptions)}$`, "u") : /* @__PURE__ */ RegExp("[ 	]+$", "u"),
+					hasExceptions: exceptions.length > 0,
+					captureMarker: RegExp(`^(${markers.map(escape).join("|")})`, "u"),
+					markers: new Set(markers)
+				}, rule;
+			}, {});
+			/**
+			* Reports a beginning spacing error with an appropriate message.
+			* @param {ASTNode} node A comment node to check.
+			* @param {string} messageId An error message to report.
+			* @param {Array} match An array of match results for markers.
+			* @param {string} refChar Character used for reference in the error message.
+			* @returns {void}
+			*/
+			function reportBegin(node, messageId, match, refChar) {
+				let commentIdentifier = node.type.toLowerCase() === "block" ? "/*" : "//";
+				context.report({
+					node,
+					fix(fixer) {
+						let start = node.range[0], end = start + 2;
+						return requireSpace ? (match && (end += match[0].length), fixer.insertTextAfterRange([start, end], " ")) : (end += match[0].length, fixer.replaceTextRange([start, end], commentIdentifier + (match[1] ? match[1] : "")));
+					},
+					messageId,
+					data: { refChar }
+				});
+			}
+			/**
+			* Reports an ending spacing error with an appropriate message.
+			* @param {ASTNode} node A comment node to check.
+			* @param {string} messageId An error message to report.
+			* @param {string} match An array of the matched whitespace characters.
+			* @returns {void}
+			*/
+			function reportEnd(node, messageId, match) {
+				context.report({
+					node,
+					fix(fixer) {
+						if (requireSpace) return fixer.insertTextAfterRange([node.range[0], node.range[1] - 2], " ");
+						let end = node.range[1] - 2, start = end - match[0].length;
+						return fixer.replaceTextRange([start, end], "");
+					},
+					messageId
+				});
+			}
+			/**
+			* Reports a given comment if it's invalid.
+			* @param {ASTNode} node a comment node to check.
+			* @returns {void}
+			*/
+			function checkCommentForSpace(node) {
+				let type = node.type.toLowerCase(), rule = styleRules[type], commentIdentifier = type === "block" ? "/*" : "//";
+				if (node.value.length === 0 || rule.markers.has(node.value)) return;
+				let beginMatch = rule.beginRegex.exec(node.value), endMatch = rule.endRegex.exec(node.value);
+				if (requireSpace) {
+					if (!beginMatch) {
+						let hasMarker = rule.captureMarker.exec(node.value), marker = hasMarker ? commentIdentifier + hasMarker[0] : commentIdentifier;
+						rule.hasExceptions ? reportBegin(node, "expectedExceptionAfter", hasMarker, marker) : reportBegin(node, "expectedSpaceAfter", hasMarker, marker);
+					}
+					balanced && type === "block" && !endMatch && reportEnd(node, "expectedSpaceBefore");
+				} else beginMatch && (beginMatch[1] ? reportBegin(node, "unexpectedSpaceAfterMarker", beginMatch, beginMatch[1]) : reportBegin(node, "unexpectedSpaceAfter", beginMatch, commentIdentifier)), balanced && type === "block" && endMatch && reportEnd(node, "unexpectedSpaceBefore", endMatch);
+			}
+			return { Program() {
+				sourceCode.getAllComments().filter((token) => token.type !== "Shebang").forEach(checkCommentForSpace);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/spaced-comment.cjs
+module.exports = require_spaced_comment().create;
+//#endregion

package/rules/strict.cjs

@@ -0,0 +1,206 @@
+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/strict.js
+/**
+* @fileoverview Rule to control usage of strict mode directives.
+* @author Brandon Mills
+*/
+var require_strict = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Gets all of the Use Strict Directives in the Directive Prologue of a group of
+	* statements.
+	* @param {ASTNode[]} statements Statements in the program or function body.
+	* @returns {ASTNode[]} All of the Use Strict Directives.
+	*/
+	function getUseStrictDirectives(statements) {
+		let directives = [];
+		for (let i = 0; i < statements.length; i++) {
+			let statement = statements[i];
+			if (statement.type === "ExpressionStatement" && statement.expression.type === "Literal" && statement.expression.value === "use strict") directives[i] = statement;
+			else break;
+		}
+		return directives;
+	}
+	/**
+	* Checks whether a given parameter is a simple parameter.
+	* @param {ASTNode} node A pattern node to check.
+	* @returns {boolean} `true` if the node is an Identifier node.
+	*/
+	function isSimpleParameter(node) {
+		return node.type === "Identifier";
+	}
+	/**
+	* Checks whether a given parameter list is a simple parameter list.
+	* @param {ASTNode[]} params A parameter list to check.
+	* @returns {boolean} `true` if the every parameter is an Identifier node.
+	*/
+	function isSimpleParameterList(params) {
+		return params.every(isSimpleParameter);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: ["safe"],
+			docs: {
+				description: "Require or disallow strict mode directives",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/strict"
+			},
+			schema: [{ enum: [
+				"never",
+				"global",
+				"function",
+				"safe"
+			] }],
+			fixable: "code",
+			messages: {
+				function: "Use the function form of 'use strict'.",
+				global: "Use the global form of 'use strict'.",
+				multiple: "Multiple 'use strict' directives.",
+				never: "Strict mode is not permitted.",
+				unnecessary: "Unnecessary 'use strict' directive.",
+				module: "'use strict' is unnecessary inside of modules.",
+				implied: "'use strict' is unnecessary when implied strict mode is enabled.",
+				unnecessaryInClasses: "'use strict' is unnecessary inside of classes.",
+				nonSimpleParameterList: "'use strict' directive inside a function with non-simple parameter list throws a syntax error since ES2016.",
+				wrap: "Wrap {{name}} in a function with 'use strict' directive."
+			}
+		},
+		create(context) {
+			let ecmaFeatures = context.languageOptions.parserOptions.ecmaFeatures || {}, scopes = [], classScopes = [], [mode] = context.options;
+			ecmaFeatures.impliedStrict ? mode = "implied" : mode === "safe" && (mode = ecmaFeatures.globalReturn || context.languageOptions.sourceType === "commonjs" ? "global" : "function");
+			/**
+			* Determines whether a reported error should be fixed, depending on the error type.
+			* @param {string} errorType The type of error
+			* @returns {boolean} `true` if the reported error should be fixed
+			*/
+			function shouldFix(errorType) {
+				return errorType === "multiple" || errorType === "unnecessary" || errorType === "module" || errorType === "implied" || errorType === "unnecessaryInClasses";
+			}
+			/**
+			* Gets a fixer function to remove a given 'use strict' directive.
+			* @param {ASTNode} node The directive that should be removed
+			* @returns {Function} A fixer function
+			*/
+			function getFixFunction(node) {
+				return (fixer) => fixer.remove(node);
+			}
+			/**
+			* Report a slice of an array of nodes with a given message.
+			* @param {ASTNode[]} nodes Nodes.
+			* @param {string} start Index to start from.
+			* @param {string} end Index to end before.
+			* @param {string} messageId Message to display.
+			* @param {boolean} fix `true` if the directive should be fixed (i.e. removed)
+			* @returns {void}
+			*/
+			function reportSlice(nodes, start, end, messageId, fix) {
+				nodes.slice(start, end).forEach((node) => {
+					context.report({
+						node,
+						messageId,
+						fix: fix ? getFixFunction(node) : null
+					});
+				});
+			}
+			/**
+			* Report all nodes in an array with a given message.
+			* @param {ASTNode[]} nodes Nodes.
+			* @param {string} messageId Message id to display.
+			* @param {boolean} fix `true` if the directive should be fixed (i.e. removed)
+			* @returns {void}
+			*/
+			function reportAll(nodes, messageId, fix) {
+				reportSlice(nodes, 0, nodes.length, messageId, fix);
+			}
+			/**
+			* Report all nodes in an array, except the first, with a given message.
+			* @param {ASTNode[]} nodes Nodes.
+			* @param {string} messageId Message id to display.
+			* @param {boolean} fix `true` if the directive should be fixed (i.e. removed)
+			* @returns {void}
+			*/
+			function reportAllExceptFirst(nodes, messageId, fix) {
+				reportSlice(nodes, 1, nodes.length, messageId, fix);
+			}
+			/**
+			* Entering a function in 'function' mode pushes a new nested scope onto the
+			* stack. The new scope is true if the nested function is strict mode code.
+			* @param {ASTNode} node The function declaration or expression.
+			* @param {ASTNode[]} useStrictDirectives The Use Strict Directives of the node.
+			* @returns {void}
+			*/
+			function enterFunctionInFunctionMode(node, useStrictDirectives) {
+				let isInClass = classScopes.length > 0, isParentGlobal = scopes.length === 0 && classScopes.length === 0, isParentStrict = scopes.length > 0 && scopes.at(-1), isStrict = useStrictDirectives.length > 0;
+				isStrict ? (isSimpleParameterList(node.params) ? isParentStrict ? context.report({
+					node: useStrictDirectives[0],
+					messageId: "unnecessary",
+					fix: getFixFunction(useStrictDirectives[0])
+				}) : isInClass && context.report({
+					node: useStrictDirectives[0],
+					messageId: "unnecessaryInClasses",
+					fix: getFixFunction(useStrictDirectives[0])
+				}) : context.report({
+					node: useStrictDirectives[0],
+					messageId: "nonSimpleParameterList"
+				}), reportAllExceptFirst(useStrictDirectives, "multiple", !0)) : isParentGlobal && (isSimpleParameterList(node.params) ? context.report({
+					node,
+					messageId: "function"
+				}) : context.report({
+					node,
+					messageId: "wrap",
+					data: { name: astUtils.getFunctionNameWithKind(node) }
+				})), scopes.push(isParentStrict || isStrict);
+			}
+			/**
+			* Exiting a function in 'function' mode pops its scope off the stack.
+			* @returns {void}
+			*/
+			function exitFunctionInFunctionMode() {
+				scopes.pop();
+			}
+			/**
+			* Enter a function and either:
+			* - Push a new nested scope onto the stack (in 'function' mode).
+			* - Report all the Use Strict Directives (in the other modes).
+			* @param {ASTNode} node The function declaration or expression.
+			* @returns {void}
+			*/
+			function enterFunction(node) {
+				let useStrictDirectives = node.body.type === "BlockStatement" ? getUseStrictDirectives(node.body.body) : [];
+				mode === "function" ? enterFunctionInFunctionMode(node, useStrictDirectives) : useStrictDirectives.length > 0 && (isSimpleParameterList(node.params) ? reportAll(useStrictDirectives, mode, shouldFix(mode)) : (context.report({
+					node: useStrictDirectives[0],
+					messageId: "nonSimpleParameterList"
+				}), reportAllExceptFirst(useStrictDirectives, "multiple", !0)));
+			}
+			let rule = {
+				Program(node) {
+					let useStrictDirectives = getUseStrictDirectives(node.body);
+					node.sourceType === "module" && (mode = "module"), mode === "global" ? (node.body.length > 0 && useStrictDirectives.length === 0 && context.report({
+						node,
+						messageId: "global"
+					}), reportAllExceptFirst(useStrictDirectives, "multiple", !0)) : reportAll(useStrictDirectives, mode, shouldFix(mode));
+				},
+				FunctionDeclaration: enterFunction,
+				FunctionExpression: enterFunction,
+				ArrowFunctionExpression: enterFunction
+			};
+			return mode === "function" && Object.assign(rule, {
+				ClassBody() {
+					classScopes.push(!0);
+				},
+				"ClassBody:exit"() {
+					classScopes.pop();
+				},
+				"FunctionDeclaration:exit": exitFunctionInFunctionMode,
+				"FunctionExpression:exit": exitFunctionInFunctionMode,
+				"ArrowFunctionExpression:exit": exitFunctionInFunctionMode
+			}), rule;
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/strict.cjs
+module.exports = require_strict().create;
+//#endregion

package/rules/switch-colon-spacing.cjs

@@ -0,0 +1,114 @@
+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/switch-colon-spacing.js
+/**
+* @fileoverview Rule to enforce spacing around colons of switch statements.
+* @author Toru Nagashima
+* @deprecated in ESLint v8.53.0
+*/
+var require_switch_colon_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: "switch-colon-spacing",
+						url: "https://eslint.style/rules/switch-colon-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce spacing around colons of switch statements",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/switch-colon-spacing"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					before: {
+						type: "boolean",
+						default: !1
+					},
+					after: {
+						type: "boolean",
+						default: !0
+					}
+				},
+				additionalProperties: !1
+			}],
+			fixable: "whitespace",
+			messages: {
+				expectedBefore: "Expected space(s) before this colon.",
+				expectedAfter: "Expected space(s) after this colon.",
+				unexpectedBefore: "Unexpected space(s) before this colon.",
+				unexpectedAfter: "Unexpected space(s) after this colon."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, options = context.options[0] || {}, beforeSpacing = options.before === !0, afterSpacing = options.after !== !1;
+			/**
+			* Check whether the spacing between the given 2 tokens is valid or not.
+			* @param {Token} left The left token to check.
+			* @param {Token} right The right token to check.
+			* @param {boolean} expected The expected spacing to check. `true` if there should be a space.
+			* @returns {boolean} `true` if the spacing between the tokens is valid.
+			*/
+			function isValidSpacing(left, right, expected) {
+				return astUtils.isClosingBraceToken(right) || !astUtils.isTokenOnSameLine(left, right) || sourceCode.isSpaceBetweenTokens(left, right) === expected;
+			}
+			/**
+			* Check whether comments exist between the given 2 tokens.
+			* @param {Token} left The left token to check.
+			* @param {Token} right The right token to check.
+			* @returns {boolean} `true` if comments exist between the given 2 tokens.
+			*/
+			function commentsExistBetween(left, right) {
+				return sourceCode.getFirstTokenBetween(left, right, {
+					includeComments: !0,
+					filter: astUtils.isCommentToken
+				}) !== null;
+			}
+			/**
+			* Fix the spacing between the given 2 tokens.
+			* @param {RuleFixer} fixer The fixer to fix.
+			* @param {Token} left The left token of fix range.
+			* @param {Token} right The right token of fix range.
+			* @param {boolean} spacing The spacing style. `true` if there should be a space.
+			* @returns {Fix|null} The fix object.
+			*/
+			function fix(fixer, left, right, spacing) {
+				return commentsExistBetween(left, right) ? null : spacing ? fixer.insertTextAfter(left, " ") : fixer.removeRange([left.range[1], right.range[0]]);
+			}
+			return { SwitchCase(node) {
+				let colonToken = astUtils.getSwitchCaseColonToken(node, sourceCode), beforeToken = sourceCode.getTokenBefore(colonToken), afterToken = sourceCode.getTokenAfter(colonToken);
+				isValidSpacing(beforeToken, colonToken, beforeSpacing) || context.report({
+					node,
+					loc: colonToken.loc,
+					messageId: beforeSpacing ? "expectedBefore" : "unexpectedBefore",
+					fix: (fixer) => fix(fixer, beforeToken, colonToken, beforeSpacing)
+				}), isValidSpacing(colonToken, afterToken, afterSpacing) || context.report({
+					node,
+					loc: colonToken.loc,
+					messageId: afterSpacing ? "expectedAfter" : "unexpectedAfter",
+					fix: (fixer) => fix(fixer, colonToken, afterToken, afterSpacing)
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/switch-colon-spacing.cjs
+module.exports = require_switch_colon_spacing().create;
+//#endregion

package/rules/symbol-description.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/symbol-description.js
+/**
+* @fileoverview Rule to enforce description with the `Symbol` object
+* @author Jarek Rencz
+*/
+var require_symbol_description = /* @__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: "Require symbol descriptions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/symbol-description"
+			},
+			fixable: null,
+			schema: [],
+			messages: { expected: "Expected Symbol to have a description." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Reports if node does not conform the rule in case rule is set to
+			* report missing description
+			* @param {ASTNode} node A CallExpression node to check.
+			* @returns {void}
+			*/
+			function checkArgument(node) {
+				node.arguments.length === 0 && context.report({
+					node,
+					messageId: "expected"
+				});
+			}
+			return { "Program:exit"(node) {
+				let scope = sourceCode.getScope(node), variable = astUtils.getVariableByName(scope, "Symbol");
+				variable && variable.defs.length === 0 && variable.references.forEach((reference) => {
+					let idNode = reference.identifier;
+					astUtils.isCallee(idNode) && checkArgument(idNode.parent);
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/symbol-description.cjs
+module.exports = require_symbol_description().create;
+//#endregion