eslint-plugin-import-lite 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 vida xie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# eslint-plugin-import-lite
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm bundle size][npm-bundle-size-src]][npm-bundle-size-href]
+[![License][license-src]][license-href]
+
+## Feature
+
+- Port some useful rules from [`eslint-plugin-import-x`](https://github.com/un-ts/eslint-plugin-import-x).
+- No need resolver and settings in [`eslint-plugin-import-x`](https://github.com/un-ts/eslint-plugin-import-x).
+- Drop babel and flow support.
+
+See all rules in [`src/rules`](./src/rules)
+
+## Motivation
+
+I extend [my own ESLint config](https://github.com/9romise/eslint-config) from [`@antfu/eslint-config`](https://github.com/antfu/eslint-config).
+
+Recently this config dropped [`eslint-plugin-import-x`](https://github.com/un-ts/eslint-plugin-import-x) cause it introduce some binary packages and make it heavy.
+
+In a [discussion]((https://github.com/9romise/eslint-import-resolver-oxc/issues/87#issuecomment-2945162572)) about built-in resolver, the maintainer plan to keep it as dependency, which makes it impossible to lightweight the package.
+
+But there are some useful rules and [some people (include me) want to bring the plugin back](https://github.com/antfu/eslint-config/issues/720).
+
+## Credits
+
+[eslint-plugin-import-x](https://github.com/un-ts/eslint-plugin-import-x) - [MIT](https://github.com/un-ts/eslint-plugin-import-x/blob/master/LICENSE)
+
+## License
+
+[MIT](./LICENSE) License © 2025-PRESENT [Vida Xie](https://github.com/9romise)
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/eslint-plugin-import-lite
+[npm-version-href]: https://npmjs.com/package/eslint-plugin-import-lite
+[npm-bundle-size-src]: https://img.shields.io/npm/unpacked-size/eslint-plugin-import-lite
+[npm-bundle-size-href]: https://npmjs.com/package/eslint-plugin-import-lite
+[license-src]: https://img.shields.io/npm/l/eslint-plugin-import-lite
+[license-href]: https://opensource.org/licenses/MIT

package/dist/ast.js

@@ -0,0 +1,13 @@
+import { TSESTree } from "@typescript-eslint/utils";
+
+//#region src/utils/ast.ts
+function getValue(node) {
+	switch (node.type) {
+		case TSESTree.AST_NODE_TYPES.Identifier: return node.name;
+		case TSESTree.AST_NODE_TYPES.Literal: return node.value;
+		default: throw new Error(`Unsupported node type: ${node.type}`);
+	}
+}
+
+//#endregion
+export { getValue };

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { ESLintRuleModule } from "./index2.js";
+import { Linter } from "eslint";
+
+//#region src/index.d.ts
+declare const _default: {
+  rules: Record<string, ESLintRuleModule<unknown[], string>>;
+  configs: {
+    recommended: Linter.Config<Linter.RulesRecord>;
+    all: Linter.Config<Linter.RulesRecord>;
+  };
+};
+//#endregion
+export { _default as default };

package/dist/index.js

@@ -0,0 +1,46 @@
+import "./utils.js";
+import "./ast.js";
+import { consistent_type_specifier_style_default } from "./rules/consistent-type-specifier-style2.js";
+import { first_default } from "./rules/first2.js";
+import { newline_after_import_default } from "./rules/newline-after-import2.js";
+import { no_default_export_default } from "./rules/no-default-export2.js";
+import { no_duplicates_default } from "./rules/no-duplicates2.js";
+import { no_mutable_exports_default } from "./rules/no-mutable-exports2.js";
+import { no_named_default_default } from "./rules/no-named-default2.js";
+
+//#region src/rules/index.ts
+const rules = {
+	"consistent-type-specifier-style": consistent_type_specifier_style_default,
+	"first": first_default,
+	"newline-after-import": newline_after_import_default,
+	"no-default-export": no_default_export_default,
+	"no-duplicates": no_duplicates_default,
+	"no-mutable-exports": no_mutable_exports_default,
+	"no-named-default": no_named_default_default
+};
+
+//#endregion
+//#region src/index.ts
+const pluginName = "import-lite";
+function generateConfig(name, filter) {
+	let ruleMeta = Object.entries(rules).filter(([_, rule]) => !rule.meta?.deprecated);
+	if (filter) ruleMeta = ruleMeta.filter(([ruleName, rule]) => filter(ruleName, rule));
+	return {
+		name: `${pluginName}/${name}`,
+		plugins: { [pluginName]: {
+			name: pluginName,
+			rules
+		} },
+		rules: Object.fromEntries(ruleMeta.map((ruleName) => [`${pluginName}/${ruleName}`, "error"]))
+	};
+}
+var src_default = {
+	rules,
+	configs: {
+		recommended: generateConfig("recommended", ([_, rule]) => rule.meta?.recommended),
+		all: generateConfig("all")
+	}
+};
+
+//#endregion
+export { src_default as default };

package/dist/index2.d.ts

@@ -0,0 +1,9 @@
+import "@typescript-eslint/utils/eslint-utils";
+import { Rule } from "eslint";
+
+//#region src/utils/index.d.ts
+interface ESLintRuleModule<T extends readonly unknown[], TMessageIds extends string> extends Rule.RuleModule {
+  defaultOptions: T;
+}
+//#endregion
+export { ESLintRuleModule };

package/dist/rules/consistent-type-specifier-style.d.ts

@@ -0,0 +1,8 @@
+import { ESLintRuleModule } from "../index2.js";
+
+//#region src/rules/consistent-type-specifier-style/consistent-type-specifier-style.d.ts
+type Options = ['prefer-inline' | 'prefer-top-level'];
+type MessageId = 'inline' | 'topLevel';
+declare const _default: ESLintRuleModule<Options, MessageId>;
+//#endregion
+export { Options, _default as default };

package/dist/rules/consistent-type-specifier-style.js

@@ -0,0 +1,5 @@
+import "../utils.js";
+import "../ast.js";
+import { consistent_type_specifier_style_default } from "./consistent-type-specifier-style2.js";
+
+export { consistent_type_specifier_style_default as default };

package/dist/rules/consistent-type-specifier-style2.js

@@ -0,0 +1,111 @@
+import { createRule } from "../utils.js";
+import { getValue } from "../ast.js";
+import { isCommaToken } from "@typescript-eslint/utils/ast-utils";
+
+//#region src/rules/consistent-type-specifier-style/consistent-type-specifier-style.ts
+function removeSpecifiers(fixes, fixer, sourceCode, specifiers) {
+	for (const specifier of specifiers) {
+		const token = sourceCode.getTokenAfter(specifier);
+		if (token && isCommaToken(token)) fixes.push(fixer.remove(token));
+		fixes.push(fixer.remove(specifier));
+	}
+}
+function getImportText(node, sourceCode, specifiers, kind) {
+	const sourceString = sourceCode.getText(node.source);
+	if (specifiers.length === 0) return "";
+	const names = specifiers.map((s) => {
+		const importedName = getValue(s.imported);
+		if (importedName === s.local.name) return importedName;
+		return `${importedName} as ${s.local.name}`;
+	});
+	return `import ${kind} {${names.join(", ")}} from ${sourceString};`;
+}
+var consistent_type_specifier_style_default = createRule({
+	name: "consistent-type-specifier-style",
+	meta: {
+		type: "suggestion",
+		docs: {
+			fixable: true,
+			description: "Enforce or ban the use of inline type-only markers for named imports."
+		},
+		fixable: "code",
+		schema: [{
+			type: "string",
+			enum: ["prefer-top-level", "prefer-inline"],
+			default: "prefer-top-level"
+		}],
+		messages: {
+			inline: "Prefer using inline {{kind}} specifiers instead of a top-level {{kind}}-only import.",
+			topLevel: "Prefer using a top-level {{kind}}-only import instead of inline {{kind}} specifiers."
+		}
+	},
+	defaultOptions: ["prefer-top-level"],
+	create(context) {
+		const { sourceCode } = context;
+		if (context.options[0] === "prefer-inline") return { ImportDeclaration(node) {
+			if (node.importKind === "value" || node.importKind == null) return;
+			if (node.specifiers.length === 0 || node.specifiers.length === 1 && (node.specifiers[0].type === "ImportDefaultSpecifier" || node.specifiers[0].type === "ImportNamespaceSpecifier")) return;
+			context.report({
+				node,
+				messageId: "inline",
+				data: { kind: node.importKind },
+				fix(fixer) {
+					const kindToken = sourceCode.getFirstToken(node, { skip: 1 });
+					return [kindToken ? fixer.remove(kindToken) : [], node.specifiers.map((specifier) => fixer.insertTextBefore(specifier, `${node.importKind} `))].flat();
+				}
+			});
+		} };
+		return { ImportDeclaration(node) {
+			if (node.importKind === "type" || node.importKind === "typeof" || node.specifiers.length === 0 || node.specifiers.length === 1 && (node.specifiers[0].type === "ImportDefaultSpecifier" || node.specifiers[0].type === "ImportNamespaceSpecifier")) return;
+			const typeSpecifiers = [];
+			const typeofSpecifiers = [];
+			const valueSpecifiers = [];
+			let defaultSpecifier = null;
+			for (const specifier of node.specifiers) {
+				if (specifier.type === "ImportDefaultSpecifier") {
+					defaultSpecifier = specifier;
+					continue;
+				}
+				if (!("importKind" in specifier)) continue;
+				if (specifier.importKind === "type") typeSpecifiers.push(specifier);
+				else if (specifier.importKind === "typeof") typeofSpecifiers.push(specifier);
+				else if (specifier.importKind === "value" || specifier.importKind == null) valueSpecifiers.push(specifier);
+			}
+			const typeImport = getImportText(node, sourceCode, typeSpecifiers, "type");
+			const typeofImport = getImportText(node, sourceCode, typeofSpecifiers, "typeof");
+			const newImports = `${typeImport}\n${typeofImport}`.trim();
+			if (typeSpecifiers.length + typeofSpecifiers.length === node.specifiers.length) {
+				const kind = [typeSpecifiers.length > 0 ? "type" : [], typeofSpecifiers.length > 0 ? "typeof" : []].flat();
+				context.report({
+					node,
+					messageId: "topLevel",
+					data: { kind: kind.join("/") },
+					fix(fixer) {
+						return fixer.replaceText(node, newImports);
+					}
+				});
+			} else for (const specifier of [...typeSpecifiers, ...typeofSpecifiers]) context.report({
+				node: specifier,
+				messageId: "topLevel",
+				data: { kind: specifier.importKind },
+				fix(fixer) {
+					const fixes = [];
+					if (valueSpecifiers.length > 0) {
+						removeSpecifiers(fixes, fixer, sourceCode, typeSpecifiers);
+						removeSpecifiers(fixes, fixer, sourceCode, typeofSpecifiers);
+						const maybeComma = sourceCode.getTokenAfter(valueSpecifiers[valueSpecifiers.length - 1]);
+						if (isCommaToken(maybeComma)) fixes.push(fixer.remove(maybeComma));
+					} else if (defaultSpecifier) {
+						const comma = sourceCode.getTokenAfter(defaultSpecifier, isCommaToken);
+						const closingBrace = sourceCode.getTokenAfter(node.specifiers[node.specifiers.length - 1], (token) => token.type === "Punctuator" && token.value === "}");
+						fixes.push(fixer.removeRange([comma.range[0], closingBrace.range[1]]));
+					}
+					return [...fixes, fixer.insertTextAfter(node, `\n${newImports}`)];
+				}
+			});
+		} };
+	}
+});
+
+//#endregion
+export { consistent_type_specifier_style_default };

package/dist/rules/first.d.ts

@@ -0,0 +1,8 @@
+import { ESLintRuleModule } from "../index2.js";
+
+//#region src/rules/first/first.d.ts
+type Options = 'absolute-first' | 'disable-absolute-first';
+type MessageId = 'absolute' | 'order';
+declare const _default: ESLintRuleModule<[(Options | undefined)?], MessageId>;
+//#endregion
+export { MessageId, Options, _default as default };

package/dist/rules/first.js

@@ -0,0 +1,4 @@
+import "../utils.js";
+import { first_default } from "./first2.js";
+
+export { first_default as default };

package/dist/rules/first2.js

@@ -0,0 +1,105 @@
+import { createRule } from "../utils.js";
+
+//#region src/rules/first/first.ts
+function getImportValue(node) {
+	return node.type === "ImportDeclaration" ? node.source.value : "moduleReference" in node && "expression" in node.moduleReference && "value" in node.moduleReference.expression && node.moduleReference.expression.value;
+}
+function isPossibleDirective(node) {
+	return node.type === "ExpressionStatement" && node.expression.type === "Literal" && typeof node.expression.value === "string";
+}
+var first_default = createRule({
+	name: "first",
+	meta: {
+		type: "suggestion",
+		docs: {
+			fixable: true,
+			description: "Ensure all imports appear before other statements."
+		},
+		fixable: "code",
+		schema: [{
+			type: "string",
+			enum: ["absolute-first", "disable-absolute-first"]
+		}],
+		messages: {
+			absolute: "Absolute imports should come before relative imports.",
+			order: "Import in body of module; reorder to top."
+		}
+	},
+	defaultOptions: [],
+	create(context, options) {
+		return { Program(n) {
+			const body = n.body;
+			if (!body?.length) return;
+			const absoluteFirst = options[0] === "absolute-first";
+			const { sourceCode } = context;
+			const originSourceCode = sourceCode.getText();
+			let nonImportCount = 0;
+			let anyExpressions = false;
+			let anyRelative = false;
+			let lastLegalImp = null;
+			const errorInfos = [];
+			let shouldSort = true;
+			let lastSortNodesIndex = 0;
+			for (const [index, node] of body.entries()) {
+				if (!anyExpressions && isPossibleDirective(node)) continue;
+				anyExpressions = true;
+				if (node.type === "ImportDeclaration" || node.type === "TSImportEqualsDeclaration") {
+					if (absoluteFirst) {
+						const importValue = getImportValue(node);
+						if (typeof importValue === "string" && /^\./.test(importValue)) anyRelative = true;
+						else if (anyRelative) context.report({
+							node: node.type === "ImportDeclaration" ? node.source : node.moduleReference,
+							messageId: "absolute"
+						});
+					}
+					if (nonImportCount > 0) {
+						/** @see https://eslint.org/docs/next/use/migrate-to-9.0.0#-removed-multiple-context-methods */
+						for (const variable of sourceCode.getDeclaredVariables(node)) {
+							if (!shouldSort) break;
+							for (const reference of variable.references) if (reference.identifier.range[0] < node.range[1]) {
+								shouldSort = false;
+								break;
+							}
+						}
+						if (shouldSort) lastSortNodesIndex = errorInfos.length;
+						errorInfos.push({
+							node,
+							range: [body[index - 1].range[1], node.range[1]]
+						});
+					} else lastLegalImp = node;
+				} else nonImportCount++;
+			}
+			if (errorInfos.length === 0) return;
+			for (const [index, { node }] of errorInfos.entries()) {
+				let fix;
+				if (index < lastSortNodesIndex) fix = (fixer) => fixer.insertTextAfter(node, "");
+				else if (index === lastSortNodesIndex) {
+					const sortNodes = errorInfos.slice(0, lastSortNodesIndex + 1);
+					fix = (fixer) => {
+						const removeFixers = sortNodes.map(({ range: range$1 }) => fixer.removeRange(range$1));
+						const range = [0, removeFixers[removeFixers.length - 1].range[1]];
+						let insertSourceCode = sortNodes.map(({ range: range$1 }) => {
+							const nodeSourceCode = originSourceCode.slice(...range$1);
+							if (/\S/.test(nodeSourceCode[0])) return `\n${nodeSourceCode}`;
+							return nodeSourceCode;
+						}).join("");
+						let replaceSourceCode = "";
+						if (!lastLegalImp) insertSourceCode = insertSourceCode.trim() + insertSourceCode.match(/^(\s+)/)[0];
+						const insertFixer = lastLegalImp ? fixer.insertTextAfter(lastLegalImp, insertSourceCode) : fixer.insertTextBefore(body[0], insertSourceCode);
+						const fixers = [insertFixer, ...removeFixers];
+						for (const [i, computedFixer] of fixers.entries()) replaceSourceCode += originSourceCode.slice(fixers[i - 1] ? fixers[i - 1].range[1] : 0, computedFixer.range[0]) + computedFixer.text;
+						return fixer.replaceTextRange(range, replaceSourceCode);
+					};
+				}
+				context.report({
+					node,
+					messageId: "order",
+					fix
+				});
+			}
+		} };
+	}
+});
+
+//#endregion
+export { first_default };

package/dist/rules/newline-after-import.d.ts

@@ -0,0 +1,12 @@
+import { ESLintRuleModule } from "../index2.js";
+
+//#region src/rules/newline-after-import/newline-after-import.d.ts
+type RuleOptions = [{
+  count?: number;
+  exactCount?: boolean;
+  considerComments?: boolean;
+}];
+type MessageId = 'newline';
+declare const _default: ESLintRuleModule<RuleOptions, "newline">;
+//#endregion
+export { MessageId, RuleOptions, _default as default };

package/dist/rules/newline-after-import.js

@@ -0,0 +1,4 @@
+import "../utils.js";
+import { newline_after_import_default } from "./newline-after-import2.js";
+
+export { newline_after_import_default as default };

package/dist/rules/newline-after-import2.js

@@ -0,0 +1,172 @@
+import { createRule } from "../utils.js";
+
+//#region src/rules/newline-after-import/newline-after-import.ts
+function isStaticRequire(node) {
+	return node && node.callee && node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0].type === "Literal" && typeof node.arguments[0].value === "string";
+}
+function containsNodeOrEqual(outerNode, innerNode) {
+	return outerNode.range[0] <= innerNode.range[0] && outerNode.range[1] >= innerNode.range[1];
+}
+function getScopeBody(scope) {
+	if (scope.block.type === "SwitchStatement") {
+		console.log("SwitchStatement scopes not supported");
+		return [];
+	}
+	const body = "body" in scope.block ? scope.block.body : null;
+	if (body && "type" in body && body.type === "BlockStatement") return body.body;
+	return Array.isArray(body) ? body : [];
+}
+function findNodeIndexInScopeBody(body, nodeToFind) {
+	return body.findIndex((node) => containsNodeOrEqual(node, nodeToFind));
+}
+function getLineDifference(node, nextNode) {
+	return nextNode.loc.start.line - node.loc.end.line;
+}
+function isClassWithDecorator(node) {
+	return node.type === "ClassDeclaration" && !!node.decorators?.length;
+}
+function isExportDefaultClass(node) {
+	return node.type === "ExportDefaultDeclaration" && node.declaration.type === "ClassDeclaration";
+}
+function isExportNameClass(node) {
+	return node.type === "ExportNamedDeclaration" && node.declaration?.type === "ClassDeclaration";
+}
+var newline_after_import_default = createRule({
+	name: "newline-after-import",
+	meta: {
+		type: "layout",
+		docs: {
+			fixable: true,
+			description: "Enforce a newline after import statements."
+		},
+		fixable: "whitespace",
+		schema: [{
+			type: "object",
+			properties: {
+				count: {
+					type: "integer",
+					minimum: 1
+				},
+				exactCount: { type: "boolean" },
+				considerComments: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		messages: { newline: "Expected {{count}} empty line{{lineSuffix}} after {{type}} statement not followed by another {{type}}." }
+	},
+	defaultOptions: [{
+		count: 1,
+		exactCount: false,
+		considerComments: false
+	}],
+	create(context, [options]) {
+		let level = 0;
+		const requireCalls = [];
+		function checkForNewLine(node, nextNode, type) {
+			if (isExportDefaultClass(nextNode) || isExportNameClass(nextNode)) {
+				const classNode = nextNode.declaration;
+				if (isClassWithDecorator(classNode)) nextNode = classNode.decorators[0];
+			} else if (isClassWithDecorator(nextNode)) nextNode = nextNode.decorators[0];
+			const lineDifference = getLineDifference(node, nextNode);
+			const EXPECTED_LINE_DIFFERENCE = options.count + 1;
+			if (lineDifference < EXPECTED_LINE_DIFFERENCE || options.exactCount && lineDifference !== EXPECTED_LINE_DIFFERENCE) {
+				let column = node.loc.start.column;
+				if (node.loc.start.line !== node.loc.end.line) column = 0;
+				context.report({
+					loc: {
+						line: node.loc.end.line,
+						column
+					},
+					messageId: "newline",
+					data: {
+						count: options.count,
+						lineSuffix: options.count > 1 ? "s" : "",
+						type
+					},
+					fix: options.exactCount && EXPECTED_LINE_DIFFERENCE < lineDifference ? void 0 : (fixer) => fixer.insertTextAfter(node, "\n".repeat(EXPECTED_LINE_DIFFERENCE - lineDifference))
+				});
+			}
+		}
+		function commentAfterImport(node, nextComment, type) {
+			const lineDifference = getLineDifference(node, nextComment);
+			const EXPECTED_LINE_DIFFERENCE = options.count + 1;
+			if (lineDifference < EXPECTED_LINE_DIFFERENCE) {
+				let column = node.loc.start.column;
+				if (node.loc.start.line !== node.loc.end.line) column = 0;
+				context.report({
+					loc: {
+						line: node.loc.end.line,
+						column
+					},
+					messageId: "newline",
+					data: {
+						count: options.count,
+						lineSuffix: options.count > 1 ? "s" : "",
+						type
+					},
+					fix: options.exactCount && EXPECTED_LINE_DIFFERENCE < lineDifference ? void 0 : (fixer) => fixer.insertTextAfter(node, "\n".repeat(EXPECTED_LINE_DIFFERENCE - lineDifference))
+				});
+			}
+		}
+		function incrementLevel() {
+			level++;
+		}
+		function decrementLevel() {
+			level--;
+		}
+		function checkImport(node) {
+			const { parent } = node;
+			if (!parent || !("body" in parent) || !parent.body) return;
+			const root = parent;
+			const nodePosition = root.body.indexOf(node);
+			const nextNode = root.body[nodePosition + 1];
+			const endLine = node.loc.end.line;
+			let nextComment;
+			if (root.comments !== void 0 && options.considerComments) nextComment = root.comments.find((o) => o.loc.start.line >= endLine && o.loc.start.line <= endLine + options.count + 1);
+			if (node.type === "TSImportEqualsDeclaration" && node.isExport) return;
+			if (nextComment) commentAfterImport(node, nextComment, "import");
+			else if (nextNode && nextNode.type !== "ImportDeclaration" && (nextNode.type !== "TSImportEqualsDeclaration" || nextNode.isExport)) checkForNewLine(node, nextNode, "import");
+		}
+		return {
+			"ImportDeclaration": checkImport,
+			"TSImportEqualsDeclaration": checkImport,
+			CallExpression(node) {
+				if (isStaticRequire(node) && level === 0) requireCalls.push(node);
+			},
+			"Program:exit": function(node) {
+				const scopeBody = getScopeBody(context.sourceCode.getScope(node));
+				for (const [index, node$1] of requireCalls.entries()) {
+					const nodePosition = findNodeIndexInScopeBody(scopeBody, node$1);
+					const statementWithRequireCall = scopeBody[nodePosition];
+					const nextStatement = scopeBody[nodePosition + 1];
+					const nextRequireCall = requireCalls[index + 1];
+					if (nextRequireCall && containsNodeOrEqual(statementWithRequireCall, nextRequireCall)) continue;
+					if (nextStatement && (!nextRequireCall || !containsNodeOrEqual(nextStatement, nextRequireCall))) {
+						let nextComment;
+						if ("comments" in statementWithRequireCall.parent && statementWithRequireCall.parent.comments !== void 0 && options.considerComments) {
+							const endLine = node$1.loc.end.line;
+							nextComment = statementWithRequireCall.parent.comments.find((o) => o.loc.start.line >= endLine && o.loc.start.line <= endLine + options.count + 1);
+						}
+						if (nextComment && nextComment !== void 0) commentAfterImport(statementWithRequireCall, nextComment, "require");
+						else checkForNewLine(statementWithRequireCall, nextStatement, "require");
+					}
+				}
+			},
+			"FunctionDeclaration": incrementLevel,
+			"FunctionExpression": incrementLevel,
+			"ArrowFunctionExpression": incrementLevel,
+			"BlockStatement": incrementLevel,
+			"ObjectExpression": incrementLevel,
+			"Decorator": incrementLevel,
+			"FunctionDeclaration:exit": decrementLevel,
+			"FunctionExpression:exit": decrementLevel,
+			"ArrowFunctionExpression:exit": decrementLevel,
+			"BlockStatement:exit": decrementLevel,
+			"ObjectExpression:exit": decrementLevel,
+			"Decorator:exit": decrementLevel
+		};
+	}
+});
+
+//#endregion
+export { newline_after_import_default };

package/dist/rules/no-default-export.d.ts

@@ -0,0 +1,8 @@
+import { ESLintRuleModule } from "../index2.js";
+
+//#region src/rules/no-default-export/no-default-export.d.ts
+type RuleOptions = [];
+type MessageIds = 'preferNamed' | 'noAliasDefault';
+declare const _default: ESLintRuleModule<never[], "preferNamed" | "noAliasDefault">;
+//#endregion
+export { MessageIds, RuleOptions, _default as default };

package/dist/rules/no-default-export.js

@@ -0,0 +1,5 @@
+import "../utils.js";
+import "../ast.js";
+import { no_default_export_default } from "./no-default-export2.js";
+
+export { no_default_export_default as default };

package/dist/rules/no-default-export2.js

@@ -0,0 +1,50 @@
+import { createRule, sourceType } from "../utils.js";
+import { getValue } from "../ast.js";
+
+//#region src/rules/no-default-export/no-default-export.ts
+var no_default_export_default = createRule({
+	name: "no-default-export",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Forbid default exports." },
+		schema: [],
+		messages: {
+			preferNamed: "Prefer named exports.",
+			noAliasDefault: "Do not alias `{{local}}` as `default`. Just export `{{local}}` itself instead."
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		if (sourceType(context) !== "module") return {};
+		const { sourceCode } = context;
+		return {
+			ExportDefaultDeclaration(node) {
+				const { loc } = sourceCode.getFirstTokens(node)[1] || {};
+				context.report({
+					node,
+					messageId: "preferNamed",
+					loc
+				});
+			},
+			ExportNamedDeclaration(node) {
+				for (const specifier of node.specifiers.filter((specifier$1) => getValue(specifier$1.exported) === "default")) {
+					const { loc } = sourceCode.getFirstTokens(node)[1] || {};
+					if (specifier.type === "ExportDefaultSpecifier") context.report({
+						node,
+						messageId: "preferNamed",
+						loc
+					});
+					else if (specifier.type === "ExportSpecifier") context.report({
+						node,
+						messageId: "noAliasDefault",
+						data: { local: getValue(specifier.local) },
+						loc
+					});
+				}
+			}
+		};
+	}
+});
+
+//#endregion
+export { no_default_export_default };

package/dist/rules/no-duplicates.d.ts

@@ -0,0 +1,18 @@
+import { ESLintRuleModule } from "../index2.js";
+import { TSESTree } from "@typescript-eslint/utils";
+
+//#region src/rules/no-duplicates/no-duplicates.d.ts
+type Options = [{
+  'prefer-inline'?: boolean;
+}?];
+type MessageId = 'duplicate';
+interface ModuleMap {
+  imported: Map<string, TSESTree.ImportDeclaration[]>;
+  nsImported: Map<string, TSESTree.ImportDeclaration[]>;
+  defaultTypesImported: Map<string, TSESTree.ImportDeclaration[]>;
+  namespaceTypesImported: Map<string, TSESTree.ImportDeclaration[]>;
+  namedTypesImported: Map<string, TSESTree.ImportDeclaration[]>;
+}
+declare const _default: ESLintRuleModule<Options, "duplicate">;
+//#endregion
+export { MessageId, ModuleMap, Options, _default as default };

package/dist/rules/no-duplicates.js

@@ -0,0 +1,4 @@
+import "../utils.js";
+import { no_duplicates_default } from "./no-duplicates2.js";
+
+export { no_duplicates_default as default };

package/dist/rules/no-duplicates2.js

@@ -0,0 +1,196 @@
+import { createRule } from "../utils.js";
+
+//#region src/rules/no-duplicates/no-duplicates.ts
+function checkImports(imported, context) {
+	imported.forEach((nodes, module) => {
+		if (nodes.length <= 1) return;
+		for (let i = 0, len = nodes.length; i < len; i++) {
+			const node = nodes[i];
+			context.report({
+				node: node.source,
+				messageId: "duplicate",
+				data: { module },
+				fix: i === 0 ? getFix(nodes, context.sourceCode, context) : null
+			});
+		}
+	});
+}
+function getFix(nodes, sourceCode, context) {
+	const first = nodes[0];
+	if (hasProblematicComments(first, sourceCode) || hasNamespace(first)) return null;
+	const defaultImportNames = new Set(nodes.flatMap((x) => getDefaultImportName(x) || []));
+	if (defaultImportNames.size > 1) return null;
+	const rest = nodes.slice(1);
+	const restWithoutCommentsAndNamespaces = rest.filter((node) => !hasProblematicComments(node, sourceCode) && !hasNamespace(node));
+	const restWithoutCommentsAndNamespacesHasSpecifiers = restWithoutCommentsAndNamespaces.map(hasSpecifiers);
+	const specifiers = restWithoutCommentsAndNamespaces.reduce((acc, node, nodeIndex) => {
+		const tokens = sourceCode.getTokens(node);
+		const openBrace = tokens.find((token) => isPunctuator(token, "{"));
+		const closeBrace = tokens.find((token) => isPunctuator(token, "}"));
+		if (openBrace == null || closeBrace == null) return acc;
+		acc.push({
+			importNode: node,
+			identifiers: sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]).split(","),
+			isEmpty: !restWithoutCommentsAndNamespacesHasSpecifiers[nodeIndex]
+		});
+		return acc;
+	}, []);
+	const unnecessaryImports = restWithoutCommentsAndNamespaces.filter((node, nodeIndex) => !restWithoutCommentsAndNamespacesHasSpecifiers[nodeIndex] && !specifiers.some((specifier) => specifier.importNode === node));
+	const shouldAddSpecifiers = specifiers.length > 0;
+	const shouldRemoveUnnecessary = unnecessaryImports.length > 0;
+	const shouldAddDefault = getDefaultImportName(first) == null && defaultImportNames.size === 1;
+	if (!shouldAddSpecifiers && !shouldRemoveUnnecessary && !shouldAddDefault) return null;
+	const preferInline = context.options[0] && context.options[0]["prefer-inline"];
+	return (fixer) => {
+		const tokens = sourceCode.getTokens(first);
+		const openBrace = tokens.find((token) => isPunctuator(token, "{"));
+		const closeBrace = tokens.find((token) => isPunctuator(token, "}"));
+		const firstToken = sourceCode.getFirstToken(first);
+		const [defaultImportName] = defaultImportNames;
+		const firstHasTrailingComma = closeBrace != null && isPunctuator(sourceCode.getTokenBefore(closeBrace), ",");
+		const firstIsEmpty = !hasSpecifiers(first);
+		const firstExistingIdentifiers = firstIsEmpty ? /* @__PURE__ */ new Set() : new Set(sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]).split(",").map((x) => x.split(" as ")[0].trim()));
+		const [specifiersText] = specifiers.reduce(([result, needsComma, existingIdentifiers], specifier) => {
+			const isTypeSpecifier = "importNode" in specifier && specifier.importNode.importKind === "type";
+			const [specifierText, updatedExistingIdentifiers] = specifier.identifiers.reduce(([text, set], cur) => {
+				const trimmed = cur.trim();
+				if (trimmed.length === 0 || existingIdentifiers.has(trimmed)) return [text, set];
+				const curWithType = preferInline && isTypeSpecifier ? cur.replace(/^(\s*)/, "$1type ") : cur;
+				return [text.length > 0 ? `${text},${curWithType}` : curWithType, set.add(trimmed)];
+			}, ["", existingIdentifiers]);
+			return [
+				needsComma && !specifier.isEmpty && specifierText.length > 0 ? `${result},${specifierText}` : `${result}${specifierText}`,
+				specifier.isEmpty ? needsComma : true,
+				updatedExistingIdentifiers
+			];
+		}, [
+			"",
+			!firstHasTrailingComma && !firstIsEmpty,
+			firstExistingIdentifiers
+		]);
+		const fixes = [];
+		if (shouldAddSpecifiers && preferInline && first.importKind === "type") {
+			const typeIdentifierToken = tokens.find((token) => token.type === "Identifier" && token.value === "type");
+			if (typeIdentifierToken) fixes.push(fixer.removeRange([typeIdentifierToken.range[0], typeIdentifierToken.range[1] + 1]));
+			for (const identifier of tokens.filter((token) => firstExistingIdentifiers.has(token.value))) fixes.push(fixer.replaceTextRange([identifier.range[0], identifier.range[1]], `type ${identifier.value}`));
+		}
+		if (openBrace == null && shouldAddSpecifiers && shouldAddDefault) fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName}, {${specifiersText}} from`));
+		else if (openBrace == null && !shouldAddSpecifiers && shouldAddDefault) fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName} from`));
+		else if (openBrace != null && closeBrace != null && shouldAddDefault) {
+			fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName},`));
+			if (shouldAddSpecifiers) fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));
+		} else if (openBrace == null && shouldAddSpecifiers && !shouldAddDefault) if (first.specifiers.length === 0) fixes.push(fixer.insertTextAfter(firstToken, ` {${specifiersText}} from`));
+		else fixes.push(fixer.insertTextAfter(first.specifiers[0], `, {${specifiersText}}`));
+		else if (openBrace != null && closeBrace != null && !shouldAddDefault) {
+			const tokenBefore = sourceCode.getTokenBefore(closeBrace);
+			fixes.push(fixer.insertTextAfter(tokenBefore, specifiersText));
+		}
+		for (const specifier of specifiers) {
+			const importNode = specifier.importNode;
+			fixes.push(fixer.remove(importNode));
+			const charAfterImportRange = [importNode.range[1], importNode.range[1] + 1];
+			const charAfterImport = sourceCode.text.slice(charAfterImportRange[0], charAfterImportRange[1]);
+			if (charAfterImport === "\n") fixes.push(fixer.removeRange(charAfterImportRange));
+		}
+		for (const node of unnecessaryImports) {
+			fixes.push(fixer.remove(node));
+			const charAfterImportRange = [node.range[1], node.range[1] + 1];
+			const charAfterImport = sourceCode.text.slice(charAfterImportRange[0], charAfterImportRange[1]);
+			if (charAfterImport === "\n") fixes.push(fixer.removeRange(charAfterImportRange));
+		}
+		return fixes;
+	};
+}
+function isPunctuator(node, value) {
+	return node.type === "Punctuator" && node.value === value;
+}
+function getDefaultImportName(node) {
+	const defaultSpecifier = node.specifiers.find((specifier) => specifier.type === "ImportDefaultSpecifier");
+	return defaultSpecifier?.local.name;
+}
+function hasNamespace(node) {
+	return node.specifiers.some((specifier) => specifier.type === "ImportNamespaceSpecifier");
+}
+function hasSpecifiers(node) {
+	return node.specifiers.some((specifier) => specifier.type === "ImportSpecifier");
+}
+function hasProblematicComments(node, sourceCode) {
+	return hasCommentBefore(node, sourceCode) || hasCommentAfter(node, sourceCode) || hasCommentInsideNonSpecifiers(node, sourceCode);
+}
+function hasCommentBefore(node, sourceCode) {
+	return sourceCode.getCommentsBefore(node).some((comment) => comment.loc.end.line >= node.loc.start.line - 1);
+}
+function hasCommentAfter(node, sourceCode) {
+	return sourceCode.getCommentsAfter(node).some((comment) => comment.loc.start.line === node.loc.end.line);
+}
+function hasCommentInsideNonSpecifiers(node, sourceCode) {
+	const tokens = sourceCode.getTokens(node);
+	const openBraceIndex = tokens.findIndex((token) => isPunctuator(token, "{"));
+	const closeBraceIndex = tokens.findIndex((token) => isPunctuator(token, "}"));
+	const someTokens = openBraceIndex !== -1 && closeBraceIndex !== -1 ? [...tokens.slice(1, openBraceIndex + 1), ...tokens.slice(closeBraceIndex + 1)] : tokens.slice(1);
+	return someTokens.some((token) => sourceCode.getCommentsBefore(token).length > 0);
+}
+var no_duplicates_default = createRule({
+	name: "no-duplicates",
+	meta: {
+		type: "problem",
+		docs: {
+			recommended: true,
+			fixable: true,
+			description: "Forbid repeated import of the same module in multiple places."
+		},
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: { "prefer-inline": { type: "boolean" } },
+			additionalProperties: false
+		}],
+		messages: { duplicate: "'{{module}}' imported multiple times." }
+	},
+	defaultOptions: [],
+	create(context) {
+		const preferInline = context.options[0]?.["prefer-inline"];
+		const moduleMaps = /* @__PURE__ */ new Map();
+		function getImportMap(n) {
+			const parent = n.parent;
+			let map;
+			if (moduleMaps.has(parent)) map = moduleMaps.get(parent);
+			else {
+				map = {
+					imported: /* @__PURE__ */ new Map(),
+					nsImported: /* @__PURE__ */ new Map(),
+					defaultTypesImported: /* @__PURE__ */ new Map(),
+					namespaceTypesImported: /* @__PURE__ */ new Map(),
+					namedTypesImported: /* @__PURE__ */ new Map()
+				};
+				moduleMaps.set(parent, map);
+			}
+			if (n.importKind === "type") {
+				if (n.specifiers.length > 0 && n.specifiers[0].type === "ImportDefaultSpecifier") return map.defaultTypesImported;
+				if (n.specifiers.length > 0 && n.specifiers[0].type === "ImportNamespaceSpecifier") return map.namespaceTypesImported;
+				if (!preferInline) return map.namedTypesImported;
+			}
+			if (!preferInline && n.specifiers.some((spec) => "importKind" in spec && spec.importKind === "type")) return map.namedTypesImported;
+			return hasNamespace(n) ? map.nsImported : map.imported;
+		}
+		return {
+			ImportDeclaration(n) {
+				const resolvedPath = n.source.value;
+				const importMap = getImportMap(n);
+				if (importMap.has(resolvedPath)) importMap.get(resolvedPath).push(n);
+				else importMap.set(resolvedPath, [n]);
+			},
+			"Program:exit": function() {
+				for (const map of moduleMaps.values()) {
+					checkImports(map.imported, context);
+					checkImports(map.nsImported, context);
+					checkImports(map.defaultTypesImported, context);
+					checkImports(map.namedTypesImported, context);
+				}
+			}
+		};
+	}
+});
+
+//#endregion
+export { no_duplicates_default };

package/dist/rules/no-mutable-exports.d.ts

@@ -0,0 +1,8 @@
+import { ESLintRuleModule } from "../index2.js";
+
+//#region src/rules/no-mutable-exports/no-mutable-exports.d.ts
+type MessageId = 'noMutable';
+type Options = [];
+declare const _default: ESLintRuleModule<[], "noMutable">;
+//#endregion
+export { MessageId, Options, _default as default };

package/dist/rules/no-mutable-exports.js

@@ -0,0 +1,4 @@
+import "../utils.js";
+import { no_mutable_exports_default } from "./no-mutable-exports2.js";
+
+export { no_mutable_exports_default as default };

package/dist/rules/no-mutable-exports2.js

@@ -0,0 +1,41 @@
+import { createRule } from "../utils.js";
+
+//#region src/rules/no-mutable-exports/no-mutable-exports.ts
+var no_mutable_exports_default = createRule({
+	name: "no-mutable-exports",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Forbid the use of mutable exports with `var` or `let`." },
+		schema: [],
+		messages: { noMutable: "Exporting mutable '{{kind}}' binding, use 'const' instead." }
+	},
+	defaultOptions: [],
+	create(context) {
+		function checkDeclaration(node) {
+			if ("kind" in node && (node.kind === "var" || node.kind === "let")) context.report({
+				node,
+				messageId: "noMutable",
+				data: { kind: node.kind }
+			});
+		}
+		function checkDeclarationsInScope({ variables }, name) {
+			for (const variable of variables) if (variable.name === name) {
+				for (const def of variable.defs) if (def.type === "Variable" && def.parent) checkDeclaration(def.parent);
+			}
+		}
+		return {
+			ExportDefaultDeclaration(node) {
+				const scope = context.sourceCode.getScope(node);
+				if ("name" in node.declaration) checkDeclarationsInScope(scope, node.declaration.name);
+			},
+			ExportNamedDeclaration(node) {
+				const scope = context.sourceCode.getScope(node);
+				if (node.declaration) checkDeclaration(node.declaration);
+				else if (!node.source) for (const specifier of node.specifiers) checkDeclarationsInScope(scope, specifier.local.name);
+			}
+		};
+	}
+});
+
+//#endregion
+export { no_mutable_exports_default };

package/dist/rules/no-named-default.d.ts

@@ -0,0 +1,8 @@
+import { ESLintRuleModule } from "../index2.js";
+
+//#region src/rules/no-named-default/no-named-default.d.ts
+type Options = [];
+type MessageId = 'default';
+declare const _default: ESLintRuleModule<[], "default">;
+//#endregion
+export { MessageId, Options, _default as default };

package/dist/rules/no-named-default.js

@@ -0,0 +1,5 @@
+import "../utils.js";
+import "../ast.js";
+import { no_named_default_default } from "./no-named-default2.js";
+
+export { no_named_default_default as default };

package/dist/rules/no-named-default2.js

@@ -0,0 +1,29 @@
+import { createRule } from "../utils.js";
+import { getValue } from "../ast.js";
+
+//#region src/rules/no-named-default/no-named-default.ts
+var no_named_default_default = createRule({
+	name: "no-named-default",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Forbid named default exports." },
+		schema: [],
+		messages: { default: `Use default import syntax to import '{{importName}}'.` }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { ImportDeclaration(node) {
+			for (const im of node.specifiers) {
+				if ("importKind" in im && (im.importKind === "type" || im.importKind === "typeof")) continue;
+				if (im.type === "ImportSpecifier" && getValue(im.imported) === "default") context.report({
+					node: im.local,
+					messageId: "default",
+					data: { importName: im.local.name }
+				});
+			}
+		} };
+	}
+});
+
+//#endregion
+export { no_named_default_default };

package/dist/utils.js

@@ -0,0 +1,30 @@
+import { deepMerge, isObjectNotArray } from "@typescript-eslint/utils/eslint-utils";
+
+//#region src/utils/index.ts
+function createRule({ name, create, defaultOptions = [], meta }) {
+	return {
+		create: (context) => {
+			const optionsCount = Math.max(context.options.length, defaultOptions.length);
+			const optionsWithDefault = Array.from({ length: optionsCount }, (_, i) => {
+				if (isObjectNotArray(context.options[i]) && isObjectNotArray(defaultOptions[i])) return deepMerge(defaultOptions[i], context.options[i]);
+				return context.options[i] ?? defaultOptions[i];
+			});
+			return create(context, optionsWithDefault);
+		},
+		defaultOptions,
+		meta: {
+			...meta,
+			docs: {
+				...meta.docs,
+				url: `https://github.com/9romise/eslint-plugin-import-lite/blob/main/src/rules/${name}/README.md`
+			}
+		}
+	};
+}
+function sourceType(context) {
+	if ("sourceType" in context.parserOptions) return context.parserOptions.sourceType;
+	if ("languageOptions" in context && context.languageOptions) return context.languageOptions.sourceType;
+}
+
+//#endregion
+export { createRule, sourceType };

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "eslint-plugin-import-lite",
+  "type": "module",
+  "version": "0.1.0",
+  "packageManager": "pnpm@10.12.1",
+  "author": "Vida Xie<https://github.com/9romise>",
+  "license": "MIT",
+  "homepage": "https://github.com/9romise/eslint-plugin-import-lite#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/9romise/eslint-plugin-import-lite.git"
+  },
+  "bugs": {
+    "url": "https://github.com/9romise/eslint-plugin-import-lite/issues"
+  },
+  "keywords": [],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "test": "vitest",
+    "lint": "eslint .",
+    "update": "tsx scripts/update && eslint . --fix",
+    "typecheck": "tsc --noEmit",
+    "prepare": "npm run build"
+  },
+  "peerDependencies": {
+    "eslint": ">=9.0.0",
+    "typescript": ">=4.5"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@typescript-eslint/utils": "catalog:prod"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:dev",
+    "@typescript-eslint/parser": "catalog:test",
+    "@vida0905/eslint-config": "catalog:dev",
+    "change-case": "catalog:dev",
+    "eslint": "catalog:dev",
+    "eslint-plugin-import-lite": "workspace:*",
+    "eslint-vitest-rule-tester": "catalog:test",
+    "nano-staged": "catalog:dev",
+    "simple-git-hooks": "catalog:dev",
+    "tinyglobby": "catalog:dev",
+    "tsdown": "catalog:dev",
+    "tsx": "catalog:dev",
+    "typescript": "catalog:dev",
+    "vitest": "catalog:test"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "npx nano-staged"
+  },
+  "nano-staged": {
+    "*": "eslint --fix"
+  }
+}