oxlint-plugin-eslint 1.52.0

package/rules/prefer-reflect.cjs

@@ -0,0 +1,100 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/prefer-reflect.js
+/**
+* @fileoverview Rule to suggest using "Reflect" api over Function/Object methods
+* @author Keith Cirkel <http://keithcirkel.co.uk>
+* @deprecated in ESLint v3.9.0
+*/
+var require_prefer_reflect = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require `Reflect` methods where applicable",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/prefer-reflect"
+			},
+			deprecated: {
+				message: "The original intention of this rule was misguided.",
+				deprecatedSince: "3.9.0",
+				availableUntil: null,
+				replacedBy: []
+			},
+			schema: [{
+				type: "object",
+				properties: { exceptions: {
+					type: "array",
+					items: { enum: [
+						"apply",
+						"call",
+						"delete",
+						"defineProperty",
+						"getOwnPropertyDescriptor",
+						"getPrototypeOf",
+						"setPrototypeOf",
+						"isExtensible",
+						"getOwnPropertyNames",
+						"preventExtensions"
+					] },
+					uniqueItems: !0
+				} },
+				additionalProperties: !1
+			}],
+			messages: { preferReflect: "Avoid using {{existing}}, instead use {{substitute}}." }
+		},
+		create(context) {
+			let existingNames = {
+				apply: "Function.prototype.apply",
+				call: "Function.prototype.call",
+				defineProperty: "Object.defineProperty",
+				getOwnPropertyDescriptor: "Object.getOwnPropertyDescriptor",
+				getPrototypeOf: "Object.getPrototypeOf",
+				setPrototypeOf: "Object.setPrototypeOf",
+				isExtensible: "Object.isExtensible",
+				getOwnPropertyNames: "Object.getOwnPropertyNames",
+				preventExtensions: "Object.preventExtensions"
+			}, reflectSubstitutes = {
+				apply: "Reflect.apply",
+				call: "Reflect.apply",
+				defineProperty: "Reflect.defineProperty",
+				getOwnPropertyDescriptor: "Reflect.getOwnPropertyDescriptor",
+				getPrototypeOf: "Reflect.getPrototypeOf",
+				setPrototypeOf: "Reflect.setPrototypeOf",
+				isExtensible: "Reflect.isExtensible",
+				getOwnPropertyNames: "Reflect.getOwnPropertyNames",
+				preventExtensions: "Reflect.preventExtensions"
+			}, exceptions = (context.options[0] || {}).exceptions || [];
+			/**
+			* Reports the Reflect violation based on the `existing` and `substitute`
+			* @param {Object} node The node that violates the rule.
+			* @param {string} existing The existing method name that has been used.
+			* @param {string} substitute The Reflect substitute that should be used.
+			* @returns {void}
+			*/
+			function report(node, existing, substitute) {
+				context.report({
+					node,
+					messageId: "preferReflect",
+					data: {
+						existing,
+						substitute
+					}
+				});
+			}
+			return {
+				CallExpression(node) {
+					let methodName = (node.callee.property || {}).name, isReflectCall = (node.callee.object || {}).name === "Reflect", hasReflectSubstitute = Object.hasOwn(reflectSubstitutes, methodName), userConfiguredException = exceptions.includes(methodName);
+					hasReflectSubstitute && !isReflectCall && !userConfiguredException && report(node, existingNames[methodName], reflectSubstitutes[methodName]);
+				},
+				UnaryExpression(node) {
+					let isDeleteOperator = node.operator === "delete", targetsIdentifier = node.argument.type === "Identifier", userConfiguredException = exceptions.includes("delete");
+					isDeleteOperator && !targetsIdentifier && !userConfiguredException && report(node, "the delete keyword", "Reflect.deleteProperty");
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-reflect.cjs
+module.exports = require_prefer_reflect().create;
+//#endregion

package/rules/prefer-regex-literals.cjs

@@ -0,0 +1,256 @@
+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"), require_regexpp$1 = require("../common/regexpp.cjs"), require_regular_expressions$1 = require("../common/regular-expressions.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/prefer-regex-literals.js
+/**
+* @fileoverview Rule to disallow use of the `RegExp` constructor in favor of regular expression literals
+* @author Milos Djermanovic
+*/
+var require_prefer_regex_literals = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), { CALL, CONSTRUCT, ReferenceTracker } = require_eslint_utils$1.t(), { RegExpValidator, visitRegExpAST, RegExpParser } = require_regexpp$1.t(), { canTokensBeAdjacent } = require_ast_utils$1.t(), { REGEXPP_LATEST_ECMA_VERSION } = require_regular_expressions$1.t();
+	/**
+	* Determines whether the given node is a string literal.
+	* @param {ASTNode} node Node to check.
+	* @returns {boolean} True if the node is a string literal.
+	*/
+	function isStringLiteral(node) {
+		return node.type === "Literal" && typeof node.value == "string";
+	}
+	/**
+	* Determines whether the given node is a regex literal.
+	* @param {ASTNode} node Node to check.
+	* @returns {boolean} True if the node is a regex literal.
+	*/
+	function isRegexLiteral(node) {
+		return node.type === "Literal" && Object.hasOwn(node, "regex");
+	}
+	let validPrecedingTokens = new Set(/* @__PURE__ */ "();)[),)=)+)*)-)?)~)%)**)!)typeof)instanceof)&&)||)??)return)...)delete)void)in)<)>)<=)>=)==)===)!=)!==)<<)>>)>>>)&)|)^):){)=>)*=)<<=)>>=)>>>=)^=)|=)&=)??=)||=)&&=)**=)+=)-=)/=)%=)/)do)break)continue)debugger)case)throw".split(")"));
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ disallowRedundantWrapping: !1 }],
+			docs: {
+				description: "Disallow use of the `RegExp` constructor in favor of regular expression literals",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/prefer-regex-literals"
+			},
+			hasSuggestions: !0,
+			schema: [{
+				type: "object",
+				properties: { disallowRedundantWrapping: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: {
+				unexpectedRegExp: "Use a regular expression literal instead of the 'RegExp' constructor.",
+				replaceWithLiteral: "Replace with an equivalent regular expression literal.",
+				replaceWithLiteralAndFlags: "Replace with an equivalent regular expression literal with flags '{{ flags }}'.",
+				replaceWithIntendedLiteralAndFlags: "Replace with a regular expression literal with flags '{{ flags }}'.",
+				unexpectedRedundantRegExp: "Regular expression literal is unnecessarily wrapped within a 'RegExp' constructor.",
+				unexpectedRedundantRegExpWithFlags: "Use regular expression literal with flags instead of the 'RegExp' constructor."
+			}
+		},
+		create(context) {
+			let [{ disallowRedundantWrapping }] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Determines whether the given node is a String.raw`` tagged template expression
+			* with a static template literal.
+			* @param {ASTNode} node Node to check.
+			* @returns {boolean} True if the node is String.raw`` with a static template.
+			*/
+			function isStringRawTaggedStaticTemplateLiteral(node) {
+				return node.type === "TaggedTemplateExpression" && astUtils.isSpecificMemberAccess(node.tag, "String", "raw") && sourceCode.isGlobalReference(astUtils.skipChainExpression(node.tag).object) && astUtils.isStaticTemplateLiteral(node.quasi);
+			}
+			/**
+			* Gets the value of a string
+			* @param {ASTNode} node The node to get the string of.
+			* @returns {string|null} The value of the node.
+			*/
+			function getStringValue(node) {
+				return isStringLiteral(node) ? node.value : astUtils.isStaticTemplateLiteral(node) ? node.quasis[0].value.cooked : isStringRawTaggedStaticTemplateLiteral(node) ? node.quasi.quasis[0].value.raw : null;
+			}
+			/**
+			* Determines whether the given node is considered to be a static string by the logic of this rule.
+			* @param {ASTNode} node Node to check.
+			* @returns {boolean} True if the node is a static string.
+			*/
+			function isStaticString(node) {
+				return isStringLiteral(node) || astUtils.isStaticTemplateLiteral(node) || isStringRawTaggedStaticTemplateLiteral(node);
+			}
+			/**
+			* Determines whether the relevant arguments of the given are all static string literals.
+			* @param {ASTNode} node Node to check.
+			* @returns {boolean} True if all arguments are static strings.
+			*/
+			function hasOnlyStaticStringArguments(node) {
+				let args = node.arguments;
+				return !!((args.length === 1 || args.length === 2) && args.every(isStaticString));
+			}
+			/**
+			* Determines whether the arguments of the given node indicate that a regex literal is unnecessarily wrapped.
+			* @param {ASTNode} node Node to check.
+			* @returns {boolean} True if the node already contains a regex literal argument.
+			*/
+			function isUnnecessarilyWrappedRegexLiteral(node) {
+				let args = node.arguments;
+				return !!(args.length === 1 && isRegexLiteral(args[0]) || args.length === 2 && isRegexLiteral(args[0]) && isStaticString(args[1]));
+			}
+			/**
+			* Returns a ecmaVersion compatible for regexpp.
+			* @param {number} ecmaVersion The ecmaVersion to convert.
+			* @returns {import("@eslint-community/regexpp/ecma-versions").EcmaVersion} The resulting ecmaVersion compatible for regexpp.
+			*/
+			function getRegexppEcmaVersion(ecmaVersion) {
+				return ecmaVersion <= 5 ? 5 : Math.min(ecmaVersion, REGEXPP_LATEST_ECMA_VERSION);
+			}
+			let regexppEcmaVersion = getRegexppEcmaVersion(context.languageOptions.ecmaVersion);
+			/**
+			* Makes a character escaped or else returns null.
+			* @param {string} character The character to escape.
+			* @returns {string} The resulting escaped character.
+			*/
+			function resolveEscapes(character) {
+				switch (character) {
+					case "\n":
+					case "\\\n": return "\\n";
+					case "\r":
+					case "\\\r": return "\\r";
+					case "	":
+					case "\\	": return "\\t";
+					case "\v":
+					case "\\\v": return "\\v";
+					case "\f":
+					case "\\\f": return "\\f";
+					case "/": return "\\/";
+					default: return null;
+				}
+			}
+			/**
+			* Checks whether the given regex and flags are valid for the ecma version or not.
+			* @param {string} pattern The regex pattern to check.
+			* @param {string | undefined} flags The regex flags to check.
+			* @returns {boolean} True if the given regex pattern and flags are valid for the ecma version.
+			*/
+			function isValidRegexForEcmaVersion(pattern, flags) {
+				let validator = new RegExpValidator({ ecmaVersion: regexppEcmaVersion });
+				try {
+					return validator.validatePattern(pattern, 0, pattern.length, {
+						unicode: flags ? flags.includes("u") : !1,
+						unicodeSets: flags ? flags.includes("v") : !1
+					}), flags && validator.validateFlags(flags), !0;
+				} catch {
+					return !1;
+				}
+			}
+			/**
+			* Checks whether two given regex flags contain the same flags or not.
+			* @param {string} flagsA The regex flags.
+			* @param {string} flagsB The regex flags.
+			* @returns {boolean} True if two regex flags contain same flags.
+			*/
+			function areFlagsEqual(flagsA, flagsB) {
+				return [...flagsA].sort().join("") === [...flagsB].sort().join("");
+			}
+			/**
+			* Merges two regex flags.
+			* @param {string} flagsA The regex flags.
+			* @param {string} flagsB The regex flags.
+			* @returns {string} The merged regex flags.
+			*/
+			function mergeRegexFlags(flagsA, flagsB) {
+				return [...new Set([...flagsA, ...flagsB])].join("");
+			}
+			/**
+			* Checks whether a give node can be fixed to the given regex pattern and flags.
+			* @param {ASTNode} node The node to check.
+			* @param {string} pattern The regex pattern to check.
+			* @param {string} flags The regex flags
+			* @returns {boolean} True if a node can be fixed to the given regex pattern and flags.
+			*/
+			function canFixTo(node, pattern, flags) {
+				let tokenBefore = sourceCode.getTokenBefore(node);
+				return sourceCode.getCommentsInside(node).length === 0 && (!tokenBefore || validPrecedingTokens.has(tokenBefore.value)) && isValidRegexForEcmaVersion(pattern, flags);
+			}
+			/**
+			* Returns a safe output code considering the before and after tokens.
+			* @param {ASTNode} node The regex node.
+			* @param {string} newRegExpValue The new regex expression value.
+			* @returns {string} The output code.
+			*/
+			function getSafeOutput(node, newRegExpValue) {
+				let tokenBefore = sourceCode.getTokenBefore(node), tokenAfter = sourceCode.getTokenAfter(node);
+				return (tokenBefore && !canTokensBeAdjacent(tokenBefore, newRegExpValue) && tokenBefore.range[1] === node.range[0] ? " " : "") + newRegExpValue + (tokenAfter && !canTokensBeAdjacent(newRegExpValue, tokenAfter) && node.range[1] === tokenAfter.range[0] ? " " : "");
+			}
+			return { Program(node) {
+				let tracker = new ReferenceTracker(sourceCode.getScope(node)), traceMap = { RegExp: {
+					[CALL]: !0,
+					[CONSTRUCT]: !0
+				} };
+				for (let { node: refNode } of tracker.iterateGlobalReferences(traceMap)) if (disallowRedundantWrapping && isUnnecessarilyWrappedRegexLiteral(refNode)) {
+					let regexNode = refNode.arguments[0];
+					if (refNode.arguments.length === 2) {
+						let suggests = [], argFlags = getStringValue(refNode.arguments[1]) || "";
+						canFixTo(refNode, regexNode.regex.pattern, argFlags) && suggests.push({
+							messageId: "replaceWithLiteralAndFlags",
+							pattern: regexNode.regex.pattern,
+							flags: argFlags
+						});
+						let mergedFlags = mergeRegexFlags(regexNode.regex.flags || "", argFlags);
+						!areFlagsEqual(mergedFlags, argFlags) && canFixTo(refNode, regexNode.regex.pattern, mergedFlags) && suggests.push({
+							messageId: "replaceWithIntendedLiteralAndFlags",
+							pattern: regexNode.regex.pattern,
+							flags: mergedFlags
+						}), context.report({
+							node: refNode,
+							messageId: "unexpectedRedundantRegExpWithFlags",
+							suggest: suggests.map(({ flags, pattern, messageId }) => ({
+								messageId,
+								data: { flags },
+								fix(fixer) {
+									return fixer.replaceText(refNode, getSafeOutput(refNode, `/${pattern}/${flags}`));
+								}
+							}))
+						});
+					} else {
+						let outputs = [];
+						canFixTo(refNode, regexNode.regex.pattern, regexNode.regex.flags) && outputs.push(sourceCode.getText(regexNode)), context.report({
+							node: refNode,
+							messageId: "unexpectedRedundantRegExp",
+							suggest: outputs.map((output) => ({
+								messageId: "replaceWithLiteral",
+								fix(fixer) {
+									return fixer.replaceText(refNode, getSafeOutput(refNode, output));
+								}
+							}))
+						});
+					}
+				} else if (hasOnlyStaticStringArguments(refNode)) {
+					let regexContent = getStringValue(refNode.arguments[0]), noFix = !1, flags;
+					if (refNode.arguments[1] && (flags = getStringValue(refNode.arguments[1])), canFixTo(refNode, regexContent, flags) || (noFix = !0), /^[-\w\\[\](){} \t\r\n\v\f!@#$%^&*+=/~`.><?,'"|:;]*$/u.test(regexContent) || (noFix = !0), regexContent && !noFix) {
+						let charIncrease = 0;
+						visitRegExpAST(new RegExpParser({ ecmaVersion: regexppEcmaVersion }).parsePattern(regexContent, 0, regexContent.length, {
+							unicode: flags ? flags.includes("u") : !1,
+							unicodeSets: flags ? flags.includes("v") : !1
+						}), { onCharacterEnter(characterNode) {
+							let escaped = resolveEscapes(characterNode.raw);
+							escaped && (regexContent = regexContent.slice(0, characterNode.start + charIncrease) + escaped + regexContent.slice(characterNode.end + charIncrease), characterNode.raw.length === 1 && (charIncrease += 1));
+						} });
+					}
+					let newRegExpValue = `/${regexContent || "(?:)"}/${flags || ""}`;
+					context.report({
+						node: refNode,
+						messageId: "unexpectedRegExp",
+						suggest: noFix ? [] : [{
+							messageId: "replaceWithLiteral",
+							fix(fixer) {
+								return fixer.replaceText(refNode, getSafeOutput(refNode, newRegExpValue));
+							}
+						}]
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-regex-literals.cjs
+module.exports = require_prefer_regex_literals().create;
+//#endregion

package/rules/prefer-rest-params.cjs

@@ -0,0 +1,80 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/prefer-rest-params.js
+/**
+* @fileoverview Rule to
+* @author Toru Nagashima
+*/
+var require_prefer_rest_params = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/**
+	* Gets the variable object of `arguments` which is defined implicitly.
+	* @param {eslint-scope.Scope} scope A scope to get.
+	* @returns {eslint-scope.Variable} The found variable object.
+	*/
+	function getVariableOfArguments(scope) {
+		let variables = scope.variables;
+		for (let i = 0; i < variables.length; ++i) {
+			let variable = variables[i];
+			if (variable.name === "arguments") return variable.identifiers.length === 0 ? variable : null;
+		}
+		/* c8 ignore next */
+		return null;
+	}
+	/**
+	* Checks if the given reference is not normal member access.
+	*
+	* - arguments         .... true    // not member access
+	* - arguments[i]      .... true    // computed member access
+	* - arguments[0]      .... true    // computed member access
+	* - arguments.length  .... false   // normal member access
+	* @param {eslint-scope.Reference} reference The reference to check.
+	* @returns {boolean} `true` if the reference is not normal member access.
+	*/
+	function isNotNormalMemberAccess(reference) {
+		let id = reference.identifier, parent = id.parent;
+		return !(parent.type === "MemberExpression" && parent.object === id && !parent.computed);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require rest parameters instead of `arguments`",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/prefer-rest-params"
+			},
+			schema: [],
+			messages: { preferRestParams: "Use the rest parameters instead of 'arguments'." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Reports a given reference.
+			* @param {eslint-scope.Reference} reference A reference to report.
+			* @returns {void}
+			*/
+			function report(reference) {
+				context.report({
+					node: reference.identifier,
+					loc: reference.identifier.loc,
+					messageId: "preferRestParams"
+				});
+			}
+			/**
+			* Reports references of the implicit `arguments` variable if exist.
+			* @param {ASTNode} node The node representing the function.
+			* @returns {void}
+			*/
+			function checkForArguments(node) {
+				let argumentsVar = getVariableOfArguments(sourceCode.getScope(node));
+				argumentsVar && argumentsVar.references.filter(isNotNormalMemberAccess).forEach(report);
+			}
+			return {
+				"FunctionDeclaration:exit": checkForArguments,
+				"FunctionExpression:exit": checkForArguments
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-rest-params.cjs
+module.exports = require_prefer_rest_params().create;
+//#endregion

package/rules/prefer-spread.cjs

@@ -0,0 +1,57 @@
+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/prefer-spread.js
+/**
+* @fileoverview A rule to suggest using of the spread operator instead of `.apply()`.
+* @author Toru Nagashima
+*/
+var require_prefer_spread = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether or not a node is a `.apply()` for variadic.
+	* @param {ASTNode} node A CallExpression node to check.
+	* @returns {boolean} Whether or not the node is a `.apply()` for variadic.
+	*/
+	function isVariadicApplyCalling(node) {
+		return astUtils.isSpecificMemberAccess(node.callee, null, "apply") && node.arguments.length === 2 && node.arguments[1].type !== "ArrayExpression" && node.arguments[1].type !== "SpreadElement";
+	}
+	/**
+	* Checks whether or not `thisArg` is not changed by `.apply()`.
+	* @param {ASTNode|null} expectedThis The node that is the owner of the applied function.
+	* @param {ASTNode} thisArg The node that is given to the first argument of the `.apply()`.
+	* @param {RuleContext} context The ESLint rule context object.
+	* @returns {boolean} Whether or not `thisArg` is not changed by `.apply()`.
+	*/
+	function isValidThisArg(expectedThis, thisArg, context) {
+		return expectedThis ? astUtils.equalTokens(expectedThis, thisArg, context) : astUtils.isNullOrUndefined(thisArg);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require spread operators instead of `.apply()`",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/prefer-spread"
+			},
+			schema: [],
+			fixable: null,
+			messages: { preferSpread: "Use the spread operator instead of '.apply()'." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { CallExpression(node) {
+				if (!isVariadicApplyCalling(node)) return;
+				let applied = astUtils.skipChainExpression(astUtils.skipChainExpression(node.callee).object), expectedThis = applied.type === "MemberExpression" ? applied.object : null, thisArg = node.arguments[0];
+				isValidThisArg(expectedThis, thisArg, sourceCode) && context.report({
+					node,
+					messageId: "preferSpread"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-spread.cjs
+module.exports = require_prefer_spread().create;
+//#endregion

package/rules/prefer-template.cjs

@@ -0,0 +1,147 @@
+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/prefer-template.js
+/**
+* @fileoverview A rule to suggest using template literals instead of string concatenation.
+* @author Toru Nagashima
+*/
+var require_prefer_template = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether or not a given node is a concatenation.
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if the node is a concatenation.
+	*/
+	function isConcatenation(node) {
+		return node.type === "BinaryExpression" && node.operator === "+";
+	}
+	/**
+	* Gets the top binary expression node for concatenation in parents of a given node.
+	* @param {ASTNode} node A node to get.
+	* @returns {ASTNode} the top binary expression node in parents of a given node.
+	*/
+	function getTopConcatBinaryExpression(node) {
+		let currentNode = node;
+		for (; isConcatenation(currentNode.parent);) currentNode = currentNode.parent;
+		return currentNode;
+	}
+	/**
+	* Checks whether or not a node contains a string literal with an octal or non-octal decimal escape sequence
+	* @param {ASTNode} node A node to check
+	* @returns {boolean} `true` if at least one string literal within the node contains
+	* an octal or non-octal decimal escape sequence
+	*/
+	function hasOctalOrNonOctalDecimalEscapeSequence(node) {
+		return isConcatenation(node) ? hasOctalOrNonOctalDecimalEscapeSequence(node.left) || hasOctalOrNonOctalDecimalEscapeSequence(node.right) : node.type === "Literal" && typeof node.value == "string" ? astUtils.hasOctalOrNonOctalDecimalEscapeSequence(node.raw) : !1;
+	}
+	/**
+	* Checks whether or not a given binary expression has string literals.
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if the node has string literals.
+	*/
+	function hasStringLiteral(node) {
+		return isConcatenation(node) ? hasStringLiteral(node.right) || hasStringLiteral(node.left) : astUtils.isStringLiteral(node);
+	}
+	/**
+	* Checks whether or not a given binary expression has non string literals.
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if the node has non string literals.
+	*/
+	function hasNonStringLiteral(node) {
+		return isConcatenation(node) ? hasNonStringLiteral(node.right) || hasNonStringLiteral(node.left) : !astUtils.isStringLiteral(node);
+	}
+	/**
+	* Determines whether a given node will start with a template curly expression (`${}`) when being converted to a template literal.
+	* @param {ASTNode} node The node that will be fixed to a template literal
+	* @returns {boolean} `true` if the node will start with a template curly.
+	*/
+	function startsWithTemplateCurly(node) {
+		return node.type === "BinaryExpression" ? startsWithTemplateCurly(node.left) : node.type === "TemplateLiteral" ? node.expressions.length && node.quasis.length && node.quasis[0].range[0] === node.quasis[0].range[1] : node.type !== "Literal" || typeof node.value != "string";
+	}
+	/**
+	* Determines whether a given node end with a template curly expression (`${}`) when being converted to a template literal.
+	* @param {ASTNode} node The node that will be fixed to a template literal
+	* @returns {boolean} `true` if the node will end with a template curly.
+	*/
+	function endsWithTemplateCurly(node) {
+		return node.type === "BinaryExpression" ? startsWithTemplateCurly(node.right) : node.type === "TemplateLiteral" ? node.expressions.length && node.quasis.length && node.quasis.at(-1).range[0] === node.quasis.at(-1).range[1] : node.type !== "Literal" || typeof node.value != "string";
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require template literals instead of string concatenation",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/prefer-template"
+			},
+			schema: [],
+			fixable: "code",
+			messages: { unexpectedStringConcatenation: "Unexpected string concatenation." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, done = Object.create(null);
+			/**
+			* Gets the non-token text between two nodes, ignoring any other tokens that appear between the two tokens.
+			* @param {ASTNode} node1 The first node
+			* @param {ASTNode} node2 The second node
+			* @returns {string} The text between the nodes, excluding other tokens
+			*/
+			function getTextBetween(node1, node2) {
+				let allTokens = [node1].concat(sourceCode.getTokensBetween(node1, node2), node2), sourceText = sourceCode.getText();
+				return allTokens.slice(0, -1).reduce((accumulator, token, index) => accumulator + sourceText.slice(token.range[1], allTokens[index + 1].range[0]), "");
+			}
+			/**
+			* Returns a template literal form of the given node.
+			* @param {ASTNode} currentNode A node that should be converted to a template literal
+			* @param {string} textBeforeNode Text that should appear before the node
+			* @param {string} textAfterNode Text that should appear after the node
+			* @returns {string} A string form of this node, represented as a template literal
+			*/
+			function getTemplateLiteral(currentNode, textBeforeNode, textAfterNode) {
+				if (currentNode.type === "Literal" && typeof currentNode.value == "string") return `\`${currentNode.raw.slice(1, -1).replace(/\\*(\$\{|`)/gu, (matched) => matched.lastIndexOf("\\") % 2 ? `\\${matched}` : matched).replace(RegExp(`\\\\${currentNode.raw[0]}`, "gu"), currentNode.raw[0])}\``;
+				if (currentNode.type === "TemplateLiteral") return sourceCode.getText(currentNode);
+				if (isConcatenation(currentNode) && hasStringLiteral(currentNode)) {
+					let plusSign = sourceCode.getFirstTokenBetween(currentNode.left, currentNode.right, (token) => token.value === "+"), textBeforePlus = getTextBetween(currentNode.left, plusSign), textAfterPlus = getTextBetween(plusSign, currentNode.right), leftEndsWithCurly = endsWithTemplateCurly(currentNode.left), rightStartsWithCurly = startsWithTemplateCurly(currentNode.right);
+					return leftEndsWithCurly ? getTemplateLiteral(currentNode.left, textBeforeNode, textBeforePlus + textAfterPlus).slice(0, -1) + getTemplateLiteral(currentNode.right, null, textAfterNode).slice(1) : rightStartsWithCurly ? getTemplateLiteral(currentNode.left, textBeforeNode, null).slice(0, -1) + getTemplateLiteral(currentNode.right, textBeforePlus + textAfterPlus, textAfterNode).slice(1) : `${getTemplateLiteral(currentNode.left, textBeforeNode, null)}${textBeforePlus}+${textAfterPlus}${getTemplateLiteral(currentNode.right, textAfterNode, null)}`;
+				}
+				return `\`\${${textBeforeNode || ""}${sourceCode.getText(currentNode)}${textAfterNode || ""}}\``;
+			}
+			/**
+			* Returns a fixer object that converts a non-string binary expression to a template literal
+			* @param {SourceCodeFixer} fixer The fixer object
+			* @param {ASTNode} node A node that should be converted to a template literal
+			* @returns {Object} A fix for this binary expression
+			*/
+			function fixNonStringBinaryExpression(fixer, node) {
+				let topBinaryExpr = getTopConcatBinaryExpression(node.parent);
+				return hasOctalOrNonOctalDecimalEscapeSequence(topBinaryExpr) ? null : fixer.replaceText(topBinaryExpr, getTemplateLiteral(topBinaryExpr, null, null));
+			}
+			/**
+			* Reports if a given node is string concatenation with non string literals.
+			* @param {ASTNode} node A node to check.
+			* @returns {void}
+			*/
+			function checkForStringConcat(node) {
+				if (!astUtils.isStringLiteral(node) || !isConcatenation(node.parent)) return;
+				let topBinaryExpr = getTopConcatBinaryExpression(node.parent);
+				done[topBinaryExpr.range[0]] || (done[topBinaryExpr.range[0]] = !0, hasNonStringLiteral(topBinaryExpr) && context.report({
+					node: topBinaryExpr,
+					messageId: "unexpectedStringConcatenation",
+					fix: (fixer) => fixNonStringBinaryExpression(fixer, node)
+				}));
+			}
+			return {
+				Program() {
+					done = Object.create(null);
+				},
+				Literal: checkForStringConcat,
+				TemplateLiteral: checkForStringConcat
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/prefer-template.cjs
+module.exports = require_prefer_template().create;
+//#endregion