@zayne-labs/eslint-config 0.9.17 → 0.9.18

package/dist/src-DwSufEpw.js

@@ -0,0 +1,1769 @@
+import globals from "globals";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-visitor-keys@2.1.0/node_modules/eslint-visitor-keys/lib/visitor-keys.json
+var require_visitor_keys = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/eslint-visitor-keys@2.1.0/node_modules/eslint-visitor-keys/lib/visitor-keys.json": ((exports, module) => {
+	module.exports = {
+		"AssignmentExpression": ["left", "right"],
+		"AssignmentPattern": ["left", "right"],
+		"ArrayExpression": ["elements"],
+		"ArrayPattern": ["elements"],
+		"ArrowFunctionExpression": ["params", "body"],
+		"AwaitExpression": ["argument"],
+		"BlockStatement": ["body"],
+		"BinaryExpression": ["left", "right"],
+		"BreakStatement": ["label"],
+		"CallExpression": ["callee", "arguments"],
+		"CatchClause": ["param", "body"],
+		"ChainExpression": ["expression"],
+		"ClassBody": ["body"],
+		"ClassDeclaration": [
+			"id",
+			"superClass",
+			"body"
+		],
+		"ClassExpression": [
+			"id",
+			"superClass",
+			"body"
+		],
+		"ConditionalExpression": [
+			"test",
+			"consequent",
+			"alternate"
+		],
+		"ContinueStatement": ["label"],
+		"DebuggerStatement": [],
+		"DoWhileStatement": ["body", "test"],
+		"EmptyStatement": [],
+		"ExportAllDeclaration": ["exported", "source"],
+		"ExportDefaultDeclaration": ["declaration"],
+		"ExportNamedDeclaration": [
+			"declaration",
+			"specifiers",
+			"source"
+		],
+		"ExportSpecifier": ["exported", "local"],
+		"ExpressionStatement": ["expression"],
+		"ExperimentalRestProperty": ["argument"],
+		"ExperimentalSpreadProperty": ["argument"],
+		"ForStatement": [
+			"init",
+			"test",
+			"update",
+			"body"
+		],
+		"ForInStatement": [
+			"left",
+			"right",
+			"body"
+		],
+		"ForOfStatement": [
+			"left",
+			"right",
+			"body"
+		],
+		"FunctionDeclaration": [
+			"id",
+			"params",
+			"body"
+		],
+		"FunctionExpression": [
+			"id",
+			"params",
+			"body"
+		],
+		"Identifier": [],
+		"IfStatement": [
+			"test",
+			"consequent",
+			"alternate"
+		],
+		"ImportDeclaration": ["specifiers", "source"],
+		"ImportDefaultSpecifier": ["local"],
+		"ImportExpression": ["source"],
+		"ImportNamespaceSpecifier": ["local"],
+		"ImportSpecifier": ["imported", "local"],
+		"JSXAttribute": ["name", "value"],
+		"JSXClosingElement": ["name"],
+		"JSXElement": [
+			"openingElement",
+			"children",
+			"closingElement"
+		],
+		"JSXEmptyExpression": [],
+		"JSXExpressionContainer": ["expression"],
+		"JSXIdentifier": [],
+		"JSXMemberExpression": ["object", "property"],
+		"JSXNamespacedName": ["namespace", "name"],
+		"JSXOpeningElement": ["name", "attributes"],
+		"JSXSpreadAttribute": ["argument"],
+		"JSXText": [],
+		"JSXFragment": [
+			"openingFragment",
+			"children",
+			"closingFragment"
+		],
+		"Literal": [],
+		"LabeledStatement": ["label", "body"],
+		"LogicalExpression": ["left", "right"],
+		"MemberExpression": ["object", "property"],
+		"MetaProperty": ["meta", "property"],
+		"MethodDefinition": ["key", "value"],
+		"NewExpression": ["callee", "arguments"],
+		"ObjectExpression": ["properties"],
+		"ObjectPattern": ["properties"],
+		"PrivateIdentifier": [],
+		"Program": ["body"],
+		"Property": ["key", "value"],
+		"PropertyDefinition": ["key", "value"],
+		"RestElement": ["argument"],
+		"ReturnStatement": ["argument"],
+		"SequenceExpression": ["expressions"],
+		"SpreadElement": ["argument"],
+		"Super": [],
+		"SwitchStatement": ["discriminant", "cases"],
+		"SwitchCase": ["test", "consequent"],
+		"TaggedTemplateExpression": ["tag", "quasi"],
+		"TemplateElement": [],
+		"TemplateLiteral": ["quasis", "expressions"],
+		"ThisExpression": [],
+		"ThrowStatement": ["argument"],
+		"TryStatement": [
+			"block",
+			"handler",
+			"finalizer"
+		],
+		"UnaryExpression": ["argument"],
+		"UpdateExpression": ["argument"],
+		"VariableDeclaration": ["declarations"],
+		"VariableDeclarator": ["id", "init"],
+		"WhileStatement": ["test", "body"],
+		"WithStatement": ["object", "body"],
+		"YieldExpression": ["argument"]
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-visitor-keys@2.1.0/node_modules/eslint-visitor-keys/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/eslint-visitor-keys@2.1.0/node_modules/eslint-visitor-keys/lib/index.js": ((exports, module) => {
+	const KEYS = require_visitor_keys();
+	const NODE_TYPES = Object.freeze(Object.keys(KEYS));
+	for (const type of NODE_TYPES) Object.freeze(KEYS[type]);
+	Object.freeze(KEYS);
+	const KEY_BLACKLIST = new Set([
+		"parent",
+		"leadingComments",
+		"trailingComments"
+	]);
+	/**
+	* Check whether a given key should be used or not.
+	* @param {string} key The key to check.
+	* @returns {boolean} `true` if the key should be used.
+	*/
+	function filterKey(key) {
+		return !KEY_BLACKLIST.has(key) && key[0] !== "_";
+	}
+	module.exports = Object.freeze({
+		KEYS,
+		getKeys(node) {
+			return Object.keys(node).filter(filterKey);
+		},
+		unionWith(additionalKeys) {
+			const retv = Object.assign({}, KEYS);
+			for (const type of Object.keys(additionalKeys)) if (retv.hasOwnProperty(type)) {
+				const keys = new Set(additionalKeys[type]);
+				for (const key of retv[type]) keys.add(key);
+				retv[type] = Object.freeze(Array.from(keys));
+			} else retv[type] = Object.freeze(Array.from(additionalKeys[type]));
+			return Object.freeze(retv);
+		}
+	});
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-utils@3.0.0_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-utils/index.mjs
+var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
+/**
+* Get the innermost scope which contains a given location.
+* @param {Scope} initialScope The initial scope to search.
+* @param {Node} node The location to search.
+* @returns {Scope} The innermost scope.
+*/
+function getInnermostScope(initialScope, node) {
+	const location = node.range[0];
+	let scope = initialScope;
+	let found = false;
+	do {
+		found = false;
+		for (const childScope of scope.childScopes) {
+			const range = childScope.block.range;
+			if (range[0] <= location && location < range[1]) {
+				scope = childScope;
+				found = true;
+				break;
+			}
+		}
+	} while (found);
+	return scope;
+}
+/**
+* Find the variable of a given name.
+* @param {Scope} initialScope The scope to start finding.
+* @param {string|Node} nameOrNode The variable name to find. If this is a Node object then it should be an Identifier node.
+* @returns {Variable|null} The found variable or null.
+*/
+function findVariable(initialScope, nameOrNode) {
+	let name = "";
+	let scope = initialScope;
+	if (typeof nameOrNode === "string") name = nameOrNode;
+	else {
+		name = nameOrNode.name;
+		scope = getInnermostScope(scope, nameOrNode);
+	}
+	while (scope != null) {
+		const variable = scope.set.get(name);
+		if (variable != null) return variable;
+		scope = scope.upper;
+	}
+	return null;
+}
+/**
+* Negate the result of `this` calling.
+* @param {Token} token The token to check.
+* @returns {boolean} `true` if the result of `this(token)` is `false`.
+*/
+function negate0(token) {
+	return !this(token);
+}
+/**
+* Creates the negate function of the given function.
+* @param {function(Token):boolean} f - The function to negate.
+* @returns {function(Token):boolean} Negated function.
+*/
+function negate(f) {
+	return negate0.bind(f);
+}
+/**
+* Checks if the given token is a PunctuatorToken with the given value
+* @param {Token} token - The token to check.
+* @param {string} value - The value to check.
+* @returns {boolean} `true` if the token is a PunctuatorToken with the given value.
+*/
+function isPunctuatorTokenWithValue(token, value) {
+	return token.type === "Punctuator" && token.value === value;
+}
+/**
+* Checks if the given token is an arrow token or not.
+* @param {Token} token - The token to check.
+* @returns {boolean} `true` if the token is an arrow token.
+*/
+function isArrowToken(token) {
+	return isPunctuatorTokenWithValue(token, "=>");
+}
+/**
+* Checks if the given token is a comma token or not.
+* @param {Token} token - The token to check.
+* @returns {boolean} `true` if the token is a comma token.
+*/
+function isCommaToken(token) {
+	return isPunctuatorTokenWithValue(token, ",");
+}
+/**
+* Checks if the given token is a semicolon token or not.
+* @param {Token} token - The token to check.
+* @returns {boolean} `true` if the token is a semicolon token.
+*/
+function isSemicolonToken(token) {
+	return isPunctuatorTokenWithValue(token, ";");
+}
+/**
+* Checks if the given token is a colon token or not.
+* @param {Token} token - The token to check.
+* @returns {boolean} `true` if the token is a colon token.
+*/
+function isColonToken(token) {
+	return isPunctuatorTokenWithValue(token, ":");
+}
+/**
+* Checks if the given token is an opening parenthesis token or not.
+* @param {Token} token - The token to check.
+* @returns {boolean} `true` if the token is an opening parenthesis token.
+*/
+function isOpeningParenToken(token) {
+	return isPunctuatorTokenWithValue(token, "(");
+}
+/**
+* Checks if the given token is a closing parenthesis token or not.
+* @param {Token} token - The token to check.
+* @returns {boolean} `true` if the token is a closing parenthesis token.
+*/
+function isClosingParenToken(token) {
+	return isPunctuatorTokenWithValue(token, ")");
+}
+/**
+* Checks if the given token is an opening square bracket token or not.
+* @param {Token} token - The token to check.
+* @returns {boolean} `true` if the token is an opening square bracket token.
+*/
+function isOpeningBracketToken(token) {
+	return isPunctuatorTokenWithValue(token, "[");
+}
+/**
+* Checks if the given token is a closing square bracket token or not.
+* @param {Token} token - The token to check.
+* @returns {boolean} `true` if the token is a closing square bracket token.
+*/
+function isClosingBracketToken(token) {
+	return isPunctuatorTokenWithValue(token, "]");
+}
+/**
+* Checks if the given token is an opening brace token or not.
+* @param {Token} token - The token to check.
+* @returns {boolean} `true` if the token is an opening brace token.
+*/
+function isOpeningBraceToken(token) {
+	return isPunctuatorTokenWithValue(token, "{");
+}
+/**
+* Checks if the given token is a closing brace token or not.
+* @param {Token} token - The token to check.
+* @returns {boolean} `true` if the token is a closing brace token.
+*/
+function isClosingBraceToken(token) {
+	return isPunctuatorTokenWithValue(token, "}");
+}
+/**
+* Checks if the given token is a comment token or not.
+* @param {Token} token - The token to check.
+* @returns {boolean} `true` if the token is a comment token.
+*/
+function isCommentToken(token) {
+	return [
+		"Block",
+		"Line",
+		"Shebang"
+	].includes(token.type);
+}
+const isNotArrowToken = negate(isArrowToken);
+const isNotCommaToken = negate(isCommaToken);
+const isNotSemicolonToken = negate(isSemicolonToken);
+const isNotColonToken = negate(isColonToken);
+const isNotOpeningParenToken = negate(isOpeningParenToken);
+const isNotClosingParenToken = negate(isClosingParenToken);
+const isNotOpeningBracketToken = negate(isOpeningBracketToken);
+const isNotClosingBracketToken = negate(isClosingBracketToken);
+const isNotOpeningBraceToken = negate(isOpeningBraceToken);
+const isNotClosingBraceToken = negate(isClosingBraceToken);
+const isNotCommentToken = negate(isCommentToken);
+const globalObject = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
+const builtinNames = Object.freeze(new Set([
+	"Array",
+	"ArrayBuffer",
+	"BigInt",
+	"BigInt64Array",
+	"BigUint64Array",
+	"Boolean",
+	"DataView",
+	"Date",
+	"decodeURI",
+	"decodeURIComponent",
+	"encodeURI",
+	"encodeURIComponent",
+	"escape",
+	"Float32Array",
+	"Float64Array",
+	"Function",
+	"Infinity",
+	"Int16Array",
+	"Int32Array",
+	"Int8Array",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"JSON",
+	"Map",
+	"Math",
+	"NaN",
+	"Number",
+	"Object",
+	"parseFloat",
+	"parseInt",
+	"Promise",
+	"Proxy",
+	"Reflect",
+	"RegExp",
+	"Set",
+	"String",
+	"Symbol",
+	"Uint16Array",
+	"Uint32Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"undefined",
+	"unescape",
+	"WeakMap",
+	"WeakSet"
+]));
+const callAllowed = new Set([
+	Array.isArray,
+	typeof BigInt === "function" ? BigInt : void 0,
+	Boolean,
+	Date,
+	Date.parse,
+	decodeURI,
+	decodeURIComponent,
+	encodeURI,
+	encodeURIComponent,
+	escape,
+	isFinite,
+	isNaN,
+	isPrototypeOf,
+	...Object.getOwnPropertyNames(Math).map((k) => Math[k]).filter((f) => typeof f === "function"),
+	Number,
+	Number.isFinite,
+	Number.isNaN,
+	Number.parseFloat,
+	Number.parseInt,
+	Object,
+	Object.entries,
+	Object.is,
+	Object.isExtensible,
+	Object.isFrozen,
+	Object.isSealed,
+	Object.keys,
+	Object.values,
+	parseFloat,
+	parseInt,
+	RegExp,
+	String,
+	String.fromCharCode,
+	String.fromCodePoint,
+	String.raw,
+	Symbol.for,
+	Symbol.keyFor,
+	unescape
+].filter((f) => typeof f === "function"));
+const callPassThrough = new Set([
+	Object.freeze,
+	Object.preventExtensions,
+	Object.seal
+]);
+/**
+* Get the property descriptor.
+* @param {object} object The object to get.
+* @param {string|number|symbol} name The property name to get.
+*/
+function getPropertyDescriptor(object, name) {
+	let x = object;
+	while ((typeof x === "object" || typeof x === "function") && x !== null) {
+		const d = Object.getOwnPropertyDescriptor(x, name);
+		if (d) return d;
+		x = Object.getPrototypeOf(x);
+	}
+	return null;
+}
+/**
+* Check if a property is getter or not.
+* @param {object} object The object to check.
+* @param {string|number|symbol} name The property name to check.
+*/
+function isGetter(object, name) {
+	const d = getPropertyDescriptor(object, name);
+	return d != null && d.get != null;
+}
+/**
+* Get the element values of a given node list.
+* @param {Node[]} nodeList The node list to get values.
+* @param {Scope|undefined} initialScope The initial scope to find variables.
+* @returns {any[]|null} The value list if all nodes are constant. Otherwise, null.
+*/
+function getElementValues(nodeList, initialScope) {
+	const valueList = [];
+	for (let i = 0; i < nodeList.length; ++i) {
+		const elementNode = nodeList[i];
+		if (elementNode == null) valueList.length = i + 1;
+		else if (elementNode.type === "SpreadElement") {
+			const argument = getStaticValueR(elementNode.argument, initialScope);
+			if (argument == null) return null;
+			valueList.push(...argument.value);
+		} else {
+			const element = getStaticValueR(elementNode, initialScope);
+			if (element == null) return null;
+			valueList.push(element.value);
+		}
+	}
+	return valueList;
+}
+const operations = Object.freeze({
+	ArrayExpression(node, initialScope) {
+		const elements = getElementValues(node.elements, initialScope);
+		return elements != null ? { value: elements } : null;
+	},
+	AssignmentExpression(node, initialScope) {
+		if (node.operator === "=") return getStaticValueR(node.right, initialScope);
+		return null;
+	},
+	BinaryExpression(node, initialScope) {
+		if (node.operator === "in" || node.operator === "instanceof") return null;
+		const left = getStaticValueR(node.left, initialScope);
+		const right = getStaticValueR(node.right, initialScope);
+		if (left != null && right != null) switch (node.operator) {
+			case "==": return { value: left.value == right.value };
+			case "!=": return { value: left.value != right.value };
+			case "===": return { value: left.value === right.value };
+			case "!==": return { value: left.value !== right.value };
+			case "<": return { value: left.value < right.value };
+			case "<=": return { value: left.value <= right.value };
+			case ">": return { value: left.value > right.value };
+			case ">=": return { value: left.value >= right.value };
+			case "<<": return { value: left.value << right.value };
+			case ">>": return { value: left.value >> right.value };
+			case ">>>": return { value: left.value >>> right.value };
+			case "+": return { value: left.value + right.value };
+			case "-": return { value: left.value - right.value };
+			case "*": return { value: left.value * right.value };
+			case "/": return { value: left.value / right.value };
+			case "%": return { value: left.value % right.value };
+			case "**": return { value: Math.pow(left.value, right.value) };
+			case "|": return { value: left.value | right.value };
+			case "^": return { value: left.value ^ right.value };
+			case "&": return { value: left.value & right.value };
+		}
+		return null;
+	},
+	CallExpression(node, initialScope) {
+		const calleeNode = node.callee;
+		const args = getElementValues(node.arguments, initialScope);
+		if (args != null) if (calleeNode.type === "MemberExpression") {
+			if (calleeNode.property.type === "PrivateIdentifier") return null;
+			const object = getStaticValueR(calleeNode.object, initialScope);
+			if (object != null) {
+				if (object.value == null && (object.optional || node.optional)) return {
+					value: void 0,
+					optional: true
+				};
+				const property = getStaticPropertyNameValue(calleeNode, initialScope);
+				if (property != null) {
+					const receiver = object.value;
+					const methodName = property.value;
+					if (callAllowed.has(receiver[methodName])) return { value: receiver[methodName](...args) };
+					if (callPassThrough.has(receiver[methodName])) return { value: args[0] };
+				}
+			}
+		} else {
+			const callee = getStaticValueR(calleeNode, initialScope);
+			if (callee != null) {
+				if (callee.value == null && node.optional) return {
+					value: void 0,
+					optional: true
+				};
+				const func = callee.value;
+				if (callAllowed.has(func)) return { value: func(...args) };
+				if (callPassThrough.has(func)) return { value: args[0] };
+			}
+		}
+		return null;
+	},
+	ConditionalExpression(node, initialScope) {
+		const test = getStaticValueR(node.test, initialScope);
+		if (test != null) return test.value ? getStaticValueR(node.consequent, initialScope) : getStaticValueR(node.alternate, initialScope);
+		return null;
+	},
+	ExpressionStatement(node, initialScope) {
+		return getStaticValueR(node.expression, initialScope);
+	},
+	Identifier(node, initialScope) {
+		if (initialScope != null) {
+			const variable = findVariable(initialScope, node);
+			if (variable != null && variable.defs.length === 0 && builtinNames.has(variable.name) && variable.name in globalObject) return { value: globalObject[variable.name] };
+			if (variable != null && variable.defs.length === 1) {
+				const def = variable.defs[0];
+				if (def.parent && def.parent.kind === "const" && def.node.id.type === "Identifier") return getStaticValueR(def.node.init, initialScope);
+			}
+		}
+		return null;
+	},
+	Literal(node) {
+		//istanbul ignore if : this is implementation-specific behavior.
+		if ((node.regex != null || node.bigint != null) && node.value == null) return null;
+		return { value: node.value };
+	},
+	LogicalExpression(node, initialScope) {
+		const left = getStaticValueR(node.left, initialScope);
+		if (left != null) {
+			if (node.operator === "||" && Boolean(left.value) === true || node.operator === "&&" && Boolean(left.value) === false || node.operator === "??" && left.value != null) return left;
+			const right = getStaticValueR(node.right, initialScope);
+			if (right != null) return right;
+		}
+		return null;
+	},
+	MemberExpression(node, initialScope) {
+		if (node.property.type === "PrivateIdentifier") return null;
+		const object = getStaticValueR(node.object, initialScope);
+		if (object != null) {
+			if (object.value == null && (object.optional || node.optional)) return {
+				value: void 0,
+				optional: true
+			};
+			const property = getStaticPropertyNameValue(node, initialScope);
+			if (property != null && !isGetter(object.value, property.value)) return { value: object.value[property.value] };
+		}
+		return null;
+	},
+	ChainExpression(node, initialScope) {
+		const expression = getStaticValueR(node.expression, initialScope);
+		if (expression != null) return { value: expression.value };
+		return null;
+	},
+	NewExpression(node, initialScope) {
+		const callee = getStaticValueR(node.callee, initialScope);
+		const args = getElementValues(node.arguments, initialScope);
+		if (callee != null && args != null) {
+			const Func = callee.value;
+			if (callAllowed.has(Func)) return { value: new Func(...args) };
+		}
+		return null;
+	},
+	ObjectExpression(node, initialScope) {
+		const object = {};
+		for (const propertyNode of node.properties) if (propertyNode.type === "Property") {
+			if (propertyNode.kind !== "init") return null;
+			const key = getStaticPropertyNameValue(propertyNode, initialScope);
+			const value = getStaticValueR(propertyNode.value, initialScope);
+			if (key == null || value == null) return null;
+			object[key.value] = value.value;
+		} else if (propertyNode.type === "SpreadElement" || propertyNode.type === "ExperimentalSpreadProperty") {
+			const argument = getStaticValueR(propertyNode.argument, initialScope);
+			if (argument == null) return null;
+			Object.assign(object, argument.value);
+		} else return null;
+		return { value: object };
+	},
+	SequenceExpression(node, initialScope) {
+		const last = node.expressions[node.expressions.length - 1];
+		return getStaticValueR(last, initialScope);
+	},
+	TaggedTemplateExpression(node, initialScope) {
+		const tag = getStaticValueR(node.tag, initialScope);
+		const expressions = getElementValues(node.quasi.expressions, initialScope);
+		if (tag != null && expressions != null) {
+			const func = tag.value;
+			const strings = node.quasi.quasis.map((q) => q.value.cooked);
+			strings.raw = node.quasi.quasis.map((q) => q.value.raw);
+			if (func === String.raw) return { value: func(strings, ...expressions) };
+		}
+		return null;
+	},
+	TemplateLiteral(node, initialScope) {
+		const expressions = getElementValues(node.expressions, initialScope);
+		if (expressions != null) {
+			let value = node.quasis[0].value.cooked;
+			for (let i = 0; i < expressions.length; ++i) {
+				value += expressions[i];
+				value += node.quasis[i + 1].value.cooked;
+			}
+			return { value };
+		}
+		return null;
+	},
+	UnaryExpression(node, initialScope) {
+		if (node.operator === "delete") return null;
+		if (node.operator === "void") return { value: void 0 };
+		const arg = getStaticValueR(node.argument, initialScope);
+		if (arg != null) switch (node.operator) {
+			case "-": return { value: -arg.value };
+			case "+": return { value: +arg.value };
+			case "!": return { value: !arg.value };
+			case "~": return { value: ~arg.value };
+			case "typeof": return { value: typeof arg.value };
+		}
+		return null;
+	}
+});
+/**
+* Get the value of a given node if it's a static value.
+* @param {Node} node The node to get.
+* @param {Scope|undefined} initialScope The scope to start finding variable.
+* @returns {{value:any}|{value:undefined,optional?:true}|null} The static value of the node, or `null`.
+*/
+function getStaticValueR(node, initialScope) {
+	if (node != null && Object.hasOwnProperty.call(operations, node.type)) return operations[node.type](node, initialScope);
+	return null;
+}
+/**
+* Get the static value of property name from a MemberExpression node or a Property node.
+* @param {Node} node The node to get.
+* @param {Scope} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it.
+* @returns {{value:any}|{value:undefined,optional?:true}|null} The static value of the property name of the node, or `null`.
+*/
+function getStaticPropertyNameValue(node, initialScope) {
+	const nameNode = node.type === "Property" ? node.key : node.property;
+	if (node.computed) return getStaticValueR(nameNode, initialScope);
+	if (nameNode.type === "Identifier") return { value: nameNode.name };
+	if (nameNode.type === "Literal") {
+		if (nameNode.bigint) return { value: nameNode.bigint };
+		return { value: String(nameNode.value) };
+	}
+	return null;
+}
+/**
+* Get the value of a given node if it's a static value.
+* @param {Node} node The node to get.
+* @param {Scope} [initialScope] The scope to start finding variable. Optional. If this scope was given, this tries to resolve identifier references which are in the given node as much as possible.
+* @returns {{value:any}|{value:undefined,optional?:true}|null} The static value of the node, or `null`.
+*/
+function getStaticValue(node, initialScope = null) {
+	try {
+		return getStaticValueR(node, initialScope);
+	} catch (_error) {
+		return null;
+	}
+}
+/**
+* Get the value of a given node if it's a literal or a template literal.
+* @param {Node} node The node to get.
+* @param {Scope} [initialScope] The scope to start finding variable. Optional. If the node is an Identifier node and this scope was given, this checks the variable of the identifier, and returns the value of it if the variable is a constant.
+* @returns {string|null} The value of the node, or `null`.
+*/
+function getStringIfConstant(node, initialScope = null) {
+	if (node && node.type === "Literal" && node.value === null) {
+		if (node.regex) return `/${node.regex.pattern}/${node.regex.flags}`;
+		if (node.bigint) return node.bigint;
+	}
+	const evaluated = getStaticValue(node, initialScope);
+	return evaluated && String(evaluated.value);
+}
+/**
+* Get the property name from a MemberExpression node or a Property node.
+* @param {Node} node The node to get.
+* @param {Scope} [initialScope] The scope to start finding variable. Optional. If the node is a computed property node and this scope was given, this checks the computed property name by the `getStringIfConstant` function with the scope, and returns the value of it.
+* @returns {string|null} The property name of the node.
+*/
+function getPropertyName(node, initialScope) {
+	switch (node.type) {
+		case "MemberExpression":
+			if (node.computed) return getStringIfConstant(node.property, initialScope);
+			if (node.property.type === "PrivateIdentifier") return null;
+			return node.property.name;
+		case "Property":
+		case "MethodDefinition":
+		case "PropertyDefinition":
+			if (node.computed) return getStringIfConstant(node.key, initialScope);
+			if (node.key.type === "Literal") return String(node.key.value);
+			if (node.key.type === "PrivateIdentifier") return null;
+			return node.key.name;
+	}
+	return null;
+}
+const typeConversionBinaryOps = Object.freeze(new Set([
+	"==",
+	"!=",
+	"<",
+	"<=",
+	">",
+	">=",
+	"<<",
+	">>",
+	">>>",
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"|",
+	"^",
+	"&",
+	"in"
+]));
+const typeConversionUnaryOps = Object.freeze(new Set([
+	"-",
+	"+",
+	"!",
+	"~"
+]));
+/**
+* Check whether the given value is an ASTNode or not.
+* @param {any} x The value to check.
+* @returns {boolean} `true` if the value is an ASTNode.
+*/
+function isNode(x) {
+	return x !== null && typeof x === "object" && typeof x.type === "string";
+}
+const visitor = Object.freeze(Object.assign(Object.create(null), {
+	$visit(node, options, visitorKeys) {
+		const { type } = node;
+		if (typeof this[type] === "function") return this[type](node, options, visitorKeys);
+		return this.$visitChildren(node, options, visitorKeys);
+	},
+	$visitChildren(node, options, visitorKeys) {
+		const { type } = node;
+		for (const key of visitorKeys[type] || import_lib.default.getKeys(node)) {
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const element of value) if (isNode(element) && this.$visit(element, options, visitorKeys)) return true;
+			} else if (isNode(value) && this.$visit(value, options, visitorKeys)) return true;
+		}
+		return false;
+	},
+	ArrowFunctionExpression() {
+		return false;
+	},
+	AssignmentExpression() {
+		return true;
+	},
+	AwaitExpression() {
+		return true;
+	},
+	BinaryExpression(node, options, visitorKeys) {
+		if (options.considerImplicitTypeConversion && typeConversionBinaryOps.has(node.operator) && (node.left.type !== "Literal" || node.right.type !== "Literal")) return true;
+		return this.$visitChildren(node, options, visitorKeys);
+	},
+	CallExpression() {
+		return true;
+	},
+	FunctionExpression() {
+		return false;
+	},
+	ImportExpression() {
+		return true;
+	},
+	MemberExpression(node, options, visitorKeys) {
+		if (options.considerGetters) return true;
+		if (options.considerImplicitTypeConversion && node.computed && node.property.type !== "Literal") return true;
+		return this.$visitChildren(node, options, visitorKeys);
+	},
+	MethodDefinition(node, options, visitorKeys) {
+		if (options.considerImplicitTypeConversion && node.computed && node.key.type !== "Literal") return true;
+		return this.$visitChildren(node, options, visitorKeys);
+	},
+	NewExpression() {
+		return true;
+	},
+	Property(node, options, visitorKeys) {
+		if (options.considerImplicitTypeConversion && node.computed && node.key.type !== "Literal") return true;
+		return this.$visitChildren(node, options, visitorKeys);
+	},
+	PropertyDefinition(node, options, visitorKeys) {
+		if (options.considerImplicitTypeConversion && node.computed && node.key.type !== "Literal") return true;
+		return this.$visitChildren(node, options, visitorKeys);
+	},
+	UnaryExpression(node, options, visitorKeys) {
+		if (node.operator === "delete") return true;
+		if (options.considerImplicitTypeConversion && typeConversionUnaryOps.has(node.operator) && node.argument.type !== "Literal") return true;
+		return this.$visitChildren(node, options, visitorKeys);
+	},
+	UpdateExpression() {
+		return true;
+	},
+	YieldExpression() {
+		return true;
+	}
+}));
+/**
+* @author Toru Nagashima <https://github.com/mysticatea>
+* See LICENSE file in root directory for full license.
+*/
+const placeholder = /\$(?:[$&`']|[1-9][0-9]?)/gu;
+/** @type {WeakMap<PatternMatcher, {pattern:RegExp,escaped:boolean}>} */
+const internal = /* @__PURE__ */ new WeakMap();
+/**
+* Check whether a given character is escaped or not.
+* @param {string} str The string to check.
+* @param {number} index The location of the character to check.
+* @returns {boolean} `true` if the character is escaped.
+*/
+function isEscaped(str, index) {
+	let escaped = false;
+	for (let i = index - 1; i >= 0 && str.charCodeAt(i) === 92; --i) escaped = !escaped;
+	return escaped;
+}
+/**
+* Replace a given string by a given matcher.
+* @param {PatternMatcher} matcher The pattern matcher.
+* @param {string} str The string to be replaced.
+* @param {string} replacement The new substring to replace each matched part.
+* @returns {string} The replaced string.
+*/
+function replaceS(matcher, str, replacement) {
+	const chunks = [];
+	let index = 0;
+	/** @type {RegExpExecArray} */
+	let match = null;
+	/**
+	* @param {string} key The placeholder.
+	* @returns {string} The replaced string.
+	*/
+	function replacer(key) {
+		switch (key) {
+			case "$$": return "$";
+			case "$&": return match[0];
+			case "$`": return str.slice(0, match.index);
+			case "$'": return str.slice(match.index + match[0].length);
+			default: {
+				const i = key.slice(1);
+				if (i in match) return match[i];
+				return key;
+			}
+		}
+	}
+	for (match of matcher.execAll(str)) {
+		chunks.push(str.slice(index, match.index));
+		chunks.push(replacement.replace(placeholder, replacer));
+		index = match.index + match[0].length;
+	}
+	chunks.push(str.slice(index));
+	return chunks.join("");
+}
+/**
+* Replace a given string by a given matcher.
+* @param {PatternMatcher} matcher The pattern matcher.
+* @param {string} str The string to be replaced.
+* @param {(...strs[])=>string} replace The function to replace each matched part.
+* @returns {string} The replaced string.
+*/
+function replaceF(matcher, str, replace) {
+	const chunks = [];
+	let index = 0;
+	for (const match of matcher.execAll(str)) {
+		chunks.push(str.slice(index, match.index));
+		chunks.push(String(replace(...match, match.index, match.input)));
+		index = match.index + match[0].length;
+	}
+	chunks.push(str.slice(index));
+	return chunks.join("");
+}
+/**
+* The class to find patterns as considering escape sequences.
+*/
+var PatternMatcher = class {
+	/**
+	* Initialize this matcher.
+	* @param {RegExp} pattern The pattern to match.
+	* @param {{escaped:boolean}} options The options.
+	*/
+	constructor(pattern, { escaped = false } = {}) {
+		if (!(pattern instanceof RegExp)) throw new TypeError("'pattern' should be a RegExp instance.");
+		if (!pattern.flags.includes("g")) throw new Error("'pattern' should contains 'g' flag.");
+		internal.set(this, {
+			pattern: new RegExp(pattern.source, pattern.flags),
+			escaped: Boolean(escaped)
+		});
+	}
+	/**
+	* Find the pattern in a given string.
+	* @param {string} str The string to find.
+	* @returns {IterableIterator<RegExpExecArray>} The iterator which iterate the matched information.
+	*/
+	*execAll(str) {
+		const { pattern, escaped } = internal.get(this);
+		let match = null;
+		let lastIndex = 0;
+		pattern.lastIndex = 0;
+		while ((match = pattern.exec(str)) != null) if (escaped || !isEscaped(str, match.index)) {
+			lastIndex = pattern.lastIndex;
+			yield match;
+			pattern.lastIndex = lastIndex;
+		}
+	}
+	/**
+	* Check whether the pattern is found in a given string.
+	* @param {string} str The string to check.
+	* @returns {boolean} `true` if the pattern was found in the string.
+	*/
+	test(str) {
+		return !this.execAll(str).next().done;
+	}
+	/**
+	* Replace a given string.
+	* @param {string} str The string to be replaced.
+	* @param {(string|((...strs:string[])=>string))} replacer The string or function to replace. This is the same as the 2nd argument of `String.prototype.replace`.
+	* @returns {string} The replaced string.
+	*/
+	[Symbol.replace](str, replacer) {
+		return typeof replacer === "function" ? replaceF(this, String(str), replacer) : replaceS(this, String(str), String(replacer));
+	}
+};
+const IMPORT_TYPE = /^(?:Import|Export(?:All|Default|Named))Declaration$/u;
+const has = Function.call.bind(Object.hasOwnProperty);
+const READ = Symbol("read");
+const CALL = Symbol("call");
+const CONSTRUCT = Symbol("construct");
+const ESM = Symbol("esm");
+const requireCall = { require: { [CALL]: true } };
+/**
+* Check whether a given variable is modified or not.
+* @param {Variable} variable The variable to check.
+* @returns {boolean} `true` if the variable is modified.
+*/
+function isModifiedGlobal(variable) {
+	return variable == null || variable.defs.length !== 0 || variable.references.some((r) => r.isWrite());
+}
+/**
+* Check if the value of a given node is passed through to the parent syntax as-is.
+* For example, `a` and `b` in (`a || b` and `c ? a : b`) are passed through.
+* @param {Node} node A node to check.
+* @returns {boolean} `true` if the node is passed through.
+*/
+function isPassThrough(node) {
+	const parent = node.parent;
+	switch (parent && parent.type) {
+		case "ConditionalExpression": return parent.consequent === node || parent.alternate === node;
+		case "LogicalExpression": return true;
+		case "SequenceExpression": return parent.expressions[parent.expressions.length - 1] === node;
+		case "ChainExpression": return true;
+		default: return false;
+	}
+}
+/**
+* The reference tracker.
+*/
+var ReferenceTracker = class {
+	/**
+	* Initialize this tracker.
+	* @param {Scope} globalScope The global scope.
+	* @param {object} [options] The options.
+	* @param {"legacy"|"strict"} [options.mode="strict"] The mode to determine the ImportDeclaration's behavior for CJS modules.
+	* @param {string[]} [options.globalObjectNames=["global","globalThis","self","window"]] The variable names for Global Object.
+	*/
+	constructor(globalScope, { mode = "strict", globalObjectNames = [
+		"global",
+		"globalThis",
+		"self",
+		"window"
+	] } = {}) {
+		this.variableStack = [];
+		this.globalScope = globalScope;
+		this.mode = mode;
+		this.globalObjectNames = globalObjectNames.slice(0);
+	}
+	/**
+	* Iterate the references of global variables.
+	* @param {object} traceMap The trace map.
+	* @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.
+	*/
+	*iterateGlobalReferences(traceMap) {
+		for (const key of Object.keys(traceMap)) {
+			const nextTraceMap = traceMap[key];
+			const path = [key];
+			const variable = this.globalScope.set.get(key);
+			if (isModifiedGlobal(variable)) continue;
+			yield* this._iterateVariableReferences(variable, path, nextTraceMap, true);
+		}
+		for (const key of this.globalObjectNames) {
+			const path = [];
+			const variable = this.globalScope.set.get(key);
+			if (isModifiedGlobal(variable)) continue;
+			yield* this._iterateVariableReferences(variable, path, traceMap, false);
+		}
+	}
+	/**
+	* Iterate the references of CommonJS modules.
+	* @param {object} traceMap The trace map.
+	* @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.
+	*/
+	*iterateCjsReferences(traceMap) {
+		for (const { node } of this.iterateGlobalReferences(requireCall)) {
+			const key = getStringIfConstant(node.arguments[0]);
+			if (key == null || !has(traceMap, key)) continue;
+			const nextTraceMap = traceMap[key];
+			const path = [key];
+			if (nextTraceMap[READ]) yield {
+				node,
+				path,
+				type: READ,
+				info: nextTraceMap[READ]
+			};
+			yield* this._iteratePropertyReferences(node, path, nextTraceMap);
+		}
+	}
+	/**
+	* Iterate the references of ES modules.
+	* @param {object} traceMap The trace map.
+	* @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.
+	*/
+	*iterateEsmReferences(traceMap) {
+		const programNode = this.globalScope.block;
+		for (const node of programNode.body) {
+			if (!IMPORT_TYPE.test(node.type) || node.source == null) continue;
+			const moduleId = node.source.value;
+			if (!has(traceMap, moduleId)) continue;
+			const nextTraceMap = traceMap[moduleId];
+			const path = [moduleId];
+			if (nextTraceMap[READ]) yield {
+				node,
+				path,
+				type: READ,
+				info: nextTraceMap[READ]
+			};
+			if (node.type === "ExportAllDeclaration") for (const key of Object.keys(nextTraceMap)) {
+				const exportTraceMap = nextTraceMap[key];
+				if (exportTraceMap[READ]) yield {
+					node,
+					path: path.concat(key),
+					type: READ,
+					info: exportTraceMap[READ]
+				};
+			}
+			else for (const specifier of node.specifiers) {
+				const esm = has(nextTraceMap, ESM);
+				const it = this._iterateImportReferences(specifier, path, esm ? nextTraceMap : this.mode === "legacy" ? {
+					default: nextTraceMap,
+					...nextTraceMap
+				} : { default: nextTraceMap });
+				if (esm) yield* it;
+				else for (const report of it) {
+					report.path = report.path.filter(exceptDefault);
+					if (report.path.length >= 2 || report.type !== READ) yield report;
+				}
+			}
+		}
+	}
+	/**
+	* Iterate the references for a given variable.
+	* @param {Variable} variable The variable to iterate that references.
+	* @param {string[]} path The current path.
+	* @param {object} traceMap The trace map.
+	* @param {boolean} shouldReport = The flag to report those references.
+	* @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.
+	*/
+	*_iterateVariableReferences(variable, path, traceMap, shouldReport) {
+		if (this.variableStack.includes(variable)) return;
+		this.variableStack.push(variable);
+		try {
+			for (const reference of variable.references) {
+				if (!reference.isRead()) continue;
+				const node = reference.identifier;
+				if (shouldReport && traceMap[READ]) yield {
+					node,
+					path,
+					type: READ,
+					info: traceMap[READ]
+				};
+				yield* this._iteratePropertyReferences(node, path, traceMap);
+			}
+		} finally {
+			this.variableStack.pop();
+		}
+	}
+	/**
+	* Iterate the references for a given AST node.
+	* @param rootNode The AST node to iterate references.
+	* @param {string[]} path The current path.
+	* @param {object} traceMap The trace map.
+	* @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.
+	*/
+	*_iteratePropertyReferences(rootNode, path, traceMap) {
+		let node = rootNode;
+		while (isPassThrough(node)) node = node.parent;
+		const parent = node.parent;
+		if (parent.type === "MemberExpression") {
+			if (parent.object === node) {
+				const key = getPropertyName(parent);
+				if (key == null || !has(traceMap, key)) return;
+				path = path.concat(key);
+				const nextTraceMap = traceMap[key];
+				if (nextTraceMap[READ]) yield {
+					node: parent,
+					path,
+					type: READ,
+					info: nextTraceMap[READ]
+				};
+				yield* this._iteratePropertyReferences(parent, path, nextTraceMap);
+			}
+			return;
+		}
+		if (parent.type === "CallExpression") {
+			if (parent.callee === node && traceMap[CALL]) yield {
+				node: parent,
+				path,
+				type: CALL,
+				info: traceMap[CALL]
+			};
+			return;
+		}
+		if (parent.type === "NewExpression") {
+			if (parent.callee === node && traceMap[CONSTRUCT]) yield {
+				node: parent,
+				path,
+				type: CONSTRUCT,
+				info: traceMap[CONSTRUCT]
+			};
+			return;
+		}
+		if (parent.type === "AssignmentExpression") {
+			if (parent.right === node) {
+				yield* this._iterateLhsReferences(parent.left, path, traceMap);
+				yield* this._iteratePropertyReferences(parent, path, traceMap);
+			}
+			return;
+		}
+		if (parent.type === "AssignmentPattern") {
+			if (parent.right === node) yield* this._iterateLhsReferences(parent.left, path, traceMap);
+			return;
+		}
+		if (parent.type === "VariableDeclarator") {
+			if (parent.init === node) yield* this._iterateLhsReferences(parent.id, path, traceMap);
+		}
+	}
+	/**
+	* Iterate the references for a given Pattern node.
+	* @param {Node} patternNode The Pattern node to iterate references.
+	* @param {string[]} path The current path.
+	* @param {object} traceMap The trace map.
+	* @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.
+	*/
+	*_iterateLhsReferences(patternNode, path, traceMap) {
+		if (patternNode.type === "Identifier") {
+			const variable = findVariable(this.globalScope, patternNode);
+			if (variable != null) yield* this._iterateVariableReferences(variable, path, traceMap, false);
+			return;
+		}
+		if (patternNode.type === "ObjectPattern") {
+			for (const property of patternNode.properties) {
+				const key = getPropertyName(property);
+				if (key == null || !has(traceMap, key)) continue;
+				const nextPath = path.concat(key);
+				const nextTraceMap = traceMap[key];
+				if (nextTraceMap[READ]) yield {
+					node: property,
+					path: nextPath,
+					type: READ,
+					info: nextTraceMap[READ]
+				};
+				yield* this._iterateLhsReferences(property.value, nextPath, nextTraceMap);
+			}
+			return;
+		}
+		if (patternNode.type === "AssignmentPattern") yield* this._iterateLhsReferences(patternNode.left, path, traceMap);
+	}
+	/**
+	* Iterate the references for a given ModuleSpecifier node.
+	* @param {Node} specifierNode The ModuleSpecifier node to iterate references.
+	* @param {string[]} path The current path.
+	* @param {object} traceMap The trace map.
+	* @returns {IterableIterator<{node:Node,path:string[],type:symbol,info:any}>} The iterator to iterate references.
+	*/
+	*_iterateImportReferences(specifierNode, path, traceMap) {
+		const type = specifierNode.type;
+		if (type === "ImportSpecifier" || type === "ImportDefaultSpecifier") {
+			const key = type === "ImportDefaultSpecifier" ? "default" : specifierNode.imported.name;
+			if (!has(traceMap, key)) return;
+			path = path.concat(key);
+			const nextTraceMap = traceMap[key];
+			if (nextTraceMap[READ]) yield {
+				node: specifierNode,
+				path,
+				type: READ,
+				info: nextTraceMap[READ]
+			};
+			yield* this._iterateVariableReferences(findVariable(this.globalScope, specifierNode.local), path, nextTraceMap, false);
+			return;
+		}
+		if (type === "ImportNamespaceSpecifier") {
+			yield* this._iterateVariableReferences(findVariable(this.globalScope, specifierNode.local), path, traceMap, false);
+			return;
+		}
+		if (type === "ExportSpecifier") {
+			const key = specifierNode.local.name;
+			if (!has(traceMap, key)) return;
+			path = path.concat(key);
+			const nextTraceMap = traceMap[key];
+			if (nextTraceMap[READ]) yield {
+				node: specifierNode,
+				path,
+				type: READ,
+				info: nextTraceMap[READ]
+			};
+		}
+	}
+};
+ReferenceTracker.READ = READ;
+ReferenceTracker.CALL = CALL;
+ReferenceTracker.CONSTRUCT = CONSTRUCT;
+ReferenceTracker.ESM = ESM;
+/**
+* This is a predicate function for Array#filter.
+* @param {string} name A name part.
+* @param {number} index The index of the name.
+* @returns {boolean} `false` if it's default.
+*/
+function exceptDefault(name, index) {
+	return !(index === 1 && name === "default");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/util/ast.js
+const traverse = (context, node, visit, visited = /* @__PURE__ */ new Set()) => {
+	if (visited.has(node)) return;
+	visited.add(node);
+	visit(node);
+	(context.sourceCode.visitorKeys[node.type] || []).map((key) => node[key]).filter(Boolean).flatMap((child) => Array.isArray(child) ? child : [child]).filter(Boolean).filter((child) => typeof child.type === "string").forEach((child) => traverse(context, child, visit, visited));
+};
+const findDownstreamNodes = (context, topNode, type) => {
+	const nodes = [];
+	traverse(context, topNode, (node) => {
+		if (node.type === type) nodes.push(node);
+	});
+	return nodes;
+};
+const getUpstreamVariables = (context, variable, filter, visited = /* @__PURE__ */ new Set()) => {
+	if (visited.has(variable)) return [];
+	visited.add(variable);
+	const upstreamVariables = variable.defs.filter((def) => !!def.node.init).filter((def) => filter(def.node)).flatMap((def) => getDownstreamRefs(context, def.node.init)).map((ref) => ref.resolved).filter(Boolean).flatMap((variable$1) => getUpstreamVariables(context, variable$1, filter, visited));
+	return upstreamVariables.length === 0 ? [variable] : upstreamVariables;
+};
+const getDownstreamRefs = (context, node) => findDownstreamNodes(context, node, "Identifier").map((identifier) => getRef(context, identifier)).filter(Boolean);
+const getRef = (context, identifier) => findVariable(context.sourceCode.getScope(identifier), identifier)?.references.find((ref) => ref.identifier === identifier);
+const getCallExpr = (ref, current = ref.identifier.parent) => {
+	if (current.type === "CallExpression") {
+		let node = ref.identifier;
+		while (node.parent.type === "MemberExpression") node = node.parent;
+		if (current.callee === node) return current;
+	}
+	if (current.type === "MemberExpression") return getCallExpr(ref, current.parent);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/util/react.js
+const isReactFunctionalComponent = (node) => (node.type === "FunctionDeclaration" || node.type === "VariableDeclarator" && (node.init.type === "ArrowFunctionExpression" || node.init.type === "CallExpression")) && node.id.type === "Identifier" && node.id.name[0].toUpperCase() === node.id.name[0];
+const isReactFunctionalHOC = (node) => node.type === "VariableDeclarator" && node.init && node.init.type === "CallExpression" && node.init.callee.type === "Identifier" && !["memo", "forwardRef"].includes(node.init.callee.name) && node.init.arguments.length > 0 && (node.init.arguments[0].type === "ArrowFunctionExpression" || node.init.arguments[0].type === "FunctionExpression") && node.id.type === "Identifier" && node.id.name[0].toUpperCase() === node.id.name[0];
+const isCustomHook = (node) => (node.type === "FunctionDeclaration" || node.type === "VariableDeclarator" && node.init && (node.init.type === "ArrowFunctionExpression" || node.init.type === "FunctionExpression")) && node.id.type === "Identifier" && node.id.name.startsWith("use") && node.id.name[3] === node.id.name[3].toUpperCase();
+const isUseState = (node) => node.type === "VariableDeclarator" && node.init && node.init.type === "CallExpression" && node.init.callee.name === "useState" && node.id.type === "ArrayPattern" && (node.id.elements.length === 1 || node.id.elements.length === 2) && node.id.elements.every((el) => {
+	return !el || el.type === "Identifier";
+});
+const isPropDef = (def) => {
+	const declaringNode = def.node.type === "ArrowFunctionExpression" ? def.node.parent.type === "CallExpression" ? def.node.parent.parent : def.node.parent : def.node;
+	return def.type === "Parameter" && (isReactFunctionalComponent(declaringNode) && !isReactFunctionalHOC(declaringNode) || isCustomHook(declaringNode));
+};
+const isUseRef = (node) => node.type === "VariableDeclarator" && node.init && node.init.type === "CallExpression" && node.init.callee.name === "useRef" && node.id.type === "Identifier";
+const isUseEffect = (node) => node.type === "CallExpression" && (node.callee.type === "Identifier" && node.callee.name === "useEffect" || node.callee.type === "MemberExpression" && node.callee.object.name === "React" && node.callee.property.name === "useEffect");
+const getEffectFnRefs = (context, node) => {
+	if (!isUseEffect(node) || node.arguments.length < 1) return;
+	const effectFn = node.arguments[0];
+	if (effectFn.type !== "ArrowFunctionExpression" && effectFn.type !== "FunctionExpression") return;
+	return getDownstreamRefs(context, effectFn);
+};
+function getEffectDepsRefs(context, node) {
+	if (!isUseEffect(node) || node.arguments.length < 2) return;
+	const depsArr = node.arguments[1];
+	if (depsArr.type !== "ArrayExpression") return;
+	return getDownstreamRefs(context, depsArr);
+}
+const isStateSetter = (context, ref) => getCallExpr(ref) !== void 0 && isState(context, ref);
+const isPropCallback = (context, ref) => getCallExpr(ref) !== void 0 && isProp(context, ref);
+const isState = (context, ref) => getUpstreamReactVariables(context, ref.resolved).notEmptyEvery((variable) => variable.defs.some((def) => isUseState(def.node)));
+const isProp = (context, ref) => getUpstreamReactVariables(context, ref.resolved).notEmptyEvery((variable) => variable.defs.some((def) => isPropDef(def)));
+const isRef = (context, ref) => getUpstreamReactVariables(context, ref.resolved).notEmptyEvery((variable) => variable.defs.some((def) => isUseRef(def.node)));
+const getUseStateNode = (context, ref) => {
+	return getUpstreamReactVariables(context, ref.resolved).find((variable) => variable.defs.some((def) => isUseState(def.node)))?.defs.find((def) => isUseState(def.node))?.node;
+};
+/**
+* Walks up the AST until a `useEffect` call, returning `false` if never found, or finds any of the following on the way:
+* - An async function
+* - A function declaration, which may be called at an arbitrary later time
+* - A function passed as a callback to another function or `new` - event handler, `setTimeout`, `Promise.then()` `new ResizeObserver()`, etc.
+*
+* Otherwise returns `true`.
+*
+* Inspired by https://eslint-react.xyz/docs/rules/hooks-extra-no-direct-set-state-in-use-effect
+*/
+const isImmediateCall = (node) => {
+	if (!node.parent) return false;
+	else if (isUseEffect(node.parent)) return true;
+	else if (node.async || node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return false;
+	else return isImmediateCall(node.parent);
+};
+const isArgsAllLiterals = (context, callExpr) => callExpr.arguments.flatMap((arg) => getDownstreamRefs(context, arg)).flatMap((ref) => getUpstreamReactVariables(context, ref.resolved)).length === 0;
+const getUpstreamReactVariables = (context, variable) => getUpstreamVariables(context, variable, (node) => !isUseState(node)).filter((variable$1) => variable$1.defs.every((def) => isPropDef(def) || def.type !== "Parameter"));
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-empty-effect.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_empty_effect_default = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow empty effects." },
+		schema: [],
+		messages: { avoidEmptyEffect: "This effect is empty and could be removed." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		if (!isUseEffect(node)) return;
+		if (node.arguments?.length === 0 || getEffectFnRefs(context, node)?.length === 0) context.report({
+			node,
+			messageId: "avoidEmptyEffect"
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-adjust-state-on-prop-change.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_adjust_state_on_prop_change_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow adjusting state in an effect when a prop changes.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes"
+		},
+		schema: [],
+		messages: { avoidAdjustingStateWhenAPropChanges: "Avoid adjusting state when a prop changes. Instead, adjust the state directly during render, or refactor your state to avoid this need entirely." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		const isAllDepsProps = depsRefs.notEmptyEvery((ref) => isProp(context, ref));
+		effectFnRefs.filter((ref) => isStateSetter(context, ref)).filter((ref) => isImmediateCall(ref.identifier)).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			if (isAllDepsProps && isArgsAllLiterals(context, callExpr)) context.report({
+				node: callExpr,
+				messageId: "avoidAdjustingStateWhenAPropChanges"
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-reset-all-state-on-prop-change.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_reset_all_state_on_prop_change_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow resetting all state in an effect when a prop changes.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#resetting-all-state-when-a-prop-changes"
+		},
+		schema: [],
+		messages: { avoidResettingAllStateWhenAPropChanges: "Avoid resetting all state when a prop changes. If \"{{prop}}\" is a key, pass it as `key` instead so React will reset the component." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		const propUsedToResetAllState = findPropUsedToResetAllState(context, effectFnRefs, depsRefs, node);
+		if (propUsedToResetAllState) context.report({
+			node,
+			messageId: "avoidResettingAllStateWhenAPropChanges",
+			data: { prop: propUsedToResetAllState.identifier.name }
+		});
+	} })
+};
+const findPropUsedToResetAllState = (context, effectFnRefs, depsRefs, useEffectNode) => {
+	const stateSetterRefs = effectFnRefs.filter((ref) => isStateSetter(context, ref));
+	return stateSetterRefs.length > 0 && stateSetterRefs.every((ref) => isSetStateToInitialValue(context, ref)) && stateSetterRefs.length === countUseStates(context, findContainingNode(useEffectNode)) ? depsRefs.find((ref) => isProp(context, ref)) : void 0;
+};
+const isSetStateToInitialValue = (context, setterRef) => {
+	const setStateToValue = getCallExpr(setterRef).arguments[0];
+	const stateInitialValue = getUseStateNode(context, setterRef).init.arguments[0];
+	const isUndefined = (node) => node === void 0 || node.name === "undefined";
+	if (isUndefined(setStateToValue) && isUndefined(stateInitialValue)) return true;
+	if (setStateToValue === null && stateInitialValue === null) return true;
+	else if (setStateToValue && !stateInitialValue || !setStateToValue && stateInitialValue) return false;
+	return context.sourceCode.getText(setStateToValue) === context.sourceCode.getText(stateInitialValue);
+};
+const countUseStates = (context, componentNode) => {
+	if (!componentNode) return 0;
+	let count = 0;
+	traverse(context, componentNode, (node) => {
+		if (isUseState(node)) count++;
+	});
+	return count;
+};
+const findContainingNode = (node) => {
+	if (!node) return;
+	else if (isReactFunctionalComponent(node) || isReactFunctionalHOC(node) || isCustomHook(node)) return node;
+	else return findContainingNode(node.parent);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-event-handler.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_event_handler_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow using state and an effect as an event handler.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#sharing-logic-between-event-handlers"
+		},
+		schema: [],
+		messages: { avoidEventHandler: "Avoid using state and effects as an event handler. Instead, call the event handling code directly when the event occurs." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		findDownstreamNodes(context, node, "IfStatement").filter((ifNode) => !ifNode.alternate).filter((ifNode) => getDownstreamRefs(context, ifNode.test).notEmptyEvery((ref) => isState(context, ref))).forEach((ifNode) => {
+			context.report({
+				node: ifNode.test,
+				messageId: "avoidEventHandler"
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-pass-live-state-to-parent.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_pass_live_state_to_parent_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow passing live state to parent components in an effect.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#notifying-parent-components-about-state-changes"
+		},
+		schema: [],
+		messages: { avoidPassingLiveStateToParent: "Avoid passing live state to parents in an effect. Instead, lift the state to the parent and pass it down to the child as a prop." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		effectFnRefs.filter((ref) => isPropCallback(context, ref)).filter((ref) => isImmediateCall(ref.identifier)).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			if (callExpr.arguments.flatMap((arg) => getDownstreamRefs(context, arg)).some((ref$1) => isState(context, ref$1))) context.report({
+				node: callExpr,
+				messageId: "avoidPassingLiveStateToParent"
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-initialize-state.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_initialize_state_default = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow initializing state in an effect." },
+		schema: [],
+		messages: { avoidInitializingState: "Avoid initializing state in an effect. Instead, pass \"{{state}}\"'s initial value to its `useState`." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		if (depsRefs.length > 0) return;
+		effectFnRefs.filter((ref) => isStateSetter(context, ref)).filter((ref) => isImmediateCall(ref.identifier)).forEach((ref) => {
+			const useStateNode = getUseStateNode(context, ref);
+			const stateName = (useStateNode.id.elements[0] ?? useStateNode.id.elements[1])?.name;
+			context.report({
+				node: getCallExpr(ref),
+				messageId: "avoidInitializingState",
+				data: { state: stateName }
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-chain-state-updates.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_chain_state_updates_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow chaining state changes in an effect.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#chains-of-computations"
+		},
+		schema: [],
+		messages: { avoidChainingStateUpdates: "Avoid chaining state changes. When possible, update all relevant state simultaneously." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		const isAllDepsState = depsRefs.notEmptyEvery((ref) => isState(context, ref));
+		effectFnRefs.filter((ref) => isStateSetter(context, ref)).filter((ref) => isImmediateCall(ref.identifier)).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			if (isAllDepsState && isArgsAllLiterals(context, callExpr)) context.report({
+				node: callExpr,
+				messageId: "avoidChainingStateUpdates"
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-derived-state.js
+/**
+* @type {import('eslint').Rule.RuleModule}
+*/
+var no_derived_state_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow storing derived state in an effect.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state"
+		},
+		schema: [],
+		messages: { avoidDerivedState: "Avoid storing derived state. Compute \"{{state}}\" directly during render, optionally with `useMemo` if it's expensive." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		effectFnRefs.filter((ref) => isStateSetter(context, ref)).filter((ref) => isImmediateCall(ref.identifier)).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			const useStateNode = getUseStateNode(context, ref);
+			const stateName = (useStateNode.id.elements[0] ?? useStateNode.id.elements[1])?.name;
+			const argsRefs = callExpr.arguments.flatMap((arg) => getDownstreamRefs(context, arg));
+			const isAllArgsInternal = argsRefs.notEmptyEvery((ref$1) => isState(context, ref$1) || isProp(context, ref$1));
+			const argsUpstreamVars = argsRefs.flatMap((ref$1) => getUpstreamReactVariables(context, ref$1.resolved));
+			const depsUpstreamVars = depsRefs.flatMap((ref$1) => getUpstreamReactVariables(context, ref$1.resolved));
+			const isValueAlwaysInSync = argsUpstreamVars.notEmptyEvery((argVar) => depsUpstreamVars.some((depVar) => argVar.name === depVar.name)) && countCalls(ref) === 1;
+			if (isAllArgsInternal || isValueAlwaysInSync) context.report({
+				node: callExpr,
+				messageId: "avoidDerivedState",
+				data: { state: stateName }
+			});
+		});
+	} })
+};
+const countCalls = (ref) => ref.resolved.references.filter((ref$1) => ref$1.identifier.parent.type === "CallExpression").length;
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-pass-data-to-parent.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_pass_data_to_parent_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow passing data to parents in an effect.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#passing-data-to-the-parent"
+		},
+		schema: [],
+		messages: { avoidPassingDataToParent: "Avoid passing data to parents in an effect. Instead, let the parent fetch the data itself and pass it down to the child as a prop." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		effectFnRefs.filter((ref) => isPropCallback(context, ref)).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			if (callExpr.arguments.flatMap((arg) => getDownstreamRefs(context, arg)).notEmptyEvery((ref$1) => !isState(context, ref$1) && !isProp(context, ref$1) && !isRef(context, ref$1))) context.report({
+				node: callExpr,
+				messageId: "avoidPassingDataToParent"
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/no-manage-parent.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_manage_parent_default = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow effects that only use props." },
+		schema: [],
+		messages: { avoidManagingParent: "This effect only uses props. Consider lifting the logic up to the parent." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		if (effectFnRefs.length === 0) return;
+		if (effectFnRefs.concat(depsRefs).every((ref) => isProp(context, ref))) context.report({
+			node,
+			messageId: "avoidManagingParent"
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/util/javascript.js
+Array.prototype.notEmptyEvery = function(predicate) {
+	return this.length > 0 && this.every(predicate);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.5.3_eslint@9.36.0_jiti@2.5.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/index.js
+/**
+* @type {import("eslint").ESLint.Plugin}
+*/
+const plugin = {
+	meta: { name: "react-you-might-not-need-an-effect" },
+	configs: {},
+	rules: {
+		"no-empty-effect": no_empty_effect_default,
+		"no-adjust-state-on-prop-change": no_adjust_state_on_prop_change_default,
+		"no-reset-all-state-on-prop-change": no_reset_all_state_on_prop_change_default,
+		"no-event-handler": no_event_handler_default,
+		"no-pass-live-state-to-parent": no_pass_live_state_to_parent_default,
+		"no-pass-data-to-parent": no_pass_data_to_parent_default,
+		"no-manage-parent": no_manage_parent_default,
+		"no-initialize-state": no_initialize_state_default,
+		"no-chain-state-updates": no_chain_state_updates_default,
+		"no-derived-state": no_derived_state_default
+	}
+};
+const recommendedRules = Object.keys(plugin.rules).reduce((acc, ruleName) => {
+	acc[plugin.meta.name + "/" + ruleName] = "warn";
+	return acc;
+}, {});
+const languageOptions = {
+	globals: { ...globals.browser },
+	parserOptions: { ecmaFeatures: { jsx: true } }
+};
+Object.assign(plugin.configs, {
+	recommended: {
+		files: ["**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}"],
+		plugins: { [plugin.meta.name]: plugin },
+		rules: recommendedRules,
+		languageOptions
+	},
+	"legacy-recommended": {
+		plugins: [plugin.meta.name],
+		rules: recommendedRules,
+		...languageOptions
+	}
+});
+var src_default = plugin;
+
+//#endregion
+export { src_default as default };
+//# sourceMappingURL=src-DwSufEpw.js.map