@1adybug/prettier-plugin-sort-imports 0.0.2 → 0.0.3

package/dist/index.cjs

@@ -0,0 +1,666 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createPlugin: ()=>createPlugin,
+    default: ()=>src
+});
+const external_module_namespaceObject = require("module");
+const parser_namespaceObject = require("@babel/parser");
+const traverse_namespaceObject = require("@babel/traverse");
+var traverse_default = /*#__PURE__*/ __webpack_require__.n(traverse_namespaceObject);
+function analyzeUsedIdentifiers(code) {
+    const usedIdentifiers = new Set();
+    try {
+        const ast = (0, parser_namespaceObject.parse)(code, {
+            sourceType: "module",
+            plugins: [
+                "typescript",
+                "jsx"
+            ],
+            errorRecovery: true
+        });
+        traverse_default()(ast, {
+            Identifier (path) {
+                const node = path.node;
+                const parent = path.parent;
+                if (path.isBindingIdentifier()) return;
+                if (parent?.type === "ObjectProperty" && parent.key === node && !parent.computed) return;
+                usedIdentifiers.add(node.name);
+            },
+            JSXIdentifier (path) {
+                const node = path.node;
+                if (path.parent?.type === "JSXOpeningElement" || path.parent?.type === "JSXClosingElement") usedIdentifiers.add(node.name);
+            },
+            TSTypeReference (path) {
+                const node = path.node;
+                if ("Identifier" === node.typeName.type) usedIdentifiers.add(node.typeName.name);
+                else if ("TSQualifiedName" === node.typeName.type) {
+                    let current = node.typeName;
+                    while("TSQualifiedName" === current.type)current = current.left;
+                    if ("Identifier" === current.type) usedIdentifiers.add(current.name);
+                }
+            },
+            ExportNamedDeclaration (path) {
+                const node = path.node;
+                if (!node.source && node.specifiers) {
+                    for (const specifier of node.specifiers)if ("ExportSpecifier" === specifier.type) {
+                        if ("Identifier" === specifier.local.type) usedIdentifiers.add(specifier.local.name);
+                    }
+                }
+            }
+        });
+    } catch (error) {
+        console.error("Failed to analyze used identifiers:", error);
+    }
+    return usedIdentifiers;
+}
+function filterUnusedImports(importStatement, usedIdentifiers) {
+    if (importStatement.isSideEffect || importStatement.isExport) return importStatement;
+    const usedContents = [];
+    for (const content of importStatement.importContents){
+        const usedName = content.alias ?? content.name;
+        if ("default" === content.name || "*" === content.name) {
+            if (content.alias && usedIdentifiers.has(content.alias)) usedContents.push(content);
+        } else if (usedIdentifiers.has(usedName)) usedContents.push(content);
+    }
+    return {
+        ...importStatement,
+        importContents: usedContents,
+        isSideEffect: 0 === usedContents.length
+    };
+}
+function removeUnusedImportsFromStatements(importStatements, code) {
+    const usedIdentifiers = analyzeUsedIdentifiers(code);
+    const filteredStatements = [];
+    for (const statement of importStatements){
+        const filteredStatement = filterUnusedImports(statement, usedIdentifiers);
+        if (statement.isSideEffect || !filteredStatement.isSideEffect || 0 !== filteredStatement.importContents.length) filteredStatements.push(filteredStatement);
+    }
+    return filteredStatements;
+}
+function formatImportStatement(statement) {
+    const { path, isExport, isSideEffect, importContents, leadingComments, trailingComments, removedTrailingComments } = statement;
+    const lines = [];
+    if (leadingComments && leadingComments.length > 0) lines.push(...leadingComments);
+    if (isSideEffect) {
+        let importLine = "";
+        importLine = isExport ? `export * from "${path}"` : `import "${path}"`;
+        if (trailingComments && trailingComments.length > 0) importLine += ` ${trailingComments.join(" ")}`;
+        lines.push(importLine);
+        return lines.join("\n");
+    }
+    const hasNamedImportComments = importContents.some((content)=>"default" !== content.name && "*" !== content.name && (content.leadingComments && content.leadingComments.length > 0 || content.trailingComments && content.trailingComments.length > 0));
+    const parts = [];
+    const namedParts = [];
+    const namedPartsWithComments = [];
+    for (const content of importContents){
+        if ("default" === content.name) {
+            parts.push(content.alias ?? "default");
+            continue;
+        }
+        if ("*" === content.name) {
+            parts.push(`* as ${content.alias ?? "namespace"}`);
+            continue;
+        }
+        const typePrefix = "type" === content.type ? "type " : "";
+        let importItem = "";
+        importItem = content.alias ? `${typePrefix}${content.name} as ${content.alias}` : `${typePrefix}${content.name}`;
+        if (hasNamedImportComments) {
+            const itemLines = [];
+            if (content.leadingComments && content.leadingComments.length > 0) itemLines.push(...content.leadingComments);
+            let itemLine = importItem;
+            if (content.trailingComments && content.trailingComments.length > 0) itemLine += ` ${content.trailingComments.join(" ")}`;
+            itemLines.push(itemLine);
+            namedPartsWithComments.push(itemLines.join("\n    "));
+        } else namedParts.push(importItem);
+    }
+    const namedImports = importContents.filter((c)=>"default" !== c.name && "*" !== c.name);
+    const allNamedImportsAreTypes = namedImports.every((c)=>"type" === c.type);
+    const hasDefaultOrNamespace = importContents.some((c)=>"default" === c.name || "*" === c.name);
+    if (hasNamedImportComments && namedPartsWithComments.length > 0) {
+        const keyword = isExport ? "export" : "import";
+        const typeKeyword = allNamedImportsAreTypes && !hasDefaultOrNamespace ? "type " : "";
+        const defaultPart = parts.length > 0 ? parts.join(", ") + ", " : "";
+        const importStart = `${keyword} ${typeKeyword}${defaultPart}{`;
+        const importEnd = `} from "${path}"`;
+        lines.push(importStart);
+        lines.push(`    ${namedPartsWithComments.join(",\n    ")},`);
+        lines.push(importEnd);
+    } else {
+        if (namedParts.length > 0) if (allNamedImportsAreTypes && !hasDefaultOrNamespace) {
+            const cleanedParts = namedParts.map((part)=>part.replace(/^type /, ""));
+            parts.push(`{ ${cleanedParts.join(", ")} }`);
+        } else parts.push(`{ ${namedParts.join(", ")} }`);
+        const importClause = parts.join(", ");
+        const typeKeyword = allNamedImportsAreTypes && !hasDefaultOrNamespace ? "type " : "";
+        let importLine = "";
+        importLine = isExport ? `export ${typeKeyword}${importClause} from "${path}"` : `import ${typeKeyword}${importClause} from "${path}"`;
+        if (trailingComments && trailingComments.length > 0) importLine += ` ${trailingComments.join(" ")}`;
+        lines.push(importLine);
+    }
+    if (removedTrailingComments && removedTrailingComments.length > 0) {
+        lines.push("");
+        lines.push(...removedTrailingComments);
+    }
+    return lines.join("\n");
+}
+function formatGroups(groups, config) {
+    const lines = [];
+    const separator = config.separator;
+    for(let i = 0; i < groups.length; i++){
+        const group = groups[i];
+        if (void 0 !== separator) {
+            let separatorStr;
+            separatorStr = "string" == typeof separator ? separator : separator(group, i);
+            if (void 0 !== separatorStr) {
+                lines.push("");
+                if ("" !== separatorStr) lines.push(separatorStr);
+            }
+        }
+        for (const statement of group.importStatements)lines.push(formatImportStatement(statement));
+    }
+    return lines.join("\n");
+}
+function formatImportStatements(statements) {
+    return statements.map(formatImportStatement).join("\n");
+}
+function parseImports(code) {
+    const ast = (0, parser_namespaceObject.parse)(code, {
+        sourceType: "module",
+        plugins: [
+            "typescript",
+            "jsx"
+        ],
+        errorRecovery: true,
+        attachComment: true
+    });
+    const importStatements = [];
+    const { body } = ast.program;
+    const usedComments = new Set();
+    for (const node of body)if ("ImportDeclaration" === node.type || "ExportNamedDeclaration" === node.type && node.source || "ExportAllDeclaration" === node.type) {
+        const statement = parseImportNode(node, ast.comments ?? [], usedComments);
+        importStatements.push(statement);
+    } else break;
+    return importStatements;
+}
+function parseImportNode(node, comments, usedComments) {
+    node.type;
+    const source = node.source?.value ?? "";
+    node.loc?.start.line;
+    node.loc?.end.line;
+    const nodeStart = node.start ?? 0;
+    let nodeEnd = node.end ?? 0;
+    const leadingComments = [];
+    const trailingComments = [];
+    let start = nodeStart;
+    if (node.leadingComments) {
+        for (const comment of node.leadingComments)if (!usedComments.has(comment)) {
+            if ("CommentLine" === comment.type) leadingComments.push(`//${comment.value}`);
+            else if ("CommentBlock" === comment.type) leadingComments.push(`/*${comment.value}*/`);
+            const commentStart = comment.start ?? 0;
+            if (commentStart < start) start = commentStart;
+            usedComments.add(comment);
+        }
+    }
+    if (node.trailingComments) {
+        for (const comment of node.trailingComments)if (!usedComments.has(comment)) {
+            const commentLoc = comment.loc;
+            const nodeLoc = node.loc;
+            const isSameLine = commentLoc && nodeLoc && commentLoc.start.line === nodeLoc.end.line;
+            if (isSameLine) {
+                if ("CommentLine" === comment.type) trailingComments.push(`//${comment.value}`);
+                else if ("CommentBlock" === comment.type) trailingComments.push(`/*${comment.value}*/`);
+                const commentEnd = comment.end ?? 0;
+                if (commentEnd > nodeEnd) nodeEnd = commentEnd;
+                usedComments.add(comment);
+            }
+        }
+    }
+    const end = nodeEnd;
+    if ("ImportDeclaration" === node.type) {
+        const isTypeOnlyImport = "type" === node.importKind;
+        const importContents = parseImportSpecifiers(node, isTypeOnlyImport);
+        const isSideEffect = 0 === importContents.length;
+        return {
+            path: source,
+            isExport: false,
+            isSideEffect,
+            importContents,
+            leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+            trailingComments: trailingComments.length > 0 ? trailingComments : void 0,
+            start,
+            end
+        };
+    }
+    if ("ExportAllDeclaration" === node.type) return {
+        path: source,
+        isExport: true,
+        isSideEffect: false,
+        importContents: [],
+        leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+        trailingComments: trailingComments.length > 0 ? trailingComments : void 0,
+        start,
+        end
+    };
+    const importContents = parseExportSpecifiers(node);
+    return {
+        path: source,
+        isExport: true,
+        isSideEffect: false,
+        importContents,
+        leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+        trailingComments: trailingComments.length > 0 ? trailingComments : void 0,
+        start,
+        end
+    };
+}
+function parseImportSpecifiers(node, isTypeOnlyImport = false) {
+    const contents = [];
+    for (const specifier of node.specifiers){
+        const leadingComments = [];
+        const trailingComments = [];
+        if (specifier.leadingComments) {
+            for (const comment of specifier.leadingComments)if ("CommentLine" === comment.type) leadingComments.push(`//${comment.value}`);
+            else if ("CommentBlock" === comment.type) leadingComments.push(`/*${comment.value}*/`);
+        }
+        if (specifier.trailingComments) {
+            for (const comment of specifier.trailingComments)if ("CommentLine" === comment.type) trailingComments.push(`//${comment.value}`);
+            else if ("CommentBlock" === comment.type) trailingComments.push(`/*${comment.value}*/`);
+        }
+        if ("ImportDefaultSpecifier" === specifier.type) contents.push({
+            name: "default",
+            alias: specifier.local.name,
+            type: isTypeOnlyImport ? "type" : "variable",
+            leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+            trailingComments: trailingComments.length > 0 ? trailingComments : void 0
+        });
+        else if ("ImportNamespaceSpecifier" === specifier.type) contents.push({
+            name: "*",
+            alias: specifier.local.name,
+            type: isTypeOnlyImport ? "type" : "variable",
+            leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+            trailingComments: trailingComments.length > 0 ? trailingComments : void 0
+        });
+        else if ("ImportSpecifier" === specifier.type) {
+            const importedName = "Identifier" === specifier.imported.type ? specifier.imported.name : specifier.imported.value;
+            const localName = specifier.local.name;
+            const isTypeImport = isTypeOnlyImport || "type" === specifier.importKind;
+            contents.push({
+                name: importedName,
+                alias: importedName !== localName ? localName : void 0,
+                type: isTypeImport ? "type" : "variable",
+                leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+                trailingComments: trailingComments.length > 0 ? trailingComments : void 0
+            });
+        }
+    }
+    return contents;
+}
+function parseExportSpecifiers(node) {
+    const contents = [];
+    if (!node.specifiers) return contents;
+    for (const specifier of node.specifiers)if ("ExportSpecifier" === specifier.type) {
+        const leadingComments = [];
+        const trailingComments = [];
+        if (specifier.leadingComments) {
+            for (const comment of specifier.leadingComments)if ("CommentLine" === comment.type) leadingComments.push(`//${comment.value}`);
+            else if ("CommentBlock" === comment.type) leadingComments.push(`/*${comment.value}*/`);
+        }
+        if (specifier.trailingComments) {
+            for (const comment of specifier.trailingComments)if ("CommentLine" === comment.type) trailingComments.push(`//${comment.value}`);
+            else if ("CommentBlock" === comment.type) trailingComments.push(`/*${comment.value}*/`);
+        }
+        const localName = "Identifier" === specifier.local.type ? specifier.local.name : specifier.local.value;
+        const exportedName = "Identifier" === specifier.exported.type ? specifier.exported.name : specifier.exported.value;
+        const isTypeExport = "type" === specifier.exportKind;
+        contents.push({
+            name: localName,
+            alias: localName !== exportedName ? exportedName : void 0,
+            type: isTypeExport ? "type" : "variable",
+            leadingComments: leadingComments.length > 0 ? leadingComments : void 0,
+            trailingComments: trailingComments.length > 0 ? trailingComments : void 0
+        });
+    }
+    return contents;
+}
+function defaultGetGroup() {
+    return "default";
+}
+function defaultSortGroup(a, b) {
+    return a.name.localeCompare(b.name);
+}
+function getImportType(path) {
+    if (path.startsWith("./") || path.startsWith("../")) return "relative";
+    if (path.startsWith("@/") || path.startsWith("~/") || path.startsWith("#/")) return "alias";
+    if (path.startsWith("/")) return "alias";
+    return "module";
+}
+function getImportTypePriority(type) {
+    switch(type){
+        case "module":
+            return 0;
+        case "alias":
+            return 1;
+        case "relative":
+            return 2;
+    }
+}
+function defaultSortImportStatement(a, b) {
+    const aType = getImportType(a.path);
+    const bType = getImportType(b.path);
+    const aPriority = getImportTypePriority(aType);
+    const bPriority = getImportTypePriority(bType);
+    if (aPriority !== bPriority) return aPriority - bPriority;
+    return a.path.localeCompare(b.path);
+}
+function defaultSortImportContent(a, b) {
+    if ("type" === a.type && "type" !== b.type) return -1;
+    if ("type" !== a.type && "type" === b.type) return 1;
+    const aName = a.alias ?? a.name;
+    const bName = b.alias ?? b.name;
+    return aName.localeCompare(bName);
+}
+const DEFAULT_CONFIG = {
+    getGroup: defaultGetGroup,
+    sortGroup: defaultSortGroup,
+    sortImportStatement: defaultSortImportStatement,
+    sortImportContent: defaultSortImportContent,
+    sortSideEffect: false
+};
+function mergeConfig(userConfig) {
+    return {
+        getGroup: userConfig.getGroup ?? DEFAULT_CONFIG.getGroup,
+        sortGroup: userConfig.sortGroup ?? DEFAULT_CONFIG.sortGroup,
+        sortImportStatement: userConfig.sortImportStatement ?? DEFAULT_CONFIG.sortImportStatement,
+        sortImportContent: userConfig.sortImportContent ?? DEFAULT_CONFIG.sortImportContent,
+        separator: userConfig.separator,
+        sortSideEffect: userConfig.sortSideEffect ?? DEFAULT_CONFIG.sortSideEffect,
+        removeUnusedImports: userConfig.removeUnusedImports ?? false
+    };
+}
+function sortImports(imports, userConfig) {
+    const config = mergeConfig(userConfig);
+    if (!config.sortSideEffect) return sortImportsWithSideEffectSeparators(imports, config);
+    const groups = groupImports(imports, config);
+    const sortedGroups = sortGroups(groups, config);
+    const result = [];
+    for (const group of sortedGroups){
+        const sortedStatements = sortImportStatements(group.importStatements, config);
+        for (const statement of sortedStatements){
+            const sortedContents = sortImportContents(statement.importContents, config);
+            result.push({
+                ...statement,
+                importContents: sortedContents
+            });
+        }
+    }
+    return result;
+}
+function sortImportsWithSideEffectSeparators(imports, config) {
+    const result = [];
+    const chunks = [];
+    let currentChunk = [];
+    for (const statement of imports)if (statement.isSideEffect) {
+        if (currentChunk.length > 0) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+        }
+        chunks.push([
+            statement
+        ]);
+    } else currentChunk.push(statement);
+    if (currentChunk.length > 0) chunks.push(currentChunk);
+    for (const chunk of chunks){
+        if (1 === chunk.length && chunk[0].isSideEffect) {
+            result.push(chunk[0]);
+            continue;
+        }
+        const groups = groupImports(chunk, config);
+        const sortedGroups = sortGroups(groups, config);
+        for (const group of sortedGroups){
+            const sortedStatements = sortImportStatements(group.importStatements, config);
+            for (const statement of sortedStatements){
+                const sortedContents = sortImportContents(statement.importContents, config);
+                result.push({
+                    ...statement,
+                    importContents: sortedContents
+                });
+            }
+        }
+    }
+    return result;
+}
+function groupImports(imports, userConfig) {
+    const config = mergeConfig(userConfig);
+    const groupMap = new Map();
+    for (const statement of imports){
+        const groupName = config.getGroup(statement);
+        const statements = groupMap.get(groupName) ?? [];
+        statements.push(statement);
+        groupMap.set(groupName, statements);
+    }
+    const groups = [];
+    for (const [name, statements] of Array.from(groupMap.entries())){
+        const isSideEffect = statements.every((s)=>s.isSideEffect);
+        groups.push({
+            name,
+            isSideEffect,
+            importStatements: statements
+        });
+    }
+    return groups;
+}
+function sortGroups(groups, userConfig) {
+    const config = mergeConfig(userConfig);
+    return [
+        ...groups
+    ].sort(config.sortGroup);
+}
+function sortImportStatements(statements, userConfig) {
+    const config = mergeConfig(userConfig);
+    return [
+        ...statements
+    ].sort(config.sortImportStatement);
+}
+function sortImportContents(contents, userConfig) {
+    const config = mergeConfig(userConfig);
+    if (userConfig.sortImportContent) return [
+        ...contents
+    ].sort(config.sortImportContent);
+    const defaultImport = contents.filter((c)=>"default" === c.name);
+    const namespaceImport = contents.filter((c)=>"*" === c.name);
+    const namedImports = contents.filter((c)=>"default" !== c.name && "*" !== c.name);
+    return [
+        ...defaultImport,
+        ...namespaceImport,
+        ...namedImports.sort(config.sortImportContent)
+    ];
+}
+function mergeImports(imports) {
+    const mergedMap = new Map();
+    for (const statement of imports){
+        if (statement.isSideEffect) {
+            const key = `${statement.path}|||${statement.isExport}|||sideEffect|||${statement.start}`;
+            mergedMap.set(key, statement);
+            continue;
+        }
+        const hasNamespaceImport = statement.importContents.some((c)=>"*" === c.name);
+        if (hasNamespaceImport) {
+            const key = `${statement.path}|||${statement.isExport}|||namespace|||${statement.start}`;
+            mergedMap.set(key, statement);
+            continue;
+        }
+        const key = `${statement.path}|||${statement.isExport}`;
+        const existing = mergedMap.get(key);
+        if (existing) {
+            const mergedContents = [
+                ...existing.importContents
+            ];
+            for (const content of statement.importContents){
+                const existingContent = mergedContents.find((c)=>c.name === content.name && c.alias === content.alias);
+                if (existingContent) {
+                    if (content.leadingComments) existingContent.leadingComments = [
+                        ...existingContent.leadingComments ?? [],
+                        ...content.leadingComments
+                    ];
+                    if (content.trailingComments) existingContent.trailingComments = [
+                        ...existingContent.trailingComments ?? [],
+                        ...content.trailingComments
+                    ];
+                } else mergedContents.push(content);
+            }
+            const mergedLeadingComments = [
+                ...existing.leadingComments ?? [],
+                ...statement.leadingComments ?? []
+            ];
+            const mergedTrailingComments = existing.trailingComments ?? [];
+            const removedTrailingComments = [
+                ...existing.removedTrailingComments ?? [],
+                ...statement.trailingComments ?? []
+            ];
+            mergedMap.set(key, {
+                ...existing,
+                importContents: mergedContents,
+                leadingComments: mergedLeadingComments.length > 0 ? mergedLeadingComments : void 0,
+                trailingComments: mergedTrailingComments.length > 0 ? mergedTrailingComments : void 0,
+                removedTrailingComments: removedTrailingComments.length > 0 ? removedTrailingComments : void 0
+            });
+        } else mergedMap.set(key, {
+            ...statement
+        });
+    }
+    return Array.from(mergedMap.values());
+}
+const src_require = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+let src_userConfig = {};
+function preprocessImports(text, options) {
+    try {
+        const imports = parseImports(text);
+        if (0 === imports.length) return text;
+        const config = {
+            getGroup: src_userConfig.getGroup ?? options.getGroup,
+            sortGroup: src_userConfig.sortGroup ?? options.sortGroup,
+            sortImportStatement: src_userConfig.sortImportStatement ?? options.sortImportStatement,
+            sortImportContent: src_userConfig.sortImportContent ?? options.sortImportContent,
+            separator: src_userConfig.separator ?? options.importSortSeparator ?? options.separator,
+            sortSideEffect: src_userConfig.sortSideEffect ?? options.importSortSideEffect ?? false,
+            removeUnusedImports: src_userConfig.removeUnusedImports ?? options.importSortRemoveUnused ?? false
+        };
+        let processedImports = imports;
+        if (config.removeUnusedImports) {
+            const lastImport = imports[imports.length - 1];
+            const codeAfterImports = text.slice(lastImport.end ?? 0);
+            processedImports = removeUnusedImportsFromStatements(imports, codeAfterImports);
+        }
+        const sortedImports = sortImports(processedImports, config);
+        const mergedImports = mergeImports(sortedImports);
+        let formattedImports;
+        if (config.getGroup) {
+            const groups = groupImports(mergedImports, config);
+            const sortedGroups = sortGroups(groups, config);
+            formattedImports = formatGroups(sortedGroups, config);
+        } else formattedImports = formatImportStatements(mergedImports);
+        const firstImport = imports[0];
+        const lastImport = imports[imports.length - 1];
+        const startIndex = firstImport.start ?? 0;
+        const endIndex = lastImport.end ?? text.length;
+        const beforeImports = text.slice(0, startIndex);
+        const afterImports = text.slice(endIndex);
+        const needsExtraNewline = afterImports && !afterImports.startsWith("\n");
+        const separator = needsExtraNewline ? "\n\n" : "\n";
+        return beforeImports + formattedImports + separator + afterImports;
+    } catch (error) {
+        console.error("Failed to sort imports:", error);
+        return text;
+    }
+}
+const babelParser = src_require("prettier/parser-babel").parsers.babel;
+const typescriptParser = src_require("prettier/parser-typescript").parsers.typescript;
+const babelTsParser = src_require("prettier/parser-babel").parsers["babel-ts"];
+function createPluginInstance() {
+    return {
+        parsers: {
+            babel: {
+                ...babelParser,
+                preprocess: preprocessImports
+            },
+            typescript: {
+                ...typescriptParser,
+                preprocess: preprocessImports
+            },
+            "babel-ts": {
+                ...babelTsParser,
+                preprocess: preprocessImports
+            }
+        },
+        options: {
+            importSortSeparator: {
+                type: "string",
+                category: "Import Sort",
+                description: "分组之间的分隔符"
+            },
+            importSortSideEffect: {
+                type: "boolean",
+                category: "Import Sort",
+                description: "是否对副作用导入进行排序",
+                default: false
+            },
+            importSortRemoveUnused: {
+                type: "boolean",
+                category: "Import Sort",
+                description: "是否删除未使用的导入",
+                default: false
+            }
+        }
+    };
+}
+const src_plugin = createPluginInstance();
+function createPlugin(config = {}) {
+    src_userConfig = config;
+    return createPluginInstance();
+}
+const src = src_plugin;
+exports.createPlugin = __webpack_exports__.createPlugin;
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createPlugin",
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@1adybug/prettier-plugin-sort-imports",
     "type": "module",
-    "version": "0.0.2",
+    "version": "0.0.3",
     "description": "一个 Prettier 插件，用于对 JavaScript/TypeScript 文件的导入语句进行分组和排序",
     "keywords": [
         "prettier",
@@ -30,9 +30,12 @@
     "exports": {
         ".": {
             "types": "./dist/index.d.ts",
-            "import": "./dist/index.js"
+            "import": "./dist/index.js",
+            "require": "./dist/index.cjs"
         }
     },
+    "main": "./dist/index.cjs",
+    "module": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "files": [
         "dist"