oxlint-plugin-eslint 1.52.0

package/rules/object-curly-spacing.cjs

@@ -0,0 +1,225 @@
+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/object-curly-spacing.js
+/**
+* @fileoverview Disallows or enforces spaces inside of object literals.
+* @author Jamund Ferguson
+* @deprecated in ESLint v8.53.0
+*/
+var require_object_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: "object-curly-spacing",
+						url: "https://eslint.style/rules/object-curly-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing inside braces",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/object-curly-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["always", "never"] }, {
+				type: "object",
+				properties: {
+					arraysInObjects: { type: "boolean" },
+					objectsInObjects: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				requireSpaceBefore: "A space is required before '{{token}}'.",
+				requireSpaceAfter: "A space is required after '{{token}}'.",
+				unexpectedSpaceBefore: "There should be no space before '{{token}}'.",
+				unexpectedSpaceAfter: "There should be no space after '{{token}}'."
+			}
+		},
+		create(context) {
+			let spaced = context.options[0] === "always", sourceCode = context.sourceCode;
+			/**
+			* Determines whether an option is set, relative to the spacing option.
+			* If spaced is "always", then check whether option is set to false.
+			* If spaced is "never", then check whether option is set to true.
+			* @param {Object} option The option to exclude.
+			* @returns {boolean} Whether or not the property is excluded.
+			*/
+			function isOptionSet(option) {
+				return context.options[1] ? context.options[1][option] === !spaced : !1;
+			}
+			let options = {
+				spaced,
+				arraysInObjectsException: isOptionSet("arraysInObjects"),
+				objectsInObjectsException: isOptionSet("objectsInObjects")
+			};
+			/**
+			* Reports that there shouldn't be a space after the first token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportNoBeginningSpace(node, token) {
+				let nextToken = context.sourceCode.getTokenAfter(token, { includeComments: !0 });
+				context.report({
+					node,
+					loc: {
+						start: token.loc.end,
+						end: nextToken.loc.start
+					},
+					messageId: "unexpectedSpaceAfter",
+					data: { token: token.value },
+					fix(fixer) {
+						return fixer.removeRange([token.range[1], nextToken.range[0]]);
+					}
+				});
+			}
+			/**
+			* Reports that there shouldn't be a space before the last token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportNoEndingSpace(node, token) {
+				let previousToken = context.sourceCode.getTokenBefore(token, { includeComments: !0 });
+				context.report({
+					node,
+					loc: {
+						start: previousToken.loc.end,
+						end: token.loc.start
+					},
+					messageId: "unexpectedSpaceBefore",
+					data: { token: token.value },
+					fix(fixer) {
+						return fixer.removeRange([previousToken.range[1], token.range[0]]);
+					}
+				});
+			}
+			/**
+			* Reports that there should be a space after the first token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportRequiredBeginningSpace(node, token) {
+				context.report({
+					node,
+					loc: token.loc,
+					messageId: "requireSpaceAfter",
+					data: { token: token.value },
+					fix(fixer) {
+						return fixer.insertTextAfter(token, " ");
+					}
+				});
+			}
+			/**
+			* Reports that there should be a space before the last token
+			* @param {ASTNode} node The node to report in the event of an error.
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportRequiredEndingSpace(node, token) {
+				context.report({
+					node,
+					loc: token.loc,
+					messageId: "requireSpaceBefore",
+					data: { token: token.value },
+					fix(fixer) {
+						return fixer.insertTextBefore(token, " ");
+					}
+				});
+			}
+			/**
+			* Determines if spacing in curly braces is valid.
+			* @param {ASTNode} node The AST node to check.
+			* @param {Token} first The first token to check (should be the opening brace)
+			* @param {Token} second The second token to check (should be first after the opening brace)
+			* @param {Token} penultimate The penultimate token to check (should be last before closing brace)
+			* @param {Token} last The last token to check (should be closing brace)
+			* @returns {void}
+			*/
+			function validateBraceSpacing(node, first, second, penultimate, last) {
+				if (astUtils.isTokenOnSameLine(first, second)) {
+					let firstSpaced = sourceCode.isSpaceBetweenTokens(first, second);
+					options.spaced && !firstSpaced && reportRequiredBeginningSpace(node, first), !options.spaced && firstSpaced && second.type !== "Line" && reportNoBeginningSpace(node, first);
+				}
+				if (astUtils.isTokenOnSameLine(penultimate, last)) {
+					let penultimateType = (options.arraysInObjectsException && astUtils.isClosingBracketToken(penultimate) || options.objectsInObjectsException && astUtils.isClosingBraceToken(penultimate)) && sourceCode.getNodeByRangeIndex(penultimate.range[0]).type, closingCurlyBraceMustBeSpaced = options.arraysInObjectsException && penultimateType === "ArrayExpression" || options.objectsInObjectsException && (penultimateType === "ObjectExpression" || penultimateType === "ObjectPattern") ? !options.spaced : options.spaced, lastSpaced = sourceCode.isSpaceBetweenTokens(penultimate, last);
+					closingCurlyBraceMustBeSpaced && !lastSpaced && reportRequiredEndingSpace(node, last), !closingCurlyBraceMustBeSpaced && lastSpaced && reportNoEndingSpace(node, last);
+				}
+			}
+			/**
+			* Gets '}' token of an object node.
+			*
+			* Because the last token of object patterns might be a type annotation,
+			* this traverses tokens preceded by the last property, then returns the
+			* first '}' token.
+			* @param {ASTNode} node The node to get. This node is an
+			*      ObjectExpression or an ObjectPattern. And this node has one or
+			*      more properties.
+			* @returns {Token} '}' token.
+			*/
+			function getClosingBraceOfObject(node) {
+				let lastProperty = node.properties.at(-1);
+				return sourceCode.getTokenAfter(lastProperty, astUtils.isClosingBraceToken);
+			}
+			/**
+			* Reports a given object node if spacing in curly braces is invalid.
+			* @param {ASTNode} node An ObjectExpression or ObjectPattern node to check.
+			* @returns {void}
+			*/
+			function checkForObject(node) {
+				if (node.properties.length === 0) return;
+				let first = sourceCode.getFirstToken(node), last = getClosingBraceOfObject(node);
+				validateBraceSpacing(node, first, sourceCode.getTokenAfter(first, { includeComments: !0 }), sourceCode.getTokenBefore(last, { includeComments: !0 }), last);
+			}
+			/**
+			* Reports a given import node if spacing in curly braces is invalid.
+			* @param {ASTNode} node An ImportDeclaration node to check.
+			* @returns {void}
+			*/
+			function checkForImport(node) {
+				if (node.specifiers.length === 0) return;
+				let firstSpecifier = node.specifiers[0], lastSpecifier = node.specifiers.at(-1);
+				if (lastSpecifier.type !== "ImportSpecifier") return;
+				firstSpecifier.type !== "ImportSpecifier" && (firstSpecifier = node.specifiers[1]);
+				let first = sourceCode.getTokenBefore(firstSpecifier), last = sourceCode.getTokenAfter(lastSpecifier, astUtils.isNotCommaToken);
+				validateBraceSpacing(node, first, sourceCode.getTokenAfter(first, { includeComments: !0 }), sourceCode.getTokenBefore(last, { includeComments: !0 }), last);
+			}
+			/**
+			* Reports a given export node if spacing in curly braces is invalid.
+			* @param {ASTNode} node An ExportNamedDeclaration node to check.
+			* @returns {void}
+			*/
+			function checkForExport(node) {
+				if (node.specifiers.length === 0) return;
+				let firstSpecifier = node.specifiers[0], lastSpecifier = node.specifiers.at(-1), first = sourceCode.getTokenBefore(firstSpecifier), last = sourceCode.getTokenAfter(lastSpecifier, astUtils.isNotCommaToken);
+				validateBraceSpacing(node, first, sourceCode.getTokenAfter(first, { includeComments: !0 }), sourceCode.getTokenBefore(last, { includeComments: !0 }), last);
+			}
+			return {
+				ObjectPattern: checkForObject,
+				ObjectExpression: checkForObject,
+				ImportDeclaration: checkForImport,
+				ExportNamedDeclaration: checkForExport
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/object-curly-spacing.cjs
+module.exports = require_object_curly_spacing().create;
+//#endregion

package/rules/object-property-newline.cjs

@@ -0,0 +1,81 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/object-property-newline.js
+/**
+* @fileoverview Rule to enforce placing object properties on separate lines.
+* @author Vitor Balocco
+* @deprecated in ESLint v8.53.0
+*/
+var require_object_property_newline = /* @__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: "object-property-newline",
+						url: "https://eslint.style/rules/object-property-newline"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce placing object properties on separate lines",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/object-property-newline"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					allowAllPropertiesOnSameLine: {
+						type: "boolean",
+						default: !1
+					},
+					allowMultiplePropertiesPerLine: {
+						type: "boolean",
+						default: !1
+					}
+				},
+				additionalProperties: !1
+			}],
+			fixable: "whitespace",
+			messages: {
+				propertiesOnNewlineAll: "Object properties must go on a new line if they aren't all on the same line.",
+				propertiesOnNewline: "Object properties must go on a new line."
+			}
+		},
+		create(context) {
+			let allowSameLine = context.options[0] && (context.options[0].allowAllPropertiesOnSameLine || context.options[0].allowMultiplePropertiesPerLine), messageId = allowSameLine ? "propertiesOnNewlineAll" : "propertiesOnNewline", sourceCode = context.sourceCode;
+			return { ObjectExpression(node) {
+				if (allowSameLine && node.properties.length > 1) {
+					let firstTokenOfFirstProperty = sourceCode.getFirstToken(node.properties[0]), lastTokenOfLastProperty = sourceCode.getLastToken(node.properties.at(-1));
+					if (firstTokenOfFirstProperty.loc.end.line === lastTokenOfLastProperty.loc.start.line) return;
+				}
+				for (let i = 1; i < node.properties.length; i++) {
+					let lastTokenOfPreviousProperty = sourceCode.getLastToken(node.properties[i - 1]), firstTokenOfCurrentProperty = sourceCode.getFirstToken(node.properties[i]);
+					lastTokenOfPreviousProperty.loc.end.line === firstTokenOfCurrentProperty.loc.start.line && context.report({
+						node,
+						loc: firstTokenOfCurrentProperty.loc,
+						messageId,
+						fix(fixer) {
+							let rangeAfterComma = [sourceCode.getTokenBefore(firstTokenOfCurrentProperty).range[1], firstTokenOfCurrentProperty.range[0]];
+							return sourceCode.text.slice(rangeAfterComma[0], rangeAfterComma[1]).trim() ? null : fixer.replaceTextRange(rangeAfterComma, "\n");
+						}
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/object-property-newline.cjs
+module.exports = require_object_property_newline().create;
+//#endregion

package/rules/object-shorthand.cjs

@@ -0,0 +1,284 @@
+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/object-shorthand.js
+/**
+* @fileoverview Rule to enforce concise object methods and properties.
+* @author Jamund Ferguson
+*/
+var require_object_shorthand = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let OPTIONS = {
+		always: "always",
+		never: "never",
+		methods: "methods",
+		properties: "properties",
+		consistent: "consistent",
+		consistentAsNeeded: "consistent-as-needed"
+	}, astUtils = require_ast_utils$1.t(), CTOR_PREFIX_REGEX = /[^_$0-9]/u, JSDOC_COMMENT_REGEX = /^\s*\*/u;
+	/**
+	* Determines if the first character of the name is a capital letter.
+	* @param {string} name The name of the node to evaluate.
+	* @returns {boolean} True if the first character of the property name is a capital letter, false if not.
+	* @private
+	*/
+	function isConstructor(name) {
+		let match = CTOR_PREFIX_REGEX.exec(name);
+		if (!match) return !1;
+		let firstChar = name.charAt(match.index);
+		return firstChar === firstChar.toUpperCase();
+	}
+	/**
+	* Determines if the property can have a shorthand form.
+	* @param {ASTNode} property Property AST node
+	* @returns {boolean} True if the property can have a shorthand form
+	* @private
+	*/
+	function canHaveShorthand(property) {
+		return property.kind !== "set" && property.kind !== "get" && property.type !== "SpreadElement" && property.type !== "SpreadProperty" && property.type !== "ExperimentalSpreadProperty";
+	}
+	/**
+	* Checks whether a node is a string literal.
+	* @param {ASTNode} node Any AST node.
+	* @returns {boolean} `true` if it is a string literal.
+	*/
+	function isStringLiteral(node) {
+		return node.type === "Literal" && typeof node.value == "string";
+	}
+	/**
+	* Determines if the property is a shorthand or not.
+	* @param {ASTNode} property Property AST node
+	* @returns {boolean} True if the property is considered shorthand, false if not.
+	* @private
+	*/
+	function isShorthand(property) {
+		return property.shorthand || property.method;
+	}
+	/**
+	* Determines if the property's key and method or value are named equally.
+	* @param {ASTNode} property Property AST node
+	* @returns {boolean} True if the key and value are named equally, false if not.
+	* @private
+	*/
+	function isRedundant(property) {
+		let value = property.value;
+		return value.type === "FunctionExpression" ? !value.id : value.type === "Identifier" ? astUtils.getStaticPropertyName(property) === value.name : !1;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require or disallow method and property shorthand syntax for object literals",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/object-shorthand"
+			},
+			fixable: "code",
+			schema: { anyOf: [
+				{
+					type: "array",
+					items: [{ enum: [
+						"always",
+						"methods",
+						"properties",
+						"never",
+						"consistent",
+						"consistent-as-needed"
+					] }],
+					minItems: 0,
+					maxItems: 1
+				},
+				{
+					type: "array",
+					items: [{ enum: [
+						"always",
+						"methods",
+						"properties"
+					] }, {
+						type: "object",
+						properties: { avoidQuotes: { type: "boolean" } },
+						additionalProperties: !1
+					}],
+					minItems: 0,
+					maxItems: 2
+				},
+				{
+					type: "array",
+					items: [{ enum: ["always", "methods"] }, {
+						type: "object",
+						properties: {
+							ignoreConstructors: { type: "boolean" },
+							methodsIgnorePattern: { type: "string" },
+							avoidQuotes: { type: "boolean" },
+							avoidExplicitReturnArrows: { type: "boolean" }
+						},
+						additionalProperties: !1
+					}],
+					minItems: 0,
+					maxItems: 2
+				}
+			] },
+			messages: {
+				expectedAllPropertiesShorthanded: "Expected shorthand for all properties.",
+				expectedLiteralMethodLongform: "Expected longform method syntax for string literal keys.",
+				expectedPropertyShorthand: "Expected property shorthand.",
+				expectedPropertyLongform: "Expected longform property syntax.",
+				expectedMethodShorthand: "Expected method shorthand.",
+				expectedMethodLongform: "Expected longform method syntax.",
+				unexpectedMix: "Unexpected mix of shorthand and non-shorthand properties."
+			}
+		},
+		create(context) {
+			let APPLY = context.options[0] || OPTIONS.always, APPLY_TO_METHODS = APPLY === OPTIONS.methods || APPLY === OPTIONS.always, APPLY_TO_PROPS = APPLY === OPTIONS.properties || APPLY === OPTIONS.always, APPLY_NEVER = APPLY === OPTIONS.never, APPLY_CONSISTENT = APPLY === OPTIONS.consistent, APPLY_CONSISTENT_AS_NEEDED = APPLY === OPTIONS.consistentAsNeeded, PARAMS = context.options[1] || {}, IGNORE_CONSTRUCTORS = PARAMS.ignoreConstructors, METHODS_IGNORE_PATTERN = PARAMS.methodsIgnorePattern ? new RegExp(PARAMS.methodsIgnorePattern, "u") : null, AVOID_QUOTES = PARAMS.avoidQuotes, AVOID_EXPLICIT_RETURN_ARROWS = !!PARAMS.avoidExplicitReturnArrows, sourceCode = context.sourceCode;
+			/**
+			* Ensures that an object's properties are consistently shorthand, or not shorthand at all.
+			* @param {ASTNode} node Property AST node
+			* @param {boolean} checkRedundancy Whether to check longform redundancy
+			* @returns {void}
+			*/
+			function checkConsistency(node, checkRedundancy) {
+				let properties = node.properties.filter(canHaveShorthand);
+				if (properties.length > 0) {
+					let shorthandProperties = properties.filter(isShorthand);
+					shorthandProperties.length !== properties.length && (shorthandProperties.length > 0 ? context.report({
+						node,
+						messageId: "unexpectedMix"
+					}) : checkRedundancy && properties.every(isRedundant) && context.report({
+						node,
+						messageId: "expectedAllPropertiesShorthanded"
+					}));
+				}
+			}
+			/**
+			* Fixes a FunctionExpression node by making it into a shorthand property.
+			* @param {SourceCodeFixer} fixer The fixer object
+			* @param {ASTNode} node A `Property` node that has a `FunctionExpression` or `ArrowFunctionExpression` as its value
+			* @returns {Object} A fix for this node
+			*/
+			function makeFunctionShorthand(fixer, node) {
+				let firstKeyToken = node.computed ? sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken) : sourceCode.getFirstToken(node.key), lastKeyToken = node.computed ? sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken) : sourceCode.getLastToken(node.key), keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]), keyPrefix = "";
+				if (sourceCode.commentsExistBetween(lastKeyToken, node.value)) return null;
+				node.value.async && (keyPrefix += "async "), node.value.generator && (keyPrefix += "*");
+				let fixRange = [firstKeyToken.range[0], node.range[1]], methodPrefix = keyPrefix + keyText;
+				if (node.value.type === "FunctionExpression") {
+					let functionToken = sourceCode.getTokens(node.value).find((token) => token.type === "Keyword" && token.value === "function"), tokenBeforeParams = node.value.generator ? sourceCode.getTokenAfter(functionToken) : functionToken;
+					return fixer.replaceTextRange(fixRange, methodPrefix + sourceCode.text.slice(tokenBeforeParams.range[1], node.value.range[1]));
+				}
+				let arrowToken = sourceCode.getTokenBefore(node.value.body, astUtils.isArrowToken), fnBody = sourceCode.text.slice(arrowToken.range[1], node.value.range[1]), sliceStart = sourceCode.getFirstToken(node.value, { skip: node.value.async ? 1 : 0 }).range[0], sliceEnd = sourceCode.getTokenBefore(arrowToken).range[1], shouldAddParens = node.value.params.length === 1 && node.value.params[0].range[0] === sliceStart, oldParamText = sourceCode.text.slice(sliceStart, sliceEnd), newParamText = shouldAddParens ? `(${oldParamText})` : oldParamText;
+				return fixer.replaceTextRange(fixRange, methodPrefix + newParamText + fnBody);
+			}
+			/**
+			* Fixes a FunctionExpression node by making it into a longform property.
+			* @param {SourceCodeFixer} fixer The fixer object
+			* @param {ASTNode} node A `Property` node that has a `FunctionExpression` as its value
+			* @returns {Object} A fix for this node
+			*/
+			function makeFunctionLongform(fixer, node) {
+				let firstKeyToken = node.computed ? sourceCode.getTokens(node).find((token) => token.value === "[") : sourceCode.getFirstToken(node.key), lastKeyToken = node.computed ? sourceCode.getTokensBetween(node.key, node.value).find((token) => token.value === "]") : sourceCode.getLastToken(node.key), keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]), functionHeader = "function";
+				return node.value.async && (functionHeader = `async ${functionHeader}`), node.value.generator && (functionHeader = `${functionHeader}*`), fixer.replaceTextRange([node.range[0], lastKeyToken.range[1]], `${keyText}: ${functionHeader}`);
+			}
+			let lexicalScopeStack = [], arrowsWithLexicalIdentifiers = /* @__PURE__ */ new WeakSet(), argumentsIdentifiers = /* @__PURE__ */ new WeakSet();
+			/**
+			* Enters a function. This creates a new lexical identifier scope, so a new Set of arrow functions is pushed onto the stack.
+			* Also, this marks all `arguments` identifiers so that they can be detected later.
+			* @param {ASTNode} node The node representing the function.
+			* @returns {void}
+			*/
+			function enterFunction(node) {
+				lexicalScopeStack.unshift(/* @__PURE__ */ new Set()), sourceCode.getScope(node).variables.filter((variable) => variable.name === "arguments").forEach((variable) => {
+					variable.references.map((ref) => ref.identifier).forEach((identifier) => argumentsIdentifiers.add(identifier));
+				});
+			}
+			/**
+			* Exits a function. This pops the current set of arrow functions off the lexical scope stack.
+			* @returns {void}
+			*/
+			function exitFunction() {
+				lexicalScopeStack.shift();
+			}
+			/**
+			* Marks the current function as having a lexical keyword. This implies that all arrow functions
+			* in the current lexical scope contain a reference to this lexical keyword.
+			* @returns {void}
+			*/
+			function reportLexicalIdentifier() {
+				lexicalScopeStack[0].forEach((arrowFunction) => arrowsWithLexicalIdentifiers.add(arrowFunction));
+			}
+			return {
+				Program: enterFunction,
+				FunctionDeclaration: enterFunction,
+				FunctionExpression: enterFunction,
+				"Program:exit": exitFunction,
+				"FunctionDeclaration:exit": exitFunction,
+				"FunctionExpression:exit": exitFunction,
+				ArrowFunctionExpression(node) {
+					lexicalScopeStack[0].add(node);
+				},
+				"ArrowFunctionExpression:exit"(node) {
+					lexicalScopeStack[0].delete(node);
+				},
+				ThisExpression: reportLexicalIdentifier,
+				Super: reportLexicalIdentifier,
+				MetaProperty(node) {
+					node.meta.name === "new" && node.property.name === "target" && reportLexicalIdentifier();
+				},
+				Identifier(node) {
+					argumentsIdentifiers.has(node) && reportLexicalIdentifier();
+				},
+				ObjectExpression(node) {
+					APPLY_CONSISTENT ? checkConsistency(node, !1) : APPLY_CONSISTENT_AS_NEEDED && checkConsistency(node, !0);
+				},
+				"Property:exit"(node) {
+					let isConciseProperty = node.method || node.shorthand;
+					if (node.parent.type !== "ObjectPattern" && !(node.kind === "get" || node.kind === "set") && !(node.computed && node.value.type !== "FunctionExpression" && node.value.type !== "ArrowFunctionExpression")) {
+						if (isConciseProperty) if (node.method && (APPLY_NEVER || AVOID_QUOTES && isStringLiteral(node.key))) {
+							let messageId = APPLY_NEVER ? "expectedMethodLongform" : "expectedLiteralMethodLongform";
+							context.report({
+								node,
+								messageId,
+								fix: (fixer) => makeFunctionLongform(fixer, node)
+							});
+						} else APPLY_NEVER && context.report({
+							node,
+							messageId: "expectedPropertyLongform",
+							fix: (fixer) => fixer.insertTextAfter(node.key, `: ${node.key.name}`)
+						});
+						else if (APPLY_TO_METHODS && !node.value.id && (node.value.type === "FunctionExpression" || node.value.type === "ArrowFunctionExpression")) {
+							if (IGNORE_CONSTRUCTORS && node.key.type === "Identifier" && isConstructor(node.key.name)) return;
+							if (METHODS_IGNORE_PATTERN) {
+								let propertyName = astUtils.getStaticPropertyName(node);
+								if (propertyName !== null && METHODS_IGNORE_PATTERN.test(propertyName)) return;
+							}
+							if (AVOID_QUOTES && isStringLiteral(node.key)) return;
+							(node.value.type === "FunctionExpression" || node.value.type === "ArrowFunctionExpression" && node.value.body.type === "BlockStatement" && AVOID_EXPLICIT_RETURN_ARROWS && !arrowsWithLexicalIdentifiers.has(node.value)) && context.report({
+								node,
+								messageId: "expectedMethodShorthand",
+								fix: (fixer) => makeFunctionShorthand(fixer, node)
+							});
+						} else if (node.value.type === "Identifier" && node.key.name === node.value.name && APPLY_TO_PROPS) {
+							if (sourceCode.getCommentsInside(node).some((comment) => comment.type === "Block" && JSDOC_COMMENT_REGEX.test(comment.value) && comment.value.includes("@type"))) return;
+							context.report({
+								node,
+								messageId: "expectedPropertyShorthand",
+								fix(fixer) {
+									return sourceCode.getCommentsInside(node).length > 0 ? null : fixer.replaceText(node, node.value.name);
+								}
+							});
+						} else if (node.value.type === "Identifier" && node.key.type === "Literal" && node.key.value === node.value.name && APPLY_TO_PROPS) {
+							if (AVOID_QUOTES || sourceCode.getCommentsInside(node).some((comment) => comment.type === "Block" && comment.value.startsWith("*") && comment.value.includes("@type"))) return;
+							context.report({
+								node,
+								messageId: "expectedPropertyShorthand",
+								fix(fixer) {
+									return sourceCode.getCommentsInside(node).length > 0 ? null : fixer.replaceText(node, node.value.name);
+								}
+							});
+						}
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/object-shorthand.cjs
+module.exports = require_object_shorthand().create;
+//#endregion

package/rules/one-var-declaration-per-line.cjs

@@ -0,0 +1,75 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/one-var-declaration-per-line.js
+/**
+* @fileoverview Rule to check multiple var declarations per line
+* @author Alberto Rodríguez
+* @deprecated in ESLint v8.53.0
+*/
+var require_one_var_declaration_per_line = /* @__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: "one-var-declaration-per-line",
+						url: "https://eslint.style/rules/one-var-declaration-per-line"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Require or disallow newlines around variable declarations",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/one-var-declaration-per-line"
+			},
+			schema: [{ enum: ["always", "initializations"] }],
+			fixable: "whitespace",
+			messages: { expectVarOnNewline: "Expected variable declaration to be on a new line." }
+		},
+		create(context) {
+			let always = context.options[0] === "always";
+			/**
+			* Determine if provided keyword is a variant of for specifiers
+			* @private
+			* @param {string} keyword keyword to test
+			* @returns {boolean} True if `keyword` is a variant of for specifier
+			*/
+			function isForTypeSpecifier(keyword) {
+				return keyword === "ForStatement" || keyword === "ForInStatement" || keyword === "ForOfStatement";
+			}
+			/**
+			* Checks newlines around variable declarations.
+			* @private
+			* @param {ASTNode} node `VariableDeclaration` node to test
+			* @returns {void}
+			*/
+			function checkForNewLine(node) {
+				if (isForTypeSpecifier(node.parent.type)) return;
+				let declarations = node.declarations, prev;
+				declarations.forEach((current) => {
+					prev && prev.loc.end.line === current.loc.start.line && (always || prev.init || current.init) && context.report({
+						node,
+						messageId: "expectVarOnNewline",
+						loc: current.loc,
+						fix: (fixer) => fixer.insertTextBefore(current, "\n")
+					}), prev = current;
+				});
+			}
+			return { VariableDeclaration: checkForNewLine };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/one-var-declaration-per-line.cjs
+module.exports = require_one_var_declaration_per_line().create;
+//#endregion