@siberiacancode/eslint 2.15.2 → 2.16.0

package/dist/cjs/index.cjs

@@ -1,195 +1,578 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const antfu = require("@antfu/eslint-config");
-const pluginNext = require("@next/eslint-plugin-next");
-const pluginJsxA11y = require("eslint-plugin-jsx-a11y");
-const pluginReact = require("eslint-plugin-react");
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+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 __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
+let _antfu_eslint_config = require("@antfu/eslint-config");
+_antfu_eslint_config = __toESM(_antfu_eslint_config);
+let _eslint_css = require("@eslint/css");
+_eslint_css = __toESM(_eslint_css);
+let eslint_plugin_jsx_a11y = require("eslint-plugin-jsx-a11y");
+eslint_plugin_jsx_a11y = __toESM(eslint_plugin_jsx_a11y);
+let eslint_plugin_playwright = require("eslint-plugin-playwright");
+eslint_plugin_playwright = __toESM(eslint_plugin_playwright);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+
+//#region src/plugin/rules/function-component-definition.ts
+const NAMED_TEMPLATES = {
+	"function-declaration": "function {name}{typeParams}({params}){returnType} {body}",
+	"arrow-function": "{varType} {name}{typeAnnotation} = {typeParams}({params}){returnType} => {body}",
+	"function-expression": "{varType} {name}{typeAnnotation} = function{typeParams}({params}){returnType} {body}"
+};
+const buildFunction = (template, parts) => Object.keys(parts).reduce((acc, key) => acc.replace(new RegExp(`\\{${key}\\}`, "g"), () => parts[key] ?? ""), template);
+const hasName = (node) => {
+	if (node.type === "FunctionDeclaration") return true;
+	return node.parent?.type === "VariableDeclarator";
+};
+const getName = (node) => {
+	if (node.type === "FunctionDeclaration" && node.id?.type === "Identifier") return node.id.name;
+	const parent = node.parent;
+	if ((node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") && parent?.type === "VariableDeclarator" && parent.id?.type === "Identifier") return parent.id.name;
+};
+const getTypeParams = (node) => {
+	return node.typeParameters;
+};
+const getNodeText = (sourceCode, node) => {
+	if (!node || !("range" in node) || !node.range) return void 0;
+	return sourceCode.getText(node);
+};
+const getParams = (sourceCode, node) => {
+	if (node.params.length === 0) return void 0;
+	const first = node.params[0];
+	const last = node.params[node.params.length - 1];
+	if (first == null || last == null || !("range" in first) || !("range" in last)) return void 0;
+	return sourceCode.getText({ range: [first.range[0], last.range[1]] });
+};
+const getBody = (sourceCode, node) => {
+	const body = node.body;
+	if (!("range" in body) || !body.range) return "{}";
+	const text = sourceCode.getText(body);
+	if (body.type === "BlockStatement") return text;
+	return `{\n  return ${text}\n}`;
+};
+const getTypeAnnotation = (sourceCode, node) => {
+	if (!hasName(node) || node.type === "FunctionDeclaration") return void 0;
+	const parent = node.parent;
+	if (parent?.type !== "VariableDeclarator" || parent.id?.type !== "Identifier") return void 0;
+	const id = parent.id;
+	if (!("typeAnnotation" in id) || id.typeAnnotation === void 0 || id.typeAnnotation === null) return void 0;
+	return getNodeText(sourceCode, id.typeAnnotation);
+};
+const isUnfixableExport = (node) => node.type === "FunctionDeclaration" && node.parent?.type === "ExportDefaultDeclaration";
+const isFunctionExpressionWithName = (node) => node.type === "FunctionExpression" && "id" in node && node.id !== null && node.id !== void 0;
+const JSX_TYPES = ["JSXElement", "JSXFragment"];
+/** Walk AST and return true if any descendant is JSX */
+const containsJSX = (node) => {
+	if (JSX_TYPES.includes(node.type)) return true;
+	for (const key of Object.keys(node)) {
+		if (key === "parent") continue;
+		const value = node[key];
+		if (value !== null && value !== void 0 && typeof value === "object") {
+			if (Array.isArray(value)) {
+				if (value.some((child) => child !== null && child !== void 0 && typeof child === "object" && "type" in child && containsJSX(child))) return true;
+			} else if (value !== null && value !== void 0 && typeof value === "object" && "type" in value && containsJSX(value)) return true;
+		}
+	}
+	return false;
+};
+const walk = (node, visit) => {
+	visit(node);
+	for (const key of Object.keys(node)) {
+		if (key === "parent") continue;
+		const value = node[key];
+		if (value !== null && value !== void 0 && typeof value === "object") {
+			if (Array.isArray(value)) value.forEach((child) => {
+				if (child !== null && child !== void 0 && typeof child === "object" && "type" in child) walk(child, visit);
+			});
+			else if (value !== null && value !== void 0 && typeof value === "object" && "type" in value) walk(value, visit);
+		}
+	}
+};
+/** Collect component nodes: functions that contain JSX (and for expr/arrow, are in VariableDeclarator) */
+const getComponentNodes = (program) => {
+	const components = /* @__PURE__ */ new Set();
+	let fileHasJSX = false;
+	walk(program, (n) => {
+		const type = n.type;
+		if (type === "JSXElement" || type === "JSXFragment") fileHasJSX = true;
+	});
+	if (!fileHasJSX) return components;
+	walk(program, (n) => {
+		if (n.type === "FunctionDeclaration" && containsJSX(n)) components.add(n);
+		const withParent = n;
+		if ((n.type === "ArrowFunctionExpression" || n.type === "FunctionExpression") && withParent.parent?.type === "VariableDeclarator" && containsJSX(n)) components.add(n);
+	});
+	return components;
+};
+const functionComponentDefinition = {
+	meta: {
+		type: "layout",
+		docs: { description: "Enforce a specific function type for function components" },
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: { namedComponents: { anyOf: [{ enum: [
+				"function-declaration",
+				"arrow-function",
+				"function-expression"
+			] }, {
+				type: "array",
+				items: {
+					type: "string",
+					enum: [
+						"function-declaration",
+						"arrow-function",
+						"function-expression"
+					]
+				}
+			}] } },
+			additionalProperties: false
+		}],
+		messages: {
+			"function-declaration": "Function component is not a function declaration",
+			"function-expression": "Function component is not a function expression",
+			"arrow-function": "Function component is not an arrow function"
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = context.options[0] ?? {};
+		const namedConfig = [].concat(options.namedComponents ?? "function-declaration");
+		let fileVarType = "var";
+		const validatePairs = [];
+		let componentNodes = /* @__PURE__ */ new Set();
+		const getFixer = (node, fixOptions) => {
+			const typeAnnotation = getTypeAnnotation(sourceCode, node);
+			if (fixOptions.type === "function-declaration" && typeAnnotation) return void 0;
+			if (isUnfixableExport(node)) return void 0;
+			if (isFunctionExpressionWithName(node)) return void 0;
+			let varType = fileVarType;
+			const parent = node.parent;
+			if ((node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && parent?.type === "VariableDeclarator" && parent.parent?.type === "VariableDeclaration") varType = parent.parent.kind;
+			const typeParams = getNodeText(sourceCode, getTypeParams(node));
+			const params = getParams(sourceCode, node);
+			const returnType = getNodeText(sourceCode, "returnType" in node ? node.returnType : void 0);
+			const body = getBody(sourceCode, node);
+			const name = getName(node);
+			const text = buildFunction(fixOptions.template, {
+				typeAnnotation,
+				typeParams,
+				params,
+				returnType,
+				body,
+				name: name !== void 0 && name !== null && name !== "" ? name : "",
+				varType
+			});
+			return (fixer) => fixer.replaceTextRange(fixOptions.range, text);
+		};
+		const report = (node, fixOptions) => {
+			const fix = getFixer(node, fixOptions);
+			context.report({
+				node,
+				messageId: fixOptions.messageId,
+				fix
+			});
+		};
+		const validate = (node, functionType) => {
+			if (!componentNodes.has(node)) return;
+			if (node.parent?.type === "Property") return;
+			if (hasName(node) && !namedConfig.includes(functionType)) {
+				const parent = node.parent;
+				report(node, {
+					messageId: namedConfig[0],
+					type: namedConfig[0],
+					template: NAMED_TEMPLATES[namedConfig[0]],
+					range: node.type === "FunctionDeclaration" ? node.range : parent?.parent?.range ?? node.range
+				});
+			}
+		};
+		return {
+			Program(programNode) {
+				componentNodes = getComponentNodes(programNode);
+			},
+			FunctionDeclaration(node) {
+				validatePairs.push([node, "function-declaration"]);
+			},
+			ArrowFunctionExpression(node) {
+				validatePairs.push([node, "arrow-function"]);
+			},
+			FunctionExpression(node) {
+				validatePairs.push([node, "function-expression"]);
+			},
+			VariableDeclaration(node) {
+				if (node.kind === "const" || node.kind === "let") fileVarType = "const";
+			},
+			"Program:exit": function() {
+				if (fileVarType === "var") {
+					if (validatePairs.some(([n]) => n.parent?.type === "VariableDeclarator") || componentNodes.size > 0 && validatePairs.length > 0) fileVarType = "const";
+				}
+				validatePairs.forEach(([node, type]) => validate(node, type));
+			},
+			ImportDeclaration: () => {
+				fileVarType = "const";
+			},
+			ExportNamedDeclaration: () => {
+				fileVarType = "const";
+			},
+			ExportDefaultDeclaration: () => {
+				fileVarType = "const";
+			},
+			JSXElement: () => {
+				fileVarType = "const";
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/plugin/rules/no-unused-class.ts
+const STYLE_IMPORT_REGEXP = /\.(?:css|scss|less)$/u;
+const toCamelCase = (value) => value.replace(/-([a-z])/gu, (_substring, letter) => letter.toUpperCase());
+const extractClassNames = (source) => {
+	const classNames = /* @__PURE__ */ new Set();
+	const classNameRegExp = /\.([_a-zA-Z][\w-]*)/gu;
+	let match = classNameRegExp.exec(source);
+	while (match !== null) {
+		const className = match[1];
+		if (className !== void 0 && className !== "") classNames.add(className);
+		match = classNameRegExp.exec(source);
+	}
+	return [...classNames];
+};
+const buildClassesMap = (classNames, camelCaseOption) => {
+	const onlyCamelCase = camelCaseOption === "only" || camelCaseOption === "dashes-only";
+	const withCamelCase = camelCaseOption === true || camelCaseOption === "dashes" || onlyCamelCase;
+	const classesMap = {};
+	classNames.forEach((className) => {
+		if (!onlyCamelCase) classesMap[className] = className;
+		if (withCamelCase) classesMap[toCamelCase(className)] = className;
+	});
+	return classesMap;
+};
+const getStyleImportData = (node) => {
+	if (node.source.type !== "Literal" || typeof node.source.value !== "string") return void 0;
+	const source = node.source.value;
+	if (!STYLE_IMPORT_REGEXP.test(source)) return void 0;
+	const importSpecifier = node.specifiers.find((specifier) => specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier");
+	if (importSpecifier === void 0) return void 0;
+	return {
+		importName: importSpecifier.local.name,
+		importNode: importSpecifier,
+		styleFilePath: source
+	};
+};
+const getPropertyName = (node, camelCaseOption) => {
+	if (node.computed === false && node.property.type === "Identifier") return node.property.name;
+	if (node.computed === true && node.property.type === "Literal") {
+		if (typeof node.property.value !== "string" || node.property.value === "") return void 0;
+		return camelCaseOption === "only" ? toCamelCase(node.property.value) : node.property.value;
+	}
+	if (node.computed === true && node.property.type === "TemplateLiteral" && node.property.expressions.length === 0) {
+		const value = node.property.quasis[0]?.value.cooked;
+		if (typeof value !== "string" || value === "") return void 0;
+		return camelCaseOption === "only" ? toCamelCase(value) : value;
+	}
+};
+const getAbsoluteStylePath = (context, styleFilePath) => {
+	const filename = context.filename;
+	if (filename === "<input>") return void 0;
+	return node_path.default.resolve(node_path.default.dirname(filename), styleFilePath);
+};
+const noUnusedClass = {
+	meta: {
+		type: "problem",
+		docs: { description: "Checks that all CSS/SCSS/LESS classes imported as modules are used" },
+		schema: [{
+			type: "object",
+			properties: {
+				camelCase: { enum: [
+					true,
+					"dashes",
+					"only",
+					"dashes-only"
+				] },
+				markAsUsed: {
+					type: "array",
+					items: { type: "string" }
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	create(context) {
+		const options = context.options[0] ?? {};
+		const camelCaseOption = options.camelCase;
+		const markAsUsed = options.markAsUsed ?? [];
+		const importMap = {};
+		return {
+			ImportDeclaration(node) {
+				const styleImportData = getStyleImportData(node);
+				if (styleImportData === void 0) return;
+				const absoluteStylePath = getAbsoluteStylePath(context, styleImportData.styleFilePath);
+				if (absoluteStylePath === void 0 || !node_fs.default.existsSync(absoluteStylePath)) return;
+				const classNames = extractClassNames(node_fs.default.readFileSync(absoluteStylePath, "utf8"));
+				const classes = {};
+				classNames.forEach((className) => {
+					classes[className] = false;
+				});
+				importMap[styleImportData.importName] = {
+					classes,
+					classesMap: buildClassesMap(classNames, camelCaseOption),
+					filePath: styleImportData.styleFilePath,
+					node: styleImportData.importNode
+				};
+			},
+			MemberExpression(node) {
+				const typedNode = node;
+				if (typedNode.object.type !== "Identifier") return;
+				const entry = importMap[typedNode.object.name];
+				if (entry === void 0) return;
+				const propertyName = getPropertyName(typedNode, camelCaseOption);
+				if (propertyName === void 0 || propertyName === "") return;
+				const className = entry.classesMap[propertyName];
+				if (className === void 0 || className === "") return;
+				entry.classes[className] = true;
+			},
+			"Program:exit": () => {
+				Object.values(importMap).forEach((entry) => {
+					markAsUsed.forEach((usedClass) => {
+						if (usedClass !== "") entry.classes[usedClass] = true;
+					});
+					const unusedClasses = Object.entries(entry.classes).filter(([, used]) => used === false).map(([className]) => className);
+					if (unusedClasses.length > 0) context.report({
+						node: entry.node,
+						message: `Unused classes found in ${node_path.default.basename(entry.filePath)}: ${unusedClasses.join(", ")}`
+					});
+				});
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/plugin/index.ts
+const version = "1.0.0";
+const siberiacancodePlugin = {
+	meta: {
+		name: "@siberiacancode/eslint-plugin",
+		version
+	},
+	rules: {
+		"function-component-definition": functionComponentDefinition,
+		"no-unused-class": noUnusedClass
+	}
+};
+
+//#endregion
+//#region src/index.ts
+const getDefaultTypescriptConfig = (option) => {
+	if (typeof option === "object") return option;
+	if (option === true && node_fs.default.existsSync("./tsconfig.json")) return { tsconfigPath: "./tsconfig.json" };
+	return option;
+};
 const eslint = (inputOptions = {}, ...configs) => {
-  const { jsxA11y = false, next = false, ...options } = inputOptions;
-  const stylistic = options?.stylistic ?? false;
-  if (next) {
-    const nextRules = pluginNext.configs.recommended.rules ?? {};
-    configs.unshift({
-      name: "siberiacancode/next",
-      plugins: {
-        "siberiacancode-next": pluginNext
-      },
-      rules: {
-        ...Object.entries(nextRules).reduce((acc, [key, value]) => {
-          acc[key.replace("@next/next", "siberiacancode-next")] = value;
-          return acc;
-        }, {})
-      }
-    });
-  }
-  if (jsxA11y) {
-    const jsxA11yRules = pluginJsxA11y.flatConfigs.recommended.rules;
-    configs.unshift({
-      name: "siberiacancode/jsx-a11y",
-      plugins: {
-        "siberiacancode-jsx-a11y": pluginJsxA11y
-      },
-      rules: {
-        ...Object.entries(jsxA11yRules).reduce((acc, [key, value]) => {
-          acc[key.replace("jsx-a11y", "siberiacancode-jsx-a11y")] = value;
-          return acc;
-        }, {})
-      }
-    });
-  }
-  if (options.react) {
-    configs.unshift({
-      name: "siberiacancode/react",
-      plugins: {
-        "siberiacancode-react": pluginReact
-      },
-      rules: {
-        ...Object.entries(pluginReact.configs.recommended.rules).reduce(
-          (acc, [key, value]) => {
-            acc[key.replace("react", "siberiacancode-react")] = value;
-            return acc;
-          },
-          {}
-        ),
-        "siberiacancode-react/function-component-definition": [
-          "error",
-          {
-            namedComponents: ["arrow-function"],
-            unnamedComponents: "arrow-function"
-          }
-        ],
-        "siberiacancode-react/prop-types": "off",
-        "siberiacancode-react/react-in-jsx-scope": "off"
-      },
-      settings: {
-        react: {
-          version: "detect"
-        }
-      }
-    });
-  }
-  if (stylistic) {
-    configs.unshift({
-      name: "siberiacancode/formatter",
-      rules: {
-        "style/arrow-parens": ["error", "always"],
-        "style/brace-style": "off",
-        "style/comma-dangle": ["error", "never"],
-        "style/indent": ["error", 2, { SwitchCase: 1 }],
-        "style/jsx-curly-newline": "off",
-        "style/jsx-one-expression-per-line": "off",
-        "style/jsx-quotes": ["error", "prefer-single"],
-        "style/linebreak-style": ["error", "unix"],
-        "style/max-len": [
-          "error",
-          100,
-          2,
-          { ignoreComments: true, ignoreStrings: true, ignoreTemplateLiterals: true }
-        ],
-        "style/member-delimiter-style": "off",
-        "style/multiline-ternary": "off",
-        "style/no-tabs": "error",
-        "style/operator-linebreak": "off",
-        "style/quote-props": "off",
-        "style/quotes": ["error", "single", { allowTemplateLiterals: true }],
-        "style/semi": ["error", "always"]
-      }
-    });
-  }
-  return antfu(
-    { ...options, stylistic },
-    {
-      name: "siberiacancode/rewrite",
-      rules: {
-        "antfu/curly": "off",
-        "antfu/if-newline": "off",
-        "antfu/top-level-function": "off",
-        "no-console": "warn",
-        "react-hooks/exhaustive-deps": "off",
-        "test/prefer-lowercase-title": "off"
-      }
-    },
-    {
-      name: "siberiacancode/sort",
-      rules: {
-        "perfectionist/sort-array-includes": [
-          "error",
-          {
-            order: "asc",
-            type: "alphabetical"
-          }
-        ],
-        "perfectionist/sort-imports": [
-          "error",
-          {
-            groups: [
-              "type-import",
-              ["value-builtin", "value-external"],
-              "type-internal",
-              "value-internal",
-              ["type-parent", "type-sibling", "type-index"],
-              ["value-parent", "value-sibling", "value-index"],
-              "side-effect",
-              "side-effect-style",
-              "unknown"
-            ],
-            internalPattern: ["^~/.*", "^@/.*"],
-            newlinesBetween: 1,
-            order: "asc",
-            type: "natural"
-          }
-        ],
-        "perfectionist/sort-interfaces": [
-          "error",
-          {
-            groups: ["property", "member", "method", "index-signature"],
-            order: "asc",
-            type: "alphabetical"
-          }
-        ],
-        "perfectionist/sort-jsx-props": [
-          "error",
-          {
-            customGroups: [
-              {
-                groupName: "reserved",
-                elementNamePattern: "^(key|ref)$"
-              },
-              {
-                groupName: "callback",
-                elementNamePattern: "^on[A-Z].*"
-              }
-            ],
-            groups: ["shorthand-prop", "reserved", "multiline-prop", "unknown", "callback"],
-            order: "asc",
-            type: "alphabetical"
-          }
-        ],
-        "perfectionist/sort-union-types": [
-          "error",
-          {
-            groups: [
-              "conditional",
-              "function",
-              "import",
-              "intersection",
-              "keyword",
-              "literal",
-              "named",
-              "object",
-              "operator",
-              "tuple",
-              "union",
-              "nullish"
-            ],
-            order: "asc",
-            specialCharacters: "keep",
-            type: "alphabetical"
-          }
-        ]
-      }
-    },
-    ...configs
-  );
-};
-exports.eslint = eslint;
+	const { jsxA11y = false, playwright = false, ...options } = inputOptions;
+	const typescript = getDefaultTypescriptConfig(options?.typescript ?? false);
+	const stylistic = options?.stylistic ?? false;
+	if (jsxA11y) {
+		const jsxA11yRules = eslint_plugin_jsx_a11y.default.flatConfigs.recommended.rules;
+		configs.unshift({
+			name: "siberiacancode/jsx-a11y",
+			plugins: { "siberiacancode-jsx-a11y": eslint_plugin_jsx_a11y.default },
+			rules: { ...Object.entries(jsxA11yRules).reduce((acc, [key, value]) => {
+				acc[key.replace("jsx-a11y", "siberiacancode-jsx-a11y")] = value;
+				return acc;
+			}, {}) }
+		});
+	}
+	if (playwright) {
+		const playwrightRules = eslint_plugin_playwright.default.configs["flat/recommended"].rules;
+		configs.unshift({
+			name: "siberiacancode/playwright",
+			plugins: { "siberiacancode-playwright": eslint_plugin_playwright.default },
+			rules: { ...Object.entries(playwrightRules).reduce((acc, [key, value]) => {
+				acc[key.replace("playwright", "siberiacancode-playwright")] = value;
+				return acc;
+			}, {}) }
+		});
+	}
+	if (stylistic) configs.unshift({
+		name: "siberiacancode/formatter",
+		rules: {
+			"style/arrow-parens": ["error", "always"],
+			"style/brace-style": "off",
+			"style/comma-dangle": ["error", "never"],
+			"style/indent": [
+				"error",
+				2,
+				{ SwitchCase: 1 }
+			],
+			"style/jsx-curly-newline": "off",
+			"style/jsx-one-expression-per-line": "off",
+			"style/jsx-quotes": ["error", "prefer-single"],
+			"style/linebreak-style": ["error", "unix"],
+			"style/max-len": [
+				"error",
+				100,
+				2,
+				{
+					ignoreComments: true,
+					ignoreStrings: true,
+					ignoreTemplateLiterals: true
+				}
+			],
+			"style/member-delimiter-style": "off",
+			"style/multiline-ternary": "off",
+			"style/no-tabs": "error",
+			"style/operator-linebreak": "off",
+			"style/quote-props": "off",
+			"style/quotes": [
+				"error",
+				"single",
+				{ allowTemplateLiterals: true }
+			],
+			"style/semi": ["error", "always"]
+		}
+	});
+	configs.unshift({
+		name: "siberiacancode",
+		plugins: { siberiacancode: siberiacancodePlugin },
+		rules: {
+			"siberiacancode/function-component-definition": ["error", { namedComponents: ["arrow-function"] }],
+			"siberiacancode/no-unused-class": "error"
+		}
+	});
+	configs.unshift({
+		name: "siberiacancode/css",
+		plugins: { "siberiacancode-css": _eslint_css.default },
+		rules: { ...Object.entries(_eslint_css.default.configs.recommended.rules).reduce((acc, [key, value]) => {
+			acc[key.replace("css", "siberiacancode-css")] = value;
+			return acc;
+		}, {}) }
+	});
+	return (0, _antfu_eslint_config.default)({
+		...options,
+		typescript,
+		stylistic
+	}, {
+		name: "siberiacancode/rewrite",
+		rules: {
+			"antfu/curly": "off",
+			"antfu/if-newline": "off",
+			"antfu/top-level-function": "off",
+			"no-console": "warn",
+			"react-hooks/exhaustive-deps": "off",
+			"test/prefer-lowercase-title": "off"
+		}
+	}, {
+		name: "siberiacancode/sort",
+		rules: {
+			"perfectionist/sort-array-includes": ["error", {
+				order: "asc",
+				type: "alphabetical"
+			}],
+			"perfectionist/sort-imports": ["error", {
+				groups: [
+					"type-import",
+					["value-builtin", "value-external"],
+					"type-internal",
+					"value-internal",
+					[
+						"type-parent",
+						"type-sibling",
+						"type-index"
+					],
+					[
+						"value-parent",
+						"value-sibling",
+						"value-index"
+					],
+					"side-effect",
+					"side-effect-style",
+					"ts-equals-import",
+					"unknown"
+				],
+				internalPattern: ["^~/.+", "^@/.+"],
+				newlinesBetween: 1,
+				order: "asc",
+				type: "natural"
+			}],
+			"perfectionist/sort-interfaces": ["error", {
+				groups: [
+					"property",
+					"member",
+					"method",
+					"index-signature"
+				],
+				order: "asc",
+				type: "alphabetical"
+			}],
+			"perfectionist/sort-jsx-props": ["error", {
+				customGroups: [{
+					groupName: "reserved",
+					elementNamePattern: "^(key|ref)$"
+				}, {
+					groupName: "callback",
+					elementNamePattern: "^on[A-Z].*"
+				}],
+				groups: [
+					"shorthand-prop",
+					"reserved",
+					"multiline-prop",
+					"unknown",
+					"callback"
+				],
+				order: "asc",
+				type: "alphabetical"
+			}],
+			"perfectionist/sort-union-types": ["error", {
+				groups: [
+					"conditional",
+					"function",
+					"import",
+					"intersection",
+					"keyword",
+					"literal",
+					"named",
+					"object",
+					"operator",
+					"tuple",
+					"union",
+					"nullish"
+				],
+				order: "asc",
+				specialCharacters: "keep",
+				type: "alphabetical"
+			}]
+		}
+	}, ...configs);
+};
+
+//#endregion
+exports.eslint = eslint;