@so1ve/eslint-plugin 4.0.1 → 4.1.0

package/dist/index.d.mts

@@ -1,53 +1,65 @@
 import { ESLintUtils } from "@typescript-eslint/utils";
 
 //#region src/rules/function-style.d.ts
-type MessageIds$10 = "arrow" | "declaration";
+type MessageIds$12 = "arrow" | "declaration";
+type Options$12 = [];
+declare const rule$12: ESLintUtils.RuleModule<MessageIds$12, Options$12>;
+//#endregion
+//#region src/rules/html-spaced-comment.d.ts
+type MessageIds$11 = "expectedSpaceBefore" | "expectedSpaceAfter";
+type Options$11 = [];
+declare const rule$11: ESLintUtils.RuleModule<MessageIds$11, Options$11>;
+//#endregion
+//#region src/rules/import-dedupe.d.ts
+type MessageIds$10 = "importDedupe";
 type Options$10 = [];
 declare const rule$10: ESLintUtils.RuleModule<MessageIds$10, Options$10>;
 //#endregion
-//#region src/rules/html-spaced-comment.d.ts
-type MessageIds$9 = "expectedSpaceBefore" | "expectedSpaceAfter";
+//#region src/rules/import-export-newline.d.ts
+type MessageIds$9 = "newlineAfterLastImport" | "newlineBeforeExport" | "newlineAfterExport";
 type Options$9 = [];
 declare const rule$9: ESLintUtils.RuleModule<MessageIds$9, Options$9>;
 //#endregion
-//#region src/rules/import-dedupe.d.ts
-type MessageIds$8 = "importDedupe";
+//#region src/rules/no-import-promises-as.d.ts
+type MessageIds$8 = "noImportPromisesAs";
 type Options$8 = [];
 declare const rule$8: ESLintUtils.RuleModule<MessageIds$8, Options$8>;
 //#endregion
-//#region src/rules/import-export-newline.d.ts
-type MessageIds$7 = "newlineAfterLastImport" | "newlineBeforeExport" | "newlineAfterExport";
+//#region src/rules/no-inline-type-modifier.d.ts
+type MessageIds$7 = "noInlineTypeModifier";
 type Options$7 = [];
 declare const rule$7: ESLintUtils.RuleModule<MessageIds$7, Options$7>;
 //#endregion
-//#region src/rules/no-import-promises-as.d.ts
-type MessageIds$6 = "noImportPromisesAs";
+//#region src/rules/no-negated-comparison.d.ts
+type MessageIds$6 = "noNegatedComparison";
 type Options$6 = [];
 declare const rule$6: ESLintUtils.RuleModule<MessageIds$6, Options$6>;
 //#endregion
-//#region src/rules/no-inline-type-import.d.ts
-type MessageIds$5 = "noInlineTypeImport";
+//#region src/rules/no-useless-template-string.d.ts
+type MessageIds$5 = "noUselessTemplateString";
 type Options$5 = [];
 declare const rule$5: ESLintUtils.RuleModule<MessageIds$5, Options$5>;
 //#endregion
-//#region src/rules/no-negated-comparison.d.ts
-type MessageIds$4 = "noNegatedComparison";
+//#region src/rules/prefer-ts-expect-error.d.ts
+type MessageIds$4 = "preferExpectErrorComment";
 type Options$4 = [];
 declare const rule$4: ESLintUtils.RuleModule<MessageIds$4, Options$4>;
 //#endregion
-//#region src/rules/no-useless-template-string.d.ts
-type MessageIds$3 = "noUselessTemplateString";
+//#region src/rules/require-async-with-await.d.ts
+type MessageIds$3 = "requireAsyncWithAwait";
 type Options$3 = [];
 declare const rule$3: ESLintUtils.RuleModule<MessageIds$3, Options$3>;
 //#endregion
-//#region src/rules/prefer-ts-expect-error.d.ts
-type MessageIds$2 = "preferExpectErrorComment";
+//#region src/rules/sort-exports.d.ts
+type MessageIds$2 = "sort";
 type Options$2 = [];
 declare const rule$2: ESLintUtils.RuleModule<MessageIds$2, Options$2>;
 //#endregion
-//#region src/rules/require-async-with-await.d.ts
-type MessageIds$1 = "requireAsyncWithAwait";
-type Options$1 = [];
+//#region src/rules/sort-imports.d.ts
+type MessageIds$1 = "sort";
+type Options$1 = [{
+  groups?: string[][];
+}];
 declare const rule$1: ESLintUtils.RuleModule<MessageIds$1, Options$1>;
 //#endregion
 //#region src/rules/vue-root-element-sort-attributes.d.ts
@@ -61,16 +73,18 @@ declare const rule: ESLintUtils.RuleModule<MessageIds, Options>;
 //#region src/index.d.ts
 declare const _default: {
   rules: {
-    "function-style": typeof rule$10;
-    "html-spaced-comment": typeof rule$9;
-    "import-dedupe": typeof rule$8;
-    "import-export-newline": typeof rule$7;
-    "no-import-promises-as": typeof rule$6;
-    "no-inline-type-import": typeof rule$5;
-    "no-negated-comparison": typeof rule$4;
-    "no-useless-template-string": typeof rule$3;
-    "prefer-ts-expect-error": typeof rule$2;
-    "require-async-with-await": typeof rule$1;
+    "function-style": typeof rule$12;
+    "html-spaced-comment": typeof rule$11;
+    "import-dedupe": typeof rule$10;
+    "import-export-newline": typeof rule$9;
+    "no-import-promises-as": typeof rule$8;
+    "no-inline-type-modifier": typeof rule$7;
+    "no-negated-comparison": typeof rule$6;
+    "no-useless-template-string": typeof rule$5;
+    "prefer-ts-expect-error": typeof rule$4;
+    "require-async-with-await": typeof rule$3;
+    "sort-exports": typeof rule$2;
+    "sort-imports": typeof rule$1;
     "vue-root-element-sort-attributes": typeof rule;
   };
 };

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/types";
 import { AST_TOKEN_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import natsort from "natsort";
 
 //#region src/utils/index.ts
 const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
@@ -18,9 +19,9 @@ const getNextNode = (node) => getSiblingNode(node, 1);
 
 //#endregion
 //#region src/rules/function-style.ts
-const RULE_NAME$9 = "function-style";
-const rule$10 = createEslintRule({
-	name: RULE_NAME$9,
+const RULE_NAME$11 = "function-style";
+const rule$12 = createEslintRule({
+	name: RULE_NAME$11,
 	meta: {
 		type: "problem",
 		docs: { description: "Enforce function style." },
@@ -155,13 +156,13 @@ const rule$10 = createEslintRule({
 		};
 	}
 });
-var function_style_default = rule$10;
+var function_style_default = rule$12;
 
 //#endregion
 //#region src/rules/html-spaced-comment.ts
-const RULE_NAME$8 = "html-spaced-comment";
-const rule$9 = createEslintRule({
-	name: RULE_NAME$8,
+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" },
@@ -193,13 +194,13 @@ const rule$9 = createEslintRule({
 		});
 	} })
 });
-var html_spaced_comment_default = rule$9;
+var html_spaced_comment_default = rule$11;
 
 //#endregion
 //#region src/rules/import-dedupe.ts
-const RULE_NAME$7 = "import-dedupe";
-const rule$8 = createEslintRule({
-	name: RULE_NAME$7,
+const RULE_NAME$9 = "import-dedupe";
+const rule$10 = createEslintRule({
+	name: RULE_NAME$9,
 	meta: {
 		type: "problem",
 		docs: { description: "Fix duplication in imports." },
@@ -232,14 +233,14 @@ const rule$8 = createEslintRule({
 		}
 	} })
 });
-var import_dedupe_default = rule$8;
+var import_dedupe_default = rule$10;
 
 //#endregion
 //#region src/rules/import-export-newline.ts
-const RULE_NAME$6 = "import-export-newline";
+const RULE_NAME$8 = "import-export-newline";
 const isExportDeclaration = (node) => node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration";
-const rule$7 = createEslintRule({
-	name: RULE_NAME$6,
+const rule$9 = createEslintRule({
+	name: RULE_NAME$8,
 	meta: {
 		type: "problem",
 		docs: { description: "Enforce spacing between imports and exports." },
@@ -327,19 +328,19 @@ const rule$7 = createEslintRule({
 		};
 	}
 });
-var import_export_newline_default = rule$7;
+var import_export_newline_default = rule$9;
 
 //#endregion
 //#region src/rules/no-import-promises-as.ts
-const RULE_NAME$5 = "no-import-promises-as";
+const RULE_NAME$7 = "no-import-promises-as";
 const POSSIBLE_IMPORT_SOURCES = [
 	"dns",
 	"fs",
 	"readline",
 	"stream"
 ].flatMap((s) => [s, `node:${s}`]);
-const rule$6 = createEslintRule({
-	name: RULE_NAME$5,
+const rule$8 = createEslintRule({
+	name: RULE_NAME$7,
 	meta: {
 		type: "problem",
 		docs: { description: "Disallow import promises as." },
@@ -369,74 +370,93 @@ const rule$6 = createEslintRule({
 		} };
 	}
 });
-var no_import_promises_as_default = rule$6;
+var no_import_promises_as_default = rule$8;
 
 //#endregion
-//#region src/rules/no-inline-type-import.ts
-const RULE_NAME$4 = "no-inline-type-import";
-function generateImportsText(specifiers) {
-	let text = "{ ";
-	const texts = [];
-	for (const s of specifiers) {
-		const importedName = s.imported.type === AST_NODE_TYPES.Identifier ? s.imported.name : s.imported.raw;
-		texts.push(importedName === s.local.name ? s.local.name : `${importedName} as ${s.local.name}`);
-	}
-	text += texts.join(", ");
-	text += " }";
-	return text;
-}
-function generateTypeImportText(typeSpecifiers) {
-	let text = "type ";
-	text += generateImportsText(typeSpecifiers);
-	return text;
-}
-function generateValueImportText(defaultImportSpecifier, valueSpecifiers) {
-	const hasValueImport = valueSpecifiers.length > 0;
-	let text = "";
-	if (defaultImportSpecifier) {
-		text += defaultImportSpecifier.local.name;
-		if (hasValueImport) text += ", ";
-	}
-	if (hasValueImport) text += generateImportsText(valueSpecifiers);
-	return text;
+//#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}`;
 }
-const rule$5 = createEslintRule({
-	name: RULE_NAME$4,
+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 import." },
+		docs: { description: "Disallow inline type modifiers in import/export." },
 		fixable: "code",
 		schema: [],
-		messages: { noInlineTypeImport: "Expected no inline type import." }
+		messages: { noInlineTypeModifier: "Expected no inline type modifier." }
 	},
 	defaultOptions: [],
-	create: (context) => ({ ImportDeclaration: (node) => {
-		const { specifiers } = node;
-		const typeSpecifiers = specifiers.filter((s) => s.type === AST_NODE_TYPES.ImportSpecifier && s.importKind === "type");
-		const valueSpecifiers = specifiers.filter((s) => s.type === AST_NODE_TYPES.ImportSpecifier && s.importKind === "value");
-		const defaultImportSpecifier = specifiers.find((s) => s.type === AST_NODE_TYPES.ImportDefaultSpecifier);
-		const hasDefaultImport = !!defaultImportSpecifier;
-		const hasTypeImport = typeSpecifiers.length > 0;
-		const hasValueImport = valueSpecifiers.length > 0;
-		if (!hasTypeImport) return;
-		const texts = [];
-		texts.push(generateTypeImportText(typeSpecifiers));
-		if (hasDefaultImport || hasValueImport) texts.push(generateValueImportText(defaultImportSpecifier, valueSpecifiers));
-		const textToReport = texts.map((text) => `import ${text} from "${node.source.value}";`).join("\n");
-		context.report({
-			node,
-			messageId: "noInlineTypeImport",
-			fix(fixer) {
-				return fixer.replaceText(node, textToReport);
-			}
-		});
-	} })
+	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_import_default = rule$5;
+var no_inline_type_modifier_default = rule$7;
 
 //#endregion
 //#region src/rules/no-negated-comparison.ts
-const RULE_NAME$3 = "no-negated-comparison";
+const RULE_NAME$5 = "no-negated-comparison";
 const negatedToPositive = {
 	"==": "!=",
 	"===": "!==",
@@ -448,8 +468,8 @@ const negatedToPositive = {
 	">=": "<"
 };
 const negatives = Object.keys(negatedToPositive);
-const rule$4 = createEslintRule({
-	name: RULE_NAME$3,
+const rule$6 = createEslintRule({
+	name: RULE_NAME$5,
 	meta: {
 		type: "problem",
 		docs: { description: "Disallow negated comparison." },
@@ -473,13 +493,13 @@ const rule$4 = createEslintRule({
 		});
 	} })
 });
-var no_negated_comparison_default = rule$4;
+var no_negated_comparison_default = rule$6;
 
 //#endregion
 //#region src/rules/no-useless-template-string.ts
-const RULE_NAME$2 = "no-useless-template-string";
-const rule$3 = createEslintRule({
-	name: RULE_NAME$2,
+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." },
@@ -500,11 +520,11 @@ const rule$3 = createEslintRule({
 		});
 	} })
 });
-var no_useless_template_string_default = rule$3;
+var no_useless_template_string_default = rule$5;
 
 //#endregion
 //#region src/rules/prefer-ts-expect-error.ts
-const rule$2 = createEslintRule({
+const rule$4 = createEslintRule({
 	name: "prefer-ts-expect-error",
 	meta: {
 		type: "problem",
@@ -518,15 +538,15 @@ const rule$2 = createEslintRule({
 	create(context) {
 		const tsIgnoreRegExpSingleLine = /^\s*(?:\/\s*)?@ts-ignore/;
 		const tsIgnoreRegExpMultiLine = /^\s*(?:(?:\/|\*)+\s*)?@ts-ignore/;
-		const isLineComment = (comment) => comment.type === AST_TOKEN_TYPES.Line;
+		const isLineComment$1 = (comment) => comment.type === AST_TOKEN_TYPES.Line;
 		function getLastCommentLine(comment) {
-			if (isLineComment(comment)) return comment.value;
+			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(comment) ? tsIgnoreRegExpSingleLine.test(line) : tsIgnoreRegExpMultiLine.test(line);
+			return isLineComment$1(comment) ? tsIgnoreRegExpSingleLine.test(line) : tsIgnoreRegExpMultiLine.test(line);
 		}
 		return { Program() {
 			const comments = context.sourceCode.getAllComments();
@@ -536,19 +556,19 @@ const rule$2 = createEslintRule({
 				context.report({
 					node: comment,
 					messageId: "preferExpectErrorComment",
-					fix: isLineComment(comment) ? lineCommentRuleFixer : blockCommentRuleFixer
+					fix: isLineComment$1(comment) ? lineCommentRuleFixer : blockCommentRuleFixer
 				});
 			}
 		} };
 	}
 });
-var prefer_ts_expect_error_default = rule$2;
+var prefer_ts_expect_error_default = rule$4;
 
 //#endregion
 //#region src/rules/require-async-with-await.ts
-const RULE_NAME$1 = "require-async-with-await";
-const rule$1 = createEslintRule({
-	name: RULE_NAME$1,
+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." },
@@ -589,7 +609,581 @@ const rule$1 = createEslintRule({
 		};
 	}
 });
-var require_async_with_await_default = rule$1;
+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);
+	return lines[lines.length - 1];
+}
+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) => isImport(node) ? "PartOfChunk" : "NotPartOfChunk")) 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
@@ -662,11 +1256,13 @@ var src_default = { rules: {
 	"import-dedupe": import_dedupe_default,
 	"import-export-newline": import_export_newline_default,
 	"no-import-promises-as": no_import_promises_as_default,
-	"no-inline-type-import": no_inline_type_import_default,
+	"no-inline-type-modifier": no_inline_type_modifier_default,
 	"no-negated-comparison": no_negated_comparison_default,
 	"no-useless-template-string": no_useless_template_string_default,
 	"prefer-ts-expect-error": prefer_ts_expect_error_default,
 	"require-async-with-await": require_async_with_await_default,
+	"sort-exports": sort_exports_default,
+	"sort-imports": sort_imports_default,
 	"vue-root-element-sort-attributes": vue_root_element_sort_attributes_default
 } };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@so1ve/eslint-plugin",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "author": "Ray <i@mk1.io> (https://github.com/so1ve/)",
   "type": "module",
   "keywords": [
@@ -32,7 +32,8 @@
   },
   "dependencies": {
     "@typescript-eslint/types": "^8.50.1",
-    "@typescript-eslint/utils": "^8.50.1"
+    "@typescript-eslint/utils": "^8.50.1",
+    "natsort": "^2.0.3"
   },
   "devDependencies": {
     "@html-eslint/parser": "^0.52.0",