@so1ve/eslint-config 4.1.8 → 4.2.0

package/dist/index.mjs

@@ -1,2300 +1,30 @@
-import createCommand from "eslint-plugin-command/config";
-import pluginComments from "@eslint-community/eslint-plugin-eslint-comments";
-import pluginSo1ve from "@so1ve/eslint-plugin";
-import pluginArrayFunc from "eslint-plugin-array-func";
-import pluginImportLite from "eslint-plugin-import-lite";
-import pluginImport from "eslint-plugin-import-x";
-import pluginNode from "eslint-plugin-n";
-import * as pluginNoAwaitInPromise from "eslint-plugin-no-await-in-promise";
-import pluginOnlyError from "eslint-plugin-only-error";
-import pluginPromise from "eslint-plugin-promise";
-import * as pluginRegexp from "eslint-plugin-regexp";
-import pluginUnicorn from "eslint-plugin-unicorn";
-import pluginUnusedImports from "eslint-plugin-unused-imports";
-import globals from "globals";
-import process$1 from "node:process";
-import { fileURLToPath } from "node:url";
-import fs from "node:fs";
-import path from "node:path";
-import tseslint from "typescript-eslint";
-import { FlatConfigComposer } from "eslint-flat-config-utils";
-import { isPackageExists } from "local-pkg";
+import { GLOB_ALL_SRC, GLOB_ASTRO, GLOB_ASTRO_TS, GLOB_CSS, GLOB_DTS, GLOB_ESLINTRC, GLOB_EXCLUDE, GLOB_HTML, GLOB_JS, GLOB_JSON, GLOB_JSON5, GLOB_JSONC, GLOB_JSX, GLOB_LESS, GLOB_MARKDOWN, GLOB_MARKDOWN_CODE, GLOB_PACKAGEJSON, GLOB_SCSS, GLOB_SRC, GLOB_SRC_EXT, GLOB_STYLE, GLOB_TESTS, GLOB_TOML, GLOB_TS, GLOB_TSCONFIG, GLOB_TSX, GLOB_VUE, GLOB_YAML } from "./globs.mjs";
+import { interopDefault, renameRules } from "./utils.mjs";
+import { astro } from "./configs/astro.mjs";
+import { command } from "./configs/command.mjs";
+import { comments } from "./configs/comments.mjs";
+import { deMorgan } from "./configs/de-morgan.mjs";
+import { formatting } from "./configs/formatting.mjs";
+import { html } from "./configs/html.mjs";
+import { ignores } from "./configs/ignores.mjs";
+import { imports } from "./configs/imports.mjs";
+import { javascript } from "./configs/javascript.mjs";
+import { jsonc } from "./configs/jsonc.mjs";
+import { mdx } from "./configs/mdx.mjs";
+import { node } from "./configs/node.mjs";
+import { onlyError } from "./configs/only-error.mjs";
+import { perfectionist } from "./configs/perfectionist.mjs";
+import { pnpm } from "./configs/pnpm.mjs";
+import { promise } from "./configs/promise.mjs";
+import { solid } from "./configs/solid.mjs";
+import { sortImports } from "./configs/sort-imports.mjs";
+import { test } from "./configs/test.mjs";
+import { toml } from "./configs/toml.mjs";
+import { typescript } from "./configs/typescript.mjs";
+import { unicorn } from "./configs/unicorn.mjs";
+import { vue } from "./configs/vue.mjs";
+import { yaml } from "./configs/yaml.mjs";
+import "./configs/index.mjs";
+import { defaultPluginRenaming, getOverrides, so1ve } from "./factory.mjs";
 
-//#region src/globs.ts
-const GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
-const GLOB_SRC = `**/*.${GLOB_SRC_EXT}`;
-const GLOB_JS = "**/*.?([cm])js";
-const GLOB_JSX = "**/*.?([cm])jsx";
-const GLOB_TS = "**/*.?([cm])ts";
-const GLOB_TSX = "**/*.?([cm])tsx";
-const GLOB_DTS = "**/*.d.?([cm])tsx";
-const GLOB_STYLE = "**/*.{c,le,sc}ss";
-const GLOB_CSS = "**/*.css";
-const GLOB_LESS = "**/*.less";
-const GLOB_SCSS = "**/*.scss";
-const GLOB_JSON = "**/*.json";
-const GLOB_JSON5 = "**/*.json5";
-const GLOB_JSONC = "**/*.jsonc";
-const GLOB_ESLINTRC = "**/.eslintrc";
-const GLOB_MARKDOWN = "**/*.md?(x)";
-const GLOB_ASTRO = "**/*.astro";
-const GLOB_ASTRO_TS = "**/*.astro/*.ts";
-const GLOB_VUE = "**/*.vue";
-const GLOB_YAML = "**/*.y?(a)ml";
-const GLOB_TOML = "**/*.toml";
-const GLOB_HTML = "**/*.htm?(l)";
-const GLOB_PACKAGEJSON = "**/package.json";
-const GLOB_TSCONFIG = ["**/tsconfig.json", "**/tsconfig.*.json"];
-const GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/**`;
-const GLOB_TESTS = [
-	`**/__tests__/**/*.${GLOB_SRC_EXT}`,
-	`**/*.spec.${GLOB_SRC_EXT}`,
-	`**/*.test.${GLOB_SRC_EXT}`,
-	`**/*.bench.${GLOB_SRC_EXT}`,
-	`**/*.benchmark.${GLOB_SRC_EXT}`
-];
-const GLOB_ALL_SRC = [
-	GLOB_SRC,
-	GLOB_STYLE,
-	GLOB_JSON,
-	GLOB_JSON5,
-	GLOB_ESLINTRC,
-	GLOB_MARKDOWN,
-	GLOB_VUE,
-	GLOB_YAML,
-	GLOB_HTML
-];
-const GLOB_EXCLUDE = [
-	"**/node_modules",
-	"**/dist",
-	"**/out",
-	"**/output",
-	"**/package-lock.json",
-	"**/yarn.lock",
-	"**/pnpm-lock.yaml",
-	"**/bun.lockb",
-	"**/coverage",
-	"**/temp",
-	"**/.vitepress/cache",
-	"**/.nuxt",
-	"**/.nitro",
-	"**/.vercel",
-	"**/.netlify",
-	"**/.output",
-	"**/.vercel",
-	"**/.changeset",
-	"**/.idea",
-	"**/.vite-inspect",
-	"**/.yarn",
-	"**/CHANGELOG*.md",
-	"**/*.min.*",
-	"**/LICENSE*",
-	"**/__snapshots__",
-	"**/auto-import?(s).d.ts",
-	"**/components.d.ts",
-	"**/*.vue.js",
-	"**/*.vue.jsx",
-	"**/*.vue.ts",
-	"**/*.vue.tsx"
-];
-
-//#endregion
-//#region src/utils.ts
-/**
-* Rename plugin prefixes in a rule object. Accepts a map of prefixes to rename.
-*
-* @example
-*
-* ```ts
-* import { renameRules } from "@antfu/eslint-config";
-*
-* export default [
-*   {
-*     rules: renameRules(
-*       {
-*         "@typescript-eslint/indent": "error",
-*       },
-*       { "@typescript-eslint": "ts" },
-*     ),
-*   },
-* ];
-* ```
-*/
-const renameRules = (rules$1, map) => Object.fromEntries(Object.entries(rules$1).map(([key, value]) => {
-	for (const [from, to] of Object.entries(map)) if (key.startsWith(`${from}/`)) return [to + key.slice(from.length), value];
-	return [key, value];
-}));
-async function interopDefault(m) {
-	const resolved = await m;
-	return resolved.default ?? resolved;
-}
-
-//#endregion
-//#region src/configs/astro.ts
-async function astro({ overrides = {} } = {}) {
-	const [pluginAstro, parserAstro, parserTs] = await Promise.all([
-		interopDefault(import("eslint-plugin-astro")),
-		interopDefault(import("astro-eslint-parser")),
-		interopDefault(import("@typescript-eslint/parser"))
-	]);
-	return [{
-		name: "antfu/astro/setup",
-		plugins: { astro: pluginAstro }
-	}, {
-		files: [GLOB_ASTRO],
-		languageOptions: {
-			globals: pluginAstro.environments.astro.globals,
-			parser: parserAstro,
-			parserOptions: {
-				extraFileExtensions: [".astro"],
-				parser: parserTs
-			},
-			sourceType: "module"
-		},
-		name: "antfu/astro/rules",
-		processor: "astro/client-side-ts",
-		rules: {
-			"antfu/no-top-level-await": "off",
-			"astro/missing-client-only-directive-value": "error",
-			"astro/no-conflict-set-directives": "error",
-			"astro/no-deprecated-astro-canonicalurl": "error",
-			"astro/no-deprecated-astro-fetchcontent": "error",
-			"astro/no-deprecated-astro-resolve": "error",
-			"astro/no-deprecated-getentrybyslug": "error",
-			"astro/no-set-html-directive": "off",
-			"astro/no-unused-define-vars-in-style": "error",
-			"astro/semi": "off",
-			"astro/valid-compile": "error",
-			...overrides
-		}
-	}];
-}
-
-//#endregion
-//#region src/configs/command.ts
-const command = async () => [{
-	...createCommand(),
-	name: "so1ve/command"
-}];
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/package.json.js
-const name = "eslint-plugin-de-morgan";
-const version = "2.0.0";
-const repository = "azat-io/eslint-plugin-de-morgan";
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/create-test-with-parameters.js
-function createTestWithParameters(...parameters) {
-	return (...predicates) => predicates.every((predicate) => predicate(...parameters));
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/is-logical-expression.js
-function isLogicalExpression(node$1) {
-	return node$1.type === "LogicalExpression";
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/find-outermost-parenthesized-node.js
-function findOutermostParenthesizedNode(node$1, sourceCode) {
-	let current = node$1;
-	let [start, end] = current.range;
-	if (isInParentheses(start, end, sourceCode)) return current;
-	while (current.parent && isLogicalExpression(current)) {
-		current = current.parent;
-		[start, end] = current.range;
-		if (isInParentheses(start, end, sourceCode)) return current;
-	}
-	return current;
-}
-function isInParentheses(start, end, sourceCode) {
-	return sourceCode[start - 1] === "(" && sourceCode[end] === ")";
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/is-unary-expression.js
-function isUnaryExpression(node$1) {
-	return node$1.type === "UnaryExpression";
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/has-operator.js
-function hasOperator(operator) {
-	return (node$1) => node$1.operator === operator;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/has-negation-operator.js
-function hasNegationOperator(node$1) {
-	return createTestWithParameters(node$1)(isUnaryExpression, hasOperator("!"));
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/has-negation-inside-parens.js
-function hasNegationInsideParens(node$1, context) {
-	let outermostNode = findOutermostParenthesizedNode(node$1, context.sourceCode.getText(node$1));
-	if (!isUnaryExpression(outermostNode)) return false;
-	return hasNegationInside(outermostNode.argument);
-}
-function hasNegationInside(node$1) {
-	if (isUnaryExpression(node$1) && node$1.operator === "!" && isUnaryExpression(node$1.argument) && node$1.argument.operator === "!") return hasNegationInside(node$1.argument.argument);
-	if (hasNegationOperator(node$1)) return true;
-	if (isLogicalExpression(node$1)) return hasNegationInside(node$1.left) || hasNegationInside(node$1.right);
-	return false;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/is-binary-expression.js
-function isBinaryExpression(node$1) {
-	return node$1.type === "BinaryExpression";
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/has-boolean-context.js
-function hasBooleanContext(node$1, _context) {
-	return node$1.parent ? isControlFlowBooleanContext(node$1.parent) || isBooleanOperation(node$1.parent) || isBooleanFunction(node$1.parent) : false;
-}
-function isControlFlowBooleanContext(parent) {
-	return booleanControlFlowNodes.has(parent.type);
-}
-let booleanControlFlowNodes = /* @__PURE__ */ new Set([
-	"ConditionalExpression",
-	"LogicalExpression",
-	"DoWhileStatement",
-	"UnaryExpression",
-	"WhileStatement",
-	"ForStatement",
-	"IfStatement"
-]);
-function isBooleanOperation(parent) {
-	return isBinaryExpression(parent) && booleanOperators.has(parent.operator);
-}
-let booleanOperators = /* @__PURE__ */ new Set([
-	"instanceof",
-	"===",
-	"!==",
-	"==",
-	"!=",
-	"<=",
-	">=",
-	"in",
-	"<",
-	">"
-]);
-function isBooleanFunction(parent) {
-	return parent.type === "CallExpression" && parent.callee.type === "Identifier" && parent.callee.name === "Boolean";
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/apply-to-property.js
-function applyToProperty(property, predicate) {
-	return (object) => predicate(object[property]);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/is-conjunction.js
-function isConjunction(node$1) {
-	return createTestWithParameters(node$1)(isLogicalExpression, hasOperator("&&"));
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/sanitize-code.js
-function sanitizeCode(code) {
-	let stringLiterals = [];
-	let normalized = code.replaceAll(/(?<quote>["'`])(?:\\.|(?!\k<quote>)[^\\])*\k<quote>/gu, (match) => {
-		let placeholder = `__STRING_LITERAL_${stringLiterals.length}__`;
-		stringLiterals.push(match);
-		return placeholder;
-	}).replaceAll(/\/\/.*$/gmu, "").replaceAll(/\/\*[\s\S]*?\*\//gu, "").replaceAll(/\s+/gu, " ").replaceAll(/\(\s+/gu, "(").replaceAll(/\s+\)/gu, ")").trim();
-	for (let [index$1, string_] of stringLiterals.entries()) normalized = normalized.replace(`__STRING_LITERAL_${index$1}__`, string_);
-	return normalized;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/is-pure-group.js
-function isPureGroup(node$1, context) {
-	let outermostNode = findOutermostParenthesizedNode(node$1, context.sourceCode.getText());
-	return !hasMixedOperators(getCodeInsideParentheses(context.sourceCode.getText(outermostNode)));
-}
-function hasMixedOperators(code) {
-	let depth = 0;
-	let operatorFound = null;
-	for (let i = 0; i < code.length; i++) {
-		let char = code[i];
-		if (char === "(") {
-			depth++;
-			continue;
-		}
-		if (char === ")") {
-			depth--;
-			continue;
-		}
-		if (depth !== 0) continue;
-		let twoChars = code.slice(i, i + 2);
-		if (twoChars === "&&" || twoChars === "||") {
-			if (operatorFound === null) operatorFound = twoChars;
-			else if (operatorFound !== twoChars) return true;
-			i++;
-		}
-	}
-	return false;
-}
-function getCodeInsideParentheses(code) {
-	if (code.startsWith("!(")) return code.slice(2, -1);
-	if (code.startsWith("(")) return code.slice(1, -1);
-	return code;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/is-negated.js
-function isNegated(node$1) {
-	return hasNegationOperator(node$1) && !hasNegationOperator(node$1.argument) && (!node$1.parent || !hasNegationOperator(node$1.parent));
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/parenthesize.js
-function parenthesize(text, condition = true) {
-	return condition ? `(${text})` : text;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/is-boolean.js
-function isBoolean(node$1) {
-	return node$1.type === "Literal" && typeof node$1.value === "boolean";
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/toggle-negation.js
-function toggleNegation(node$1, context) {
-	let toggleStrategies = [
-		{
-			transformer: toggleBinaryExpression,
-			predicate: isBinaryExpression
-		},
-		{
-			transformer: toggleBooleanLiteral,
-			predicate: isBoolean
-		},
-		{
-			transformer: toggleLogicalExpression,
-			predicate: isLogicalExpression
-		}
-	];
-	for (let { transformer, predicate } of toggleStrategies) if (predicate(node$1)) return transformer(node$1, context);
-	return toggleUnaryExpression(node$1, context);
-}
-function toggleBinaryExpression(node$1, context) {
-	let left = context.sourceCode.getText(node$1.left).trim();
-	let right = context.sourceCode.getText(node$1.right).trim();
-	if ([
-		"<<",
-		">>",
-		">>>",
-		"+",
-		"-",
-		"*",
-		"/",
-		"%",
-		"**",
-		"|",
-		"^",
-		"&",
-		"in",
-		"instanceof"
-	].includes(node$1.operator)) return `!(${left} ${node$1.operator} ${right})`;
-	return `${left} ${{
-		"===": "!==",
-		"!==": "===",
-		"==": "!=",
-		"!=": "==",
-		"<": ">=",
-		">": "<=",
-		"<=": ">",
-		">=": "<"
-	}[node$1.operator]} ${right}`;
-}
-function toggleLogicalExpression(node$1, context) {
-	return toggleCode(parenthesize(context.sourceCode.getText(node$1).trim()));
-}
-function toggleUnaryExpression(node$1, context) {
-	return toggleCode(context.sourceCode.getText(node$1).trim());
-}
-function toggleCode(code) {
-	return code.startsWith("!") ? code.replace(/^!/u, "") : `!${code}`;
-}
-function toggleBooleanLiteral(node$1) {
-	return node$1.value ? "false" : "true";
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/is-disjunction.js
-function isDisjunction(node$1) {
-	return createTestWithParameters(node$1)(isLogicalExpression, hasOperator("||"));
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/transform.js
-const MAX_DEPTH = 10;
-const OPERATOR_MAPPING = {
-	"&&": "||",
-	"||": "&&"
-};
-function transform({ shouldWrapInParens, expressionType, context, node: node$1 }) {
-	let argument = node$1.argument;
-	let sourceOperator = expressionType === "conjunction" ? "&&" : "||";
-	if (argument.operator !== sourceOperator) return null;
-	let originalText = context.sourceCode.getText(argument);
-	let transformUtilityOptions = {
-		expression: argument,
-		expressionType,
-		sourceOperator,
-		targetOperator: OPERATOR_MAPPING[sourceOperator],
-		context
-	};
-	return parenthesize(hasSpecialFormatting(originalText) ? transformWithFormatting(transformUtilityOptions) : transformSimple(transformUtilityOptions), shouldWrapInParens);
-}
-function transformWithFormatting({ sourceOperator, targetOperator, expression, context }) {
-	let { sourceCode } = context;
-	let leftText = toggleNegation(expression.left, context);
-	let rightText = toggleNegation(expression.right, context);
-	if (!expression.left.range || !expression.right.range) return `${leftText} ${targetOperator} ${rightText}`;
-	let [, leftEnd] = expression.left.range;
-	let [rightStart] = expression.right.range;
-	let textBetween = sourceCode.text.slice(leftEnd, rightStart);
-	if (/\(\s*$/u.test(textBetween)) textBetween = textBetween.replace(/\(\s*$/u, "");
-	return `${leftText}${textBetween.replaceAll(new RegExp(sourceOperator.replaceAll(/[$()*+.?[\\\]^{|}]/gu, String.raw`\$&`), "gu"), targetOperator)}${rightText}`;
-}
-function flattenOperands({ expressionType, expression, context }) {
-	let result = [];
-	let stack = [{
-		expr: expression,
-		depth: 0
-	}];
-	while (stack.length > 0) {
-		let { depth, expr } = stack.pop();
-		if (depth > MAX_DEPTH || !matchesExpressionType(expr, expressionType)) {
-			result.push(toggleNegation(expr, context));
-			continue;
-		}
-		let logicalExpr = expr;
-		stack.push({
-			expr: logicalExpr.right,
-			depth: depth + 1
-		}, {
-			expr: logicalExpr.left,
-			depth: depth + 1
-		});
-	}
-	return result;
-}
-function transformSimple({ expressionType, targetOperator, expression, context }) {
-	return flattenOperands({
-		expressionType,
-		expression,
-		context
-	}).join(` ${targetOperator} `);
-}
-function matchesExpressionType(expression, type) {
-	return type === "conjunction" ? isConjunction(expression) : isDisjunction(expression);
-}
-function hasSpecialFormatting(text) {
-	return text.includes("//") || text.includes("/*") || text.includes("\n") || /\s{2,}/u.test(text);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/not.js
-function not(predicate) {
-	return (...arguments_) => !predicate(...arguments_);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/utils/or.js
-function or(...predicates) {
-	return (...arguments_) => predicates.some((predicate) => predicate(...arguments_));
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/rules/no-negated-conjunction.js
-const noNegatedConjunction = {
-	create: (context) => ({ UnaryExpression: (node$1) => {
-		if (createTestWithParameters(node$1, context)(isNegated, applyToProperty("argument", isConjunction), isPureGroup, or(hasBooleanContext, not(hasNegationInsideParens)))) {
-			let fixedExpression = transform({
-				expressionType: "conjunction",
-				shouldWrapInParens: isConjunction(node$1.parent),
-				context,
-				node: node$1
-			});
-			if (fixedExpression) {
-				let originalExpression = context.sourceCode.getText(node$1);
-				context.report({
-					data: {
-						original: sanitizeCode(originalExpression),
-						fixed: sanitizeCode(fixedExpression)
-					},
-					fix: (fixer) => fixer.replaceText(node$1, fixedExpression),
-					messageId: "convertNegatedConjunction",
-					node: node$1
-				});
-			}
-		}
-	} }),
-	meta: {
-		docs: {
-			description: "Transforms the negation of a conjunction !(A && B) into the equivalent !A || !B according to De Morgan’s law",
-			url: `https://github.com/${repository}/blob/main/docs/no-negated-conjunction.md`,
-			category: "Best Practices",
-			recommended: true
-		},
-		messages: { convertNegatedConjunction: "Replace negated conjunction `{{ original }}` with `{{ fixed }}`" },
-		type: "suggestion",
-		fixable: "code",
-		schema: []
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/rules/no-negated-disjunction.js
-const noNegatedDisjunction = {
-	create: (context) => ({ UnaryExpression: (node$1) => {
-		if (createTestWithParameters(node$1, context)(isNegated, applyToProperty("argument", isDisjunction), isPureGroup, or(hasBooleanContext, not(hasNegationInsideParens)))) {
-			let fixedExpression = transform({
-				expressionType: "disjunction",
-				shouldWrapInParens: false,
-				context,
-				node: node$1
-			});
-			if (fixedExpression) {
-				let originalExpression = context.sourceCode.getText(node$1);
-				context.report({
-					data: {
-						original: sanitizeCode(originalExpression),
-						fixed: sanitizeCode(fixedExpression)
-					},
-					fix: (fixer) => fixer.replaceText(node$1, fixedExpression),
-					messageId: "convertNegatedDisjunction",
-					node: node$1
-				});
-			}
-		}
-	} }),
-	meta: {
-		docs: {
-			description: "Transforms the negation of a disjunction !(A || B) into the equivalent !A && !B according to De Morgan’s law",
-			url: `https://github.com/${repository}/blob/main/docs/no-negated-disjunction.md`,
-			category: "Best Practices",
-			recommended: true
-		},
-		messages: { convertNegatedDisjunction: "Replace negated disjunction `{{ original }}` with `{{ fixed }}`" },
-		type: "suggestion",
-		fixable: "code",
-		schema: []
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/eslint-plugin-de-morgan@2.0.0_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-de-morgan/dist/index.js
-let pluginName = "de-morgan";
-let rules = {
-	"no-negated-conjunction": noNegatedConjunction,
-	"no-negated-disjunction": noNegatedDisjunction
-};
-function getRules() {
-	return Object.fromEntries(Object.keys(rules).map((ruleName) => [`${pluginName}/${ruleName}`, "error"]));
-}
-function createConfig() {
-	return {
-		plugins: { [pluginName]: { rules } },
-		rules: getRules()
-	};
-}
-function createLegacyConfig() {
-	return {
-		plugins: [pluginName],
-		rules: getRules()
-	};
-}
-let configs = {
-	"recommended-legacy": createLegacyConfig(),
-	recommended: createConfig()
-};
-const index = {
-	meta: {
-		version,
-		name
-	},
-	configs,
-	rules
-};
-
-//#endregion
-//#region src/configs/comments.ts
-const comments = () => [{
-	name: "so1ve/comments/setup",
-	plugins: { "eslint-comments": pluginComments }
-}, {
-	name: "so1ve/comments/rules",
-	rules: {
-		"eslint-comments/disable-enable-pair": "off",
-		"eslint-comments/no-aggregating-enable": "error",
-		"eslint-comments/no-duplicate-disable": "error",
-		"eslint-comments/no-unlimited-disable": "off",
-		"eslint-comments/no-unused-enable": "error"
-	}
-}];
-
-//#endregion
-//#region src/configs/de-morgan.ts
-const deMorgan = () => [{
-	...index.configs.recommended,
-	name: "so1ve/de-morgan"
-}];
-
-//#endregion
-//#region src/configs/formatting.ts
-async function formatting(options) {
-	return [
-		{
-			name: "so1ve/formatting/setup",
-			plugins: { style: await interopDefault(import("@stylistic/eslint-plugin")) }
-		},
-		{
-			name: "so1ve/formatting/rules",
-			rules: {
-				"curly": ["error", "all"],
-				"so1ve/function-style": "error",
-				"so1ve/import-export-newline": "error",
-				"so1ve/no-import-promises-as": "error",
-				"so1ve/no-negated-comparison": "error",
-				"so1ve/no-useless-template-string": "error",
-				"style/lines-between-class-members": [
-					"error",
-					"always",
-					{ exceptAfterSingleLine: true }
-				],
-				"style/no-extra-parens": ["error", "functions"],
-				"style/padding-line-between-statements": ["error", {
-					blankLine: "always",
-					prev: "*",
-					next: "return"
-				}],
-				"style/quote-props": ["error", "consistent-as-needed"],
-				"style/spaced-comment": [
-					"error",
-					"always",
-					{
-						line: {
-							markers: ["/"],
-							exceptions: ["/", "#"]
-						},
-						block: {
-							markers: ["!"],
-							exceptions: ["*"],
-							balanced: true
-						}
-					}
-				]
-			}
-		},
-		(options?.jsonc ?? true) && [{
-			name: "so1ve/formatting/rules/sort-package-json",
-			files: [GLOB_PACKAGEJSON],
-			rules: { "jsonc/sort-keys": [
-				"error",
-				{
-					pathPattern: "^$",
-					order: [
-						"name",
-						"displayName",
-						"private",
-						"preview",
-						"version",
-						"packageManager",
-						"publisher",
-						"author",
-						"contributors",
-						"type",
-						"description",
-						"keywords",
-						"homepage",
-						"repository",
-						"bugs",
-						"funding",
-						"categories",
-						"license",
-						"sideEffects",
-						"exports",
-						"bin",
-						"main",
-						"module",
-						"browser",
-						"unpkg",
-						"jsdelivr",
-						"types",
-						"typesVersions",
-						"icon",
-						"files",
-						"engines",
-						"extensionKind",
-						"activationEvents",
-						"contributes",
-						"eslintConfig",
-						"publishConfig",
-						"scripts",
-						"husky",
-						"simple-git-hooks",
-						"lint-staged",
-						"dependencies",
-						"devDependencies",
-						"optionalDependencies",
-						"peerDependencies",
-						"peerDependenciesMeta",
-						"pnpm",
-						"overrides",
-						"resolutions"
-					]
-				},
-				{
-					pathPattern: "^scripts$",
-					order: { type: "asc" }
-				},
-				{
-					pathPattern: "^exports.*$",
-					order: [
-						"types",
-						"require",
-						"import",
-						"default"
-					]
-				},
-				{
-					pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies(Meta)?$",
-					order: { type: "asc" }
-				},
-				{
-					pathPattern: "^(?:resolutions|overrides|pnpm.overrides)$",
-					order: { type: "asc" }
-				},
-				{
-					pathPattern: "^workspaces\\.catalog$",
-					order: { type: "asc" }
-				},
-				{
-					pathPattern: "^workspaces\\.catalogs\\.[^.]+$",
-					order: { type: "asc" }
-				},
-				{
-					pathPattern: "^(?:gitHooks|husky|simple-git-hooks)$",
-					order: [
-						"pre-commit",
-						"prepare-commit-msg",
-						"commit-msg",
-						"post-commit",
-						"pre-rebase",
-						"post-rewrite",
-						"post-checkout",
-						"post-merge",
-						"pre-push",
-						"pre-auto-gc"
-					]
-				}
-			] }
-		}, {
-			name: "so1ve/formatting/rules/sort-tsconfig",
-			files: GLOB_TSCONFIG,
-			rules: {
-				"jsonc/sort-array-values": [
-					"error",
-					{
-						pathPattern: "^compilerOptions\\.types$",
-						order: { type: "asc" }
-					},
-					{
-						pathPattern: "^include$",
-						order: { type: "asc" }
-					},
-					{
-						pathPattern: "^exclude$",
-						order: { type: "asc" }
-					}
-				],
-				"jsonc/sort-keys": [
-					"error",
-					{
-						pathPattern: "^$",
-						order: [
-							"extends",
-							"compilerOptions",
-							"references",
-							"files",
-							"include",
-							"exclude"
-						]
-					},
-					{
-						pathPattern: "^compilerOptions$",
-						order: [
-							"incremental",
-							"composite",
-							"tsBuildInfoFile",
-							"disableSourceOfProjectReferenceRedirect",
-							"disableSolutionSearching",
-							"disableReferencedProjectLoad",
-							"target",
-							"jsx",
-							"jsxFactory",
-							"jsxFragmentFactory",
-							"jsxImportSource",
-							"lib",
-							"moduleDetection",
-							"noLib",
-							"reactNamespace",
-							"useDefineForClassFields",
-							"emitDecoratorMetadata",
-							"experimentalDecorators",
-							"baseUrl",
-							"rootDir",
-							"rootDirs",
-							"customConditions",
-							"module",
-							"moduleResolution",
-							"moduleSuffixes",
-							"noResolve",
-							"resolveJsonModule",
-							"resolvePackageJsonExports",
-							"resolvePackageJsonImports",
-							"typeRoots",
-							"types",
-							"allowArbitraryExtensions",
-							"allowImportingTsExtensions",
-							"allowUmdGlobalAccess",
-							"allowJs",
-							"checkJs",
-							"maxNodeModuleJsDepth",
-							"strict",
-							"strictBindCallApply",
-							"strictFunctionTypes",
-							"strictNullChecks",
-							"strictPropertyInitialization",
-							"allowUnreachableCode",
-							"allowUnusedLabels",
-							"alwaysStrict",
-							"erasableSyntaxOnly",
-							"exactOptionalPropertyTypes",
-							"noFallthroughCasesInSwitch",
-							"noImplicitAny",
-							"noImplicitOverride",
-							"noImplicitReturns",
-							"noImplicitThis",
-							"noPropertyAccessFromIndexSignature",
-							"noUncheckedIndexedAccess",
-							"noUnusedLocals",
-							"noUnusedParameters",
-							"useUnknownInCatchVariables",
-							"declaration",
-							"declarationDir",
-							"declarationMap",
-							"downlevelIteration",
-							"emitBOM",
-							"emitDeclarationOnly",
-							"importHelpers",
-							"importsNotUsedAsValues",
-							"inlineSourceMap",
-							"inlineSources",
-							"mapRoot",
-							"newLine",
-							"noEmit",
-							"noEmitHelpers",
-							"noEmitOnError",
-							"outDir",
-							"outFile",
-							"preserveConstEnums",
-							"preserveValueImports",
-							"removeComments",
-							"sourceMap",
-							"sourceRoot",
-							"stripInternal",
-							"allowSyntheticDefaultImports",
-							"esModuleInterop",
-							"forceConsistentCasingInFileNames",
-							"isolatedModules",
-							"preserveSymlinks",
-							"verbatimModuleSyntax",
-							"skipDefaultLibCheck",
-							"skipLibCheck",
-							"paths"
-						]
-					},
-					{
-						pathPattern: "^compilerOptions\\.paths$",
-						order: { type: "asc" }
-					}
-				]
-			}
-		}],
-		(options?.test ?? true) && {
-			name: "so1ve/formatting/rules/test",
-			files: GLOB_TESTS,
-			rules: { "jest-formatting/padding-around-all": "error" }
-		}
-	].flat().filter(Boolean);
-}
-
-//#endregion
-//#region src/configs/html.ts
-async function html() {
-	const [parserHtml, pluginHtml, pluginHtmlJsSupport] = await Promise.all([
-		interopDefault(import("@html-eslint/parser")),
-		interopDefault(import("@html-eslint/eslint-plugin")),
-		interopDefault(import("eslint-plugin-html"))
-	]);
-	return [{
-		name: "so1ve/html/setup",
-		plugins: {
-			"html": pluginHtml,
-			"html-js-support": pluginHtmlJsSupport
-		}
-	}, {
-		name: "so1ve/html/rules",
-		languageOptions: { parser: parserHtml },
-		settings: { "html/report-bad-indent": "off" },
-		files: [GLOB_HTML],
-		rules: {
-			...renameRules(pluginHtml.configs.recommended.rules, { "@html-eslint": "html" }),
-			"html/attrs-newline": "off",
-			"html/indent": "off",
-			"html/no-extra-spacing-attrs": "off",
-			"html/no-trailing-spaces": "off",
-			"html/quotes": "off",
-			"html/require-closing-tags": "off",
-			"so1ve/html-spaced-comment": "error",
-			"style/spaced-comment": "off"
-		}
-	}];
-}
-
-//#endregion
-//#region src/configs/ignores.ts
-function ignores(userIgnores = []) {
-	let ignores$1 = [...GLOB_EXCLUDE];
-	ignores$1 = typeof userIgnores === "function" ? userIgnores(ignores$1) : [...ignores$1, ...userIgnores];
-	return [{
-		name: "so1ve/ignores",
-		ignores: ignores$1
-	}];
-}
-
-//#endregion
-//#region src/configs/imports.ts
-const imports = (options = {}) => [
-	{
-		name: "so1ve/imports/setup",
-		plugins: {
-			"import": pluginImport,
-			"import-lite": pluginImportLite
-		}
-	},
-	{
-		name: "so1ve/imports/rules",
-		languageOptions: { parserOptions: {
-			ecmaVersion: "latest",
-			sourceType: "module"
-		} },
-		settings: {
-			"import/parsers": {
-				"espree": [
-					".js",
-					".cjs",
-					".mjs",
-					".jsx"
-				],
-				"@typescript-eslint/parser": [
-					".ts",
-					".mts",
-					".cts",
-					".tsx",
-					".d.ts"
-				]
-			},
-			"import/resolver": { ...options.typescript ? {
-				node: { extensions: [
-					".js",
-					".jsx",
-					".mjs",
-					".ts",
-					".tsx",
-					".d.ts"
-				] },
-				typescript: { extensions: [
-					".js",
-					".jsx",
-					".mjs",
-					".ts",
-					".tsx",
-					".d.ts"
-				] }
-			} : { node: { extensions: [".js", ".mjs"] } } }
-		},
-		rules: {
-			"import-lite/no-duplicates": "error",
-			"import-lite/no-named-default": "error",
-			"import/default": "error",
-			"import/export": "error",
-			"import/first": "error",
-			"import/named": "error",
-			"import/namespace": "off",
-			"import/no-named-as-default": "error",
-			"import/no-useless-path-segments": ["error", { noUselessIndex: true }],
-			"import/no-webpack-loader-syntax": "error"
-		}
-	},
-	{
-		name: "so1ve/imports/rules/dts",
-		files: [GLOB_DTS],
-		rules: { "import/no-duplicates": "off" }
-	}
-];
-
-//#endregion
-//#region src/configs/javascript.ts
-async function javascript({ overrides } = {}) {
-	const regexpRecommended = pluginRegexp.configs["flat/recommended"];
-	return [
-		{
-			name: "so1ve/javascript/setup",
-			plugins: {
-				"array-func": pluginArrayFunc,
-				"no-await-in-promise": pluginNoAwaitInPromise,
-				"so1ve": pluginSo1ve,
-				"unused-imports": pluginUnusedImports
-			}
-		},
-		{
-			name: "so1ve/javascript/rules",
-			languageOptions: {
-				ecmaVersion: "latest",
-				globals: {
-					...globals.browser,
-					...globals.es2021,
-					...globals.node,
-					document: "readonly",
-					navigator: "readonly",
-					window: "readonly"
-				},
-				parserOptions: {
-					ecmaFeatures: { jsx: true },
-					ecmaVersion: "latest",
-					sourceType: "module"
-				},
-				sourceType: "module"
-			},
-			linterOptions: { reportUnusedDisableDirectives: true },
-			rules: {
-				"accessor-pairs": ["error", {
-					setWithoutGet: true,
-					enforceForClassMembers: true
-				}],
-				"array-bracket-newline": "off",
-				"array-callback-return": "error",
-				"array-element-newline": "off",
-				"array-func/avoid-reverse": "error",
-				"array-func/from-map": "off",
-				"array-func/no-unnecessary-this-arg": "off",
-				"array-func/prefer-array-from": "off",
-				"array-func/prefer-flat-map": "error",
-				"array-func/prefer-flat": "off",
-				"arrow-body-style": "off",
-				"arrow-parens": "off",
-				"block-scoped-var": "error",
-				"complexity": ["off", 11],
-				"consistent-return": "off",
-				"constructor-super": "error",
-				"default-case-last": "error",
-				"dot-notation": ["error", { allowKeywords: true }],
-				"eqeqeq": ["error", "smart"],
-				"function-call-argument-newline": "off",
-				"function-paren-newline": "off",
-				"generator-star": "off",
-				"implicit-arrow-linebreak": "off",
-				"indent-legacy": "off",
-				"indent": "off",
-				"jsx-quotes": "off",
-				"linebreak-style": "off",
-				"new-cap": ["error", {
-					newIsCap: true,
-					capIsNew: false,
-					properties: true
-				}],
-				"newline-per-chained-call": "off",
-				"no-alert": "error",
-				"no-array-constructor": "error",
-				"no-arrow-condition": "off",
-				"no-async-promise-executor": "error",
-				"no-await-in-promise/no-await-in-promise": "error",
-				"no-caller": "error",
-				"no-case-declarations": "error",
-				"no-class-assign": "error",
-				"no-comma-dangle": "off",
-				"no-compare-neg-zero": "error",
-				"no-cond-assign": ["error", "always"],
-				"no-confusing-arrow": "off",
-				"no-console": ["error", { allow: [
-					"error",
-					"warn",
-					"table",
-					"time"
-				] }],
-				"no-const-assign": "error",
-				"no-constant-condition": "error",
-				"no-control-regex": "error",
-				"no-debugger": "error",
-				"no-delete-var": "error",
-				"no-dupe-args": "error",
-				"no-dupe-class-members": "error",
-				"no-dupe-keys": "error",
-				"no-duplicate-case": "error",
-				"no-empty-character-class": "error",
-				"no-empty-pattern": "error",
-				"no-empty": ["error", { allowEmptyCatch: true }],
-				"no-eval": "error",
-				"no-ex-assign": "error",
-				"no-extend-native": "error",
-				"no-extra-bind": "error",
-				"no-extra-boolean-cast": "error",
-				"no-extra-semi": "off",
-				"no-fallthrough": "error",
-				"no-func-assign": "error",
-				"no-global-assign": "error",
-				"no-implied-eval": "error",
-				"no-import-assign": "error",
-				"no-invalid-regexp": "error",
-				"no-invalid-this": "error",
-				"no-irregular-whitespace": "error",
-				"no-iterator": "error",
-				"no-labels": ["error", {
-					allowLoop: true,
-					allowSwitch: false
-				}],
-				"no-lone-blocks": "error",
-				"no-loss-of-precision": "error",
-				"no-misleading-character-class": "error",
-				"no-multi-str": "error",
-				"no-new-func": "error",
-				"no-new-native-nonconstructor": "error",
-				"no-new-wrappers": "error",
-				"no-obj-calls": "error",
-				"no-object-constructor": "error",
-				"no-octal-escape": "error",
-				"no-octal": "error",
-				"no-param-reassign": "off",
-				"no-proto": "error",
-				"no-prototype-builtins": "error",
-				"no-redeclare": ["error", { builtinGlobals: false }],
-				"no-regex-spaces": "error",
-				"no-reserved-keys": "off",
-				"no-restricted-globals": [
-					"error",
-					{
-						name: "global",
-						message: "Use `globalThis` instead."
-					},
-					{
-						name: "self",
-						message: "Use `globalThis` instead."
-					},
-					{
-						name: "isNaN",
-						message: "Use `Number.isNaN` instead"
-					},
-					{
-						name: "isFinite",
-						message: "Use `Number.isFinite` instead"
-					},
-					{
-						name: "parseFloat",
-						message: "Use `Number.parseFloat` instead"
-					},
-					{
-						name: "parseInt",
-						message: "Use `Number.parseInt` instead"
-					}
-				],
-				"no-restricted-properties": [
-					"error",
-					{
-						object: "globalThis",
-						property: "isNaN",
-						message: "Use `Number.isNaN` instead"
-					},
-					{
-						object: "globalThis",
-						property: "isFinite",
-						message: "Use `Number.isFinite` instead"
-					},
-					{
-						object: "globalThis",
-						property: "parseFloat",
-						message: "Use `Number.parseFloat` instead"
-					},
-					{
-						object: "globalThis",
-						property: "parseInt",
-						message: "Use `Number.parseInt` instead"
-					},
-					{
-						object: "window",
-						property: "isNaN",
-						message: "Use `Number.isNaN` instead"
-					},
-					{
-						object: "window",
-						property: "isFinite",
-						message: "Use `Number.isFinite` instead"
-					},
-					{
-						object: "window",
-						property: "parseFloat",
-						message: "Use `Number.parseFloat` instead"
-					},
-					{
-						object: "window",
-						property: "parseInt",
-						message: "Use `Number.parseInt` instead"
-					}
-				],
-				"no-restricted-syntax": [
-					"error",
-					"DebuggerStatement",
-					"LabeledStatement",
-					"WithStatement"
-				],
-				"no-return-await": "off",
-				"no-self-assign": ["error", { props: true }],
-				"no-self-compare": "error",
-				"no-sequences": "error",
-				"no-shadow-restricted-names": "error",
-				"no-space-before-semi": "off",
-				"no-spaced-func": "off",
-				"no-template-curly-in-string": "error",
-				"no-this-before-super": "error",
-				"no-throw-literal": "error",
-				"no-undef-init": "error",
-				"no-undef": "error",
-				"no-unexpected-multiline": "error",
-				"no-unmodified-loop-condition": "error",
-				"no-unneeded-ternary": ["error", { defaultAssignment: false }],
-				"no-unreachable-loop": "error",
-				"no-unreachable": "error",
-				"no-unsafe-finally": "error",
-				"no-unsafe-negation": "error",
-				"no-unused-expressions": ["error", {
-					allowShortCircuit: true,
-					allowTernary: true,
-					allowTaggedTemplates: true
-				}],
-				"no-unused-vars": ["error", {
-					args: "none",
-					caughtErrors: "none",
-					ignoreRestSiblings: true,
-					vars: "all"
-				}],
-				"no-use-before-define": ["error", {
-					functions: false,
-					classes: false,
-					variables: true
-				}],
-				"no-useless-backreference": "error",
-				"no-useless-call": "error",
-				"no-useless-catch": "error",
-				"no-useless-computed-key": "error",
-				"no-useless-constructor": "error",
-				"no-useless-rename": "error",
-				"no-useless-return": "error",
-				"no-var": "error",
-				"no-void": "error",
-				"no-with": "error",
-				"no-wrap-func": "off",
-				"nonblock-statement-body-position": "off",
-				"object-shorthand": [
-					"error",
-					"always",
-					{ ignoreConstructors: false }
-				],
-				"one-var-declaration-per-line": "off",
-				"one-var": ["error", "never"],
-				"prefer-arrow-callback": ["error", {
-					allowNamedFunctions: false,
-					allowUnboundThis: true
-				}],
-				"prefer-const": ["error", {
-					destructuring: "all",
-					ignoreReadBeforeAssign: true
-				}],
-				"prefer-exponentiation-operator": "error",
-				"prefer-promise-reject-errors": "error",
-				"prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
-				"prefer-rest-params": "error",
-				"prefer-spread": "error",
-				"prefer-template": "error",
-				"require-await": "off",
-				"so1ve/import-dedupe": "error",
-				"so1ve/require-async-with-await": "error",
-				"switch-colon-spacing": "off",
-				"symbol-description": "off",
-				"unused-imports/no-unused-imports": "error",
-				"unused-imports/no-unused-vars": ["error", {
-					vars: "all",
-					varsIgnorePattern: "^_",
-					args: "after-used",
-					argsIgnorePattern: "^_",
-					ignoreRestSiblings: true
-				}],
-				"use-isnan": ["error", {
-					enforceForSwitchCase: true,
-					enforceForIndexOf: true
-				}],
-				"valid-typeof": ["error", { requireStringLiterals: true }],
-				"vars-on-top": "error",
-				"wrap-regex": "off",
-				"yoda": ["error", "never"],
-				...overrides
-			}
-		},
-		{
-			...regexpRecommended,
-			name: "so1ve/javascript/regexp",
-			rules: {
-				...regexpRecommended.rules,
-				"regexp/no-unused-capturing-group": "off"
-			}
-		},
-		{
-			name: "so1ve/javascript/cli",
-			files: [`scripts/${GLOB_SRC}`, `cli.${GLOB_SRC_EXT}`],
-			rules: { "no-console": "off" }
-		}
-	];
-}
-
-//#endregion
-//#region src/configs/jsonc.ts
-async function jsonc() {
-	const [parserJsonc, pluginJsonc] = await Promise.all([interopDefault(import("jsonc-eslint-parser")), interopDefault(import("eslint-plugin-jsonc"))]);
-	return [{
-		name: "so1ve/jsonc/setup",
-		plugins: { jsonc: pluginJsonc }
-	}, {
-		name: "so1ve/jsonc/rules",
-		files: [
-			GLOB_JSON,
-			GLOB_JSON5,
-			GLOB_JSONC,
-			GLOB_ESLINTRC
-		],
-		languageOptions: { parser: parserJsonc },
-		rules: {
-			...pluginJsonc.configs.base.overrides[0].rules,
-			...pluginJsonc.configs["recommended-with-jsonc"].rules,
-			"jsonc/no-octal-escape": "error",
-			"jsonc/quotes-props": "off",
-			"jsonc/quotes": "off"
-		}
-	}];
-}
-
-//#endregion
-//#region src/configs/mdx.ts
-async function mdx({ componentExts = [], overrides } = {}) {
-	const pluginMdx = await interopDefault(import("eslint-plugin-mdx"));
-	return [{
-		...pluginMdx.flat,
-		name: "so1ve/mdx/setup",
-		processor: pluginMdx.createRemarkProcessor({
-			lintCodeBlocks: true,
-			languageMapper: {}
-		})
-	}, {
-		...pluginMdx.flatCodeBlocks,
-		name: "so1ve/mdx/rules",
-		files: [...pluginMdx.flatCodeBlocks.files, ...componentExts.map((ext) => `${GLOB_MARKDOWN}/*.${ext}`)],
-		rules: {
-			...pluginMdx.flatCodeBlocks.rules,
-			"html/require-doctype": "off",
-			"import/no-unresolved": "off",
-			"no-alert": "off",
-			"no-console": "off",
-			"no-restricted-imports": "off",
-			"no-undef": "off",
-			"no-unused-expressions": "off",
-			"ts/consistent-type-imports": "off",
-			"ts/no-namespace": "off",
-			"ts/no-redeclare": "off",
-			"ts/no-require-imports": "off",
-			"ts/no-unused-expressions": "off",
-			"ts/no-unused-vars": "off",
-			"ts/no-use-before-define": "off",
-			"ts/no-var-requires": "off",
-			"unused-imports/no-unused-imports": "off",
-			"unused-imports/no-unused-vars": "off",
-			...overrides
-		}
-	}];
-}
-
-//#endregion
-//#region src/configs/node.ts
-const node = () => [{
-	name: "so1ve/node/setup",
-	plugins: { node: pluginNode }
-}, {
-	name: "so1ve/node/rules",
-	rules: {
-		"node/handle-callback-err": ["error", "^(err|error)$"],
-		"node/no-callback-literal": "off",
-		"node/no-deprecated-api": "error",
-		"node/no-exports-assign": "error",
-		"node/no-new-require": "error",
-		"node/no-path-concat": "error",
-		"node/process-exit-as-throw": "error"
-	}
-}];
-
-//#endregion
-//#region src/configs/only-error.ts
-const onlyError = () => [{
-	name: "so1ve/only-error",
-	plugins: { "only-error": pluginOnlyError }
-}];
-
-//#endregion
-//#region src/configs/perfectionist.ts
-async function perfectionist() {
-	return [{
-		name: "so1ve/perfectionist/setup",
-		plugins: { perfectionist: await interopDefault(import("eslint-plugin-perfectionist")) }
-	}, {
-		name: "so1ve/perfectionist/rules",
-		rules: {
-			"perfectionist/sort-array-includes": ["error", {
-				ignoreCase: false,
-				partitionByComment: true,
-				partitionByNewLine: true,
-				type: "natural"
-			}],
-			"perfectionist/sort-decorators": ["error", { type: "natural" }],
-			"perfectionist/sort-heritage-clauses": ["error", { type: "natural" }],
-			"perfectionist/sort-maps": ["error", {
-				partitionByComment: true,
-				partitionByNewLine: true,
-				type: "natural"
-			}],
-			"perfectionist/sort-sets": ["error", {
-				partitionByComment: true,
-				partitionByNewLine: true,
-				type: "natural"
-			}]
-		}
-	}];
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/find-up-simple@1.0.1/node_modules/find-up-simple/index.js
-const toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-function findUpSync(name$1, { cwd = process$1.cwd(), type = "file", stopAt } = {}) {
-	let directory = path.resolve(toPath(cwd) ?? "");
-	const { root } = path.parse(directory);
-	stopAt = path.resolve(directory, toPath(stopAt) ?? root);
-	const isAbsoluteName = path.isAbsolute(name$1);
-	while (directory) {
-		const filePath = isAbsoluteName ? name$1 : path.join(directory, name$1);
-		try {
-			const stats = fs.statSync(filePath, { throwIfNoEntry: false });
-			if (type === "file" && stats?.isFile() || type === "directory" && stats?.isDirectory()) return filePath;
-		} catch {}
-		if (directory === stopAt || directory === root) break;
-		directory = path.dirname(directory);
-	}
-}
-
-//#endregion
-//#region src/configs/pnpm.ts
-async function pnpm(options) {
-	const { json = true, yaml: yaml$1 = true } = options;
-	const [pluginPnpm, yamlParser, jsoncParser] = await Promise.all([
-		interopDefault(import("eslint-plugin-pnpm")),
-		yaml$1 ? interopDefault(import("yaml-eslint-parser")) : void 0,
-		json ? interopDefault(import("jsonc-eslint-parser")) : void 0
-	]);
-	const configs$1 = [];
-	if (json) configs$1.push({
-		files: ["package.json", "**/package.json"],
-		languageOptions: { parser: jsoncParser },
-		name: "so1ve/pnpm/package-json",
-		plugins: { pnpm: pluginPnpm },
-		rules: { "pnpm/json-prefer-workspace-settings": "error" }
-	});
-	if (yaml$1) configs$1.push({
-		files: ["pnpm-workspace.yaml"],
-		languageOptions: { parser: yamlParser },
-		name: "so1ve/pnpm/pnpm-workspace-yaml",
-		plugins: { pnpm: pluginPnpm },
-		rules: { "pnpm/yaml-enforce-settings": ["error", { settings: { shellEmulator: true } }] }
-	}, {
-		files: ["pnpm-workspace.yaml"],
-		name: "so1ve/yaml/pnpm-workspace-yaml-sort",
-		rules: { "yaml/sort-keys": [
-			"error",
-			{
-				order: [
-					...[
-						"cacheDir",
-						"catalogMode",
-						"cleanupUnusedCatalogs",
-						"dedupeDirectDeps",
-						"deployAllFiles",
-						"enablePrePostScripts",
-						"engineStrict",
-						"extendNodePath",
-						"hoist",
-						"hoistPattern",
-						"hoistWorkspacePackages",
-						"ignoreCompatibilityDb",
-						"ignoreDepScripts",
-						"ignoreScripts",
-						"ignoreWorkspaceRootCheck",
-						"managePackageManagerVersions",
-						"minimumReleaseAge",
-						"minimumReleaseAgeExclude",
-						"modulesDir",
-						"nodeLinker",
-						"nodeVersion",
-						"optimisticRepeatInstall",
-						"packageManagerStrict",
-						"packageManagerStrictVersion",
-						"preferSymlinkedExecutables",
-						"preferWorkspacePackages",
-						"publicHoistPattern",
-						"registrySupportsTimeField",
-						"requiredScripts",
-						"resolutionMode",
-						"savePrefix",
-						"scriptShell",
-						"shamefullyHoist",
-						"shellEmulator",
-						"stateDir",
-						"supportedArchitectures",
-						"symlink",
-						"tag",
-						"trustPolicy",
-						"trustPolicyExclude",
-						"updateNotifier"
-					],
-					"packages",
-					"overrides",
-					"patchedDependencies",
-					...[
-						"allowedDeprecatedVersions",
-						"allowNonAppliedPatches",
-						"configDependencies",
-						"ignoredBuiltDependencies",
-						"ignoredOptionalDependencies",
-						"neverBuiltDependencies",
-						"onlyBuiltDependencies",
-						"onlyBuiltDependenciesFile",
-						"packageExtensions",
-						"peerDependencyRules"
-					],
-					"catalog",
-					"catalogs"
-				],
-				pathPattern: "^$"
-			},
-			{
-				order: { type: "asc" },
-				pathPattern: ".*"
-			}
-		] }
-	});
-	return configs$1;
-}
-
-//#endregion
-//#region src/configs/promise.ts
-const promise = () => [{
-	name: "so1ve/promise/setup",
-	plugins: { promise: pluginPromise }
-}, {
-	name: "so1ve/promise/rules",
-	rules: { "promise/param-names": "error" }
-}];
-
-//#endregion
-//#region src/configs/solid.ts
-async function solid({ overrides, typescript: typescript$1 } = {}) {
-	const pluginSolid = await interopDefault(import("eslint-plugin-solid"));
-	return [{
-		name: "so1ve/solid/setup",
-		plugins: { solid: pluginSolid }
-	}, {
-		name: "so1ve/solid/rules",
-		languageOptions: {
-			sourceType: "module",
-			parserOptions: { ecmaFeatures: { jsx: true } }
-		},
-		rules: {
-			...pluginSolid.configs.recommended.rules,
-			...typescript$1 ? pluginSolid.configs.typescript.rules : {},
-			...overrides
-		}
-	}];
-}
-
-//#endregion
-//#region src/configs/sort-imports.ts
-const sortImports = () => [{
-	name: "so1ve/sort-imports/rules",
-	rules: {
-		"so1ve/sort-imports": "error",
-		"so1ve/sort-exports": "error"
-	}
-}];
-
-//#endregion
-//#region src/configs/test.ts
-async function test({ overrides } = {}) {
-	const [pluginNoOnlyTests, pluginVitest, pluginJestFormatting] = await Promise.all([
-		interopDefault(import("eslint-plugin-no-only-tests")),
-		interopDefault(import("@vitest/eslint-plugin")),
-		interopDefault(import("eslint-plugin-jest-formatting"))
-	]);
-	return [{
-		name: "so1ve/test/setup",
-		plugins: {
-			"jest-formatting": pluginJestFormatting,
-			"no-only-tests": pluginNoOnlyTests,
-			"vitest": pluginVitest
-		}
-	}, {
-		name: "so1ve/test/rules",
-		files: GLOB_TESTS,
-		rules: {
-			...pluginVitest.configs.recommended.rules,
-			"no-only-tests/no-only-tests": "error",
-			"vitest/expect-expect": "off",
-			"vitest/no-alias-methods": "error",
-			"vitest/no-interpolation-in-snapshots": "error",
-			"vitest/no-test-prefixes": "error",
-			"vitest/prefer-comparison-matcher": "error",
-			"vitest/prefer-expect-resolves": "error",
-			"vitest/prefer-mock-promise-shorthand": "error",
-			"vitest/prefer-spy-on": "error",
-			"vitest/prefer-to-be-falsy": "error",
-			"vitest/prefer-to-be-object": "error",
-			"vitest/prefer-to-be-truthy": "error",
-			"vitest/prefer-to-contain": "error",
-			"vitest/prefer-to-have-length": "error",
-			"vitest/prefer-todo": "error",
-			"vitest/valid-describe-callback": "off",
-			"vitest/valid-title": "off",
-			...overrides
-		}
-	}];
-}
-
-//#endregion
-//#region src/configs/toml.ts
-async function toml({ overrides } = {}) {
-	const [parserToml, pluginToml] = await Promise.all([interopDefault(import("toml-eslint-parser")), interopDefault(import("eslint-plugin-toml"))]);
-	return [{
-		name: "so1ve/toml/setup",
-		plugins: { toml: pluginToml }
-	}, {
-		name: "so1ve/toml/rules",
-		languageOptions: { parser: parserToml },
-		files: [GLOB_TOML],
-		rules: {
-			...pluginToml.configs.recommended.rules,
-			"no-irregular-whitespace": "off",
-			"style/spaced-comment": "off",
-			...overrides
-		}
-	}];
-}
-
-//#endregion
-//#region src/configs/typescript.ts
-const typescript = async ({ componentExts = [], parserOptions, overrides } = {}) => [
-	{
-		name: "so1ve/typescript/setup",
-		plugins: {
-			import: pluginImport,
-			ts: tseslint.plugin
-		}
-	},
-	{
-		name: "so1ve/typescript/rules",
-		files: [
-			GLOB_TS,
-			GLOB_TSX,
-			...componentExts.map((ext) => `**/*.${ext}`)
-		],
-		languageOptions: {
-			parser: tseslint.parser,
-			parserOptions: {
-				sourceType: "module",
-				extraFileExtensions: componentExts.map((ext) => `.${ext}`),
-				...parserOptions
-			}
-		},
-		settings: { "import/resolver": {
-			node: { extensions: [
-				".js",
-				".jsx",
-				".mjs",
-				".ts",
-				".tsx",
-				".d.ts"
-			] },
-			typescript: { extensions: [
-				".js",
-				".jsx",
-				".mjs",
-				".ts",
-				".tsx",
-				".d.ts"
-			] }
-		} },
-		rules: {
-			...renameRules(tseslint.configs.eslintRecommended.rules, { "@typescript-eslint": "ts" }),
-			...renameRules(tseslint.configs.recommended.map((config) => config.rules).filter(Boolean).reduce((a, b) => ({
-				...a,
-				...b
-			}), {}), { "@typescript-eslint": "ts" }),
-			"import/named": "off",
-			"no-dupe-class-members": "off",
-			"no-invalid-this": "off",
-			"no-redeclare": "off",
-			"no-use-before-define": "off",
-			"no-useless-constructor": "off",
-			"object-curly-spacing": "off",
-			"so1ve/no-inline-type-modifier": "error",
-			"so1ve/prefer-ts-expect-error": "error",
-			"space-before-blocks": "off",
-			"space-before-function-paren": "off",
-			"ts/ban-ts-comment": ["error", { minimumDescriptionLength: 0 }],
-			"ts/ban-ts-ignore": "off",
-			"ts/brace-style": "off",
-			"ts/camelcase": "off",
-			"ts/comma-dangle": "off",
-			"ts/comma-spacing": "off",
-			"ts/consistent-indexed-object-style": ["error", "record"],
-			"ts/consistent-type-definitions": ["error", "interface"],
-			"ts/consistent-type-imports": ["error", {
-				disallowTypeAnnotations: false,
-				prefer: "type-imports"
-			}],
-			"ts/explicit-function-return-type": "off",
-			"ts/explicit-member-accessibility": ["error", {
-				accessibility: "explicit",
-				overrides: { constructors: "no-public" }
-			}],
-			"ts/explicit-module-boundary-types": "off",
-			"ts/func-call-spacing": "off",
-			"ts/indent": "off",
-			"ts/keyword-spacing": "off",
-			"ts/member-delimiter-style": "off",
-			"ts/method-signature-style": ["error", "property"],
-			"ts/no-dupe-class-members": "error",
-			"ts/no-duplicate-enum-values": "error",
-			"ts/no-empty-function": "off",
-			"ts/no-empty-interface": "off",
-			"ts/no-empty-object-type": "off",
-			"ts/no-explicit-any": "off",
-			"ts/no-extra-semi": "off",
-			"ts/no-invalid-this": "error",
-			"ts/no-non-null-asserted-nullish-coalescing": "error",
-			"ts/no-non-null-assertion": "off",
-			"ts/no-parameter-properties": "off",
-			"ts/no-redeclare": "error",
-			"ts/no-require-imports": "error",
-			"ts/no-restricted-types": ["error", { types: {
-				String: {
-					message: "Use `string` instead.",
-					fixWith: "string"
-				},
-				Number: {
-					message: "Use `number` instead.",
-					fixWith: "number"
-				},
-				Boolean: {
-					message: "Use `boolean` instead.",
-					fixWith: "boolean"
-				},
-				Symbol: {
-					message: "Use `symbol` instead.",
-					fixWith: "symbol"
-				},
-				BigInt: {
-					message: "Use `bigint` instead.",
-					fixWith: "bigint"
-				},
-				Function: {
-					message: "Use `(...args: any[]) => any` instead.",
-					fixWith: "(...args: any[]) => any"
-				}
-			} }],
-			"ts/no-unsafe-function-type": "error",
-			"ts/no-unused-vars": "off",
-			"ts/no-use-before-define": ["error", {
-				functions: false,
-				classes: false,
-				variables: true
-			}],
-			"ts/no-wrapper-object-types": "error",
-			"ts/prefer-for-of": "error",
-			"ts/quotes": "off",
-			"ts/semi": "off",
-			"ts/space-before-blocks": "off",
-			"ts/space-before-function-paren": "off",
-			"ts/triple-slash-reference": "off",
-			"ts/type-annotation-spacing": "off",
-			...overrides
-		}
-	},
-	{
-		name: "so1ve/typescript/rules/type-aware",
-		files: [
-			GLOB_TS,
-			GLOB_TSX,
-			...componentExts.map((ext) => `**/*.${ext}`)
-		],
-		ignores: [GLOB_MARKDOWN_CODE, GLOB_ASTRO_TS],
-		languageOptions: {
-			parser: tseslint.parser,
-			parserOptions: {
-				sourceType: "module",
-				projectService: true,
-				tsconfigRootDir: process.cwd()
-			}
-		},
-		settings: { "import/resolver": {
-			node: { extensions: [
-				".js",
-				".jsx",
-				".mjs",
-				".ts",
-				".tsx",
-				".d.ts"
-			] },
-			typescript: { extensions: [
-				".js",
-				".jsx",
-				".mjs",
-				".ts",
-				".tsx",
-				".d.ts"
-			] }
-		} },
-		rules: {
-			"dot-notation": "off",
-			"no-implied-eval": "off",
-			"no-throw-literal": "off",
-			"no-void": ["error", { allowAsStatement: true }],
-			"ts/array-type": ["error", {
-				default: "array",
-				readonly: "array"
-			}],
-			"ts/await-thenable": "error",
-			"ts/consistent-generic-constructors": "error",
-			"ts/consistent-type-assertions": ["error", {
-				assertionStyle: "as",
-				objectLiteralTypeAssertions: "allow"
-			}],
-			"ts/consistent-type-exports": "error",
-			"ts/dot-notation": ["error", { allowKeywords: true }],
-			"ts/no-for-in-array": "error",
-			"ts/no-implied-eval": "error",
-			"ts/no-unnecessary-type-arguments": "error",
-			"ts/no-unnecessary-type-assertion": "error",
-			"ts/non-nullable-type-assertion-style": "error",
-			"ts/only-throw-error": "error",
-			"ts/prefer-nullish-coalescing": "error",
-			"ts/prefer-optional-chain": "error",
-			"ts/prefer-return-this-type": "error",
-			"ts/restrict-template-expressions": ["error", {
-				allowAny: true,
-				allowNumber: true,
-				allowBoolean: true
-			}]
-		}
-	},
-	{
-		name: "so1ve/typescript/rules/dts",
-		files: ["**/*.d.ts"],
-		rules: {
-			"eslint-comments/no-unlimited-disable": "off",
-			"import/no-duplicates": "off",
-			"unused-imports/no-unused-vars": "off"
-		}
-	},
-	{
-		name: "so1ve/typescript/rules/js",
-		files: ["**/*.js", "**/*.cjs"],
-		rules: {
-			"ts/no-require-imports": "off",
-			"ts/no-var-requires": "off"
-		}
-	}
-];
-
-//#endregion
-//#region src/configs/unicorn.ts
-const unicorn = () => [{
-	name: "so1ve/unicorn/setup",
-	plugins: { unicorn: pluginUnicorn }
-}, {
-	name: "so1ve/unicorn/rules",
-	rules: {
-		"unicorn/consistent-assert": "error",
-		"unicorn/consistent-date-clone": "error",
-		"unicorn/consistent-empty-array-spread": "error",
-		"unicorn/consistent-existence-index-check": "error",
-		"unicorn/error-message": "error",
-		"unicorn/escape-case": "error",
-		"unicorn/explicit-length-check": "error",
-		"unicorn/new-for-builtins": "error",
-		"unicorn/no-array-for-each": "error",
-		"unicorn/no-await-in-promise-methods": "error",
-		"unicorn/no-for-loop": "error",
-		"unicorn/no-instanceof-builtins": "error",
-		"unicorn/no-lonely-if": "error",
-		"unicorn/no-negated-condition": "error",
-		"unicorn/no-new-array": "error",
-		"unicorn/no-new-buffer": "error",
-		"unicorn/no-useless-collection-argument": "error",
-		"unicorn/no-useless-spread": "error",
-		"unicorn/no-zero-fractions": "error",
-		"unicorn/numeric-separators-style": "error",
-		"unicorn/prefer-array-find": "error",
-		"unicorn/prefer-array-flat": "error",
-		"unicorn/prefer-array-index-of": "error",
-		"unicorn/prefer-array-some": "error",
-		"unicorn/prefer-class-fields": "error",
-		"unicorn/prefer-date-now": "error",
-		"unicorn/prefer-includes": "error",
-		"unicorn/prefer-json-parse-buffer": "error",
-		"unicorn/prefer-modern-dom-apis": "error",
-		"unicorn/prefer-modern-math-apis": "error",
-		"unicorn/prefer-negative-index": "error",
-		"unicorn/prefer-node-protocol": "error",
-		"unicorn/prefer-object-from-entries": "error",
-		"unicorn/prefer-optional-catch-binding": "error",
-		"unicorn/prefer-prototype-methods": "error",
-		"unicorn/prefer-query-selector": "error",
-		"unicorn/prefer-regexp-test": "error",
-		"unicorn/prefer-response-static-json": "error",
-		"unicorn/prefer-set-size": "error",
-		"unicorn/prefer-spread": "error",
-		"unicorn/prefer-string-slice": "error",
-		"unicorn/prefer-string-starts-ends-with": "error",
-		"unicorn/prefer-type-error": "error",
-		"unicorn/relative-url-style": ["error", "always"],
-		"unicorn/require-module-specifiers": "error",
-		"unicorn/switch-case-braces": "error",
-		"unicorn/throw-new-error": "error"
-	}
-}];
-
-//#endregion
-//#region src/configs/vue.ts
-async function vue({ overrides, typescript: typescript$1 } = {}) {
-	const [parserVue, pluginVue] = await Promise.all([interopDefault(import("vue-eslint-parser")), interopDefault(import("eslint-plugin-vue"))]);
-	return [{
-		name: "so1ve/vue/setup",
-		plugins: { vue: pluginVue }
-	}, {
-		name: "so1ve/vue/rules",
-		files: [GLOB_VUE],
-		languageOptions: {
-			parser: parserVue,
-			parserOptions: {
-				ecmaFeatures: { jsx: true },
-				extraFileExtensions: [".vue"],
-				parser: typescript$1 ? tseslint.parser : null,
-				sourceType: "module"
-			}
-		},
-		processor: pluginVue.processors[".vue"],
-		rules: {
-			...pluginVue.configs.base.rules,
-			...pluginVue.configs.essential.rules,
-			...pluginVue.configs["strongly-recommended"].rules,
-			...pluginVue.configs.recommended.rules,
-			"no-undef": "off",
-			"no-unused-vars": "off",
-			"so1ve/vue-root-element-sort-attributes": "error",
-			"ts/no-unused-vars": "off",
-			"vue/array-bracket-spacing": "off",
-			"vue/arrow-spacing": "off",
-			"vue/attributes-order": ["error", {
-				order: [
-					"DEFINITION",
-					"LIST_RENDERING",
-					"CONDITIONALS",
-					"RENDER_MODIFIERS",
-					"TWO_WAY_BINDING",
-					"OTHER_DIRECTIVES",
-					["UNIQUE", "SLOT"],
-					"GLOBAL",
-					"OTHER_ATTR",
-					"EVENTS",
-					"CONTENT"
-				],
-				alphabetical: true
-			}],
-			"vue/block-lang": ["error", {
-				script: { lang: ["js", "ts"] },
-				template: { lang: [
-					"html",
-					"jade",
-					"pug",
-					"ejs"
-				] },
-				style: { lang: [
-					"css",
-					"sass",
-					"scss",
-					"less",
-					"stylus",
-					"postcss"
-				] }
-			}],
-			"vue/block-order": ["error", { order: [
-				"script:not([setup])",
-				"script[setup]",
-				"template",
-				"style"
-			] }],
-			"vue/block-spacing": "off",
-			"vue/brace-style": "off",
-			"vue/comma-dangle": "off",
-			"vue/comma-spacing": "off",
-			"vue/comma-style": "off",
-			"vue/component-api-style": ["error", ["script-setup", "composition"]],
-			"vue/component-name-in-template-casing": [
-				"error",
-				"PascalCase",
-				{ registeredComponentsOnly: false }
-			],
-			"vue/component-options-name-casing": ["error", "PascalCase"],
-			"vue/custom-event-name-casing": ["error", "camelCase"],
-			"vue/define-macros-order": ["error", { order: [
-				"defineOptions",
-				"defineEmits",
-				"defineProps",
-				"defineSlots"
-			] }],
-			"vue/dot-location": ["error", "property"],
-			"vue/dot-notation": ["error", { allowKeywords: true }],
-			"vue/eqeqeq": ["error", "smart"],
-			"vue/html-closing-bracket-spacing": "off",
-			"vue/html-comment-content-newline": ["error", {
-				singleline: "ignore",
-				multiline: "always"
-			}],
-			"vue/html-comment-content-spacing": [
-				"error",
-				"always",
-				{ exceptions: ["-"] }
-			],
-			"vue/html-comment-indent": ["error", "tab"],
-			"vue/html-indent": "off",
-			"vue/html-quotes": "off",
-			"vue/html-self-closing": ["error", {
-				html: {
-					void: "always",
-					normal: "always",
-					component: "always"
-				},
-				svg: "always",
-				math: "always"
-			}],
-			"vue/key-spacing": "off",
-			"vue/keyword-spacing": "off",
-			"vue/max-attributes-per-line": "off",
-			"vue/multi-word-component-names": "off",
-			"vue/multiline-html-element-content-newline": "off",
-			"vue/mustache-interpolation-spacing": "off",
-			"vue/no-console": ["error", { allow: [
-				"error",
-				"warn",
-				"table",
-				"time"
-			] }],
-			"vue/no-constant-condition": "error",
-			"vue/no-empty-pattern": "error",
-			"vue/no-irregular-whitespace": "error",
-			"vue/no-loss-of-precision": "error",
-			"vue/no-multi-spaces": "off",
-			"vue/no-multiple-template-root": "off",
-			"vue/no-restricted-syntax": [
-				"error",
-				"DebuggerStatement",
-				"LabeledStatement",
-				"WithStatement"
-			],
-			"vue/no-restricted-v-bind": ["error", "/^v-/"],
-			"vue/no-sparse-arrays": "error",
-			"vue/no-static-inline-styles": ["error", { allowBinding: true }],
-			"vue/no-unused-refs": "error",
-			"vue/no-useless-concat": "error",
-			"vue/no-useless-v-bind": ["error", { ignoreIncludesComment: true }],
-			"vue/no-v-html": "off",
-			"vue/no-v-text-v-html-on-component": "error",
-			"vue/object-curly-newline": ["error", {
-				multiline: true,
-				consistent: true
-			}],
-			"vue/object-property-newline": ["error", { allowMultiplePropertiesPerLine: true }],
-			"vue/object-shorthand": [
-				"error",
-				"always",
-				{
-					ignoreConstructors: false,
-					avoidQuotes: true
-				}
-			],
-			"vue/operator-linebreak": "off",
-			"vue/padding-line-between-blocks": ["error", "always"],
-			"vue/prefer-define-options": "error",
-			"vue/prefer-separate-static-class": "error",
-			"vue/prefer-template": "error",
-			"vue/prefer-true-attribute-shorthand": "error",
-			"vue/quote-props": ["error", "consistent-as-needed"],
-			"vue/require-default-prop": "off",
-			"vue/require-macro-variable-name": ["error", {
-				defineProps: "props",
-				defineEmits: "emit",
-				defineSlots: "slots",
-				useSlots: "slots",
-				useAttrs: "attrs"
-			}],
-			"vue/require-prop-types": "off",
-			"vue/require-typed-ref": "error",
-			"vue/singleline-html-element-content-newline": "off",
-			"vue/template-curly-spacing": "off",
-			"vue/v-bind-style": [
-				"error",
-				"shorthand",
-				{ sameNameShorthand: "always" }
-			],
-			"vue/v-for-delimiter-style": ["error", "in"],
-			...overrides
-		}
-	}];
-}
-
-//#endregion
-//#region src/configs/yaml.ts
-async function yaml({ overrides } = {}) {
-	const [parserYaml, pluginYaml] = await Promise.all([interopDefault(import("yaml-eslint-parser")), interopDefault(import("eslint-plugin-yml"))]);
-	return [{
-		name: "so1ve/yaml/setup",
-		plugins: { yaml: pluginYaml }
-	}, {
-		name: "so1ve/yaml/rules",
-		languageOptions: { parser: parserYaml },
-		files: [GLOB_YAML],
-		rules: {
-			...renameRules(pluginYaml.configs.prettier.rules, { yml: "yaml" }),
-			...renameRules(pluginYaml.configs.recommended.rules, { yml: "yaml" }),
-			"style/spaced-comment": "off",
-			"yaml/no-empty-document": "off",
-			...overrides
-		}
-	}];
-}
-
-//#endregion
-//#region src/factory.ts
-const flatConfigProps = [
-	"files",
-	"ignores",
-	"languageOptions",
-	"linterOptions",
-	"processor",
-	"plugins",
-	"rules",
-	"settings"
-];
-const VuePackages = [
-	"vue",
-	"nuxt",
-	"vitepress",
-	"@slidev/cli"
-];
-const defaultPluginRenaming = {
-	"@html-eslint": "html",
-	"@stylistic": "style",
-	"@typescript-eslint": "ts",
-	"import-x": "import",
-	"n": "node",
-	"yml": "yaml"
-};
-/**
-* Construct an array of ESLint flat config items.
-*/
-function so1ve(options = {}, ...userConfigs) {
-	const { astro: enableAstro = isPackageExists("astro"), componentExts = [], gitignore: enableGitignore = true, ignores: userIgnores = [], pnpm: enablePnpm = !!findUpSync("pnpm-workspace.yaml"), solid: enableSolid = isPackageExists("solid-js"), typescript: enableTypeScript = isPackageExists("typescript"), vue: enableVue = VuePackages.some((i) => isPackageExists(i)) } = options;
-	const configs$1 = [];
-	if (enableGitignore) if (typeof enableGitignore === "boolean") {
-		if (fs.existsSync(".gitignore")) configs$1.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [r()]));
-	} else configs$1.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [r(enableGitignore)]));
-	configs$1.push(ignores(userIgnores), javascript({ overrides: getOverrides(options, "javascript") }), comments(), node(), onlyError(), promise(), sortImports(), imports(), unicorn(), command(), deMorgan());
-	if (enablePnpm) configs$1.push(pnpm({
-		json: options.jsonc !== false,
-		yaml: options.yaml !== false,
-		...typeof enablePnpm === "boolean" ? {} : enablePnpm
-	}));
-	if (enableVue) componentExts.push("vue");
-	if (enableTypeScript) configs$1.push(typescript({
-		componentExts,
-		overrides: getOverrides(options, "typescript")
-	}));
-	if (options.test ?? true) configs$1.push(test({ overrides: getOverrides(options, "test") }));
-	if (enableAstro) configs$1.push(astro({ overrides: getOverrides(options, "astro") }));
-	if (enableVue) configs$1.push(vue({
-		overrides: getOverrides(options, "vue"),
-		typescript: !!enableTypeScript
-	}));
-	if (enableSolid) configs$1.push(solid({
-		overrides: getOverrides(options, "solid"),
-		typescript: !!enableTypeScript
-	}));
-	if (options.formatting ?? true) configs$1.push(formatting(options));
-	if (options.perfectionist ?? true) configs$1.push(perfectionist());
-	if (options.html ?? true) configs$1.push(html());
-	if (options.jsonc ?? true) configs$1.push(jsonc());
-	if (options.toml ?? true) configs$1.push(toml({ overrides: getOverrides(options, "toml") }));
-	if (options.yaml ?? true) configs$1.push(yaml({ overrides: getOverrides(options, "yaml") }));
-	if (options.mdx ?? true) configs$1.push(mdx({
-		componentExts,
-		overrides: getOverrides(options, "mdx")
-	}));
-	const fusedConfig = flatConfigProps.reduce((acc, key) => {
-		if (key in options) acc[key] = options[key];
-		return acc;
-	}, {});
-	if (Object.keys(fusedConfig).length > 0) configs$1.push([fusedConfig]);
-	return new FlatConfigComposer().append(...configs$1, ...userConfigs).renamePlugins(defaultPluginRenaming);
-}
-function getOverrides(options, key) {
-	const sub = typeof options[key] === "boolean" ? {} : options[key] ?? {};
-	return {
-		...options.overrides?.[key],
-		..."overrides" in sub ? sub.overrides : {}
-	};
-}
-
-//#endregion
 export { GLOB_ALL_SRC, GLOB_ASTRO, GLOB_ASTRO_TS, GLOB_CSS, GLOB_DTS, GLOB_ESLINTRC, GLOB_EXCLUDE, GLOB_HTML, GLOB_JS, GLOB_JSON, GLOB_JSON5, GLOB_JSONC, GLOB_JSX, GLOB_LESS, GLOB_MARKDOWN, GLOB_MARKDOWN_CODE, GLOB_PACKAGEJSON, GLOB_SCSS, GLOB_SRC, GLOB_SRC_EXT, GLOB_STYLE, GLOB_TESTS, GLOB_TOML, GLOB_TS, GLOB_TSCONFIG, GLOB_TSX, GLOB_VUE, GLOB_YAML, astro, command, comments, deMorgan, defaultPluginRenaming, formatting, getOverrides, html, ignores, imports, interopDefault, javascript, jsonc, mdx, node, onlyError, perfectionist, pnpm, promise, renameRules, so1ve, solid, sortImports, test, toml, typescript, unicorn, vue, yaml };