oxlint-plugin-eslint 1.52.0

package/rules/preserve-caught-error.cjs

@@ -0,0 +1,196 @@
+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/preserve-caught-error.js
+/**
+* @fileoverview Rule to preserve caught errors when re-throwing exceptions
+* @author Amnish Singh Arora
+*/
+var require_preserve_caught_error = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), UNKNOWN_CAUSE = Symbol("unknown_cause"), BUILT_IN_ERROR_TYPES = new Set([
+		"Error",
+		"EvalError",
+		"RangeError",
+		"ReferenceError",
+		"SyntaxError",
+		"TypeError",
+		"URIError",
+		"AggregateError"
+	]);
+	/**
+	* Finds and returns information about the `cause` property of an error being thrown.
+	* @param {ASTNode} throwStatement `ThrowStatement` to be checked.
+	* @returns {{ value: ASTNode; multipleDefinitions: boolean; } | UNKNOWN_CAUSE | null}
+	* Information about the `cause` of the error being thrown, such as the value node and
+	* whether there are multiple definitions of `cause`. `null` if there is no `cause`.
+	*/
+	function getErrorCause(throwStatement) {
+		let throwExpression = throwStatement.argument, optionsIndex = throwExpression.callee.name === "AggregateError" ? 2 : 1, spreadExpressionIndex = throwExpression.arguments.findIndex((arg) => arg.type === "SpreadElement");
+		if (spreadExpressionIndex >= 0 && spreadExpressionIndex <= optionsIndex) return UNKNOWN_CAUSE;
+		let errorOptions = throwExpression.arguments[optionsIndex];
+		if (errorOptions) {
+			if (errorOptions.type === "ObjectExpression") {
+				if (errorOptions.properties.some((prop) => prop.type === "SpreadElement")) return UNKNOWN_CAUSE;
+				let causeProperties = errorOptions.properties.filter((prop) => astUtils.getStaticPropertyName(prop) === "cause"), causeProperty = causeProperties.at(-1);
+				return causeProperty ? {
+					value: causeProperty.value,
+					multipleDefinitions: causeProperties.length > 1
+				} : null;
+			}
+			return UNKNOWN_CAUSE;
+		}
+		return null;
+	}
+	/**
+	* Finds and returns the `CatchClause` node, that the `node` is part of.
+	* @param {ASTNode} node The AST node to be evaluated.
+	* @returns {ASTNode | null } The closest parent `CatchClause` node, `null` if the `node` is not in a catch block.
+	*/
+	function findParentCatch(node) {
+		let currentNode = node;
+		for (; currentNode && currentNode.type !== "CatchClause";) {
+			if ([
+				"FunctionDeclaration",
+				"FunctionExpression",
+				"ArrowFunctionExpression",
+				"StaticBlock"
+			].includes(currentNode.type)) return null;
+			currentNode = currentNode.parent;
+		}
+		return currentNode;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ requireCatchParameter: !1 }],
+			docs: {
+				description: "Disallow losing originally caught error when re-throwing custom errors",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/preserve-caught-error"
+			},
+			schema: [{
+				type: "object",
+				properties: { requireCatchParameter: {
+					type: "boolean",
+					description: "Requires the catch blocks to always have the caught error parameter so it is not discarded."
+				} },
+				additionalProperties: !1
+			}],
+			messages: {
+				missingCause: "There is no `cause` attached to the symptom error being thrown.",
+				incorrectCause: "The symptom error is being thrown with an incorrect `cause`.",
+				includeCause: "Include the original caught error as the `cause` of the symptom error.",
+				missingCatchErrorParam: "The caught error is not accessible because the catch clause lacks the error parameter. Start referencing the caught error using the catch parameter.",
+				partiallyLostError: "Re-throws cannot preserve the caught error as a part of it is being lost due to destructuring.",
+				caughtErrorShadowed: "The caught error is being attached as `cause`, but is shadowed by a closer scoped redeclaration."
+			},
+			hasSuggestions: !0
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, [{ requireCatchParameter }] = context.options;
+			/**
+			* Checks if a `ThrowStatement` is constructing and throwing a new `Error` object.
+			*
+			* Covers all the error types on `globalThis` that support `cause` property:
+			* https://github.com/microsoft/TypeScript/blob/main/src/lib/es2022.error.d.ts
+			* @param {ASTNode} throwStatement The `ThrowStatement` that needs to be checked.
+			* @returns {boolean} `true` if a new "Error" is being thrown, else `false`.
+			*/
+			function isThrowingNewError(throwStatement) {
+				return (throwStatement.argument.type === "NewExpression" || throwStatement.argument.type === "CallExpression") && throwStatement.argument.callee.type === "Identifier" && BUILT_IN_ERROR_TYPES.has(throwStatement.argument.callee.name) && sourceCode.isGlobalReference(throwStatement.argument.callee);
+			}
+			/**
+			* Inserts `cause: <caughtErrorName>` into an inline options object expression.
+			* @param {RuleFixer} fixer The fixer object.
+			* @param {ASTNode} optionsNode The options object node.
+			* @param {string} caughtErrorName The name of the caught error (e.g., "err").
+			* @returns {Fix} The fix object.
+			*/
+			function insertCauseIntoOptions(fixer, optionsNode, caughtErrorName) {
+				let properties = optionsNode.properties;
+				if (properties.length === 0) return fixer.insertTextAfter(sourceCode.getFirstToken(optionsNode), `cause: ${caughtErrorName}`);
+				let lastProp = properties.at(-1);
+				return fixer.insertTextAfter(lastProp, `, cause: ${caughtErrorName}`);
+			}
+			return { ThrowStatement(node) {
+				let parentCatch = findParentCatch(node), throwStatement = node;
+				if (parentCatch && isThrowingNewError(throwStatement)) {
+					if (parentCatch.param && parentCatch.param.type !== "Identifier") {
+						context.report({
+							messageId: "partiallyLostError",
+							node: parentCatch
+						});
+						return;
+					}
+					let caughtError = parentCatch.param?.type === "Identifier" ? parentCatch.param : null;
+					if (!caughtError) {
+						if (requireCatchParameter) {
+							context.report({
+								node: throwStatement,
+								messageId: "missingCatchErrorParam"
+							});
+							return;
+						}
+						return;
+					}
+					let errorCauseInfo = getErrorCause(throwStatement);
+					if (errorCauseInfo === UNKNOWN_CAUSE) return;
+					if (errorCauseInfo === null) {
+						context.report({
+							messageId: "missingCause",
+							node: throwStatement,
+							suggest: [{
+								messageId: "includeCause",
+								fix(fixer) {
+									let throwExpression = throwStatement.argument, args = throwExpression.arguments;
+									if (throwExpression.callee.name === "AggregateError") {
+										let errorsArg = args[0], messageArg = args[1], optionsArg = args[2];
+										if (!errorsArg) {
+											let lastToken = sourceCode.getLastToken(throwExpression), lastCalleeToken = sourceCode.getLastToken(throwExpression.callee), parenToken = sourceCode.getFirstTokenBetween(lastCalleeToken, lastToken, astUtils.isOpeningParenToken);
+											return parenToken ? fixer.insertTextAfter(parenToken, `[], "", { cause: ${caughtError.name} }`) : fixer.insertTextAfter(throwExpression.callee, `([], "", { cause: ${caughtError.name} })`);
+										}
+										return messageArg ? optionsArg ? optionsArg.type === "ObjectExpression" ? insertCauseIntoOptions(fixer, optionsArg, caughtError.name) : null : fixer.insertTextAfter(messageArg, `, { cause: ${caughtError.name} }`) : fixer.insertTextAfter(errorsArg, `, "", { cause: ${caughtError.name} }`);
+									}
+									let messageArg = args[0], optionsArg = args[1];
+									if (!messageArg) {
+										let lastToken = sourceCode.getLastToken(throwExpression), lastCalleeToken = sourceCode.getLastToken(throwExpression.callee), parenToken = sourceCode.getFirstTokenBetween(lastCalleeToken, lastToken, astUtils.isOpeningParenToken);
+										return parenToken ? fixer.insertTextAfter(parenToken, `"", { cause: ${caughtError.name} }`) : fixer.insertTextAfter(throwExpression.callee, `("", { cause: ${caughtError.name} })`);
+									}
+									return optionsArg ? optionsArg.type === "ObjectExpression" ? insertCauseIntoOptions(fixer, optionsArg, caughtError.name) : null : fixer.insertTextAfter(messageArg, `, { cause: ${caughtError.name} }`);
+								}
+							}]
+						});
+						return;
+					}
+					let { value: thrownErrorCause } = errorCauseInfo;
+					if (!(thrownErrorCause.type === "Identifier" && thrownErrorCause.name === caughtError.name)) {
+						let suggest = errorCauseInfo.multipleDefinitions ? null : [{
+							messageId: "includeCause",
+							fix(fixer) {
+								return thrownErrorCause.parent.method || thrownErrorCause.parent.shorthand || thrownErrorCause.parent.kind !== "init" ? fixer.replaceText(thrownErrorCause.parent, `cause: ${caughtError.name}`) : fixer.replaceText(thrownErrorCause, caughtError.name);
+							}
+						}];
+						context.report({
+							messageId: "incorrectCause",
+							node: thrownErrorCause,
+							suggest
+						});
+						return;
+					}
+					let scope = sourceCode.getScope(throwStatement);
+					do {
+						if (scope.set.get(caughtError.name)) break;
+						scope = scope.upper;
+					} while (scope);
+					scope?.block !== parentCatch && context.report({
+						messageId: "caughtErrorShadowed",
+						node: throwStatement
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/preserve-caught-error.cjs
+module.exports = require_preserve_caught_error().create;
+//#endregion

package/rules/quote-props.cjs

@@ -0,0 +1,224 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_keywords$1 = require("../common/keywords.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/quote-props.js
+/**
+* @fileoverview Rule to flag non-quoted property names in object literals.
+* @author Mathias Bynens <http://mathiasbynens.be/>
+* @deprecated in ESLint v8.53.0
+*/
+var require_quote_props = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let espree = require_ast_utils$1.r(), astUtils = require_ast_utils$1.t(), keywords = require_keywords$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: "quote-props",
+						url: "https://eslint.style/rules/quote-props"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Require quotes around object literal property names",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/quote-props"
+			},
+			schema: { anyOf: [{
+				type: "array",
+				items: [{ enum: [
+					"always",
+					"as-needed",
+					"consistent",
+					"consistent-as-needed"
+				] }],
+				minItems: 0,
+				maxItems: 1
+			}, {
+				type: "array",
+				items: [{ enum: [
+					"always",
+					"as-needed",
+					"consistent",
+					"consistent-as-needed"
+				] }, {
+					type: "object",
+					properties: {
+						keywords: { type: "boolean" },
+						unnecessary: { type: "boolean" },
+						numbers: { type: "boolean" }
+					},
+					additionalProperties: !1
+				}],
+				minItems: 0,
+				maxItems: 2
+			}] },
+			fixable: "code",
+			messages: {
+				requireQuotesDueToReservedWord: "Properties should be quoted as '{{property}}' is a reserved word.",
+				inconsistentlyQuotedProperty: "Inconsistently quoted property '{{key}}' found.",
+				unnecessarilyQuotedProperty: "Unnecessarily quoted property '{{property}}' found.",
+				unquotedReservedProperty: "Unquoted reserved word '{{property}}' used as key.",
+				unquotedNumericProperty: "Unquoted number literal '{{property}}' used as key.",
+				unquotedPropertyFound: "Unquoted property '{{property}}' found.",
+				redundantQuoting: "Properties shouldn't be quoted as all quotes are redundant."
+			}
+		},
+		create(context) {
+			let MODE = context.options[0], KEYWORDS = context.options[1] && context.options[1].keywords, CHECK_UNNECESSARY = !context.options[1] || context.options[1].unnecessary !== !1, NUMBERS = context.options[1] && context.options[1].numbers, sourceCode = context.sourceCode;
+			/**
+			* Checks whether a certain string constitutes an ES3 token
+			* @param {string} tokenStr The string to be checked.
+			* @returns {boolean} `true` if it is an ES3 token.
+			*/
+			function isKeyword(tokenStr) {
+				return keywords.includes(tokenStr);
+			}
+			/**
+			* Checks if an espree-tokenized key has redundant quotes (i.e. whether quotes are unnecessary)
+			* @param {string} rawKey The raw key value from the source
+			* @param {espreeTokens} tokens The espree-tokenized node key
+			* @param {boolean} [skipNumberLiterals=false] Indicates whether number literals should be checked
+			* @returns {boolean} Whether or not a key has redundant quotes.
+			* @private
+			*/
+			function areQuotesRedundant(rawKey, tokens, skipNumberLiterals) {
+				return tokens.length === 1 && tokens[0].start === 0 && tokens[0].end === rawKey.length && ([
+					"Identifier",
+					"Keyword",
+					"Null",
+					"Boolean"
+				].includes(tokens[0].type) || tokens[0].type === "Numeric" && !skipNumberLiterals && String(+tokens[0].value) === tokens[0].value);
+			}
+			/**
+			* Returns a string representation of a property node with quotes removed
+			* @param {ASTNode} key Key AST Node, which may or may not be quoted
+			* @returns {string} A replacement string for this property
+			*/
+			function getUnquotedKey(key) {
+				return key.type === "Identifier" ? key.name : key.value;
+			}
+			/**
+			* Returns a string representation of a property node with quotes added
+			* @param {ASTNode} key Key AST Node, which may or may not be quoted
+			* @returns {string} A replacement string for this property
+			*/
+			function getQuotedKey(key) {
+				return key.type === "Literal" && typeof key.value == "string" ? sourceCode.getText(key) : `"${key.type === "Identifier" ? key.name : key.value}"`;
+			}
+			/**
+			* Ensures that a property's key is quoted only when necessary
+			* @param {ASTNode} node Property AST node
+			* @returns {void}
+			*/
+			function checkUnnecessaryQuotes(node) {
+				let key = node.key;
+				if (!(node.method || node.computed || node.shorthand)) if (key.type === "Literal" && typeof key.value == "string") {
+					let tokens;
+					try {
+						tokens = espree.tokenize(key.value);
+					} catch {
+						return;
+					}
+					if (tokens.length !== 1 || isKeyword(tokens[0].value) && KEYWORDS) return;
+					CHECK_UNNECESSARY && areQuotesRedundant(key.value, tokens, NUMBERS) && context.report({
+						node,
+						messageId: "unnecessarilyQuotedProperty",
+						data: { property: key.value },
+						fix: (fixer) => fixer.replaceText(key, getUnquotedKey(key))
+					});
+				} else KEYWORDS && key.type === "Identifier" && isKeyword(key.name) ? context.report({
+					node,
+					messageId: "unquotedReservedProperty",
+					data: { property: key.name },
+					fix: (fixer) => fixer.replaceText(key, getQuotedKey(key))
+				}) : NUMBERS && key.type === "Literal" && astUtils.isNumericLiteral(key) && context.report({
+					node,
+					messageId: "unquotedNumericProperty",
+					data: { property: key.value },
+					fix: (fixer) => fixer.replaceText(key, getQuotedKey(key))
+				});
+			}
+			/**
+			* Ensures that a property's key is quoted
+			* @param {ASTNode} node Property AST node
+			* @returns {void}
+			*/
+			function checkOmittedQuotes(node) {
+				let key = node.key;
+				!node.method && !node.computed && !node.shorthand && !(key.type === "Literal" && typeof key.value == "string") && context.report({
+					node,
+					messageId: "unquotedPropertyFound",
+					data: { property: key.name || key.value },
+					fix: (fixer) => fixer.replaceText(key, getQuotedKey(key))
+				});
+			}
+			/**
+			* Ensures that an object's keys are consistently quoted, optionally checks for redundancy of quotes
+			* @param {ASTNode} node Property AST node
+			* @param {boolean} checkQuotesRedundancy Whether to check quotes' redundancy
+			* @returns {void}
+			*/
+			function checkConsistency(node, checkQuotesRedundancy) {
+				let quotedProps = [], unquotedProps = [], keywordKeyName = null, necessaryQuotes = !1;
+				node.properties.forEach((property) => {
+					let key = property.key;
+					if (!(!key || property.method || property.computed || property.shorthand)) if (key.type === "Literal" && typeof key.value == "string") {
+						if (quotedProps.push(property), checkQuotesRedundancy) {
+							let tokens;
+							try {
+								tokens = espree.tokenize(key.value);
+							} catch {
+								necessaryQuotes = !0;
+								return;
+							}
+							necessaryQuotes = necessaryQuotes || !areQuotesRedundant(key.value, tokens) || KEYWORDS && isKeyword(tokens[0].value);
+						}
+					} else KEYWORDS && checkQuotesRedundancy && key.type === "Identifier" && isKeyword(key.name) ? (unquotedProps.push(property), necessaryQuotes = !0, keywordKeyName = key.name) : unquotedProps.push(property);
+				}), checkQuotesRedundancy && quotedProps.length && !necessaryQuotes ? quotedProps.forEach((property) => {
+					context.report({
+						node: property,
+						messageId: "redundantQuoting",
+						fix: (fixer) => fixer.replaceText(property.key, getUnquotedKey(property.key))
+					});
+				}) : unquotedProps.length && keywordKeyName ? unquotedProps.forEach((property) => {
+					context.report({
+						node: property,
+						messageId: "requireQuotesDueToReservedWord",
+						data: { property: keywordKeyName },
+						fix: (fixer) => fixer.replaceText(property.key, getQuotedKey(property.key))
+					});
+				}) : quotedProps.length && unquotedProps.length && unquotedProps.forEach((property) => {
+					context.report({
+						node: property,
+						messageId: "inconsistentlyQuotedProperty",
+						data: { key: property.key.name || property.key.value },
+						fix: (fixer) => fixer.replaceText(property.key, getQuotedKey(property.key))
+					});
+				});
+			}
+			return {
+				Property(node) {
+					(MODE === "always" || !MODE) && checkOmittedQuotes(node), MODE === "as-needed" && checkUnnecessaryQuotes(node);
+				},
+				ObjectExpression(node) {
+					MODE === "consistent" && checkConsistency(node, !1), MODE === "consistent-as-needed" && checkConsistency(node, !0);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/quote-props.cjs
+module.exports = require_quote_props().create;
+//#endregion

package/rules/quotes.cjs

@@ -0,0 +1,187 @@
+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/quotes.js
+/**
+* @fileoverview A rule to choose between single and double quote marks
+* @author Matt DuVall <http://www.mattduvall.com/>, Brandon Payton
+* @deprecated in ESLint v8.53.0
+*/
+var require_quotes = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), QUOTE_SETTINGS = {
+		double: {
+			quote: "\"",
+			alternateQuote: "'",
+			description: "doublequote"
+		},
+		single: {
+			quote: "'",
+			alternateQuote: "\"",
+			description: "singlequote"
+		},
+		backtick: {
+			quote: "`",
+			alternateQuote: "\"",
+			description: "backtick"
+		}
+	}, UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Array.from(astUtils.LINEBREAKS).join("")}]`, "u");
+	/** @type {import('../types').Rule.RuleModule} */
+	QUOTE_SETTINGS.double.convert = QUOTE_SETTINGS.single.convert = QUOTE_SETTINGS.backtick.convert = function(str) {
+		let newQuote = this.quote, oldQuote = str[0];
+		return newQuote === oldQuote ? str : newQuote + str.slice(1, -1).replace(/\\(\$\{|\r\n?|\n|.)|["'`]|\$\{|(\r\n?|\n)/gu, (match, escaped, newline) => escaped === oldQuote || oldQuote === "`" && escaped === "${" ? escaped : match === newQuote || newQuote === "`" && match === "${" ? `\\${match}` : newline && oldQuote === "`" ? "\\n" : match) + newQuote;
+	}, 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: "quotes",
+						url: "https://eslint.style/rules/quotes"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce the consistent use of either backticks, double, or single quotes",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/quotes"
+			},
+			fixable: "code",
+			schema: [{ enum: [
+				"single",
+				"double",
+				"backtick"
+			] }, { anyOf: [{ enum: ["avoid-escape"] }, {
+				type: "object",
+				properties: {
+					avoidEscape: { type: "boolean" },
+					allowTemplateLiterals: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}] }],
+			messages: { wrongQuotes: "Strings must use {{description}}." }
+		},
+		create(context) {
+			let quoteOption = context.options[0], settings = QUOTE_SETTINGS[quoteOption || "double"], options = context.options[1], allowTemplateLiterals = options && options.allowTemplateLiterals === !0, sourceCode = context.sourceCode, avoidEscape = options && options.avoidEscape === !0;
+			options === "avoid-escape" && (avoidEscape = !0);
+			/**
+			* Determines if a given node is part of JSX syntax.
+			*
+			* This function returns `true` in the following cases:
+			*
+			* - `<div className="foo"></div>` ... If the literal is an attribute value, the parent of the literal is `JSXAttribute`.
+			* - `<div>foo</div>` ... If the literal is a text content, the parent of the literal is `JSXElement`.
+			* - `<>foo</>` ... If the literal is a text content, the parent of the literal is `JSXFragment`.
+			*
+			* In particular, this function returns `false` in the following cases:
+			*
+			* - `<div className={"foo"}></div>`
+			* - `<div>{"foo"}</div>`
+			*
+			* In both cases, inside of the braces is handled as normal JavaScript.
+			* The braces are `JSXExpressionContainer` nodes.
+			* @param {ASTNode} node The Literal node to check.
+			* @returns {boolean} True if the node is a part of JSX, false if not.
+			* @private
+			*/
+			function isJSXLiteral(node) {
+				return node.parent.type === "JSXAttribute" || node.parent.type === "JSXElement" || node.parent.type === "JSXFragment";
+			}
+			/**
+			* Checks whether or not a given node is a directive.
+			* The directive is a `ExpressionStatement` which has only a string literal not surrounded by
+			* parentheses.
+			* @param {ASTNode} node A node to check.
+			* @returns {boolean} Whether or not the node is a directive.
+			* @private
+			*/
+			function isDirective(node) {
+				return node.type === "ExpressionStatement" && node.expression.type === "Literal" && typeof node.expression.value == "string" && !astUtils.isParenthesised(sourceCode, node.expression);
+			}
+			/**
+			* Checks whether a specified node is either part of, or immediately follows a (possibly empty) directive prologue.
+			* @see {@link http://www.ecma-international.org/ecma-262/6.0/#sec-directive-prologues-and-the-use-strict-directive}
+			* @param {ASTNode} node A node to check.
+			* @returns {boolean} Whether a specified node is either part of, or immediately follows a (possibly empty) directive prologue.
+			* @private
+			*/
+			function isExpressionInOrJustAfterDirectivePrologue(node) {
+				if (!astUtils.isTopLevelExpressionStatement(node.parent)) return !1;
+				let block = node.parent.parent;
+				for (let i = 0; i < block.body.length; ++i) {
+					let statement = block.body[i];
+					if (statement === node.parent) return !0;
+					if (!isDirective(statement)) break;
+				}
+				return !1;
+			}
+			/**
+			* Checks whether or not a given node is allowed as non backtick.
+			* @param {ASTNode} node A node to check.
+			* @returns {boolean} Whether or not the node is allowed as non backtick.
+			* @private
+			*/
+			function isAllowedAsNonBacktick(node) {
+				let parent = node.parent;
+				switch (parent.type) {
+					case "ExpressionStatement": return !astUtils.isParenthesised(sourceCode, node) && isExpressionInOrJustAfterDirectivePrologue(node);
+					case "Property":
+					case "PropertyDefinition":
+					case "MethodDefinition": return parent.key === node && !parent.computed;
+					case "ImportDeclaration":
+					case "ExportNamedDeclaration": return parent.source === node;
+					case "ExportAllDeclaration": return parent.exported === node || parent.source === node;
+					case "ImportSpecifier": return parent.imported === node;
+					case "ExportSpecifier": return parent.local === node || parent.exported === node;
+					default: return !1;
+				}
+			}
+			/**
+			* Checks whether or not a given TemplateLiteral node is actually using any of the special features provided by template literal strings.
+			* @param {ASTNode} node A TemplateLiteral node to check.
+			* @returns {boolean} Whether or not the TemplateLiteral node is using any of the special features provided by template literal strings.
+			* @private
+			*/
+			function isUsingFeatureOfTemplateLiteral(node) {
+				return !!(node.parent.type === "TaggedTemplateExpression" && node === node.parent.quasi || node.expressions.length > 0 || node.quasis.length >= 1 && UNESCAPED_LINEBREAK_PATTERN.test(node.quasis[0].value.raw));
+			}
+			return {
+				Literal(node) {
+					let val = node.value, rawVal = node.raw;
+					if (settings && typeof val == "string") {
+						let isValid = quoteOption === "backtick" && isAllowedAsNonBacktick(node) || isJSXLiteral(node) || astUtils.isSurroundedBy(rawVal, settings.quote);
+						!isValid && avoidEscape && (isValid = astUtils.isSurroundedBy(rawVal, settings.alternateQuote) && rawVal.includes(settings.quote)), isValid || context.report({
+							node,
+							messageId: "wrongQuotes",
+							data: { description: settings.description },
+							fix(fixer) {
+								return quoteOption === "backtick" && astUtils.hasOctalOrNonOctalDecimalEscapeSequence(rawVal) ? null : fixer.replaceText(node, settings.convert(node.raw));
+							}
+						});
+					}
+				},
+				TemplateLiteral(node) {
+					allowTemplateLiterals || quoteOption === "backtick" || isUsingFeatureOfTemplateLiteral(node) || context.report({
+						node,
+						messageId: "wrongQuotes",
+						data: { description: settings.description },
+						fix(fixer) {
+							return astUtils.isTopLevelExpressionStatement(node.parent) && !astUtils.isParenthesised(sourceCode, node) ? null : fixer.replaceText(node, settings.convert(sourceCode.getText(node)));
+						}
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/quotes.cjs
+module.exports = require_quotes().create;
+//#endregion