@so1ve/eslint-plugin 4.1.7 → 4.2.0

package/dist/index.mjs

@@ -1,1258 +1,17 @@
-import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/types";
-import { AST_TOKEN_TYPES, ESLintUtils } from "@typescript-eslint/utils";
-import natsort from "natsort";
+import function_style_default from "./rules/function-style.mjs";
+import html_spaced_comment_default from "./rules/html-spaced-comment.mjs";
+import import_dedupe_default from "./rules/import-dedupe.mjs";
+import import_export_newline_default from "./rules/import-export-newline.mjs";
+import no_import_promises_as_default from "./rules/no-import-promises-as.mjs";
+import no_inline_type_modifier_default from "./rules/no-inline-type-modifier.mjs";
+import no_negated_comparison_default from "./rules/no-negated-comparison.mjs";
+import no_useless_template_string_default from "./rules/no-useless-template-string.mjs";
+import prefer_ts_expect_error_default from "./rules/prefer-ts-expect-error.mjs";
+import require_async_with_await_default from "./rules/require-async-with-await.mjs";
+import sort_exports_default from "./rules/sort-exports.mjs";
+import sort_imports_default from "./rules/sort-imports.mjs";
+import vue_root_element_sort_attributes_default from "./rules/vue-root-element-sort-attributes.mjs";
 
-//#region src/utils/index.ts
-const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
-function getSiblingNode(node, offset) {
-	if (!node) return;
-	const { parent } = node;
-	if (parent && "body" in parent) {
-		const { body } = parent;
-		if (!Array.isArray(body)) return;
-		const targetIndex = body.indexOf(node) + offset;
-		if (targetIndex >= 0 && targetIndex < body.length) return body[targetIndex];
-	}
-}
-const getPreviousNode = (node) => getSiblingNode(node, -1);
-const getNextNode = (node) => getSiblingNode(node, 1);
-
-//#endregion
-//#region src/rules/function-style.ts
-const RULE_NAME$11 = "function-style";
-const rule$12 = createEslintRule({
-	name: RULE_NAME$11,
-	meta: {
-		type: "problem",
-		docs: { description: "Enforce function style." },
-		fixable: "code",
-		schema: [],
-		messages: {
-			arrow: "Expected an arrow function shorthand.",
-			declaration: "Expected a function declaration."
-		}
-	},
-	defaultOptions: [],
-	create: (context) => {
-		const sourceCode = context.sourceCode;
-		const scopeStack = [];
-		let haveThisAccess = false;
-		function getSingleReturnStatement(node) {
-			const { body } = node;
-			if (body.type !== AST_NODE_TYPES.BlockStatement) return;
-			const { body: blockBody } = body;
-			if (blockBody.length !== 1) return;
-			const [statement] = blockBody;
-			if (statement?.type !== AST_NODE_TYPES.ReturnStatement) return;
-			const allComments = sourceCode.getCommentsInside(node);
-			const statementComments = sourceCode.getCommentsInside(statement);
-			if (allComments.length !== statementComments.length) return;
-			return statement;
-		}
-		const extractFunctionInfo = (node) => ({
-			async: node.async,
-			generics: node.typeParameters ? sourceCode.getText(node.typeParameters) : "",
-			params: node.params.map((param) => sourceCode.getText(param)).join(", "),
-			returnType: node.returnType ? sourceCode.getText(node.returnType) : "",
-			body: sourceCode.getText(node.body)
-		});
-		function generateArrowFunction(name, info, returnValue, asVariable = true) {
-			const asyncKeyword = info.async ? "async " : "";
-			return `${asVariable && name ? `const ${name} = ` : ""}${asyncKeyword}${info.generics}(${info.params})${info.returnType} => ${returnValue};`;
-		}
-		function generateFunctionDeclaration(name, info) {
-			return `${info.async ? "async " : ""}function ${name}${info.generics}(${info.params})${info.returnType} ${info.body}`;
-		}
-		function setupScope(node) {
-			scopeStack.push(sourceCode.getScope(node));
-		}
-		function clearThisAccess() {
-			scopeStack.pop();
-			haveThisAccess = false;
-		}
-		function getFunctionExpressionParentNameString(node) {
-			const parent = node.parent;
-			if (parent?.id?.typeAnnotation || parent?.type !== AST_NODE_TYPES.VariableDeclarator || haveThisAccess) return null;
-			return parent.id.name;
-		}
-		function shouldConvertFunctionDeclarationToArrow(node) {
-			if (haveThisAccess) return { shouldConvert: false };
-			const previousNode = getPreviousNode(node.parent);
-			if (previousNode?.type === AST_NODE_TYPES.ExportNamedDeclaration && previousNode.declaration?.type === AST_NODE_TYPES.TSDeclareFunction) return { shouldConvert: false };
-			const returnStatement = getSingleReturnStatement(node);
-			const isExportDefault = node.parent?.type === AST_NODE_TYPES.ExportDefaultDeclaration;
-			if (!returnStatement?.argument || !node.id?.name && !isExportDefault || node.generator) return { shouldConvert: false };
-			return {
-				shouldConvert: true,
-				returnStatement
-			};
-		}
-		return {
-			"FunctionExpression": setupScope,
-			"FunctionExpression:exit"(node) {
-				const name = getFunctionExpressionParentNameString(node);
-				if (!name) {
-					clearThisAccess();
-					return;
-				}
-				const info = extractFunctionInfo(node);
-				const grandParent = node.parent?.parent;
-				if (!grandParent) return;
-				context.report({
-					node,
-					messageId: "declaration",
-					fix: (fixer) => fixer.replaceText(grandParent, generateFunctionDeclaration(name, info))
-				});
-				clearThisAccess();
-			},
-			"FunctionDeclaration:not(TSDeclareFunction + FunctionDeclaration)": setupScope,
-			"FunctionDeclaration:not(TSDeclareFunction + FunctionDeclaration):exit"(node) {
-				if (haveThisAccess) return;
-				const { shouldConvert, returnStatement } = shouldConvertFunctionDeclarationToArrow(node);
-				if (!shouldConvert || !returnStatement?.argument) {
-					clearThisAccess();
-					return;
-				}
-				const info = extractFunctionInfo(node);
-				const isExportDefault = node.parent?.type === AST_NODE_TYPES.ExportDefaultDeclaration;
-				const returnValue = `(${sourceCode.getText(returnStatement.argument)})`;
-				context.report({
-					node,
-					messageId: "arrow",
-					fix: (fixer) => fixer.replaceText(node, generateArrowFunction(node.id?.name ?? null, info, returnValue, !isExportDefault))
-				});
-				clearThisAccess();
-			},
-			"ArrowFunctionExpression": setupScope,
-			"ArrowFunctionExpression:exit"(node) {
-				if (haveThisAccess) return;
-				const { body, parent } = node;
-				const returnStatement = getSingleReturnStatement(node);
-				if (returnStatement?.argument) {
-					const returnValue = `(${sourceCode.getText(returnStatement.argument)})`;
-					context.report({
-						node,
-						messageId: "arrow",
-						fix: (fixer) => fixer.replaceText(node.body, returnValue)
-					});
-				} else if (body.type === AST_NODE_TYPES.BlockStatement && !parent?.id?.typeAnnotation) {
-					const { body: blockBody } = body;
-					if (blockBody.length > 0 && node.parent?.parent?.type === AST_NODE_TYPES.VariableDeclaration) {
-						const grandParent = node.parent.parent;
-						const name = node.parent.id.name;
-						const info = extractFunctionInfo(node);
-						context.report({
-							node: grandParent,
-							messageId: "declaration",
-							fix: (fixer) => fixer.replaceText(grandParent, generateFunctionDeclaration(name, info))
-						});
-					}
-				}
-				clearThisAccess();
-			},
-			ThisExpression(node) {
-				haveThisAccess = scopeStack.includes(sourceCode.getScope(node));
-			}
-		};
-	}
-});
-var function_style_default = rule$12;
-
-//#endregion
-//#region src/rules/html-spaced-comment.ts
-const RULE_NAME$10 = "html-spaced-comment";
-const rule$11 = createEslintRule({
-	name: RULE_NAME$10,
-	meta: {
-		type: "layout",
-		docs: { description: "Enforce consistent spacing in HTML comments" },
-		fixable: "whitespace",
-		schema: [],
-		messages: {
-			expectedSpaceBefore: "Expected space after '<!--'.",
-			expectedSpaceAfter: "Expected space before '-->'."
-		}
-	},
-	defaultOptions: [],
-	create: (context) => ({ Comment(node) {
-		if (node.value?.type !== "CommentContent") return;
-		const rawValue = node.value.value;
-		if (rawValue.trim().length === 0) return;
-		if (!rawValue.startsWith(" ") && !rawValue.startsWith("\n")) context.report({
-			node: node.value,
-			messageId: "expectedSpaceBefore",
-			fix(fixer) {
-				return fixer.insertTextBefore(node.value, " ");
-			}
-		});
-		if (!rawValue.endsWith(" ") && !rawValue.endsWith("\n")) context.report({
-			node: node.value,
-			messageId: "expectedSpaceAfter",
-			fix(fixer) {
-				return fixer.insertTextAfter(node.value, " ");
-			}
-		});
-	} })
-});
-var html_spaced_comment_default = rule$11;
-
-//#endregion
-//#region src/rules/import-dedupe.ts
-const RULE_NAME$9 = "import-dedupe";
-const rule$10 = createEslintRule({
-	name: RULE_NAME$9,
-	meta: {
-		type: "problem",
-		docs: { description: "Fix duplication in imports." },
-		fixable: "code",
-		schema: [],
-		messages: { importDedupe: "Expect no duplication in imports." }
-	},
-	defaultOptions: [],
-	create: (context) => ({ ImportDeclaration(node) {
-		if (node.specifiers.length <= 1) return;
-		const names = /* @__PURE__ */ new Set();
-		for (const n of node.specifiers) {
-			const id = n.local.name;
-			if (names.has(id)) context.report({
-				node,
-				loc: {
-					start: n.loc.end,
-					end: n.loc.start
-				},
-				messageId: "importDedupe",
-				fix(fixer) {
-					const start = n.range[0];
-					let end = n.range[1];
-					const nextToken = context.sourceCode.getTokenAfter(n);
-					if (nextToken?.value === ",") end = nextToken.range[1];
-					return fixer.removeRange([start, end]);
-				}
-			});
-			names.add(id);
-		}
-	} })
-});
-var import_dedupe_default = rule$10;
-
-//#endregion
-//#region src/rules/import-export-newline.ts
-const RULE_NAME$8 = "import-export-newline";
-const isExportDeclaration = (node) => node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration";
-const rule$9 = createEslintRule({
-	name: RULE_NAME$8,
-	meta: {
-		type: "problem",
-		docs: { description: "Enforce spacing between imports and exports." },
-		fixable: "code",
-		schema: [],
-		messages: {
-			newlineAfterLastImport: "Expected a blank line after the last import.",
-			newlineBeforeExport: "Expected a blank line before the export.",
-			newlineAfterExport: "Expected a blank line after the export."
-		}
-	},
-	defaultOptions: [],
-	create: (context) => {
-		const sourceCode = context.sourceCode;
-		let lastImportNode = null;
-		const exportNodes = [];
-		function checkExport(node) {
-			exportNodes.push(node);
-		}
-		function checkNewline(node, direction) {
-			let token;
-			let expectedLine;
-			let tokenLine;
-			if (direction === "after") {
-				const endNode = sourceCode.getCommentsAfter(node).find((c) => c.loc.start.line === node.loc.end.line) ?? node;
-				token = sourceCode.getTokenAfter(endNode);
-				const nextComment = sourceCode.getCommentsAfter(endNode)[0];
-				expectedLine = endNode.loc.end.line + 1;
-				tokenLine = token?.loc.start.line;
-				const commentLine = nextComment?.loc.start.line;
-				if (token && (expectedLine === tokenLine || expectedLine === commentLine || tokenLine === endNode.loc.end.line) && token.value !== "}" && token.value !== "<\/script>") return endNode;
-				return null;
-			}
-			const startNode = sourceCode.getCommentsBefore(node)[0] || node;
-			token = sourceCode.getTokenBefore(startNode);
-			expectedLine = startNode.loc.start.line - 1;
-			tokenLine = token?.loc.end.line;
-			if (token && expectedLine === tokenLine) return startNode;
-			return null;
-		}
-		return {
-			ImportDeclaration(node) {
-				lastImportNode = node;
-			},
-			ExportNamedDeclaration: checkExport,
-			ExportDefaultDeclaration: checkExport,
-			ExportAllDeclaration: checkExport,
-			"Program:exit"() {
-				if (lastImportNode) {
-					const parent = lastImportNode.parent;
-					const nextNode = getNextNode(lastImportNode);
-					const isLastInBlock = parent && "body" in parent && Array.isArray(parent.body) && parent.body[parent.body.length - 1] === lastImportNode;
-					if (nextNode && !isLastInBlock) {
-						const lastImportFixNode = checkNewline(lastImportNode, "after");
-						if (lastImportFixNode) context.report({
-							node: lastImportNode,
-							messageId: "newlineAfterLastImport",
-							fix: (fixer) => fixer.insertTextAfter(lastImportFixNode, "\n")
-						});
-					}
-				}
-				for (const node of exportNodes) {
-					const prevNode = getPreviousNode(node);
-					const parent = node.parent;
-					const isFirstInBlock = parent && "body" in parent && Array.isArray(parent.body) && parent.body[0] === node;
-					if ((!prevNode || !isExportDeclaration(prevNode)) && (!lastImportNode || prevNode !== lastImportNode) && !isFirstInBlock) {
-						const beforeFixNode = checkNewline(node, "before");
-						if (beforeFixNode) context.report({
-							node,
-							messageId: "newlineBeforeExport",
-							fix: (fixer) => fixer.insertTextBefore(beforeFixNode, "\n")
-						});
-					}
-					const nextNode = getNextNode(node);
-					if (nextNode && !isExportDeclaration(nextNode)) {
-						const afterFixNode = checkNewline(node, "after");
-						if (afterFixNode) context.report({
-							node,
-							messageId: "newlineAfterExport",
-							fix: (fixer) => fixer.insertTextAfter(afterFixNode, "\n")
-						});
-					}
-				}
-			}
-		};
-	}
-});
-var import_export_newline_default = rule$9;
-
-//#endregion
-//#region src/rules/no-import-promises-as.ts
-const RULE_NAME$7 = "no-import-promises-as";
-const POSSIBLE_IMPORT_SOURCES = [
-	"dns",
-	"fs",
-	"readline",
-	"stream"
-].flatMap((s) => [s, `node:${s}`]);
-const rule$8 = createEslintRule({
-	name: RULE_NAME$7,
-	meta: {
-		type: "problem",
-		docs: { description: "Disallow import promises as." },
-		fixable: "code",
-		schema: [],
-		messages: { noImportPromisesAs: "Expect no import promises as." }
-	},
-	defaultOptions: [],
-	create: (context) => {
-		const { text } = context.sourceCode;
-		return { ImportDeclaration(node) {
-			if (!POSSIBLE_IMPORT_SOURCES.includes(node.source.value)) return;
-			const promisesSpecifier = node.specifiers.find((s) => s.type === "ImportSpecifier" && s.imported.type === "Identifier" && s.imported.name === "promises" && s.local.name !== "promises");
-			const as = promisesSpecifier?.local.name;
-			if (!promisesSpecifier || !as) return;
-			context.report({
-				node,
-				messageId: "noImportPromisesAs",
-				*fix(fixer) {
-					const s = promisesSpecifier.range[0];
-					let e = promisesSpecifier.range[1];
-					if (text[e] === ",") e += 1;
-					yield fixer.removeRange([s, e]);
-					yield fixer.insertTextAfter(node, `\nimport ${as} from "${node.source.value}/promises";`);
-				}
-			});
-		} };
-	}
-});
-var no_import_promises_as_default = rule$8;
-
-//#endregion
-//#region src/rules/no-inline-type-modifier.ts
-const RULE_NAME$6 = "no-inline-type-modifier";
-const getName = (node) => node.type === AST_NODE_TYPES.Identifier ? node.name : node.raw;
-function getSpecifierText(s) {
-	const isExport = s.type === AST_NODE_TYPES.ExportSpecifier;
-	const name1 = getName(isExport ? s.local : s.imported);
-	const name2 = getName(isExport ? s.exported : s.local);
-	return name1 === name2 ? name1 : `${name1} as ${name2}`;
-}
-function generateSpecifiersText(specifiers) {
-	return `{ ${specifiers.map(getSpecifierText).join(", ")} }`;
-}
-const generateTypeText = (specifiers) => `type ${generateSpecifiersText(specifiers)}`;
-function generateValueText(valueSpecifiers, defaultSpecifier) {
-	const parts = [];
-	if (defaultSpecifier) parts.push(defaultSpecifier.local.name);
-	if (valueSpecifiers.length > 0) parts.push(generateSpecifiersText(valueSpecifiers));
-	return parts.join(", ");
-}
-function classifySpecifiers(specifiers) {
-	const typeSpecifiers = [];
-	const valueSpecifiers = [];
-	let defaultSpecifier;
-	for (const s of specifiers) if (s.type === AST_NODE_TYPES.ImportDefaultSpecifier) defaultSpecifier = s;
-	else if (s.type === AST_NODE_TYPES.ImportSpecifier) if (s.importKind === "type") typeSpecifiers.push(s);
-	else valueSpecifiers.push(s);
-	else if (s.type === AST_NODE_TYPES.ExportSpecifier) if (s.exportKind === "type") typeSpecifiers.push(s);
-	else valueSpecifiers.push(s);
-	return {
-		typeSpecifiers,
-		valueSpecifiers,
-		defaultSpecifier
-	};
-}
-const rule$7 = createEslintRule({
-	name: RULE_NAME$6,
-	meta: {
-		type: "layout",
-		docs: { description: "Disallow inline type modifiers in import/export." },
-		fixable: "code",
-		schema: [],
-		messages: { noInlineTypeModifier: "Expected no inline type modifier." }
-	},
-	defaultOptions: [],
-	create: (context) => ({
-		ImportDeclaration: (node) => {
-			const { typeSpecifiers, valueSpecifiers, defaultSpecifier } = classifySpecifiers(node.specifiers);
-			if (typeSpecifiers.length === 0) return;
-			const texts = [];
-			texts.push(generateTypeText(typeSpecifiers));
-			if (defaultSpecifier || valueSpecifiers.length > 0) texts.push(generateValueText(valueSpecifiers, defaultSpecifier));
-			const textToReport = texts.map((text) => `import ${text} from "${node.source.value}";`).join("\n");
-			context.report({
-				node,
-				messageId: "noInlineTypeModifier",
-				fix(fixer) {
-					return fixer.replaceText(node, textToReport);
-				}
-			});
-		},
-		ExportNamedDeclaration: (node) => {
-			if (node.declaration || node.exportKind === "type") return;
-			const { typeSpecifiers, valueSpecifiers } = classifySpecifiers(node.specifiers);
-			if (typeSpecifiers.length === 0) return;
-			const fromText = node.source ? ` from "${node.source.value}"` : "";
-			const texts = [];
-			texts.push(generateTypeText(typeSpecifiers));
-			if (valueSpecifiers.length > 0) texts.push(generateValueText(valueSpecifiers));
-			const textToReport = texts.map((text) => `export ${text}${fromText};`).join("\n");
-			context.report({
-				node,
-				messageId: "noInlineTypeModifier",
-				fix(fixer) {
-					return fixer.replaceText(node, textToReport);
-				}
-			});
-		}
-	})
-});
-var no_inline_type_modifier_default = rule$7;
-
-//#endregion
-//#region src/rules/no-negated-comparison.ts
-const RULE_NAME$5 = "no-negated-comparison";
-const negatedToPositive = {
-	"==": "!=",
-	"===": "!==",
-	"!=": "==",
-	"!==": "===",
-	"<": ">=",
-	"<=": ">",
-	">": "<=",
-	">=": "<"
-};
-const negatives = Object.keys(negatedToPositive);
-const rule$6 = createEslintRule({
-	name: RULE_NAME$5,
-	meta: {
-		type: "problem",
-		docs: { description: "Disallow negated comparison." },
-		fixable: "code",
-		schema: [],
-		messages: { noNegatedComparison: "Expect no negated comparison." }
-	},
-	defaultOptions: [],
-	create: (context) => ({ BinaryExpression(node) {
-		const { parent, left, right, operator } = node;
-		if (!parent) return;
-		if (negatives.includes(operator) && parent.type === AST_NODE_TYPES.UnaryExpression && parent.operator === "!") context.report({
-			node,
-			messageId: "noNegatedComparison",
-			*fix(fixer) {
-				const operatorRange = [left.range[1], right.range[0]];
-				const fixedOperator = negatedToPositive[operator];
-				yield fixer.replaceTextRange(operatorRange, fixedOperator);
-				yield fixer.removeRange([parent.range[0], parent.range[0] + 1]);
-			}
-		});
-	} })
-});
-var no_negated_comparison_default = rule$6;
-
-//#endregion
-//#region src/rules/no-useless-template-string.ts
-const RULE_NAME$4 = "no-useless-template-string";
-const rule$5 = createEslintRule({
-	name: RULE_NAME$4,
-	meta: {
-		type: "problem",
-		docs: { description: "No useless template string." },
-		fixable: "code",
-		schema: [],
-		messages: { noUselessTemplateString: "No useless template string." }
-	},
-	defaultOptions: [],
-	create: (context) => ({ "TemplateLiteral:not(TaggedTemplateExpression > TemplateLiteral)"(node) {
-		const { quasis } = node;
-		const isSafe = !quasis.some(({ value: { raw } }) => raw.includes("\"") || raw.includes("'") || raw.includes("\n"));
-		if (node.expressions.length === 0 && isSafe) context.report({
-			node,
-			messageId: "noUselessTemplateString",
-			fix(fixer) {
-				return fixer.replaceTextRange(node.range, `"${node.quasis[0].value.raw}"`);
-			}
-		});
-	} })
-});
-var no_useless_template_string_default = rule$5;
-
-//#endregion
-//#region src/rules/prefer-ts-expect-error.ts
-const rule$4 = createEslintRule({
-	name: "prefer-ts-expect-error",
-	meta: {
-		type: "problem",
-		docs: { description: "Enforce using `@ts-expect-error` over `@ts-ignore`" },
-		fixable: "code",
-		messages: { preferExpectErrorComment: "Use \"@ts-expect-error\" to ensure an error is actually being suppressed." },
-		replacedBy: ["@typescript-eslint/ban-ts-comment"],
-		schema: []
-	},
-	defaultOptions: [],
-	create(context) {
-		const tsIgnoreRegExpSingleLine = /^\s*(?:\/\s*)?@ts-ignore/;
-		const tsIgnoreRegExpMultiLine = /^\s*(?:(?:\/|\*)+\s*)?@ts-ignore/;
-		const isLineComment$1 = (comment) => comment.type === AST_TOKEN_TYPES.Line;
-		function getLastCommentLine(comment) {
-			if (isLineComment$1(comment)) return comment.value;
-			const commentlines = comment.value.split("\n");
-			return commentlines[commentlines.length - 1];
-		}
-		function isValidTsIgnorePresent(comment) {
-			const line = getLastCommentLine(comment);
-			return isLineComment$1(comment) ? tsIgnoreRegExpSingleLine.test(line) : tsIgnoreRegExpMultiLine.test(line);
-		}
-		return { Program() {
-			const comments = context.sourceCode.getAllComments();
-			for (const comment of comments) if (isValidTsIgnorePresent(comment)) {
-				const lineCommentRuleFixer = (fixer) => fixer.replaceText(comment, `//${comment.value.replace("@ts-ignore", "@ts-expect-error")}`);
-				const blockCommentRuleFixer = (fixer) => fixer.replaceText(comment, `/*${comment.value.replace("@ts-ignore", "@ts-expect-error")}*/`);
-				context.report({
-					node: comment,
-					messageId: "preferExpectErrorComment",
-					fix: isLineComment$1(comment) ? lineCommentRuleFixer : blockCommentRuleFixer
-				});
-			}
-		} };
-	}
-});
-var prefer_ts_expect_error_default = rule$4;
-
-//#endregion
-//#region src/rules/require-async-with-await.ts
-const RULE_NAME$3 = "require-async-with-await";
-const rule$3 = createEslintRule({
-	name: RULE_NAME$3,
-	meta: {
-		type: "problem",
-		docs: { description: "Require using async keyword with await." },
-		fixable: "code",
-		schema: [],
-		messages: { requireAsyncWithAwait: "Expect using async keyword with await." }
-	},
-	defaultOptions: [],
-	create: (context) => {
-		const functionNodeStack = [];
-		function setupNode(node) {
-			functionNodeStack.push(node);
-		}
-		function clearNode() {
-			functionNodeStack.pop();
-		}
-		return {
-			"FunctionExpression": setupNode,
-			"FunctionExpression:exit": clearNode,
-			"FunctionDeclaration": setupNode,
-			"FunctionDeclaration:exit": clearNode,
-			"ArrowFunctionExpression": setupNode,
-			"ArrowFunctionExpression:exit": clearNode,
-			AwaitExpression() {
-				const node = functionNodeStack[functionNodeStack.length - 1];
-				if (!node || node.async) return;
-				let fixRange;
-				if (node.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression) fixRange = node.range;
-				if (node.type === TSESTree.AST_NODE_TYPES.FunctionDeclaration || node.type === TSESTree.AST_NODE_TYPES.FunctionExpression) if (node.parent.type === TSESTree.AST_NODE_TYPES.Property || node.parent.type === TSESTree.AST_NODE_TYPES.MethodDefinition) {
-					if (node.parent.kind === "method" || node.parent.kind === "init") fixRange = node.parent.key.range;
-				} else fixRange = node.range;
-				if (fixRange) context.report({
-					node,
-					messageId: "requireAsyncWithAwait",
-					fix: (fixer) => fixer.insertTextBeforeRange(fixRange, "async ")
-				});
-			}
-		};
-	}
-});
-var require_async_with_await_default = rule$3;
-
-//#endregion
-//#region src/utils/sort-imports.ts
-const NEWLINE = /(\r?\n)/;
-const hasNewline = (text) => NEWLINE.test(text);
-function guessNewline(sourceCode) {
-	const match = NEWLINE.exec(sourceCode.text);
-	return match == null ? "\n" : match[0];
-}
-const withCode = (token, sourceCode) => ({
-	...token,
-	code: sourceCode.getText(token)
-});
-function parseWhitespace(whitespace) {
-	const allItems = whitespace.split(NEWLINE);
-	return (allItems.length >= 5 ? [...allItems.slice(0, 2), ...allItems.slice(-1)] : allItems).map((spacesOrNewline, index) => index % 2 === 0 ? {
-		type: "Spaces",
-		code: spacesOrNewline
-	} : {
-		type: "Newline",
-		code: spacesOrNewline
-	}).filter((token) => token.code !== "");
-}
-const naturalSort = ("default" in natsort ? natsort.default : natsort)();
-function compare(path1, path2) {
-	const path1Depth = path1.split("-").filter((p) => p === "__").length;
-	const path2Depth = path2.split("-").filter((p) => p === "__").length;
-	const path1IsDot = path1 === "_-,";
-	const path2IsDot = path2 === "_-,";
-	if (path1IsDot && !path2IsDot) return 1;
-	if (path2IsDot && !path1IsDot) return -1;
-	return path1Depth === path2Depth ? naturalSort(path1, path2) : path2Depth - path1Depth;
-}
-const isIdentifier = (node) => node.type === "Identifier";
-const isKeyword = (node) => node.type === "Keyword";
-const isPunctuator = (node, value) => node.type === "Punctuator" && typeof node.value === "string" && node.value === value;
-const isBlockComment = (node) => node.type === "Block";
-const isLineComment = (node) => node.type === "Line";
-const isSpaces = (node) => node.type === "Spaces";
-const isNewline = (node) => node.type === "Newline";
-const getImportExportKind = (node) => node.importKind ?? node.exportKind ?? "value";
-function getSource(node) {
-	const source = String(node.source.value);
-	return {
-		source: source.replace(/^[./]*\.$/, "$&/").replace(/^[./]*\/$/, "$&,").replace(/[./_-]/g, (char) => {
-			switch (char) {
-				case ".": return "_";
-				case "/": return "-";
-				case "_": return ".";
-				case "-": return "/";
-				default: throw new Error(`Unknown source substitution character: ${char}`);
-			}
-		}),
-		originalSource: source,
-		kind: getImportExportKind(node)
-	};
-}
-function findLastIndex(array, fn) {
-	for (let index = array.length - 1; index >= 0; index--) if (fn(array[index], index, array)) return index;
-	return -1;
-}
-const flatMap = (array, fn) => array.flatMap((item, index) => fn(item, index));
-function getAllTokens(node, sourceCode) {
-	const tokens = sourceCode.getTokens(node);
-	const lastTokenIndex = tokens.length - 1;
-	return flatMap(tokens, (token, tokenIndex) => {
-		const newToken = withCode(token, sourceCode);
-		if (tokenIndex === lastTokenIndex) return [newToken];
-		const comments = sourceCode.getCommentsAfter(token);
-		const last = comments.length > 0 ? comments[comments.length - 1] : token;
-		const nextToken = tokens[tokenIndex + 1];
-		return [
-			newToken,
-			...flatMap(comments, (comment, commentIndex) => {
-				const previous = commentIndex === 0 ? token : comments[commentIndex - 1];
-				return [...parseWhitespace(sourceCode.text.slice(previous.range[1], comment.range[0])), withCode(comment, sourceCode)];
-			}),
-			...parseWhitespace(sourceCode.text.slice(last.range[1], nextToken.range[0]))
-		];
-	});
-}
-const printTokens = (tokens) => tokens.map((token) => token.code).join("");
-const removeBlankLines = (whitespace) => printTokens(parseWhitespace(whitespace));
-function printCommentsBefore(node, comments, sourceCode) {
-	const lastIndex = comments.length - 1;
-	return comments.map((comment, index) => {
-		const next = index === lastIndex ? node : comments[index + 1];
-		return sourceCode.getText(comment) + removeBlankLines(sourceCode.text.slice(comment.range[1], next.range[0]));
-	}).join("");
-}
-const printCommentsAfter = (node, comments, sourceCode) => comments.map((comment, index) => {
-	const previous = index === 0 ? node : comments[index - 1];
-	return removeBlankLines(sourceCode.text.slice(previous.range[1], comment.range[0])) + sourceCode.getText(comment);
-}).join("");
-function getIndentationAt(index, sourceCode) {
-	const lines = sourceCode.text.slice(0, index).split(NEWLINE);
-	const linePrefix = lines[lines.length - 1];
-	return /^\s*$/u.test(linePrefix) ? linePrefix : "";
-}
-function getTrailingSpacesAt(index, sourceCode) {
-	const { text } = sourceCode;
-	let end = index;
-	while (end < text.length) {
-		const char = text[end];
-		if (char === " " || char === "	") {
-			end++;
-			continue;
-		}
-		break;
-	}
-	return text.slice(index, end);
-}
-const sortImportExportItems = (items) => [...items].sort((itemA, itemB) => itemA.isSideEffectImport && itemB.isSideEffectImport ? itemA.index - itemB.index : itemA.isSideEffectImport ? -1 : itemB.isSideEffectImport ? 1 : compare(itemA.source.source, itemB.source.source) || compare(itemA.source.originalSource, itemB.source.originalSource) || compare(itemA.source.kind, itemB.source.kind) || itemA.index - itemB.index);
-const getSpecifierName = (node) => node.type === "Identifier" ? node.name : node.value;
-const getExternalName = (node) => getSpecifierName("imported" in node ? node.imported : node.exported);
-const getLocalName = (node) => getSpecifierName(node.local);
-function compareImportExportKind(kindA, kindB) {
-	if (kindA === kindB) return 0;
-	return kindA === "type" ? -1 : 1;
-}
-const sortSpecifierItems = (items) => [...items].sort((itemA, itemB) => compareImportExportKind(getImportExportKind(itemA.node), getImportExportKind(itemB.node)) || compare(getExternalName(itemA.node), getExternalName(itemB.node)) || compare(getLocalName(itemA.node), getLocalName(itemB.node)) || itemA.index - itemB.index);
-function extractChunks(parentNode, isPartOfChunk$1) {
-	const chunks = [];
-	let chunk = [];
-	let lastNode;
-	for (const node of parentNode.body) {
-		const result = isPartOfChunk$1(node, lastNode);
-		switch (result) {
-			case "PartOfChunk":
-				chunk.push(node);
-				break;
-			case "PartOfNewChunk":
-				if (chunk.length > 0) chunks.push(chunk);
-				chunk = [node];
-				break;
-			case "NotPartOfChunk":
-				if (chunk.length > 0) {
-					chunks.push(chunk);
-					chunk = [];
-				}
-				break;
-			default: {
-				const _never = result;
-				throw new Error(`Unknown chunk result: ${String(_never)}`);
-			}
-		}
-		lastNode = node;
-	}
-	if (chunk.length > 0) chunks.push(chunk);
-	return chunks;
-}
-function maybeReportSorting(context, sorted, start, end) {
-	const sourceCode = context.sourceCode;
-	if (sourceCode.getText().slice(start, end) !== sorted) context.report({
-		messageId: "sort",
-		loc: {
-			start: sourceCode.getLocFromIndex(start),
-			end: sourceCode.getLocFromIndex(end)
-		},
-		fix: (fixer) => fixer.replaceTextRange([start, end], sorted)
-	});
-}
-function printSortedItems(sortedItems, originalItems, sourceCode) {
-	const newline = guessNewline(sourceCode);
-	const sorted = sortedItems.map((groups) => groups.map((groupItems) => groupItems.map((item) => item.code).join(newline)).join(newline)).join(newline + newline);
-	const flattened = flatMap(sortedItems, (groups) => flatMap(groups, (g) => g));
-	const lastSortedItem = flattened[flattened.length - 1];
-	const lastOriginalItem = originalItems[originalItems.length - 1];
-	const nextToken = lastSortedItem.needsNewline ? sourceCode.getTokenAfter(lastOriginalItem.node, {
-		includeComments: true,
-		filter: (token) => token.type !== "Line" && (token.type !== "Block" || token.loc.end.line !== lastOriginalItem.node.loc.end.line)
-	}) : void 0;
-	return sorted + (nextToken != null && nextToken.loc.start.line === lastOriginalItem.node.loc.end.line ? newline : "");
-}
-const makeEmptyItem = () => ({
-	state: "before",
-	before: [],
-	after: [],
-	specifier: [],
-	hadComma: false
-});
-function getSpecifierItems(tokens) {
-	const result = {
-		before: [],
-		after: [],
-		items: []
-	};
-	let current = makeEmptyItem();
-	for (const token of tokens) switch (current.state) {
-		case "before":
-			switch (token.type) {
-				case "Newline":
-					current.before.push(token);
-					if (result.before.length === 0 && result.items.length === 0) {
-						result.before = current.before;
-						current = makeEmptyItem();
-					}
-					break;
-				case "Spaces":
-				case "Block":
-				case "Line":
-					current.before.push(token);
-					break;
-				default:
-					if (result.before.length === 0 && result.items.length === 0) {
-						result.before = current.before;
-						current = makeEmptyItem();
-					}
-					current.state = "specifier";
-					current.specifier.push(token);
-			}
-			break;
-		case "specifier":
-			switch (token.type) {
-				case "Punctuator":
-					if (isPunctuator(token, ",")) {
-						current.hadComma = true;
-						current.state = "after";
-					} else current.specifier.push(token);
-					break;
-				default: current.specifier.push(token);
-			}
-			break;
-		case "after":
-			switch (token.type) {
-				case "Newline":
-					current.after.push(token);
-					result.items.push(current);
-					current = makeEmptyItem();
-					break;
-				case "Spaces":
-				case "Line":
-					current.after.push(token);
-					break;
-				case "Block":
-					if (hasNewline(token.code)) {
-						result.items.push(current);
-						current = makeEmptyItem();
-						current.before.push(token);
-					} else current.after.push(token);
-					break;
-				default:
-					result.items.push(current);
-					current = makeEmptyItem();
-					current.state = "specifier";
-					current.specifier.push(token);
-			}
-			break;
-		default: {
-			const _never = current.state;
-			throw new Error(`Unknown state: ${String(_never)}`);
-		}
-	}
-	switch (current.state) {
-		case "before":
-			result.after = current.before;
-			break;
-		case "specifier": {
-			const lastIdentifierIndex = findLastIndex(current.specifier, (t) => isIdentifier(t) || isKeyword(t));
-			const specifier = current.specifier.slice(0, lastIdentifierIndex + 1);
-			const after = current.specifier.slice(lastIdentifierIndex + 1);
-			const newlineIndexRaw = after.findIndex((t) => isNewline(t));
-			const newlineIndex = newlineIndexRaw === -1 ? -1 : newlineIndexRaw + 1;
-			const multilineBlockCommentIndex = after.findIndex((t) => isBlockComment(t) && hasNewline(t.code));
-			const sliceIndex = newlineIndex >= 0 && multilineBlockCommentIndex !== -1 ? Math.min(newlineIndex, multilineBlockCommentIndex) : newlineIndex >= 0 ? newlineIndex : multilineBlockCommentIndex === -1 ? endsWithSpaces(after) ? after.length - 1 : -1 : multilineBlockCommentIndex;
-			current.specifier = specifier;
-			current.after = sliceIndex === -1 ? after : after.slice(0, sliceIndex);
-			result.items.push(current);
-			result.after = sliceIndex === -1 ? [] : after.slice(sliceIndex);
-			break;
-		}
-		case "after":
-			if (endsWithSpaces(current.after)) {
-				const last = current.after.pop();
-				if (last) result.after = [last];
-			}
-			result.items.push(current);
-			break;
-		default: {
-			const _never = current.state;
-			throw new Error(`Unknown state: ${String(_never)}`);
-		}
-	}
-	return {
-		before: result.before,
-		after: result.after,
-		items: result.items.map((item) => ({
-			before: item.before,
-			after: item.after,
-			specifier: item.specifier,
-			hadComma: item.hadComma
-		}))
-	};
-}
-function needsStartingNewline(tokens) {
-	const before = tokens.filter((token) => !isSpaces(token));
-	if (before.length === 0) return false;
-	const firstToken = before[0];
-	return isLineComment(firstToken) || isBlockComment(firstToken) && !hasNewline(firstToken.code);
-}
-function endsWithSpaces(tokens) {
-	const last = tokens.length > 0 ? tokens[tokens.length - 1] : void 0;
-	return last == null ? false : isSpaces(last);
-}
-function printWithSortedSpecifiers(node, sourceCode, getSpecifiers$2) {
-	const allTokens = getAllTokens(node, sourceCode);
-	const openBraceIndex = allTokens.findIndex((token) => isPunctuator(token, "{"));
-	const closeBraceIndex = allTokens.findIndex((token) => isPunctuator(token, "}"));
-	const specifiers = getSpecifiers$2(node);
-	if (openBraceIndex === -1 || closeBraceIndex === -1 || specifiers.length <= 1) return printTokens(allTokens);
-	const itemsResult = getSpecifierItems(allTokens.slice(openBraceIndex + 1, closeBraceIndex));
-	const sortedItems = sortSpecifierItems(itemsResult.items.map((originalItem, index) => ({
-		...originalItem,
-		node: specifiers[index],
-		index
-	})));
-	const newline = guessNewline(sourceCode);
-	const hasTrailingComma = (() => {
-		for (let index = closeBraceIndex - 1; index > openBraceIndex; index--) {
-			const token = allTokens[index];
-			if (token.type === "Spaces" || token.type === "Newline" || token.type === "Block" || token.type === "Line") continue;
-			return isPunctuator(token, ",");
-		}
-		return false;
-	})();
-	const lastIndex = sortedItems.length - 1;
-	const sorted = flatMap(sortedItems, (item, index) => {
-		const previous = index === 0 ? void 0 : sortedItems[index - 1];
-		const maybeNewline$1 = previous != null && needsStartingNewline(item.before) && (previous.after.length <= 0 || !isNewline(previous.after[previous.after.length - 1])) ? [{
-			type: "Newline",
-			code: newline
-		}] : [];
-		if (index < lastIndex || hasTrailingComma) return [
-			...maybeNewline$1,
-			...item.before,
-			...item.specifier,
-			{
-				type: "Comma",
-				code: ","
-			},
-			...item.after
-		];
-		const nonBlankIndex = item.after.findIndex((token) => !isNewline(token) && !isSpaces(token));
-		const after = item.hadComma ? nonBlankIndex === -1 ? [] : item.after.slice(nonBlankIndex) : item.after;
-		return [
-			...maybeNewline$1,
-			...item.before,
-			...item.specifier,
-			...after
-		];
-	});
-	const maybeNewline = needsStartingNewline(itemsResult.after) && !isNewline(sorted[sorted.length - 1]) ? [{
-		type: "Newline",
-		code: newline
-	}] : [];
-	return printTokens([
-		...allTokens.slice(0, openBraceIndex + 1),
-		...itemsResult.before,
-		...sorted,
-		...maybeNewline,
-		...itemsResult.after,
-		...allTokens.slice(closeBraceIndex)
-	]);
-}
-function handleLastSemicolon(chunk, sourceCode) {
-	const lastIndex = chunk.length - 1;
-	const lastNode = chunk[lastIndex];
-	const tokens = sourceCode.getLastTokens(lastNode, { count: 2 });
-	if (tokens.length < 2) return [...chunk];
-	const [nextToLastToken, lastToken] = tokens;
-	if (!(lastToken.type === "Punctuator" && lastToken.value === ";")) return [...chunk];
-	if (nextToLastToken.loc.end.line === lastToken.loc.start.line || sourceCode.getTokenAfter(lastToken) == null) return [...chunk];
-	const newLastNode = {
-		...lastNode,
-		range: [lastNode.range[0], nextToLastToken.range[1]],
-		loc: {
-			start: lastNode.loc.start,
-			end: nextToLastToken.loc.end
-		}
-	};
-	return [...chunk.slice(0, lastIndex), newLastNode];
-}
-function getImportExportItems(passedChunk, sourceCode, isSideEffectImport$1, getSpecifiers$2) {
-	const chunk = handleLastSemicolon(passedChunk, sourceCode);
-	return chunk.map((node, nodeIndex) => {
-		const lastLine = nodeIndex === 0 ? node.loc.start.line - 1 : chunk[nodeIndex - 1].loc.end.line;
-		const commentsBefore = sourceCode.getCommentsBefore(node).filter((comment) => comment.loc.start.line <= node.loc.start.line && comment.loc.end.line > lastLine && (nodeIndex > 0 || comment.loc.start.line > lastLine));
-		const commentsAfter = sourceCode.getCommentsAfter(node).filter((comment) => comment.loc.end.line === node.loc.end.line);
-		const before = printCommentsBefore(node, commentsBefore, sourceCode);
-		const after = printCommentsAfter(node, commentsAfter, sourceCode);
-		const indentation = getIndentationAt((commentsBefore.length > 0 ? commentsBefore[0] : node).range[0], sourceCode);
-		const trailingSpaces = getTrailingSpacesAt((commentsAfter.length > 0 ? commentsAfter[commentsAfter.length - 1] : node).range[1], sourceCode);
-		const code = indentation + before + printWithSortedSpecifiers(node, sourceCode, getSpecifiers$2) + after + trailingSpaces;
-		const all = [
-			...commentsBefore,
-			node,
-			...commentsAfter
-		];
-		const [start] = all[0].range;
-		const [, end] = all[all.length - 1].range;
-		const source = getSource(node);
-		const lastAfter = commentsAfter.length > 0 ? commentsAfter[commentsAfter.length - 1] : void 0;
-		return {
-			node,
-			code,
-			start: start - indentation.length,
-			end: end + trailingSpaces.length,
-			isSideEffectImport: isSideEffectImport$1(node, sourceCode),
-			source,
-			index: nodeIndex,
-			needsNewline: lastAfter?.type === "Line"
-		};
-	});
-}
-
-//#endregion
-//#region src/rules/sort-exports.ts
-const RULE_NAME$2 = "sort-exports";
-function isParentWithBody$1(node) {
-	if (!node) return false;
-	if (!("body" in node)) return false;
-	const maybe = node;
-	return Array.isArray(maybe.body);
-}
-const isExportFrom = (node) => node.type === "ExportNamedDeclaration" && node.source != null || node.type === "ExportAllDeclaration" && node.source != null;
-function isPartOfChunk(node, lastNode, sourceCode) {
-	if (!isExportFrom(node)) return "NotPartOfChunk";
-	return sourceCode.getCommentsBefore(node).some((comment) => (lastNode == null || comment.loc.start.line > lastNode.loc.end.line) && comment.loc.end.line < node.loc.start.line) ? "PartOfNewChunk" : "PartOfChunk";
-}
-const getSpecifiers$1 = (exportNode) => exportNode.type === "ExportNamedDeclaration" ? exportNode.specifiers : [];
-function maybeReportChunkSorting$1(chunk, context) {
-	const sourceCode = context.sourceCode;
-	const items = getImportExportItems(chunk.filter(isExportFrom), sourceCode, () => false, getSpecifiers$1);
-	const sorted = printSortedItems([[sortImportExportItems(items)]], items, sourceCode);
-	const start = items[0].start;
-	const end = items[items.length - 1].end;
-	maybeReportSorting(context, sorted, start, end);
-}
-function maybeReportExportSpecifierSorting(node, context) {
-	const sorted = printWithSortedSpecifiers(node, context.sourceCode, (n) => n.specifiers);
-	const [start, end] = node.range;
-	maybeReportSorting(context, sorted, start, end);
-}
-const rule$2 = createEslintRule({
-	name: RULE_NAME$2,
-	meta: {
-		type: "layout",
-		docs: {
-			description: "Sort export declarations.",
-			url: "https://github.com/lydell/eslint-plugin-simple-import-sort#sort-order"
-		},
-		fixable: "code",
-		schema: [],
-		messages: { sort: "Run autofix to sort these exports!" }
-	},
-	defaultOptions: [],
-	create: (context) => {
-		const parents = /* @__PURE__ */ new Set();
-		function addParent(node) {
-			if (isExportFrom(node) && isParentWithBody$1(node.parent)) parents.add(node.parent);
-		}
-		return {
-			ExportNamedDeclaration(node) {
-				if (node.source == null && node.declaration == null) maybeReportExportSpecifierSorting(node, context);
-				else addParent(node);
-			},
-			ExportAllDeclaration(node) {
-				addParent(node);
-			},
-			"Program:exit"() {
-				const sourceCode = context.sourceCode;
-				for (const parent of parents) for (const chunk of extractChunks(parent, (node, lastNode) => isPartOfChunk(node, lastNode, sourceCode))) maybeReportChunkSorting$1(chunk, context);
-				parents.clear();
-			}
-		};
-	}
-});
-var sort_exports_default = rule$2;
-
-//#endregion
-//#region src/rules/sort-imports.ts
-const RULE_NAME$1 = "sort-imports";
-function isParentWithBody(node) {
-	if (!node) return false;
-	if (!("body" in node)) return false;
-	const maybe = node;
-	return Array.isArray(maybe.body);
-}
-const defaultGroups = [
-	["^node:"],
-	["^@?\\w"],
-	["^"],
-	["^\\."],
-	["^\\u0000"]
-];
-const isImportSpecifier = (node) => node.type === "ImportSpecifier";
-const getSpecifiers = (importNode) => importNode.specifiers.filter(isImportSpecifier);
-const isImport = (node) => node.type === "ImportDeclaration";
-function isSideEffectImport(importNode, sourceCode) {
-	const token = sourceCode.getFirstToken(importNode, { skip: 1 });
-	const startsWithBrace = token != null && isPunctuator(token, "{");
-	return importNode.specifiers.length === 0 && (!importNode.importKind || importNode.importKind === "value") && !startsWithBrace;
-}
-const rule$1 = createEslintRule({
-	name: RULE_NAME$1,
-	meta: {
-		type: "layout",
-		docs: {
-			description: "Sort import declarations.",
-			url: "https://github.com/lydell/eslint-plugin-simple-import-sort#sort-order"
-		},
-		fixable: "code",
-		schema: [{
-			type: "object",
-			properties: { groups: {
-				type: "array",
-				items: {
-					type: "array",
-					items: { type: "string" }
-				}
-			} },
-			additionalProperties: false
-		}],
-		messages: { sort: "Run autofix to sort these imports!" }
-	},
-	defaultOptions: [{ groups: defaultGroups }],
-	create: (context) => {
-		const outerGroups = (context.options[0]?.groups ?? defaultGroups).map((groups) => groups.map((item) => new RegExp(item, "u")));
-		const parents = /* @__PURE__ */ new Set();
-		return {
-			ImportDeclaration(node) {
-				if (isParentWithBody(node.parent)) parents.add(node.parent);
-			},
-			"Program:exit"() {
-				const sourceCode = context.sourceCode;
-				for (const parent of parents) for (const chunk of extractChunks(parent, (node, lastNode) => {
-					if (!isImport(node)) return "NotPartOfChunk";
-					return lastNode != null && isImport(lastNode) && lastNode.loc.end.line === node.loc.start.line ? "PartOfNewChunk" : "PartOfChunk";
-				})) maybeReportChunkSorting(chunk, context, outerGroups, sourceCode);
-				parents.clear();
-			}
-		};
-	}
-});
-var sort_imports_default = rule$1;
-function maybeReportChunkSorting(chunk, context, outerGroups, sourceCode) {
-	const items = getImportExportItems(chunk.filter(isImport), sourceCode, isSideEffectImport, getSpecifiers);
-	const sorted = printSortedItems(makeSortedItems(items, outerGroups), items, sourceCode);
-	const start = items[0].start;
-	const end = items[items.length - 1].end;
-	maybeReportSorting(context, sorted, start, end);
-}
-function makeSortedItems(items, outerGroups) {
-	const itemGroups = outerGroups.map((groups) => groups.map((regex) => ({
-		regex,
-		items: []
-	})));
-	const rest = [];
-	for (const item of items) {
-		const { originalSource } = item.source;
-		const source = item.isSideEffectImport ? `\0${originalSource}` : item.source.kind === "value" ? originalSource : `${originalSource}\0`;
-		let matchedGroup;
-		let longestMatchLength = -1;
-		for (const groups of itemGroups) for (const group of groups) {
-			const match = group.regex.exec(source);
-			if (match != null && match[0].length > longestMatchLength) {
-				matchedGroup = group;
-				longestMatchLength = match[0].length;
-			}
-		}
-		if (matchedGroup == null) rest.push(item);
-		else matchedGroup.items.push(item);
-	}
-	return [...itemGroups, [{
-		regex: /^/,
-		items: rest
-	}]].map((groups) => groups.filter((group) => group.items.length > 0)).filter((groups) => groups.length > 0).map((groups) => groups.map((group) => sortImportExportItems(group.items)));
-}
-
-//#endregion
-//#region src/rules/vue-root-element-sort-attributes.ts
-const RULE_NAME = "vue-root-element-sort-attributes";
-const defaultOptions = { script: ["setup", "lang"] };
-const rule = createEslintRule({
-	name: RULE_NAME,
-	meta: {
-		type: "layout",
-		docs: { description: "Sort attributes of root <script>, <template>, and <style> elements in Vue files." },
-		fixable: "code",
-		schema: [{
-			type: "object",
-			properties: { script: {
-				type: "array",
-				items: { type: "string" }
-			} },
-			additionalProperties: true
-		}],
-		messages: { wrongOrder: "Attributes of root element should be sorted in a specific order." }
-	},
-	defaultOptions: [defaultOptions],
-	create(context, [options]) {
-		const order = {
-			...options,
-			script: options.script ?? defaultOptions.script
-		};
-		const sourceCode = context.sourceCode;
-		const documentFragment = sourceCode.parserServices.getDocumentFragment?.();
-		function getTopLevelHTMLElements() {
-			if (documentFragment) return documentFragment.children.filter((n) => n.type === "VElement");
-			return [];
-		}
-		return { Program: (_node) => {
-			const topLevelElements = getTopLevelHTMLElements();
-			for (const element of topLevelElements) {
-				if (!(element.name in order)) continue;
-				const expectedOrder = order[element.name];
-				const attributesToCheck = [];
-				let reprintAttributes = false;
-				for (const attribute of element.startTag.attributes) {
-					if (attribute.key.type !== "VIdentifier" || attribute.directive) continue;
-					if (expectedOrder.includes(attribute.key.name)) attributesToCheck.push(attribute);
-				}
-				const currentOrder = attributesToCheck.map((attr) => attr.key.name);
-				const expectedFilteredOrder = expectedOrder.filter((name) => currentOrder.includes(name));
-				if (JSON.stringify(currentOrder) !== JSON.stringify(expectedFilteredOrder)) reprintAttributes = true;
-				if (reprintAttributes) context.report({
-					node: element.startTag,
-					messageId: "wrongOrder",
-					*fix(fixer) {
-						const sortedAttributes = [...attributesToCheck].sort((a, b) => expectedOrder.indexOf(a.key.name) - expectedOrder.indexOf(b.key.name));
-						for (const [i, originalAttr] of attributesToCheck.entries()) {
-							const sortedAttr = sortedAttributes[i];
-							if (originalAttr.key.name !== sortedAttr.key.name) yield fixer.replaceText(originalAttr, sourceCode.getText(sortedAttr));
-						}
-					}
-				});
-			}
-		} };
-	}
-});
-var vue_root_element_sort_attributes_default = rule;
-
-//#endregion
 //#region src/index.ts
 var src_default = { rules: {
 	"function-style": function_style_default,