oxlint-plugin-eslint 1.52.0

package/rules/template-curly-spacing.cjs

@@ -0,0 +1,112 @@
+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/template-curly-spacing.js
+/**
+* @fileoverview Rule to enforce spacing around embedded expressions of template strings
+* @author Toru Nagashima
+* @deprecated in ESLint v8.53.0
+*/
+var require_template_curly_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: "template-curly-spacing",
+						url: "https://eslint.style/rules/template-curly-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require or disallow spacing around embedded expressions of template strings",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/template-curly-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["always", "never"] }],
+			messages: {
+				expectedBefore: "Expected space(s) before '}'.",
+				expectedAfter: "Expected space(s) after '${'.",
+				unexpectedBefore: "Unexpected space(s) before '}'.",
+				unexpectedAfter: "Unexpected space(s) after '${'."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, always = context.options[0] === "always";
+			/**
+			* Checks spacing before `}` of a given token.
+			* @param {Token} token A token to check. This is a Template token.
+			* @returns {void}
+			*/
+			function checkSpacingBefore(token) {
+				if (!token.value.startsWith("}")) return;
+				let prevToken = sourceCode.getTokenBefore(token, { includeComments: !0 }), hasSpace = sourceCode.isSpaceBetween(prevToken, token);
+				astUtils.isTokenOnSameLine(prevToken, token) && (always && !hasSpace && context.report({
+					loc: {
+						start: token.loc.start,
+						end: {
+							line: token.loc.start.line,
+							column: token.loc.start.column + 1
+						}
+					},
+					messageId: "expectedBefore",
+					fix: (fixer) => fixer.insertTextBefore(token, " ")
+				}), !always && hasSpace && context.report({
+					loc: {
+						start: prevToken.loc.end,
+						end: token.loc.start
+					},
+					messageId: "unexpectedBefore",
+					fix: (fixer) => fixer.removeRange([prevToken.range[1], token.range[0]])
+				}));
+			}
+			/**
+			* Checks spacing after `${` of a given token.
+			* @param {Token} token A token to check. This is a Template token.
+			* @returns {void}
+			*/
+			function checkSpacingAfter(token) {
+				if (!token.value.endsWith("${")) return;
+				let nextToken = sourceCode.getTokenAfter(token, { includeComments: !0 }), hasSpace = sourceCode.isSpaceBetween(token, nextToken);
+				astUtils.isTokenOnSameLine(token, nextToken) && (always && !hasSpace && context.report({
+					loc: {
+						start: {
+							line: token.loc.end.line,
+							column: token.loc.end.column - 2
+						},
+						end: token.loc.end
+					},
+					messageId: "expectedAfter",
+					fix: (fixer) => fixer.insertTextAfter(token, " ")
+				}), !always && hasSpace && context.report({
+					loc: {
+						start: token.loc.end,
+						end: nextToken.loc.start
+					},
+					messageId: "unexpectedAfter",
+					fix: (fixer) => fixer.removeRange([token.range[1], nextToken.range[0]])
+				}));
+			}
+			return { TemplateElement(node) {
+				let token = sourceCode.getFirstToken(node);
+				checkSpacingBefore(token), checkSpacingAfter(token);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/template-curly-spacing.cjs
+module.exports = require_template_curly_spacing().create;
+//#endregion

package/rules/template-tag-spacing.cjs

@@ -0,0 +1,82 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/template-tag-spacing.js
+/**
+* @fileoverview Rule to check spacing between template tags and their literals
+* @author Jonathan Wilsson
+* @deprecated in ESLint v8.53.0
+*/
+var require_template_tag_spacing = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @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: "template-tag-spacing",
+						url: "https://eslint.style/rules/template-tag-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require or disallow spacing between template tags and their literals",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/template-tag-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["always", "never"] }],
+			messages: {
+				unexpected: "Unexpected space between template tag and template literal.",
+				missing: "Missing space between template tag and template literal."
+			}
+		},
+		create(context) {
+			let never = context.options[0] !== "always", sourceCode = context.sourceCode;
+			/**
+			* Check if a space is present between a template tag and its literal
+			* @param {ASTNode} node node to evaluate
+			* @returns {void}
+			* @private
+			*/
+			function checkSpacing(node) {
+				let tagToken = sourceCode.getTokenBefore(node.quasi), literalToken = sourceCode.getFirstToken(node.quasi), hasWhitespace = sourceCode.isSpaceBetweenTokens(tagToken, literalToken);
+				never && hasWhitespace ? context.report({
+					node,
+					loc: {
+						start: tagToken.loc.end,
+						end: literalToken.loc.start
+					},
+					messageId: "unexpected",
+					fix(fixer) {
+						let comments = sourceCode.getCommentsBefore(node.quasi);
+						return comments.some((comment) => comment.type === "Line") ? null : fixer.replaceTextRange([tagToken.range[1], literalToken.range[0]], comments.reduce((text, comment) => text + sourceCode.getText(comment), ""));
+					}
+				}) : !never && !hasWhitespace && context.report({
+					node,
+					loc: {
+						start: node.loc.start,
+						end: literalToken.loc.start
+					},
+					messageId: "missing",
+					fix(fixer) {
+						return fixer.insertTextAfter(tagToken, " ");
+					}
+				});
+			}
+			return { TaggedTemplateExpression: checkSpacing };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/template-tag-spacing.cjs
+module.exports = require_template_tag_spacing().create;
+//#endregion

package/rules/unicode-bom.cjs

@@ -0,0 +1,52 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/unicode-bom.js
+/**
+* @fileoverview Require or disallow Unicode BOM
+* @author Andrew Johnston <https://github.com/ehjay>
+*/
+var require_unicode_bom = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "layout",
+			defaultOptions: ["never"],
+			docs: {
+				description: "Require or disallow Unicode byte order mark (BOM)",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/unicode-bom"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["always", "never"] }],
+			messages: {
+				expected: "Expected Unicode BOM (Byte Order Mark).",
+				unexpected: "Unexpected Unicode BOM (Byte Order Mark)."
+			}
+		},
+		create(context) {
+			return { Program: function checkUnicodeBOM(node) {
+				let sourceCode = context.sourceCode, location = {
+					column: 0,
+					line: 1
+				}, [requireBOM] = context.options;
+				!sourceCode.hasBOM && requireBOM === "always" ? context.report({
+					node,
+					loc: location,
+					messageId: "expected",
+					fix(fixer) {
+						return fixer.insertTextBeforeRange([0, 1], "");
+					}
+				}) : sourceCode.hasBOM && requireBOM === "never" && context.report({
+					node,
+					loc: location,
+					messageId: "unexpected",
+					fix(fixer) {
+						return fixer.removeRange([-1, 0]);
+					}
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/unicode-bom.cjs
+module.exports = require_unicode_bom().create;
+//#endregion

package/rules/use-isnan.cjs

@@ -0,0 +1,144 @@
+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/use-isnan.js
+/**
+* @fileoverview Rule to flag comparisons to the value NaN
+* @author James Allardice
+*/
+var require_use_isnan = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Determines if the given node is a NaN `Identifier` node.
+	* @param {ASTNode|null} node The node to check.
+	* @returns {boolean} `true` if the node is 'NaN' identifier.
+	*/
+	function isNaNIdentifier(node) {
+		if (!node) return !1;
+		let nodeToCheck = node.type === "SequenceExpression" ? node.expressions.at(-1) : node;
+		return astUtils.isSpecificId(nodeToCheck, "NaN") || astUtils.isSpecificMemberAccess(nodeToCheck, "Number", "NaN");
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			hasSuggestions: !0,
+			type: "problem",
+			docs: {
+				description: "Require calls to `isNaN()` when checking for `NaN`",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/use-isnan"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					enforceForSwitchCase: { type: "boolean" },
+					enforceForIndexOf: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			defaultOptions: [{
+				enforceForIndexOf: !1,
+				enforceForSwitchCase: !0
+			}],
+			messages: {
+				comparisonWithNaN: "Use the isNaN function to compare with NaN.",
+				switchNaN: "'switch(NaN)' can never match a case clause. Use Number.isNaN instead of the switch.",
+				caseNaN: "'case NaN' can never match. Use Number.isNaN before the switch.",
+				indexOfNaN: "Array prototype method '{{ methodName }}' cannot find NaN.",
+				replaceWithIsNaN: "Replace with Number.isNaN.",
+				replaceWithCastingAndIsNaN: "Replace with Number.isNaN and cast to a Number.",
+				replaceWithFindIndex: "Replace with Array.prototype.{{ methodName }}."
+			}
+		},
+		create(context) {
+			let [{ enforceForIndexOf, enforceForSwitchCase }] = context.options, sourceCode = context.sourceCode, fixableOperators = new Set([
+				"==",
+				"===",
+				"!=",
+				"!=="
+			]), castableOperators = new Set(["==", "!="]);
+			/**
+			* Get a fixer for a binary expression that compares to NaN.
+			* @param  {ASTNode} node The node to fix.
+			* @param {function(string): string} wrapValue A function that wraps the compared value with a fix.
+			* @returns {function(Fixer): Fix} The fixer function.
+			*/
+			function getBinaryExpressionFixer(node, wrapValue) {
+				return (fixer) => {
+					let comparedValue = isNaNIdentifier(node.left) ? node.right : node.left, shouldWrap = comparedValue.type === "SequenceExpression", negation = node.operator[0] === "!" ? "!" : "", comparedValueText = sourceCode.getText(comparedValue);
+					shouldWrap && (comparedValueText = `(${comparedValueText})`);
+					let fixedValue = wrapValue(comparedValueText);
+					return fixer.replaceText(node, `${negation}${fixedValue}`);
+				};
+			}
+			/**
+			* Checks the given `BinaryExpression` node for `foo === NaN` and other comparisons.
+			* @param {ASTNode} node The node to check.
+			* @returns {void}
+			*/
+			function checkBinaryExpression(node) {
+				if (/^(?:[<>]|[!=]=)=?$/u.test(node.operator) && (isNaNIdentifier(node.left) || isNaNIdentifier(node.right))) {
+					let suggestedFixes = [], isSequenceExpression = (isNaNIdentifier(node.left) ? node.left : node.right).type === "SequenceExpression", isSuggestable = fixableOperators.has(node.operator) && !isSequenceExpression, isCastable = castableOperators.has(node.operator);
+					isSuggestable && (suggestedFixes.push({
+						messageId: "replaceWithIsNaN",
+						fix: getBinaryExpressionFixer(node, (value) => `Number.isNaN(${value})`)
+					}), isCastable && suggestedFixes.push({
+						messageId: "replaceWithCastingAndIsNaN",
+						fix: getBinaryExpressionFixer(node, (value) => `Number.isNaN(Number(${value}))`)
+					})), context.report({
+						node,
+						messageId: "comparisonWithNaN",
+						suggest: suggestedFixes
+					});
+				}
+			}
+			/**
+			* Checks the discriminant and all case clauses of the given `SwitchStatement` node for `switch(NaN)` and `case NaN:`
+			* @param {ASTNode} node The node to check.
+			* @returns {void}
+			*/
+			function checkSwitchStatement(node) {
+				isNaNIdentifier(node.discriminant) && context.report({
+					node,
+					messageId: "switchNaN"
+				});
+				for (let switchCase of node.cases) isNaNIdentifier(switchCase.test) && context.report({
+					node: switchCase,
+					messageId: "caseNaN"
+				});
+			}
+			/**
+			* Checks the given `CallExpression` node for `.indexOf(NaN)` and `.lastIndexOf(NaN)`.
+			* @param {ASTNode} node The node to check.
+			* @returns {void}
+			*/
+			function checkCallExpression(node) {
+				let callee = astUtils.skipChainExpression(node.callee);
+				if (callee.type === "MemberExpression") {
+					let methodName = astUtils.getStaticPropertyName(callee);
+					if ((methodName === "indexOf" || methodName === "lastIndexOf") && node.arguments.length <= 2 && isNaNIdentifier(node.arguments[0])) {
+						let isSuggestable = node.arguments[0].type !== "SequenceExpression" && !node.arguments[1], suggestedFixes = [];
+						if (isSuggestable) {
+							let shouldWrap = callee.computed, findIndexMethod = methodName === "indexOf" ? "findIndex" : "findLastIndex", propertyName = shouldWrap ? `"${findIndexMethod}"` : findIndexMethod;
+							suggestedFixes.push({
+								messageId: "replaceWithFindIndex",
+								data: { methodName: findIndexMethod },
+								fix: (fixer) => [fixer.replaceText(callee.property, propertyName), fixer.replaceText(node.arguments[0], "Number.isNaN")]
+							});
+						}
+						context.report({
+							node,
+							messageId: "indexOfNaN",
+							data: { methodName },
+							suggest: suggestedFixes
+						});
+					}
+				}
+			}
+			let listeners = { BinaryExpression: checkBinaryExpression };
+			return enforceForSwitchCase && (listeners.SwitchStatement = checkSwitchStatement), enforceForIndexOf && (listeners.CallExpression = checkCallExpression), listeners;
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/use-isnan.cjs
+module.exports = require_use_isnan().create;
+//#endregion

package/rules/valid-typeof.cjs

@@ -0,0 +1,104 @@
+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/valid-typeof.js
+/**
+* @fileoverview Ensures that the results of typeof are compared against a valid string
+* @author Ian Christian Myers
+*/
+var require_valid_typeof = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{ requireStringLiterals: !1 }],
+			docs: {
+				description: "Enforce comparing `typeof` expressions against valid strings",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/valid-typeof"
+			},
+			hasSuggestions: !0,
+			schema: [{
+				type: "object",
+				properties: { requireStringLiterals: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: {
+				invalidValue: "Invalid typeof comparison value.",
+				notString: "Typeof comparisons should be to string literals.",
+				suggestString: "Use `\"{{type}}\"` instead of `{{type}}`."
+			}
+		},
+		create(context) {
+			let VALID_TYPES = new Set([
+				"symbol",
+				"undefined",
+				"object",
+				"boolean",
+				"number",
+				"string",
+				"function",
+				"bigint"
+			]), OPERATORS = new Set([
+				"==",
+				"===",
+				"!=",
+				"!=="
+			]), sourceCode = context.sourceCode, [{ requireStringLiterals }] = context.options, globalScope;
+			/**
+			* Checks whether the given node represents a reference to a global variable that is not declared in the source code.
+			* These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
+			* @param {ASTNode} node `Identifier` node to check.
+			* @returns {boolean} `true` if the node is a reference to a global variable.
+			*/
+			function isReferenceToGlobalVariable(node) {
+				let variable = globalScope.set.get(node.name);
+				return variable && variable.defs.length === 0 && variable.references.some((ref) => ref.identifier === node);
+			}
+			/**
+			* Determines whether a node is a typeof expression.
+			* @param {ASTNode} node The node
+			* @returns {boolean} `true` if the node is a typeof expression
+			*/
+			function isTypeofExpression(node) {
+				return node.type === "UnaryExpression" && node.operator === "typeof";
+			}
+			return {
+				Program(node) {
+					globalScope = sourceCode.getScope(node);
+				},
+				UnaryExpression(node) {
+					if (isTypeofExpression(node)) {
+						let { parent } = node;
+						if (parent.type === "BinaryExpression" && OPERATORS.has(parent.operator)) {
+							let sibling = parent.left === node ? parent.right : parent.left;
+							if (sibling.type === "Literal" || astUtils.isStaticTemplateLiteral(sibling)) {
+								let value = sibling.type === "Literal" ? sibling.value : sibling.quasis[0].value.cooked;
+								VALID_TYPES.has(value) || context.report({
+									node: sibling,
+									messageId: "invalidValue"
+								});
+							} else sibling.type === "Identifier" && sibling.name === "undefined" && isReferenceToGlobalVariable(sibling) ? context.report({
+								node: sibling,
+								messageId: requireStringLiterals ? "notString" : "invalidValue",
+								suggest: [{
+									messageId: "suggestString",
+									data: { type: "undefined" },
+									fix(fixer) {
+										return fixer.replaceText(sibling, "\"undefined\"");
+									}
+								}]
+							}) : requireStringLiterals && !isTypeofExpression(sibling) && context.report({
+								node: sibling,
+								messageId: "notString"
+							});
+						}
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/valid-typeof.cjs
+module.exports = require_valid_typeof().create;
+//#endregion

package/rules/vars-on-top.cjs

@@ -0,0 +1,94 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/vars-on-top.js
+/**
+* @fileoverview Rule to enforce var declarations are only at the top of a function.
+* @author Danny Fritz
+* @author Gyandeep Singh
+*/
+var require_vars_on_top = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require `var` declarations be placed at the top of their containing scope",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/vars-on-top"
+			},
+			schema: [],
+			messages: { top: "All 'var' declarations must be at the top of the function scope." }
+		},
+		create(context) {
+			/**
+			* Has AST suggesting a directive.
+			* @param {ASTNode} node any node
+			* @returns {boolean} whether the given node structurally represents a directive
+			*/
+			function looksLikeDirective(node) {
+				return node.type === "ExpressionStatement" && node.expression.type === "Literal" && typeof node.expression.value == "string";
+			}
+			/**
+			* Check to see if its a ES6 import declaration
+			* @param {ASTNode} node any node
+			* @returns {boolean} whether the given node represents a import declaration
+			*/
+			function looksLikeImport(node) {
+				return node.type === "ImportDeclaration" || node.type === "ImportSpecifier" || node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier";
+			}
+			/**
+			* Checks whether a given node is a variable declaration or not.
+			* @param {ASTNode} node any node
+			* @returns {boolean} `true` if the node is a variable declaration.
+			*/
+			function isVariableDeclaration(node) {
+				return node.type === "VariableDeclaration" || node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration";
+			}
+			/**
+			* Checks whether this variable is on top of the block body
+			* @param {ASTNode} node The node to check
+			* @param {ASTNode[]} statements collection of ASTNodes for the parent node block
+			* @returns {boolean} True if var is on top otherwise false
+			*/
+			function isVarOnTop(node, statements) {
+				let l = statements.length, i = 0;
+				if (node.parent.type !== "StaticBlock") for (; i < l && !(!looksLikeDirective(statements[i]) && !looksLikeImport(statements[i])); ++i);
+				for (; i < l; ++i) {
+					if (!isVariableDeclaration(statements[i])) return !1;
+					if (statements[i] === node) return !0;
+				}
+				return !1;
+			}
+			/**
+			* Checks whether variable is on top at the global level
+			* @param {ASTNode} node The node to check
+			* @param {ASTNode} parent Parent of the node
+			* @returns {void}
+			*/
+			function globalVarCheck(node, parent) {
+				isVarOnTop(node, parent.body) || context.report({
+					node,
+					messageId: "top"
+				});
+			}
+			/**
+			* Checks whether variable is on top at functional block scope level
+			* @param {ASTNode} node The node to check
+			* @returns {void}
+			*/
+			function blockScopeVarCheck(node) {
+				let { parent } = node;
+				parent.type === "BlockStatement" && /Function/u.test(parent.parent.type) && isVarOnTop(node, parent.body) || parent.type === "StaticBlock" && isVarOnTop(node, parent.body) || context.report({
+					node,
+					messageId: "top"
+				});
+			}
+			return { "VariableDeclaration[kind='var']"(node) {
+				node.parent.type === "ExportNamedDeclaration" ? globalVarCheck(node.parent, node.parent.parent) : node.parent.type === "Program" ? globalVarCheck(node, node.parent) : blockScopeVarCheck(node);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/vars-on-top.cjs
+module.exports = require_vars_on_top().create;
+//#endregion