oxlint-plugin-eslint 1.52.0

package/rules/no-negated-in-lhs.cjs

@@ -0,0 +1,43 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-negated-in-lhs.js
+/**
+* @fileoverview A rule to disallow negated left operands of the `in` operator
+* @author Michael Ficarra
+* @deprecated in ESLint v3.3.0
+*/
+var require_no_negated_in_lhs = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow negating the left operand in `in` expressions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-negated-in-lhs"
+			},
+			deprecated: {
+				message: "Renamed rule.",
+				url: "https://eslint.org/blog/2016/08/eslint-v3.3.0-released/#deprecated-rules",
+				deprecatedSince: "3.3.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{ rule: {
+					name: "no-unsafe-negation",
+					url: "https://eslint.org/docs/rules/no-unsafe-negation"
+				} }]
+			},
+			schema: [],
+			messages: { negatedLHS: "The 'in' expression's left operand is negated." }
+		},
+		create(context) {
+			return { BinaryExpression(node) {
+				node.operator === "in" && node.left.type === "UnaryExpression" && node.left.operator === "!" && context.report({
+					node,
+					messageId: "negatedLHS"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-negated-in-lhs.cjs
+module.exports = require_no_negated_in_lhs().create;
+//#endregion

package/rules/no-nested-ternary.cjs

@@ -0,0 +1,33 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-nested-ternary.js
+/**
+* @fileoverview Rule to flag nested ternary expressions
+* @author Ian Christian Myers
+*/
+var require_no_nested_ternary = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow nested ternary expressions",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-nested-ternary"
+			},
+			schema: [],
+			messages: { noNestedTernary: "Do not nest ternary expressions." }
+		},
+		create(context) {
+			return { ConditionalExpression(node) {
+				(node.alternate.type === "ConditionalExpression" || node.consequent.type === "ConditionalExpression") && context.report({
+					node,
+					messageId: "noNestedTernary"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-nested-ternary.cjs
+module.exports = require_no_nested_ternary().create;
+//#endregion

package/rules/no-new-func.cjs

@@ -0,0 +1,50 @@
+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/no-new-func.js
+/**
+* @fileoverview Rule to flag when using new Function
+* @author Ilya Volodin
+*/
+var require_no_new_func = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), callMethods = new Set([
+		"apply",
+		"bind",
+		"call"
+	]);
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow `new` operators with the `Function` object",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-new-func"
+			},
+			schema: [],
+			messages: { noFunctionConstructor: "The Function constructor is eval." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { "Program:exit"(node) {
+				let variable = sourceCode.getScope(node).set.get("Function");
+				variable && variable.defs.length === 0 && variable.references.forEach((ref) => {
+					let idNode = ref.identifier, { parent } = idNode, evalNode;
+					if (parent) {
+						if (idNode === parent.callee && (parent.type === "NewExpression" || parent.type === "CallExpression")) evalNode = parent;
+						else if (parent.type === "MemberExpression" && idNode === parent.object && callMethods.has(astUtils.getStaticPropertyName(parent))) {
+							let maybeCallee = parent.parent.type === "ChainExpression" ? parent.parent : parent;
+							maybeCallee.parent.type === "CallExpression" && maybeCallee.parent.callee === maybeCallee && (evalNode = maybeCallee.parent);
+						}
+					}
+					evalNode && context.report({
+						node: evalNode,
+						messageId: "noFunctionConstructor"
+					});
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-new-func.cjs
+module.exports = require_no_new_func().create;
+//#endregion

package/rules/no-new-native-nonconstructor.cjs

@@ -0,0 +1,42 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-new-native-nonconstructor.js
+/**
+* @fileoverview Rule to disallow use of the new operator with global non-constructor functions
+* @author Sosuke Suzuki
+*/
+var require_no_new_native_nonconstructor = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let nonConstructorGlobalFunctionNames = ["Symbol", "BigInt"];
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow `new` operators with global non-constructor functions",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-new-native-nonconstructor"
+			},
+			schema: [],
+			messages: { noNewNonconstructor: "`{{name}}` cannot be called as a constructor." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { "Program:exit"(node) {
+				let globalScope = sourceCode.getScope(node);
+				for (let nonConstructorName of nonConstructorGlobalFunctionNames) {
+					let variable = globalScope.set.get(nonConstructorName);
+					variable && variable.defs.length === 0 && variable.references.forEach((ref) => {
+						let idNode = ref.identifier, parent = idNode.parent;
+						parent && parent.type === "NewExpression" && parent.callee === idNode && context.report({
+							node: idNode,
+							messageId: "noNewNonconstructor",
+							data: { name: nonConstructorName }
+						});
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-new-native-nonconstructor.cjs
+module.exports = require_no_new_native_nonconstructor().create;
+//#endregion

package/rules/no-new-object.cjs

@@ -0,0 +1,47 @@
+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/no-new-object.js
+/**
+* @fileoverview A rule to disallow calls to the Object constructor
+* @author Matt DuVall <http://www.mattduvall.com/>
+* @deprecated in ESLint v8.50.0
+*/
+var require_no_new_object = /* @__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: "Disallow `Object` constructors",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-new-object"
+			},
+			deprecated: {
+				message: "The new rule flags more situations where object literal syntax can be used, and it does not report a problem when the `Object` constructor is invoked with an argument.",
+				url: "https://eslint.org/blog/2023/09/eslint-v8.50.0-released/",
+				deprecatedSince: "8.50.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{ rule: {
+					name: "no-object-constructor",
+					url: "https://eslint.org/docs/rules/no-object-constructor"
+				} }]
+			},
+			schema: [],
+			messages: { preferLiteral: "The object literal notation {} is preferable." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { NewExpression(node) {
+				let variable = astUtils.getVariableByName(sourceCode.getScope(node), node.callee.name);
+				variable && variable.identifiers.length > 0 || node.callee.name === "Object" && context.report({
+					node,
+					messageId: "preferLiteral"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-new-object.cjs
+module.exports = require_no_new_object().create;
+//#endregion

package/rules/no-new-require.cjs

@@ -0,0 +1,50 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-new-require.js
+/**
+* @fileoverview Rule to disallow use of new operator with the `require` function
+* @author Wil Moore III
+* @deprecated in ESLint v7.0.0
+*/
+var require_no_new_require = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Node.js rules were moved out of ESLint core.",
+				url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
+				deprecatedSince: "7.0.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "eslint-plugin-n now maintains deprecated Node.js-related rules.",
+					plugin: {
+						name: "eslint-plugin-n",
+						url: "https://github.com/eslint-community/eslint-plugin-n"
+					},
+					rule: {
+						name: "no-new-require",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-new-require.md"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Disallow `new` operators with calls to `require`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-new-require"
+			},
+			schema: [],
+			messages: { noNewRequire: "Unexpected use of new with require." }
+		},
+		create(context) {
+			return { NewExpression(node) {
+				node.callee.type === "Identifier" && node.callee.name === "require" && context.report({
+					node,
+					messageId: "noNewRequire"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-new-require.cjs
+module.exports = require_no_new_require().create;
+//#endregion

package/rules/no-new-symbol.cjs

@@ -0,0 +1,48 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-new-symbol.js
+/**
+* @fileoverview Rule to disallow use of the new operator with the `Symbol` object
+* @author Alberto Rodríguez
+* @deprecated in ESLint v9.0.0
+*/
+var require_no_new_symbol = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow `new` operators with the `Symbol` object",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-new-symbol"
+			},
+			deprecated: {
+				message: "The rule was replaced with a more general rule.",
+				url: "https://eslint.org/docs/latest/use/migrate-to-9.0.0#eslint-recommended",
+				deprecatedSince: "9.0.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{ rule: {
+					name: "no-new-native-nonconstructor",
+					url: "https://eslint.org/docs/latest/rules/no-new-native-nonconstructor"
+				} }]
+			},
+			schema: [],
+			messages: { noNewSymbol: "`Symbol` cannot be called as a constructor." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { "Program:exit"(node) {
+				let variable = sourceCode.getScope(node).set.get("Symbol");
+				variable && variable.defs.length === 0 && variable.references.forEach((ref) => {
+					let idNode = ref.identifier, parent = idNode.parent;
+					parent && parent.type === "NewExpression" && parent.callee === idNode && context.report({
+						node: idNode,
+						messageId: "noNewSymbol"
+					});
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-new-symbol.cjs
+module.exports = require_no_new_symbol().create;
+//#endregion

package/rules/no-new-wrappers.cjs

@@ -0,0 +1,44 @@
+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/no-new-wrappers.js
+/**
+* @fileoverview Rule to flag when using constructor for wrapper objects
+* @author Ilya Volodin
+*/
+var require_no_new_wrappers = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { getVariableByName } = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow `new` operators with the `String`, `Number`, and `Boolean` objects",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-new-wrappers"
+			},
+			schema: [],
+			messages: { noConstructor: "Do not use {{fn}} as a constructor." }
+		},
+		create(context) {
+			let { sourceCode } = context;
+			return { NewExpression(node) {
+				let wrapperObjects = [
+					"String",
+					"Number",
+					"Boolean"
+				], { name } = node.callee;
+				if (wrapperObjects.includes(name)) {
+					let variable = getVariableByName(sourceCode.getScope(node), name);
+					variable && variable.identifiers.length === 0 && context.report({
+						node,
+						messageId: "noConstructor",
+						data: { fn: name }
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-new-wrappers.cjs
+module.exports = require_no_new_wrappers().create;
+//#endregion

package/rules/no-new.cjs

@@ -0,0 +1,33 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-new.js
+/**
+* @fileoverview Rule to flag statements with function invocation preceded by
+* "new" and not part of assignment
+* @author Ilya Volodin
+*/
+var require_no_new = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow `new` operators outside of assignments or comparisons",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-new"
+			},
+			schema: [],
+			messages: { noNewStatement: "Do not use 'new' for side effects." }
+		},
+		create(context) {
+			return { "ExpressionStatement > NewExpression"(node) {
+				context.report({
+					node: node.parent,
+					messageId: "noNewStatement"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-new.cjs
+module.exports = require_no_new().create;
+//#endregion

package/rules/no-nonoctal-decimal-escape.cjs

@@ -0,0 +1,80 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-nonoctal-decimal-escape.js
+/**
+* @fileoverview Rule to disallow `\8` and `\9` escape sequences in string literals.
+* @author Milos Djermanovic
+*/
+var require_no_nonoctal_decimal_escape = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/**
+	* @import { SourceRange } from "@eslint/core";
+	*/
+	let QUICK_TEST_REGEX = /\\[89]/u;
+	/**
+	* Returns unicode escape sequence that represents the given character.
+	* @param {string} character A single code unit.
+	* @returns {string} "\uXXXX" sequence.
+	*/
+	function getUnicodeEscape(character) {
+		return `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow `\\8` and `\\9` escape sequences in string literals",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-nonoctal-decimal-escape"
+			},
+			hasSuggestions: !0,
+			schema: [],
+			messages: {
+				decimalEscape: "Don't use '{{decimalEscape}}' escape sequence.",
+				refactor: "Replace '{{original}}' with '{{replacement}}'. This maintains the current functionality.",
+				escapeBackslash: "Replace '{{original}}' with '{{replacement}}' to include the actual backslash character."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Creates a new Suggestion object.
+			* @param {string} messageId "refactor" or "escapeBackslash".
+			* @param {SourceRange} range The range to replace.
+			* @param {string} replacement New text for the range.
+			* @returns {Object} Suggestion
+			*/
+			function createSuggestion(messageId, range, replacement) {
+				return {
+					messageId,
+					data: {
+						original: sourceCode.getText().slice(...range),
+						replacement
+					},
+					fix(fixer) {
+						return fixer.replaceTextRange(range, replacement);
+					}
+				};
+			}
+			return { Literal(node) {
+				if (typeof node.value != "string" || !QUICK_TEST_REGEX.test(node.raw)) return;
+				let regex = /(?:[^\\]|(?<previousEscape>\\.))*?(?<decimalEscape>\\[89])/suy, match;
+				for (; match = regex.exec(node.raw);) {
+					let { previousEscape, decimalEscape } = match.groups, decimalEscapeRangeEnd = node.range[0] + match.index + match[0].length, decimalEscapeRangeStart = decimalEscapeRangeEnd - decimalEscape.length, decimalEscapeRange = [decimalEscapeRangeStart, decimalEscapeRangeEnd], suggest = [];
+					previousEscape === "\\0" ? suggest.push(createSuggestion("refactor", [decimalEscapeRangeStart - previousEscape.length, decimalEscapeRangeEnd], `${getUnicodeEscape("\0")}${decimalEscape[1]}`), createSuggestion("refactor", decimalEscapeRange, getUnicodeEscape(decimalEscape[1]))) : suggest.push(createSuggestion("refactor", decimalEscapeRange, decimalEscape[1])), suggest.push(createSuggestion("escapeBackslash", decimalEscapeRange, `\\${decimalEscape}`)), context.report({
+						node,
+						loc: {
+							start: sourceCode.getLocFromIndex(decimalEscapeRangeStart),
+							end: sourceCode.getLocFromIndex(decimalEscapeRangeEnd)
+						},
+						messageId: "decimalEscape",
+						data: { decimalEscape },
+						suggest
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-nonoctal-decimal-escape.cjs
+module.exports = require_no_nonoctal_decimal_escape().create;
+//#endregion

package/rules/no-obj-calls.cjs

@@ -0,0 +1,64 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.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/no-obj-calls.js
+/**
+* @fileoverview Rule to flag use of an object property of the global object (Math and JSON) as a function
+* @author James Allardice
+*/
+var require_no_obj_calls = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { CALL, CONSTRUCT, ReferenceTracker } = require_eslint_utils$1.t(), getPropertyName = require_ast_utils$1.t().getStaticPropertyName, nonCallableGlobals = [
+		"Atomics",
+		"JSON",
+		"Math",
+		"Reflect",
+		"Intl"
+	];
+	/**
+	* Returns the name of the node to report
+	* @param {ASTNode} node A node to report
+	* @returns {string} name to report
+	*/
+	function getReportNodeName(node) {
+		return node.type === "ChainExpression" ? getReportNodeName(node.expression) : node.type === "MemberExpression" ? getPropertyName(node) : node.name;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow calling global object properties as functions",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-obj-calls"
+			},
+			schema: [],
+			messages: {
+				unexpectedCall: "'{{name}}' is not a function.",
+				unexpectedRefCall: "'{{name}}' is reference to '{{ref}}', which is not a function."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { Program(node) {
+				let tracker = new ReferenceTracker(sourceCode.getScope(node)), traceMap = {};
+				for (let g of nonCallableGlobals) traceMap[g] = {
+					[CALL]: !0,
+					[CONSTRUCT]: !0
+				};
+				for (let { node: refNode, path } of tracker.iterateGlobalReferences(traceMap)) {
+					let name = getReportNodeName(refNode.callee), ref = path[0], messageId = name === ref ? "unexpectedCall" : "unexpectedRefCall";
+					context.report({
+						node: refNode,
+						messageId,
+						data: {
+							name,
+							ref
+						}
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-obj-calls.cjs
+module.exports = require_no_obj_calls().create;
+//#endregion

package/rules/no-object-constructor.cjs

@@ -0,0 +1,69 @@
+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/no-object-constructor.js
+/**
+* @fileoverview Rule to disallow calls to the `Object` constructor without an argument
+* @author Francesco Trotta
+*/
+var require_no_object_constructor = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { getVariableByName, isArrowToken, isStartOfExpressionStatement, needsPrecedingSemicolon } = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow calls to the `Object` constructor without an argument",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-object-constructor"
+			},
+			hasSuggestions: !0,
+			schema: [],
+			messages: {
+				preferLiteral: "The object literal notation {} is preferable.",
+				useLiteral: "Replace with '{{replacement}}'.",
+				useLiteralAfterSemicolon: "Replace with '{{replacement}}', add preceding semicolon."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Determines whether or not an object literal that replaces a specified node needs to be enclosed in parentheses.
+			* @param {ASTNode} node The node to be replaced.
+			* @returns {boolean} Whether or not parentheses around the object literal are required.
+			*/
+			function needsParentheses(node) {
+				if (isStartOfExpressionStatement(node)) return !0;
+				let prevToken = sourceCode.getTokenBefore(node);
+				return !!(prevToken && isArrowToken(prevToken));
+			}
+			/**
+			* Reports on nodes where the `Object` constructor is called without arguments.
+			* @param {ASTNode} node The node to evaluate.
+			* @returns {void}
+			*/
+			function check(node) {
+				if (node.callee.type !== "Identifier" || node.callee.name !== "Object" || node.arguments.length) return;
+				let variable = getVariableByName(sourceCode.getScope(node), "Object");
+				if (variable && variable.identifiers.length === 0) {
+					let replacement, fixText, messageId = "useLiteral";
+					needsParentheses(node) ? (replacement = "({})", needsPrecedingSemicolon(sourceCode, node) ? (fixText = ";({})", messageId = "useLiteralAfterSemicolon") : fixText = "({})") : replacement = fixText = "{}", context.report({
+						node,
+						messageId: "preferLiteral",
+						suggest: [{
+							messageId,
+							data: { replacement },
+							fix: (fixer) => fixer.replaceText(node, fixText)
+						}]
+					});
+				}
+			}
+			return {
+				CallExpression: check,
+				NewExpression: check
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-object-constructor.cjs
+module.exports = require_no_object_constructor().create;
+//#endregion

package/rules/no-octal-escape.cjs

@@ -0,0 +1,35 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-octal-escape.js
+/**
+* @fileoverview Rule to flag octal escape sequences in string literals.
+* @author Ian Christian Myers
+*/
+var require_no_octal_escape = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow octal escape sequences in string literals",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-octal-escape"
+			},
+			schema: [],
+			messages: { octalEscapeSequence: "Don't use octal: '\\{{sequence}}'. Use '\\u....' instead." }
+		},
+		create(context) {
+			return { Literal(node) {
+				if (typeof node.value != "string") return;
+				let match = node.raw.match(/^(?:[^\\]|\\.)*?\\([0-3][0-7]{1,2}|[4-7][0-7]|0(?=[89])|[1-7])/su);
+				match && context.report({
+					node,
+					messageId: "octalEscapeSequence",
+					data: { sequence: match[1] }
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-octal-escape.cjs
+module.exports = require_no_octal_escape().create;
+//#endregion