susee 0.1.1 → 0.1.2

package/dist/index.mjs

@@ -6,95 +6,29 @@ this file except in compliance with the License. You may obtain a copy of the
 License at http://www.apache.org/licenses/LICENSE-2.0
 ***************************************************************************** */
 import TsConfig from "@suseejs/tsconfig";
-import anonymous from "@suseejs/anonymous";
 import dependencies from "@suseejs/dependencies";
-import duplicateHandlers from "@suseejs/duplicates";
 import fs from "node:fs";
 import path from "node:path";
 import resolves from "@phothinmaung/resolves";
 import tcolor from "@suseejs/tcolor";
 import transformFunction from "@suseejs/transformer";
 import ts from "typescript";
-import utils from "@suseejs/utils";
-function removeExportExpressionHandler(compilerOptions) {
-    return ({ file, content }) => {
-        const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+import utilities from "@suseejs/utils";
+import { Buffer } from "node:buffer";
+const bundleCreator = (bundleVisitor, compilerOptions, ...args) => {
+    return (depsTree) => {
+        const sourceFile = ts.createSourceFile(depsTree.file, depsTree.content, ts.ScriptTarget.Latest, true);
         const transformer = (context) => {
-            const { factory } = context;
-            const visitor = (node) => {
-                if (ts.isFunctionDeclaration(node) ||
-                    ts.isClassDeclaration(node) ||
-                    ts.isInterfaceDeclaration(node) ||
-                    ts.isTypeAliasDeclaration(node) ||
-                    ts.isEnumDeclaration(node) ||
-                    ts.isVariableStatement(node)) {
-                    const modifiers = node.modifiers?.filter((m) => m.kind !== ts.SyntaxKind.ExportKeyword &&
-                        m.kind !== ts.SyntaxKind.DefaultKeyword);
-                    if (modifiers?.length !== node.modifiers?.length) {
-                        if (ts.isFunctionDeclaration(node)) {
-                            return factory.updateFunctionDeclaration(node, modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body);
-                        }
-                        if (ts.isClassDeclaration(node)) {
-                            return factory.updateClassDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
-                        }
-                        if (ts.isInterfaceDeclaration(node)) {
-                            return factory.updateInterfaceDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
-                        }
-                        if (ts.isTypeAliasDeclaration(node)) {
-                            return factory.updateTypeAliasDeclaration(node, modifiers, node.name, node.typeParameters, node.type);
-                        }
-                        if (ts.isEnumDeclaration(node)) {
-                            return factory.updateEnumDeclaration(node, modifiers, node.name, node.members);
-                        }
-                        if (ts.isVariableStatement(node)) {
-                            return factory.updateVariableStatement(node, modifiers, node.declarationList);
-                        }
-                    }
-                }
-                if (ts.isExportDeclaration(node)) {
-                    return factory.createEmptyStatement();
-                }
-                if (ts.isExportAssignment(node)) {
-                    const expr = node.expression;
-                    if (ts.isIdentifier(expr)) {
-                        return factory.createEmptyStatement();
-                    }
-                }
-                return ts.visitEachChild(node, visitor, context);
-            };
-            return (rootNode) => ts.visitNode(rootNode, visitor);
-        };
-        let _content = transformFunction(transformer, sourceFile, compilerOptions);
-        _content = _content.replace(/^s*;\s*$/gm, "").trim();
-        return { file, content: _content };
-    };
-}
-function removeImportExpressionHandler(removedStatements, compilerOptions) {
-    return ({ file, content }) => {
-        const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
-        const transformer = (context) => {
-            const { factory } = context;
-            const visitor = (node) => {
-                if (ts.isImportDeclaration(node)) {
-                    const text = node.getText(sourceFile);
-                    removedStatements.push(text);
-                    return factory.createEmptyStatement();
-                }
-                if (ts.isImportEqualsDeclaration(node)) {
-                    const text = node.getText(sourceFile);
-                    removedStatements.push(text);
-                    return factory.createEmptyStatement();
-                }
-                return ts.visitEachChild(node, visitor, context);
-            };
+            const visitor = bundleVisitor(context, depsTree, sourceFile, ...args);
             return (rootNode) => ts.visitNode(rootNode, visitor);
         };
         let _content = transformFunction(transformer, sourceFile, compilerOptions);
         _content = _content.replace(/^s*;\s*$/gm, "").trim();
-        return { file, content: _content };
+        const { content, ...rest } = depsTree;
+        return { content: _content, ...rest };
     };
-}
-function mergeImports(imports) {
+};
+function mergeImportsStatement(imports) {
     const importMap = new Map();
     const typeImportMap = new Map();
     const defaultImports = new Map();
@@ -192,8 +126,714 @@ function mergeImports(imports) {
     }
     return mergedImports.sort();
 }
-async function bundler({ depsFiles, compilerOptions, renameDuplicates, }) {
-    const reName = renameDuplicates ?? true;
+const anonymousCallExpressionVisitor = (context, depsTree, _sourceFile, exportDefaultImportNameMap) => {
+    const { factory } = context;
+    const visit = (node) => {
+        if (ts.isCallExpression(node)) {
+            if (ts.isIdentifier(node.expression)) {
+                const base = node.expression.text;
+                const mapping = exportDefaultImportNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                if (mapping) {
+                    return factory.updateCallExpression(node, factory.createIdentifier(mapping.newName), node.typeArguments, node.arguments);
+                }
+            }
+        }
+        else if (ts.isPropertyAccessExpression(node)) {
+            if (ts.isIdentifier(node.expression)) {
+                const base = node.expression.text;
+                const mapping = exportDefaultImportNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                if (mapping) {
+                    return factory.updatePropertyAccessExpression(node, factory.createIdentifier(mapping.newName), node.name);
+                }
+            }
+        }
+        else if (ts.isNewExpression(node)) {
+            if (ts.isIdentifier(node.expression)) {
+                const base = node.expression.text;
+                const mapping = exportDefaultImportNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                if (mapping) {
+                    return factory.updateNewExpression(node, factory.createIdentifier(mapping.newName), node.typeArguments, node.arguments);
+                }
+            }
+        }
+        else if (ts.isExportSpecifier(node)) {
+            if (ts.isIdentifier(node.name)) {
+                const base = node.name.text;
+                const mapping = exportDefaultImportNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                if (mapping) {
+                    return factory.updateExportSpecifier(node, node.isTypeOnly, node.propertyName, factory.createIdentifier(mapping.newName));
+                }
+            }
+        }
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+const normalizePathKey = (filePath) => {
+    const parsed = path.parse(filePath);
+    let noExt = path.join(parsed.dir, parsed.name);
+    if (parsed.name === "index") {
+        noExt = parsed.dir;
+    }
+    return path.normalize(noExt);
+};
+const getFileKey = (filePath) => normalizePathKey(filePath);
+const getModuleKeyFromSpecifier = (moduleSpecifier, sourceFile, containingFile) => {
+    let spec = "";
+    if (ts.isStringLiteral(moduleSpecifier)) {
+        spec = moduleSpecifier.text;
+    }
+    else {
+        spec = moduleSpecifier.getText(sourceFile).replace(/^['"]|['"]$/g, "");
+    }
+    if (spec.startsWith(".") || spec.startsWith("/")) {
+        const baseDir = path.dirname(containingFile);
+        return normalizePathKey(path.resolve(baseDir, spec));
+    }
+    return spec;
+};
+function uniqueName() {
+    const storedPrefix = new Map();
+    const obj = {
+        setPrefix({ key, value }) {
+            const names = [];
+            let _fix;
+            if (storedPrefix.has(key)) {
+                console.warn(`${key} already exist`);
+                throw new Error();
+            }
+            else {
+                _fix = value;
+                storedPrefix.set(key, value);
+            }
+            function getName(input) {
+                const length = names.length;
+                const _name = _fix
+                    ? `${_fix}${input}_${length + 1}`
+                    : `$nyein${input}_${length + 1}`;
+                names.push(_name);
+                return _name;
+            }
+            return { getName };
+        },
+        getPrefix(key) {
+            if (storedPrefix.has(key)) {
+                return storedPrefix.get(key);
+            }
+        },
+    };
+    return obj;
+}
+const prefixKey = "AnonymousName";
+const genName = uniqueName().setPrefix({ key: prefixKey, value: "a_" });
+const anonymousExportVisitor = (context, depsTree, sourceFile, exportDefaultExportNameMap) => {
+    const { factory } = context;
+    const visit = (node) => {
+        const fileName = path.basename(depsTree.file).split(".")[0];
+        if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) &&
+            node.name === undefined) {
+            let exp = false;
+            let def = false;
+            node.modifiers?.forEach((mod) => {
+                if (mod.kind === ts.SyntaxKind.ExportKeyword) {
+                    exp = true;
+                }
+                if (mod.kind === ts.SyntaxKind.DefaultKeyword) {
+                    def = true;
+                }
+            });
+            if (exp && def) {
+                const base = genName.getName(fileName);
+                exportDefaultExportNameMap.push({
+                    base,
+                    file: fileName,
+                    newName: base,
+                    isEd: true,
+                });
+                if (ts.isFunctionDeclaration(node)) {
+                    return factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, factory.createIdentifier(base), node.typeParameters, node.parameters, node.type, node.body);
+                }
+                else if (ts.isClassDeclaration(node)) {
+                    return factory.updateClassDeclaration(node, node.modifiers, factory.createIdentifier(base), node.typeParameters, node.heritageClauses, node.members);
+                }
+            }
+        }
+        else if (ts.isExportAssignment(node) &&
+            !node.name &&
+            !node.isExportEquals) {
+            if (ts.isArrowFunction(node.expression)) {
+                const base = genName.getName(fileName);
+                const arrowFunctionNode = factory.createArrowFunction(node.expression.modifiers, node.expression.typeParameters, node.expression.parameters, node.expression.type, node.expression.equalsGreaterThanToken, node.expression.body);
+                const variableDeclarationNode = factory.createVariableDeclaration(factory.createIdentifier(base), node.expression.exclamationToken, node.expression.type, arrowFunctionNode);
+                const variableDeclarationListNode = factory.createVariableDeclarationList([variableDeclarationNode], ts.NodeFlags.Const);
+                const variableStatementNode = factory.createVariableStatement(node.expression.modifiers, variableDeclarationListNode);
+                const exportAssignmentNode = factory.createExportAssignment(undefined, undefined, factory.createIdentifier(base));
+                exportDefaultExportNameMap.push({
+                    base,
+                    file: fileName,
+                    newName: base,
+                    isEd: true,
+                });
+                return factory.updateSourceFile(sourceFile, [variableStatementNode, exportAssignmentNode], sourceFile.isDeclarationFile, sourceFile.referencedFiles, sourceFile.typeReferenceDirectives, sourceFile.hasNoDefaultLib, sourceFile.libReferenceDirectives);
+            }
+            else if (ts.isObjectLiteralExpression(node.expression)) {
+                const base = genName.getName(fileName);
+                const variableDeclarationNode = factory.createVariableDeclaration(factory.createIdentifier(base), undefined, undefined, node.expression);
+                const variableDeclarationListNode = factory.createVariableDeclarationList([variableDeclarationNode], ts.NodeFlags.Const);
+                const variableStatementNode = factory.createVariableStatement(undefined, variableDeclarationListNode);
+                const exportAssignmentNode = factory.createExportAssignment(undefined, undefined, factory.createIdentifier(base));
+                exportDefaultExportNameMap.push({
+                    base,
+                    file: fileName,
+                    newName: base,
+                    isEd: true,
+                });
+                return factory.updateSourceFile(sourceFile, [variableStatementNode, exportAssignmentNode], sourceFile.isDeclarationFile, sourceFile.referencedFiles, sourceFile.typeReferenceDirectives, sourceFile.hasNoDefaultLib, sourceFile.libReferenceDirectives);
+            }
+            else if (ts.isArrayLiteralExpression(node.expression)) {
+                const base = genName.getName(fileName);
+                const arrayLiteralExpressionNode = factory.createArrayLiteralExpression(node.expression.elements, true);
+                const variableDeclarationNode = factory.createVariableDeclaration(factory.createIdentifier(base), undefined, undefined, arrayLiteralExpressionNode);
+                const variableDeclarationListNode = factory.createVariableDeclarationList([variableDeclarationNode], ts.NodeFlags.Const);
+                const variableStatementNode = factory.createVariableStatement(undefined, variableDeclarationListNode);
+                const exportAssignmentNode = factory.createExportAssignment(undefined, undefined, factory.createIdentifier(base));
+                exportDefaultExportNameMap.push({
+                    base,
+                    file: fileName,
+                    newName: base,
+                    isEd: true,
+                });
+                return factory.updateSourceFile(sourceFile, [variableStatementNode, exportAssignmentNode], sourceFile.isDeclarationFile, sourceFile.referencedFiles, sourceFile.typeReferenceDirectives, sourceFile.hasNoDefaultLib, sourceFile.libReferenceDirectives);
+            }
+            else if (ts.isStringLiteral(node.expression)) {
+                const base = genName.getName(fileName);
+                const stringLiteralNode = factory.createStringLiteral(node.expression.text);
+                const variableDeclarationNode = factory.createVariableDeclaration(factory.createIdentifier(base), undefined, undefined, stringLiteralNode);
+                const variableDeclarationListNode = factory.createVariableDeclarationList([variableDeclarationNode], ts.NodeFlags.Const);
+                const variableStatementNode = factory.createVariableStatement(undefined, variableDeclarationListNode);
+                const exportAssignmentNode = factory.createExportAssignment(undefined, undefined, factory.createIdentifier(base));
+                exportDefaultExportNameMap.push({
+                    base,
+                    file: fileName,
+                    newName: base,
+                    isEd: true,
+                });
+                return factory.updateSourceFile(sourceFile, [variableStatementNode, exportAssignmentNode], sourceFile.isDeclarationFile, sourceFile.referencedFiles, sourceFile.typeReferenceDirectives, sourceFile.hasNoDefaultLib, sourceFile.libReferenceDirectives);
+            }
+            else if (ts.isNumericLiteral(node.expression)) {
+                const base = genName.getName(fileName);
+                const numericLiteralNode = factory.createNumericLiteral(node.expression.text);
+                const variableDeclarationNode = factory.createVariableDeclaration(factory.createIdentifier(base), undefined, undefined, numericLiteralNode);
+                const variableDeclarationListNode = factory.createVariableDeclarationList([variableDeclarationNode], ts.NodeFlags.Const);
+                const variableStatementNode = factory.createVariableStatement(undefined, variableDeclarationListNode);
+                const exportAssignmentNode = factory.createExportAssignment(undefined, undefined, factory.createIdentifier(base));
+                exportDefaultExportNameMap.push({
+                    base,
+                    file: fileName,
+                    newName: base,
+                    isEd: true,
+                });
+                return factory.updateSourceFile(sourceFile, [variableStatementNode, exportAssignmentNode], sourceFile.isDeclarationFile, sourceFile.referencedFiles, sourceFile.typeReferenceDirectives, sourceFile.hasNoDefaultLib, sourceFile.libReferenceDirectives);
+            }
+        }
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+const anonymousImportVisitor = (context, depsTree, sourceFile, exportDefaultExportNameMap, exportDefaultImportNameMap) => {
+    const { factory } = context;
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node)) {
+            const fileName = node.moduleSpecifier.getText(sourceFile);
+            const _name = path.basename(fileName).split(".")[0].trim();
+            if (node.importClause?.name && ts.isIdentifier(node.importClause.name)) {
+                const base = node.importClause.name.text.trim();
+                const mapping = exportDefaultExportNameMap.find((v) => v.file === _name);
+                if (mapping) {
+                    exportDefaultImportNameMap.push({
+                        base,
+                        file: depsTree.file,
+                        newName: mapping.newName,
+                        isEd: true,
+                    });
+                    const newImportClause = factory.updateImportClause(node.importClause, node.importClause.phaseModifier, factory.createIdentifier(mapping.newName), node.importClause.namedBindings);
+                    return factory.updateImportDeclaration(node, node.modifiers, newImportClause, node.moduleSpecifier, node.attributes);
+                }
+            }
+        }
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+const duplicateCallExpressionVisitor = (context, depsTree, _sourceFile, callNameMap, importNameMap) => {
+    const { factory } = context;
+    const visit = (node) => {
+        if (ts.isCallExpression(node)) {
+            if (ts.isIdentifier(node.expression)) {
+                const base = node.expression.text;
+                let new_name = null;
+                const mapping = callNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                const importMapping = importNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                if (mapping) {
+                    new_name = mapping.newName;
+                }
+                else if (importMapping) {
+                    new_name = importMapping.newName;
+                }
+                if (new_name) {
+                    return factory.updateCallExpression(node, factory.createIdentifier(new_name), node.typeArguments, node.arguments);
+                }
+            }
+        }
+        else if (ts.isPropertyAccessExpression(node)) {
+            if (ts.isIdentifier(node.expression)) {
+                const base = node.expression.text;
+                let new_name = null;
+                const mapping = callNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                const importMapping = importNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                if (mapping) {
+                    new_name = mapping.newName;
+                }
+                else if (importMapping) {
+                    new_name = importMapping.newName;
+                }
+                if (new_name) {
+                    return factory.updatePropertyAccessExpression(node, factory.createIdentifier(new_name), node.name);
+                }
+            }
+        }
+        else if (ts.isNewExpression(node)) {
+            if (ts.isIdentifier(node.expression)) {
+                const base = node.expression.text;
+                let new_name = null;
+                const mapping = callNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                const importMapping = importNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                if (mapping) {
+                    new_name = mapping.newName;
+                }
+                else if (importMapping) {
+                    new_name = importMapping.newName;
+                }
+                if (new_name) {
+                    return factory.updateNewExpression(node, factory.createIdentifier(new_name), node.typeArguments, node.arguments);
+                }
+            }
+        }
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+const duplicateCollectionVisitor = (context, depsTree, _sourceFile, namesMap) => {
+    const visit = (node, isGlobalScope = true) => {
+        if (isGlobalScope) {
+            if (ts.isVariableStatement(node)) {
+                node.declarationList.declarations.forEach((decl) => {
+                    if (ts.isIdentifier(decl.name)) {
+                        const $name = decl.name.text;
+                        if (!namesMap.has($name)) {
+                            namesMap.set($name, new Set([{ file: depsTree.file }]));
+                        }
+                        else {
+                            namesMap.get($name).add({ file: depsTree.file });
+                        }
+                    }
+                });
+            }
+            else if (ts.isFunctionDeclaration(node) ||
+                ts.isClassDeclaration(node) ||
+                ts.isEnumDeclaration(node) ||
+                ts.isInterfaceDeclaration(node) ||
+                ts.isTypeAliasDeclaration(node)) {
+                const $name = node.name?.text;
+                if ($name) {
+                    if (!namesMap.has($name)) {
+                        namesMap.set($name, new Set([{ file: depsTree.file }]));
+                    }
+                    else {
+                        namesMap.get($name).add({ file: depsTree.file });
+                    }
+                }
+            }
+        }
+        if (ts.isBlock(node) ||
+            ts.isFunctionDeclaration(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isArrowFunction(node) ||
+            ts.isMethodDeclaration(node) ||
+            ts.isClassDeclaration(node)) {
+            if (ts.isBlock(node)) {
+                ts.visitNodes(node.statements, (child) => visit(child, false));
+            }
+            else {
+                ts.forEachChild(node, (child) => {
+                    visit(child, false);
+                });
+            }
+        }
+        else {
+            return ts.visitEachChild(node, (child) => visit(child, isGlobalScope), context);
+        }
+        return node;
+    };
+    return visit;
+};
+const duplicateExportExpressionVisitor = (context, depsTree, _sourceFile, callNameMap, importNameMap, exportNameMap) => {
+    const { factory } = context;
+    const visit = (node) => {
+        if (ts.isExportSpecifier(node)) {
+            if (ts.isIdentifier(node.name)) {
+                const base = node.name.text;
+                let new_name = null;
+                const mapping = callNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                const importMapping = importNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                if (mapping) {
+                    exportNameMap.push({
+                        base,
+                        file: getFileKey(depsTree.file),
+                        newName: mapping.newName,
+                    });
+                    new_name = mapping.newName;
+                }
+                else if (importMapping) {
+                    new_name = importMapping.newName;
+                }
+                if (new_name) {
+                    return factory.updateExportSpecifier(node, node.isTypeOnly, node.propertyName, factory.createIdentifier(new_name));
+                }
+            }
+        }
+        else if (ts.isExportAssignment(node)) {
+            const expr = node.expression;
+            if (ts.isIdentifier(expr)) {
+                const base = expr.text;
+                let new_name = null;
+                const mapping = callNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                const importMapping = importNameMap.find((m) => m.base === base && m.file === depsTree.file);
+                if (mapping) {
+                    exportNameMap.push({
+                        base,
+                        file: getFileKey(depsTree.file),
+                        newName: mapping.newName,
+                    });
+                    new_name = mapping.newName;
+                }
+                else if (importMapping) {
+                    new_name = importMapping.newName;
+                }
+                if (new_name) {
+                    return factory.updateExportAssignment(node, node.modifiers, factory.createIdentifier(new_name));
+                }
+            }
+        }
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+const duplicateImportExpressionVisitor = (context, depsTree, sourceFile, exportNameMap, importNameMap) => {
+    const { factory } = context;
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node)) {
+            const moduleKey = getModuleKeyFromSpecifier(node.moduleSpecifier, sourceFile, depsTree.file);
+            let baseNames = [];
+            if (node.importClause?.namedBindings &&
+                ts.isNamedImports(node.importClause.namedBindings)) {
+                baseNames = node.importClause.namedBindings.elements.map((el) => el.name.text.trim());
+            }
+            if (node.importClause?.name && ts.isIdentifier(node.importClause.name)) {
+                const base = node.importClause.name.text.trim();
+                const mapping = exportNameMap.find((m) => m.base === base && m.file === moduleKey);
+                if (mapping) {
+                    importNameMap.push({
+                        base: mapping.base,
+                        file: depsTree.file,
+                        newName: mapping.newName,
+                    });
+                    const newImportClause = factory.updateImportClause(node.importClause, node.importClause.phaseModifier, factory.createIdentifier(mapping.newName), node.importClause.namedBindings);
+                    return factory.updateImportDeclaration(node, node.modifiers, newImportClause, node.moduleSpecifier, node.attributes);
+                }
+            }
+            if (baseNames.length > 0 &&
+                node.importClause &&
+                node.importClause.namedBindings &&
+                ts.isNamedImports(node.importClause.namedBindings)) {
+                const updatedElements = node.importClause.namedBindings.elements.map((el) => {
+                    const mapping = exportNameMap.find((m) => m.base === el.name.text.trim() && m.file === moduleKey);
+                    if (mapping) {
+                        importNameMap.push({
+                            base: mapping.base,
+                            file: depsTree.file,
+                            newName: mapping.newName,
+                        });
+                        return factory.updateImportSpecifier(el, el.isTypeOnly, el.propertyName, factory.createIdentifier(mapping.newName));
+                    }
+                    return el;
+                });
+                const newNamedImports = factory.updateNamedImports(node.importClause.namedBindings, updatedElements);
+                const newImportClause = factory.updateImportClause(node.importClause, node.importClause.phaseModifier, node.importClause.name, newNamedImports);
+                return factory.updateImportDeclaration(node, node.modifiers, newImportClause, node.moduleSpecifier, node.attributes);
+            }
+        }
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+const dupName = uniqueName().setPrefix({
+    key: "DuplicatesNames",
+    value: "d_",
+});
+const duplicateUpdateVisitor = (context, depsTree, _sourceFile, namesMap, callNameMap) => {
+    const { factory } = context;
+    const visit = (node) => {
+        if (ts.isVariableStatement(node)) {
+            const newDeclarations = node.declarationList.declarations.map((decl) => {
+                if (ts.isIdentifier(decl.name)) {
+                    const base = decl.name.text;
+                    if (namesMap.has(base) && namesMap.get(base).size > 1) {
+                        const newName = dupName.getName(base);
+                        callNameMap.push({ base, file: depsTree.file, newName });
+                        return factory.updateVariableDeclaration(decl, factory.createIdentifier(newName), decl.exclamationToken, decl.type, decl.initializer);
+                    }
+                }
+                return decl;
+            });
+            const newDeclList = factory.updateVariableDeclarationList(node.declarationList, newDeclarations);
+            return factory.updateVariableStatement(node, node.modifiers, newDeclList);
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                const base = node.name.text;
+                if (namesMap.has(base) && namesMap.get(base).size > 1) {
+                    const newName = dupName.getName(base);
+                    callNameMap.push({ base, file: depsTree.file, newName });
+                    return factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, factory.createIdentifier(newName), node.typeParameters, node.parameters, node.type, node.body);
+                }
+            }
+        }
+        else if (ts.isClassDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                const base = node.name.text;
+                if (namesMap.has(base) && namesMap.get(base).size > 1) {
+                    const newName = dupName.getName(base);
+                    callNameMap.push({ base, file: depsTree.file, newName });
+                    return factory.updateClassDeclaration(node, node.modifiers, factory.createIdentifier(newName), node.typeParameters, node.heritageClauses, node.members);
+                }
+            }
+        }
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+const removeExportsVisitor = (context) => {
+    const { factory } = context;
+    const visit = (node) => {
+        const inside_nameSpace = utilities.isInsideNamespace(node);
+        if (!inside_nameSpace) {
+            if (ts.isFunctionDeclaration(node) ||
+                ts.isClassDeclaration(node) ||
+                ts.isInterfaceDeclaration(node) ||
+                ts.isTypeAliasDeclaration(node) ||
+                ts.isEnumDeclaration(node) ||
+                ts.isVariableStatement(node)) {
+                const modifiers = node.modifiers?.filter((m) => m.kind !== ts.SyntaxKind.ExportKeyword &&
+                    m.kind !== ts.SyntaxKind.DefaultKeyword);
+                if (modifiers?.length !== node.modifiers?.length) {
+                    if (ts.isFunctionDeclaration(node)) {
+                        return factory.updateFunctionDeclaration(node, modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body);
+                    }
+                    if (ts.isClassDeclaration(node)) {
+                        return factory.updateClassDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
+                    }
+                    if (ts.isInterfaceDeclaration(node)) {
+                        return factory.updateInterfaceDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
+                    }
+                    if (ts.isTypeAliasDeclaration(node)) {
+                        return factory.updateTypeAliasDeclaration(node, modifiers, node.name, node.typeParameters, node.type);
+                    }
+                    if (ts.isEnumDeclaration(node)) {
+                        return factory.updateEnumDeclaration(node, modifiers, node.name, node.members);
+                    }
+                    if (ts.isVariableStatement(node)) {
+                        return factory.updateVariableStatement(node, modifiers, node.declarationList);
+                    }
+                }
+            }
+        }
+        if (ts.isExportDeclaration(node)) {
+            return factory.createEmptyStatement();
+        }
+        if (ts.isExportAssignment(node)) {
+            const expr = node.expression;
+            if (ts.isIdentifier(expr)) {
+                return factory.createEmptyStatement();
+            }
+        }
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+let properties = [];
+const typeObj = {};
+const typesNames = [];
+function findProperty(node) {
+    const properties = [];
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+        properties.push(node.expression.text);
+    }
+    node.forEachChild((n) => findProperty(n));
+    return properties;
+}
+const removeImportsVisitor = (context, depsTree, sourceFile, removedStatements) => {
+    const typeOnlyImportEquals = new Set();
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportEqualsDeclaration(stmt) && stmt.isTypeOnly) {
+            const moduleReference = stmt.moduleReference;
+            if (ts.isExternalModuleReference(moduleReference) &&
+                ts.isStringLiteral(moduleReference.expression)) {
+                typeOnlyImportEquals.add(stmt.name.text);
+            }
+        }
+    }
+    const { factory } = context;
+    const visit = (node) => {
+        properties = [...properties, ...findProperty(node)];
+        const obj = {
+            isNamespace: false,
+            isTypeOnly: false,
+            isTypeNamespace: false,
+            source: "",
+            importedString: undefined,
+            importedObject: undefined,
+        };
+        if (ts.isTypeReferenceNode(node) &&
+            ts.isQualifiedName(node.typeName) &&
+            ts.isIdentifier(node.typeName.left) &&
+            ts.isIdentifier(node.typeName.right)) {
+            const left = node.typeName.left.text;
+            const right = node.typeName.right.text;
+            typesNames.push(left);
+            if (left in typeObj) {
+                typeObj[left]?.push(right);
+            }
+            else {
+                typeObj[left] = [right];
+            }
+            if (utilities.checkModuleType(sourceFile, depsTree.file).isCommonJs) {
+                if (left !== "ts" && !typeOnlyImportEquals.has(left)) {
+                    return factory.updateTypeReferenceNode(node, factory.createIdentifier(right), undefined);
+                }
+            }
+        }
+        if (ts.isImportDeclaration(node)) {
+            const text = node.getText(sourceFile);
+            removedStatements.push(text);
+            return factory.createEmptyStatement();
+        }
+        if (ts.isImportEqualsDeclaration(node)) {
+            const name = node.name.text;
+            const moduleReference = node.moduleReference;
+            if (node.isTypeOnly) {
+                obj.isTypeOnly = true;
+            }
+            obj.importedString = name;
+            if (!obj.isTypeOnly) {
+                if (properties.includes(name)) {
+                    obj.isNamespace = true;
+                }
+            }
+            if (ts.isExternalModuleReference(moduleReference) &&
+                ts.isStringLiteral(moduleReference.expression)) {
+                obj.source = moduleReference.expression.text;
+            }
+            let t;
+            if (obj.importedString && !obj.importedObject) {
+                if (obj.isTypeOnly) {
+                    if (typeOnlyImportEquals.has(obj.importedString)) {
+                        t = `import type * as ${obj.importedString} from "${obj.source}";`;
+                    }
+                    else {
+                        if (typesNames.includes(obj.importedString)) {
+                            t = `import type { ${typeObj[obj.importedString]?.join(",")} } from "${obj.source}";`;
+                        }
+                        else {
+                            t = `import type ${obj.importedString} from "${obj.source}";`;
+                        }
+                    }
+                }
+                else {
+                    if (obj.isNamespace && obj.source && obj.source !== "typescript") {
+                        t = `import * as ${obj.importedString} from "${obj.source}";`;
+                    }
+                    else {
+                        t = `import ${obj.importedString} from "${obj.source}";`;
+                    }
+                }
+            }
+            if (!obj.importedString && obj.importedObject) {
+                t = `import { ${obj.importedObject.join(", ")} } from "${obj.source}";`;
+            }
+            if (t) {
+                removedStatements.push(t);
+                return factory.createEmptyStatement();
+            }
+        }
+        if (ts.isVariableStatement(node)) {
+            const decls = node.declarationList.declarations;
+            if (decls.length === 1) {
+                const decl = decls[0];
+                if (decl.initializer &&
+                    ts.isCallExpression(decl.initializer) &&
+                    ts.isIdentifier(decl.initializer.expression) &&
+                    decl.initializer.expression.escapedText === "require") {
+                    const arg = decl.initializer.arguments[0];
+                    if (ts.isStringLiteral(arg)) {
+                        obj.source = arg.text;
+                    }
+                    if (ts.isIdentifier(decl.name)) {
+                        const _n = decl.name.text;
+                        obj.importedString = _n;
+                        if (properties.includes(_n)) {
+                            obj.isNamespace = true;
+                        }
+                    }
+                    else if (ts.isObjectBindingPattern(decl.name)) {
+                        const _names = [];
+                        for (const ele of decl.name.elements) {
+                            if (ts.isIdentifier(ele.name)) {
+                                _names.push(ele.name.text);
+                            }
+                        }
+                        if (_names.length > 0) {
+                            obj.importedObject = _names;
+                        }
+                    }
+                    let tt;
+                    if (obj.importedString && !obj.importedObject) {
+                        if (obj.isNamespace) {
+                            tt = `import * as ${obj.importedString} from "${obj.source}";`;
+                        }
+                        else {
+                            tt = `import ${obj.importedString} from "${obj.source}";`;
+                        }
+                    }
+                    if (!obj.importedString && obj.importedObject) {
+                        tt = `import { ${obj.importedObject.join(", ")} } from "${obj.source}";`;
+                    }
+                    if (tt) {
+                        removedStatements.push(tt);
+                        return factory.createEmptyStatement();
+                    }
+                }
+            }
+        }
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+async function bundler(point) {
+    let depsFiles = point.depFiles;
+    const reName = point.rename;
+    const compilerOptions = point.tsOptions.default;
+    const plugins = point.plugins;
     const namesMap = new Map();
     const callNameMap = [];
     const importNameMap = [];
@@ -201,30 +841,136 @@ async function bundler({ depsFiles, compilerOptions, renameDuplicates, }) {
     const exportDefaultExportNameMap = [];
     const exportDefaultImportNameMap = [];
     let removedStatements = [];
-    if (reName) {
-        depsFiles = await duplicateHandlers.renamed(depsFiles, namesMap, callNameMap, importNameMap, exportNameMap, compilerOptions);
+    const duplicate = async (reName) => {
+        if (reName) {
+            const re_name = resolves([
+                [bundleCreator, duplicateCollectionVisitor, compilerOptions, namesMap],
+                [
+                    bundleCreator,
+                    duplicateUpdateVisitor,
+                    compilerOptions,
+                    namesMap,
+                    callNameMap,
+                ],
+                [
+                    bundleCreator,
+                    duplicateCallExpressionVisitor,
+                    compilerOptions,
+                    callNameMap,
+                    importNameMap,
+                ],
+                [
+                    bundleCreator,
+                    duplicateExportExpressionVisitor,
+                    compilerOptions,
+                    importNameMap,
+                    exportNameMap,
+                ],
+                [
+                    bundleCreator,
+                    duplicateImportExpressionVisitor,
+                    compilerOptions,
+                    exportNameMap,
+                    importNameMap,
+                ],
+                [
+                    bundleCreator,
+                    duplicateExportExpressionVisitor,
+                    compilerOptions,
+                    importNameMap,
+                    exportNameMap,
+                ],
+                [
+                    bundleCreator,
+                    duplicateExportExpressionVisitor,
+                    compilerOptions,
+                    importNameMap,
+                    exportNameMap,
+                ],
+            ]);
+            const re_name_call = await re_name.concurrent();
+            for (const call of re_name_call) {
+                await utilities.wait(500);
+                depsFiles = depsFiles.map(call);
+            }
+        }
+        else {
+            let _err = false;
+            const un_rename = resolves([
+                [bundleCreator, duplicateCollectionVisitor, compilerOptions, namesMap],
+            ]);
+            const un_rename_call = await un_rename.concurrent();
+            depsFiles.map(un_rename_call[0]);
+            await utilities.wait(1000);
+            namesMap.forEach((files, name) => {
+                if (files.size > 1) {
+                    _err = true;
+                    console.warn(`Name -> ${name} declared in multiple files :`);
+                    files.forEach((f) => console.warn(`  - ${f.file}`));
+                }
+            });
+            await utilities.wait(1000);
+            if (_err) {
+                process.exit(1);
+            }
+        }
+    };
+    if (plugins.length) {
+        for (let plugin of plugins) {
+            plugin = typeof plugin === "function" ? plugin() : plugin;
+            if (plugin.type === "dependency") {
+                if (plugin.async) {
+                    depsFiles = await plugin.func(depsFiles);
+                }
+                else {
+                    depsFiles = plugin.func(depsFiles);
+                }
+            }
+        }
     }
-    else {
-        depsFiles = await duplicateHandlers.notRenamed(depsFiles, namesMap, compilerOptions);
+    await utilities.wait(1000);
+    await duplicate(reName);
+    const anonymous = resolves([
+        [
+            bundleCreator,
+            anonymousExportVisitor,
+            compilerOptions,
+            exportDefaultExportNameMap,
+        ],
+        [
+            bundleCreator,
+            anonymousImportVisitor,
+            compilerOptions,
+            exportDefaultImportNameMap,
+            exportDefaultImportNameMap,
+        ],
+        [
+            bundleCreator,
+            anonymousCallExpressionVisitor,
+            compilerOptions,
+            exportDefaultImportNameMap,
+        ],
+    ]);
+    const anonymousCall = await anonymous.concurrent();
+    for (const call of anonymousCall) {
+        depsFiles = depsFiles.map(call);
     }
-    await utils.wait(1000);
-    depsFiles = await anonymous(depsFiles, exportDefaultExportNameMap, exportDefaultImportNameMap, compilerOptions);
-    await utils.wait(1000);
+    await utilities.wait(1000);
     const removeImports = resolves([
-        [removeImportExpressionHandler, removedStatements, compilerOptions],
+        [bundleCreator, removeImportsVisitor, compilerOptions, removedStatements],
     ]);
     const removeImport = await removeImports.concurrent();
     depsFiles = depsFiles.map(removeImport[0]);
-    await utils.wait(1000);
+    await utilities.wait(500);
     const removeExports = resolves([
-        [removeExportExpressionHandler, compilerOptions],
+        [bundleCreator, removeExportsVisitor, compilerOptions],
     ]);
     const removeExport = await removeExports.concurrent();
     const deps_files = depsFiles.slice(0, -1).map(removeExport[0]);
     const mainFile = depsFiles.slice(-1);
     const regexp = /["']((?!\.\/|\.\.\/)[^"']+)["']/;
     removedStatements = removedStatements.filter((i) => regexp.test(i));
-    removedStatements = mergeImports(removedStatements);
+    removedStatements = mergeImportsStatement(removedStatements);
     const importStatements = removedStatements.join("\n").trim();
     const depFilesContent = deps_files
         .map((i) => {
@@ -240,80 +986,35 @@ async function bundler({ depsFiles, compilerOptions, renameDuplicates, }) {
     })
         .join("\n")
         .trim();
-    await utils.wait(1000);
-    const content = `${importStatements}\n${depFilesContent}\n${mainFileContent}`;
-    return content;
-}
-function checkExports(file, str) {
-    const sourceFile = ts.createSourceFile(file, str, ts.ScriptTarget.Latest, true);
-    let nameExport = false;
-    let defExport = false;
-    const transformer = (context) => {
-        const visitor = (node) => {
-            if (ts.isExportAssignment(node) &&
-                !node.isExportEquals &&
-                node.modifiers === undefined &&
-                ts.isIdentifier(node.expression)) {
-                defExport = true;
-            }
-            else if (ts.isFunctionDeclaration(node) ||
-                ts.isClassDeclaration(node)) {
-                let exp = false;
-                let def = false;
-                node.modifiers?.forEach((mod) => {
-                    if (mod.kind === ts.SyntaxKind.ExportKeyword) {
-                        exp = true;
-                    }
-                    if (mod.kind === ts.SyntaxKind.DefaultKeyword) {
-                        def = true;
-                    }
-                });
-                if (exp && def)
-                    defExport = true;
-            }
-            else if (ts.isExportAssignment(node) &&
-                ts.isObjectLiteralExpression(node.expression)) {
-                const pros = node.expression.properties;
-                for (const pro of pros) {
-                    if (pro.name && ts.isIdentifier(pro.name)) {
-                        defExport = true;
-                    }
+    await utilities.wait(1000);
+    let content = `${importStatements}\n${depFilesContent}\n${mainFileContent}`;
+    if (plugins.length) {
+        for (let plugin of plugins) {
+            plugin = typeof plugin === "function" ? plugin() : plugin;
+            if (plugin.type === "pre-process") {
+                if (plugin.async) {
+                    content = await plugin.func(content);
+                }
+                else {
+                    content = plugin.func(content);
                 }
             }
-            else if (ts.isNamedExports(node)) {
-                nameExport = true;
-            }
-            else if (ts.isVariableStatement(node) ||
-                ts.isFunctionDeclaration(node) ||
-                ts.isInterfaceDeclaration(node) ||
-                ts.isTypeAliasDeclaration(node)) {
-                const isInsideNamespace = (n) => {
-                    let current = n.parent;
-                    while (current) {
-                        if (ts.isModuleDeclaration(current) &&
-                            current.flags === ts.NodeFlags.Namespace) {
-                            return true;
-                        }
-                        current = current.parent;
-                    }
-                    return false;
-                };
-                node?.modifiers?.forEach((mod) => {
-                    if (mod.kind === ts.SyntaxKind.ExportKeyword) {
-                        if (!isInsideNamespace(node)) {
-                            nameExport = true;
-                        }
-                    }
-                });
-            }
-            return ts.visitEachChild(node, visitor, context);
-        };
-        return (rootNode) => ts.visitNode(rootNode, visitor);
+        }
+    }
+    return { bundledContent: content, ...point };
+}
+async function bundle(object) {
+    const points = [];
+    for (const point of object.points) {
+        const _point = await bundler(point);
+        points.push(_point);
+    }
+    return {
+        points,
+        allowUpdatePackageJson: object.allowUpdatePackageJson,
     };
-    ts.transform(sourceFile, [transformer]);
-    return { nameExport, defExport };
 }
-const createHost = (sourceCode, fileName) => {
+function createHost(sourceCode, fileName) {
     const createdFiles = {};
     const host = {
         getSourceFile: (file, languageVersion) => {
@@ -335,80 +1036,106 @@ const createHost = (sourceCode, fileName) => {
         getNewLine: () => "\n",
     };
     return { createdFiles, host };
-};
-function replaceInJs(fileName, sourceCode, compilerOptions) {
-    const sourceFile = ts.createSourceFile(fileName, sourceCode, ts.ScriptTarget.Latest, true);
-    const transformer = (context) => {
-        const { factory } = context;
-        const visitor = (node) => {
-            if (ts.isExpressionStatement(node)) {
-                const expr = node.expression;
-                if (ts.isBinaryExpression(expr) &&
-                    ts.isPropertyAccessExpression(expr.left) &&
-                    ts.isIdentifier(expr.left.expression) &&
-                    expr.left.expression.escapedText === "exports" &&
-                    ts.isIdentifier(expr.left.name) &&
-                    expr.left.name.escapedText === "default" &&
-                    expr.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-                    ts.isIdentifier(expr.right)) {
-                    const newLeftExpr = factory.createIdentifier("module");
-                    const newName = factory.createIdentifier("exports");
-                    const newLeft = factory.updatePropertyAccessExpression(expr.left, newLeftExpr, newName);
-                    const newExpr = factory.updateBinaryExpression(expr, newLeft, expr.operatorToken, expr.right);
-                    return factory.updateExpressionStatement(node, newExpr);
-                }
-            }
-            return ts.visitEachChild(node, visitor, context);
-        };
-        return (rootNode) => ts.visitNode(rootNode, visitor);
-    };
-    return transformFunction(transformer, sourceFile, compilerOptions);
 }
-function replaceInTs(fileName, sourceCode, compilerOptions) {
-    const sourceFile = ts.createSourceFile(fileName, sourceCode, ts.ScriptTarget.Latest, true);
-    const transformer = (context) => {
-        const { factory } = context;
-        const visitor = (node) => {
-            if (ts.isExportAssignment(node) &&
-                node.modifiers === undefined &&
-                !node.isExportEquals) {
-                return factory.createExportAssignment(node.modifiers, true, node.expression);
-            }
-            return ts.visitEachChild(node, visitor, context);
-        };
-        return (rootNode) => ts.visitNode(rootNode, visitor);
-    };
-    return transformFunction(transformer, sourceFile, compilerOptions);
+const isCjs = (files) => files.commonjs && files.commonjsTypes;
+const isEsm = (files) => files.esm && files.esmTypes;
+function getExports(files, exportPath) {
+    return isCjs(files) && isEsm(files)
+        ? {
+            [exportPath]: {
+                import: {
+                    default: `./${path.relative(process.cwd(), files.esm)}`,
+                    types: `./${path.relative(process.cwd(), files.esmTypes)}`,
+                },
+                require: {
+                    default: `./${path.relative(process.cwd(), files.commonjs)}`,
+                    types: `./${path.relative(process.cwd(), files.commonjsTypes)}`,
+                },
+            },
+        }
+        : isCjs(files) && !isEsm(files)
+            ? {
+                [exportPath]: {
+                    require: {
+                        default: `./${path.relative(process.cwd(), files.commonjs)}`,
+                        types: `./${path.relative(process.cwd(), files.commonjsTypes)}`,
+                    },
+                },
+            }
+            : !isCjs(files) && isEsm(files)
+                ? {
+                    [exportPath]: {
+                        import: {
+                            default: `./${path.relative(process.cwd(), files.esm)}`,
+                            types: `./${path.relative(process.cwd(), files.esmTypes)}`,
+                        },
+                    },
+                }
+                : {};
 }
-async function clearFolder(folderPath) {
-    folderPath = path.resolve(process.cwd(), folderPath);
-    try {
-        const entries = await fs.promises.readdir(folderPath, {
-            withFileTypes: true,
-        });
-        await Promise.all(entries.map((entry) => fs.promises.rm(path.join(folderPath, entry.name), {
-            recursive: true,
-        })));
+async function writePackage(files, exportPath) {
+    let isMain = true;
+    if (exportPath !== ".") {
+        isMain = false;
     }
-    catch (error) {
-        if (error.code !== "ENOENT") {
-            throw error;
-        }
+    const pkgFile = ts.sys.resolvePath("package.json");
+    const _pkgtext = fs.readFileSync(pkgFile, "utf8");
+    const pkgtext = JSON.parse(_pkgtext);
+    let { name, version, description, main, module, type, types, exports, ...rest } = pkgtext;
+    await utilities.wait(500);
+    type = "module";
+    let _main = {};
+    let _module = {};
+    let _types = {};
+    let _exports = {};
+    if (isMain) {
+        _main = files.main
+            ? { main: path.relative(process.cwd(), files.main) }
+            : {};
+        _module = files.module
+            ? { module: path.relative(process.cwd(), files.module) }
+            : {};
+        _types = files.types
+            ? { types: path.relative(process.cwd(), files.types) }
+            : {};
+        _exports = { exports: { ...getExports(files, exportPath) } };
+    }
+    else {
+        _main = main ? { main: main } : {};
+        _module = module ? { module: module } : {};
+        _types = types ? { types: types } : {};
+        const normalizedExports = exports && typeof exports === "object" && !Array.isArray(exports)
+            ? { ...exports }
+            : {};
+        _exports = {
+            exports: { ...normalizedExports, ...getExports(files, exportPath) },
+        };
     }
+    await utilities.wait(1000);
+    const pkgJson = {
+        name,
+        version,
+        description,
+        type,
+        ..._main,
+        ..._types,
+        ..._module,
+        ..._exports,
+        ...rest,
+    };
+    utilities.writeCompileFile(pkgFile, JSON.stringify(pkgJson, null, 2));
 }
-async function writeCompileFile(file, content) {
-    const filePath = ts.sys.resolvePath(file);
-    const dir = path.dirname(filePath);
-    if (!ts.sys.directoryExists(dir)) {
-        await fs.promises.mkdir(dir, { recursive: true });
-    }
-    await utils.wait(500);
-    await fs.promises.writeFile(filePath, content);
+function splitCamelCase(str) {
+    const splitString = str
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/(_|-|\/)([a-z] || [A-Z])/g, " ")
+        .replace(/([A-Z])/g, (match) => match.toLowerCase())
+        .replace(/^([a-z])/, (match) => match.toUpperCase());
+    return splitString;
 }
-class Compilers {
-    constructor(options) {
-        this._target = options?.target ?? "both";
-        this._configPath = options?.configPath;
+class Compiler {
+    constructor(object) {
+        this.object = object;
         this.files = {
             commonjs: undefined,
             commonjsTypes: undefined,
@@ -418,48 +1145,46 @@ class Compilers {
             module: undefined,
             types: undefined,
         };
-        this.outDir = "";
     }
-    async commonjs(sourceCode, fileName, compilerOptions, isMain, hooks, isUpdate = true) {
-        console.time(tcolor.green("Compiled Commonjs"));
-        const ck = checkExports(fileName, sourceCode);
-        if (ck.defExport && ck.nameExport) {
-            console.warn(tcolor.yellow("Both name export and default export are exported from your project,that will effect on default export for commonjs output"));
-        }
+    _isUpdate() {
+        return this.object.allowUpdatePackageJson;
+    }
+    async _commonjs(point) {
+        const isMain = point.exportPath === ".";
+        const _name = isMain ? "Main" : splitCamelCase(point.exportPath.slice(2));
+        console.time(tcolor.cyan(`Compiled commonjs for ${_name} export path`));
+        const fileName = point.fileName;
+        const sourceCode = point.bundledContent;
+        const format = point.format;
+        const plugins = point.plugins;
+        const compilerOptions = point.tsOptions.cjs;
         const _host = createHost(sourceCode, fileName);
         const createdFiles = _host.createdFiles;
         const host = _host.host;
         const program = ts.createProgram([fileName], compilerOptions, host);
         program.emit();
         Object.entries(createdFiles).map(async ([outName, content]) => {
-            if (ck.defExport && !ck.nameExport) {
-                const ext = utils.extname(outName);
-                if (ext === ".js") {
-                    content = replaceInJs(fileName, content, compilerOptions);
-                }
-                if (ext === ".ts") {
-                    content = replaceInTs(fileName, content, compilerOptions);
-                }
-            }
-            if (hooks?.length) {
-                for (const hook of hooks) {
-                    if (hook.async) {
-                        content = await hook.func(content, outName);
-                    }
-                    else {
-                        content = hook.func(content, outName);
+            if (plugins.length) {
+                for (let plugin of plugins) {
+                    plugin = typeof plugin === "function" ? plugin() : plugin;
+                    if (plugin.type === "post-process") {
+                        if (plugin.async) {
+                            content = await plugin.func(content, outName);
+                        }
+                        else {
+                            content = plugin.func(content, outName);
+                        }
                     }
                 }
             }
-            if (isUpdate) {
+            if (this._isUpdate()) {
                 if (outName.match(/.js/g)) {
                     this.files.commonjs = outName.replace(/.js/g, ".cjs");
                 }
                 if (outName.match(/.d.ts/g)) {
                     this.files.commonjsTypes = outName.replace(/.d.ts/g, ".d.cts");
                 }
-                if (isMain &&
-                    (this._target === "both" || this._target === "commonjs")) {
+                if (isMain && (format === "both" || format === "commonjs")) {
                     if (this.files.commonjs)
                         this.files.main = this.files.commonjs;
                     if (this.files.commonjsTypes)
@@ -469,59 +1194,98 @@ class Compilers {
             outName = outName.replace(/.js/g, ".cjs");
             outName = outName.replace(/.map.js/g, ".map.cjs");
             outName = outName.replace(/.d.ts/g, ".d.cts");
-            await utils.wait(500);
-            if (this._target !== "both" && this._target !== "esm") {
-                await clearFolder(utils.dirname(outName));
+            await utilities.wait(500);
+            if (format === "commonjs") {
+                await utilities.clearFolder(path.dirname(outName));
             }
-            await writeCompileFile(outName, content);
+            await utilities.writeCompileFile(outName, content);
         });
-        console.timeEnd(tcolor.green("Compiled Commonjs"));
+        console.timeEnd(tcolor.cyan(`Compiled commonjs for ${_name} export path`));
     }
-    async esm(sourceCode, fileName, compilerOptions, isMain, hooks, isUpdate = true) {
-        console.time(tcolor.green("Compiled ESM"));
+    async _esm(point) {
+        const isMain = point.exportPath === ".";
+        const _name = isMain ? "Main" : splitCamelCase(point.exportPath.slice(2));
+        console.time(tcolor.cyan(`Compiled esm for ${_name} export path`));
+        const fileName = point.fileName;
+        const sourceCode = point.bundledContent;
+        const format = point.format;
+        const plugins = point.plugins;
+        const compilerOptions = point.tsOptions.esm;
         const _host = createHost(sourceCode, fileName);
         const createdFiles = _host.createdFiles;
         const host = _host.host;
         const program = ts.createProgram([fileName], compilerOptions, host);
         program.emit();
         Object.entries(createdFiles).map(async ([outName, content]) => {
-            if (hooks?.length) {
-                for (const hook of hooks) {
-                    if (hook.async) {
-                        content = await hook.func(content, outName);
-                    }
-                    else {
-                        content = hook.func(content, outName);
+            if (plugins.length) {
+                for (let plugin of plugins) {
+                    plugin = typeof plugin === "function" ? plugin() : plugin;
+                    if (plugin.type === "post-process") {
+                        if (plugin.async) {
+                            content = await plugin.func(content, outName);
+                        }
+                        else {
+                            content = plugin.func(content, outName);
+                        }
                     }
                 }
             }
-            if (isUpdate) {
+            if (this._isUpdate()) {
                 if (outName.match(/.js/g)) {
                     this.files.esm = outName.replace(/.js/g, ".mjs");
                 }
                 if (outName.match(/.d.ts/g)) {
                     this.files.esmTypes = outName.replace(/.d.ts/g, ".d.mts");
                 }
-                if (isMain && this._target === "both" && this.files.esm) {
+                if (isMain && format === "both" && this.files.esm) {
                     this.files.module = this.files.esm;
                 }
             }
             outName = outName.replace(/.js/g, ".mjs");
             outName = outName.replace(/.map.js/g, ".map.mjs");
             outName = outName.replace(/.d.ts/g, ".d.mts");
-            await utils.wait(500);
-            if (this._target !== "commonjs") {
-                await clearFolder(utils.dirname(outName));
+            await utilities.wait(500);
+            if (format !== "commonjs") {
+                await utilities.clearFolder(path.dirname(outName));
             }
-            await writeCompileFile(outName, content);
+            await utilities.writeCompileFile(outName, content);
         });
-        console.timeEnd(tcolor.green("Compiled ESM"));
+        console.timeEnd(tcolor.cyan(`Compiled esm for ${_name} export path`));
+    }
+    async compile() {
+        for (const point of this.object.points) {
+            await utilities.wait(500);
+            switch (point.format) {
+                case "commonjs":
+                    await this._commonjs(point);
+                    if (this._isUpdate()) {
+                        await writePackage(this.files, point.exportPath);
+                    }
+                    break;
+                case "esm":
+                    await this._esm(point);
+                    if (this._isUpdate()) {
+                        await writePackage(this.files, point.exportPath);
+                    }
+                    break;
+                case "both":
+                    await this._esm(point);
+                    await utilities.wait(1000);
+                    await this._commonjs(point);
+                    if (this._isUpdate()) {
+                        await writePackage(this.files, point.exportPath);
+                    }
+                    break;
+            }
+            await utilities.wait(500);
+        }
     }
 }
-const depsCheck = {
-    types(deps, compilerOptions) {
+var checks;
+(function (checks) {
+    function typesCheck(dep, compilerOptions) {
         if (!compilerOptions.noCheck) {
-            const filePaths = deps.map((i) => i.file);
+            const filePaths = dep.map((i) => i.file);
             let _err = false;
             const program = ts.createProgram(filePaths, compilerOptions);
             for (const filePath of filePaths) {
@@ -552,23 +1316,12 @@ const depsCheck = {
                 return true;
             }
         }
-    },
-    ext(deps) {
-        const tsExt = new Set([".ts", ".mts", ".cts", ".tsx"]);
-        for (const dep of deps) {
-            const ext = utils.extname(dep.file);
-            if (!tsExt.has(ext)) {
-                console.error(tcolor.magenta(`${dep.file} has no valid TypeScript extension`));
-                ts.sys.exit(1);
-            }
-        }
-        return true;
-    },
-    moduleType(deps) {
+    }
+    function moduleType(_dep) {
         let _esmCount = 0;
         let cjsCount = 0;
-        let unknowCount = 0;
-        for (const dep of deps) {
+        let unknownCount = 0;
+        for (const dep of _dep) {
             try {
                 const sourceFile = ts.createSourceFile(dep.file, dep.content, ts.ScriptTarget.Latest, true);
                 let hasESMImports = false;
@@ -619,10 +1372,10 @@ const depsCheck = {
             }
             catch (error) {
                 console.error(tcolor.magenta(`Error checking module format for ${dep.file} : \n ${error}`));
-                unknowCount++;
+                unknownCount++;
             }
         }
-        if (unknowCount) {
+        if (unknownCount) {
             console.error(tcolor.magenta("Unknown error when checking module types in the dependencies tree."));
             ts.sys.exit(1);
         }
@@ -631,126 +1384,29 @@ const depsCheck = {
             ts.sys.exit(1);
         }
         return true;
-    },
-    nodeCheck(nodeEnvOption, nodeModules) {
-        if (!nodeEnvOption && nodeModules.length > 0) {
-            console.error();
-            ts.sys.exit(1);
+    }
+    function ext(_dep) {
+        const tsExt = new Set([".ts", ".mts", ".cts", ".tsx"]);
+        for (const dep of _dep) {
+            const ext = path.extname(dep.file);
+            if (!tsExt.has(ext)) {
+                console.error(tcolor.magenta(`${dep.file} has no valid TypeScript extension`));
+                ts.sys.exit(1);
+            }
         }
         return true;
-    },
-    async make(deps, compilerOptions, nodeModules, nodeEnv = true) {
+    }
+    async function init(_dep, options) {
         const res = resolves([
-            [depsCheck.ext, deps],
-            [depsCheck.nodeCheck, nodeEnv, nodeModules],
-            [depsCheck.moduleType, deps],
-            [depsCheck.types, deps, compilerOptions],
+            [ext, _dep],
+            [moduleType, _dep],
+            [typesCheck, _dep, options],
         ]);
         const results = await res.concurrent();
         return results.every((r) => r === true);
-    },
-};
-async function getDependencies(entry) {
-    const deps = await dependencies(entry);
-    const sorted = deps.sort();
-    const circularMessages = [];
-    const nodeModules = deps.node();
-    const depFiles = [];
-    await utils.wait(100);
-    for (const dep of sorted) {
-        const file = utils.resolvePath(dep);
-        const content = utils.readFile(file);
-        depFiles.push({ file, content });
-    }
-    const circular = deps
-        .mutual()
-        .map((i) => `${i[0]} -> ${i[1]} \n ${i[1]} -> ${i[0]} \n`);
-    const unknown = deps.warn().map((i) => `${i}\n`);
-    if (circular.length)
-        circularMessages.push(circular.join(""));
-    if (unknown.length)
-        circularMessages.push(unknown.join(""));
-    return {
-        depFiles,
-        sorted,
-        circularMessages,
-        nodeModules,
-    };
-}
-const getCompilerOptions = (exportPath, configPath) => {
-    const config = new TsConfig(configPath);
-    const generalOptions = () => config.getCompilerOptions();
-    const commonjs = () => {
-        const _config = new TsConfig(configPath);
-        _config.addCompilerOptions({ outDir: "dist" });
-        _config.removeCompilerOption("rootDir");
-        _config.removeCompilerOption("module");
-        const _options = _config.getCompilerOptions();
-        let out_dir = _options.outDir;
-        let isMain = true;
-        if (exportPath !== ".") {
-            out_dir = `${out_dir}/${exportPath.slice(2)}`;
-            isMain = false;
-        }
-        const { outDir, module, ...restOptions } = _options;
-        const compilerOptions = {
-            outDir: out_dir,
-            module: ts.ModuleKind.CommonJS,
-            ...restOptions,
-        };
-        return {
-            isMain,
-            compilerOptions,
-            out_dir,
-        };
-    };
-    const esm = () => {
-        const __config = new TsConfig(configPath);
-        __config.addCompilerOptions({ outDir: "dist" });
-        __config.removeCompilerOption("rootDir");
-        const _options = __config.getCompilerOptions();
-        let out_dir = _options.outDir;
-        let isMain = true;
-        if (exportPath !== ".") {
-            out_dir = `${out_dir}/${exportPath.slice(2)}`;
-            isMain = false;
-        }
-        const { outDir, module, ...restOptions } = _options;
-        const compilerOptions = {
-            outDir: out_dir,
-            module: ts.ModuleKind.ES2022,
-            ...restOptions,
-        };
-        return {
-            isMain,
-            compilerOptions,
-            out_dir,
-        };
-    };
-    return { commonjs, esm, generalOptions };
-};
-async function entry({ entryPath, exportPath, configPath, nodeEnv, }) {
-    const deps = await getDependencies(entryPath);
-    const depFiles = deps.depFiles;
-    const nodeModules = deps.nodeModules;
-    await utils.wait(1000);
-    const opts = getCompilerOptions(exportPath, configPath);
-    const generalOptions = opts.generalOptions();
-    const modOpts = {
-        commonjs: () => opts.commonjs(),
-        esm: () => opts.esm(),
-    };
-    await utils.wait(1000);
-    const checked = await depsCheck.make(depFiles, generalOptions, nodeModules, nodeEnv);
-    if (!checked) {
-        ts.sys.exit(1);
     }
-    return {
-        depFiles,
-        modOpts,
-        generalOptions,
-    };
-}
+    checks.init = init;
+})(checks || (checks = {}));
 const getConfigPath = () => {
     const fileNames = ["susee.config.ts", "susee.config.js", "susee.config.mjs"];
     let configFile;
@@ -769,18 +1425,18 @@ function checkEntries(entries) {
         ts.sys.exit(1);
     }
     const objectStore = {};
-    const duplicates = [];
+    const duplicateExportPaths = [];
     for (const obj of entries) {
         const value = obj.exportPath;
         if (objectStore[value]) {
-            duplicates.push(`"${value}"`);
+            duplicateExportPaths.push(`"${value}"`);
         }
         else {
             objectStore[value] = true;
         }
     }
-    if (duplicates.length > 0) {
-        console.error(tcolor.magenta(`Duplicate export paths/path (${duplicates.join(",")}) found in your susee.config file , that will error for bundled output`));
+    if (duplicateExportPaths.length > 0) {
+        console.error(tcolor.magenta(`Duplicate export paths/path (${duplicateExportPaths.join(",")}) found in your susee.config file , that will error for bundled output`));
         ts.sys.exit(1);
     }
     for (const obj of entries) {
@@ -800,151 +1456,178 @@ async function getConfig() {
     const config = _default.default;
     const entryCheck = resolves([[checkEntries, config.entryPoints]]);
     await entryCheck.series();
-    await utils.wait(1000);
+    await utilities.wait(1000);
+    const points = [];
+    for (const ent of config.entryPoints) {
+        const point = {
+            entry: ent.entry,
+            exportPath: ent.exportPath,
+            format: ent.format ?? "esm",
+            tsconfigFilePath: ent.tsconfigFilePath ?? undefined,
+            renameDuplicates: ent.renameDuplicates ?? true,
+            outDir: config.outDir ?? "dist",
+        };
+        points.push(point);
+    }
     return {
-        entryPoints: config.entryPoints,
-        postProcessHooks: config.postProcessHooks ?? [],
+        points,
+        plugins: config.plugins ?? [],
         allowUpdatePackageJson: config.allowUpdatePackageJson ?? true,
-        nodeEnv: config.nodeEnv ?? true,
-        renameDuplicates: config.renameDuplicates ?? true,
     };
 }
-const isCjs = (files) => files.commonjs && files.commonjsTypes;
-const isEsm = (files) => files.esm && files.esmTypes;
-function getExports(files, exportPath) {
-    return isCjs(files) && isEsm(files)
-        ? {
-            [exportPath]: {
-                import: {
-                    default: `./${path.relative(process.cwd(), files.esm)}`,
-                    types: `./${path.relative(process.cwd(), files.esmTypes)}`,
-                },
-                require: {
-                    default: `./${path.relative(process.cwd(), files.commonjs)}`,
-                    types: `./${path.relative(process.cwd(), files.commonjsTypes)}`,
-                },
-            },
-        }
-        : isCjs(files) && !isEsm(files)
-            ? {
-                [exportPath]: {
-                    require: {
-                        default: `./${path.relative(process.cwd(), files.commonjs)}`,
-                        types: `./${path.relative(process.cwd(), files.commonjsTypes)}`,
-                    },
-                },
-            }
-            : !isCjs(files) && isEsm(files)
-                ? {
-                    [exportPath]: {
-                        import: {
-                            default: `./${path.relative(process.cwd(), files.esm)}`,
-                            types: `./${path.relative(process.cwd(), files.esmTypes)}`,
-                        },
-                    },
-                }
-                : {};
+async function fileSizes(path) {
+    const s = await fs.promises.stat(path);
+    const logical = s.size;
+    const allocated = s.blocks !== null ? s.blocks * 512 : null;
+    return { logical, allocated };
 }
-async function writePackage(files, exportPath) {
-    let isMain = true;
-    if (exportPath !== ".") {
-        isMain = false;
-    }
-    const pkgFile = utils.resolvePath("package.json");
-    const _pkgtext = utils.readFile(pkgFile);
-    const pkgtext = JSON.parse(_pkgtext);
-    let { name, version, description, main, module, type, types, exports, ...rest } = pkgtext;
-    await utils.wait(500);
-    type = isEsm(files) ? "module" : "commonjs";
-    let _main = {};
-    let _module = {};
-    let _types = {};
-    let _exports = {};
-    if (isMain) {
-        _main = files.main
-            ? { main: path.relative(process.cwd(), files.main) }
-            : {};
-        _module = files.module
-            ? { module: path.relative(process.cwd(), files.module) }
-            : {};
-        _types = files.types
-            ? { types: path.relative(process.cwd(), files.types) }
-            : {};
-        _exports = { exports: { ...getExports(files, exportPath) } };
+const checkExport = (str, file) => {
+    const esmRex = /export default .*/gm;
+    const cjsRex = /export = .*/gm;
+    const ctsRex = /.cts/g;
+    if (str.match(esmRex) || (str.match(cjsRex) && file.match(ctsRex))) {
+        return true;
     }
     else {
-        _main = main ? { main: main } : {};
-        _module = module ? { module: module } : {};
-        _types = types ? { types: types } : {};
-        const normalizedExports = exports && typeof exports === "object" && !Array.isArray(exports)
-            ? { ...exports }
-            : {};
-        _exports = {
-            exports: { ...normalizedExports, ...getExports(files, exportPath) },
+        return false;
+    }
+};
+async function generateDependencies(entryFile, plugins) {
+    const deps = await dependencies(entryFile);
+    const sorted = deps.sort();
+    let depsFiles = [];
+    await utilities.wait(1000);
+    for (const dep of sorted) {
+        const file = ts.sys.resolvePath(dep);
+        const content = await fs.promises.readFile(file, "utf8");
+        const s = await fileSizes(file);
+        const length = content.length;
+        const includeDefExport = checkExport(content, file);
+        const _files = {
+            file,
+            content,
+            length,
+            includeDefExport,
+            size: {
+                logical: s.logical,
+                allocated: s.allocated,
+                utf8: new TextEncoder().encode(content).length,
+                buffBytes: Buffer.byteLength(content, "utf8"),
+            },
         };
+        depsFiles.push(_files);
     }
-    await utils.wait(1000);
-    const pkgJson = {
-        name,
-        version,
-        description,
-        type,
-        ..._main,
-        ..._types,
-        ..._module,
-        ..._exports,
-        ...rest,
-    };
-    utils.writeFile(pkgFile, JSON.stringify(pkgJson, null, 2));
+    if (plugins.length) {
+        for (const plugin of plugins) {
+            const _plug = typeof plugin === "function" ? plugin() : plugin;
+            if (_plug.type === "dependency") {
+                if (_plug.async) {
+                    depsFiles = await _plug.func(depsFiles);
+                }
+                else {
+                    depsFiles = _plug.func(depsFiles);
+                }
+                await utilities.wait(1000);
+            }
+        }
+    }
+    return depsFiles;
 }
-async function susee() {
-    const config = await getConfig();
-    console.info(tcolor.cyan("Start Bundle"));
-    const compile = async (e) => {
-        const target = e.moduleType ? e.moduleType : "esm";
-        const configPath = e.tsconfigFilePath;
-        const ent = await entry({
-            entryPath: e.entry,
-            exportPath: e.exportPath,
-            configPath: e.tsconfigFilePath,
-            nodeEnv: config.nodeEnv,
-        });
-        const sourceCode = await bundler({
-            depsFiles: ent.depFiles,
-            compilerOptions: ent.generalOptions,
-            renameDuplicates: config.renameDuplicates,
+class GetOptions {
+    constructor(point) {
+        this._point = point;
+        this._options = {};
+    }
+    __init() {
+        const __opts = new TsConfig(this._point.tsconfigFilePath);
+        const __outDir = this._point.exportPath === "."
+            ? this._point.outDir
+            : `${this._point.outDir}/${this._point.exportPath.slice(2)}`;
+        __opts.removeCompilerOption("rootDir");
+        __opts.removeCompilerOption("module");
+        __opts.editCompilerOptions({
+            moduleResolution: ts.ModuleResolutionKind.NodeNext,
+            outDir: __outDir,
         });
-        const mdOpts = ent.modOpts;
-        const cjsOpts = mdOpts.commonjs();
-        const esmOpts = mdOpts.esm();
-        const compiler = new Compilers({ target, configPath });
-        if (target === "commonjs") {
-            await compiler.commonjs(sourceCode, e.entry, cjsOpts.compilerOptions, cjsOpts.isMain, config.postProcessHooks, config.allowUpdatePackageJson);
+        this._options = __opts.getCompilerOptions();
+    }
+    __init2() {
+        this.__init();
+        let { types, lib, ...restOptions } = this._options;
+        if (types) {
+            if (!types.includes("node")) {
+                types = ["node", ...types];
+            }
         }
-        else if (target === "esm") {
-            await compiler.esm(sourceCode, e.entry, esmOpts.compilerOptions, esmOpts.isMain, config.postProcessHooks, config.allowUpdatePackageJson);
+        else {
+            types = ["node"];
         }
-        else if (target === "both") {
-            await compiler.esm(sourceCode, e.entry, esmOpts.compilerOptions, esmOpts.isMain, config.postProcessHooks, config.allowUpdatePackageJson);
-            await utils.wait(1000);
-            await compiler.commonjs(sourceCode, e.entry, cjsOpts.compilerOptions, cjsOpts.isMain, config.postProcessHooks, config.allowUpdatePackageJson);
+        if (lib) {
+            lib = [...new Set(["ESNext", ...lib])];
         }
-        await utils.wait(1000);
-        if (config.allowUpdatePackageJson) {
-            await writePackage(compiler.files, e.exportPath);
+        else {
+            lib = ["ESNext"];
         }
-    };
-    for (const entry of config.entryPoints) {
-        const entName = entry.exportPath === "." ? "main" : entry.exportPath.slice(2);
-        await utils.wait(1000);
-        console.info(tcolor.cyan(`Start ${tcolor.green("->")} "${entName}" export path`));
-        await compile(entry);
-        console.info(tcolor.cyan(`End ${tcolor.green("->")} "${entName}" export path`));
-        if (config.entryPoints.indexOf(entry) + 1 < config.entryPoints.length) {
-            console.info("-----------------------------------");
+        return { types, lib, ...restOptions };
+    }
+    get commonjs() {
+        const opts = this.__init2();
+        const { module, ...rest } = opts;
+        return { module: ts.ModuleKind.CommonJS, ...rest };
+    }
+    get esm() {
+        const opts = this.__init2();
+        const { module, ...rest } = opts;
+        return { module: ts.ModuleKind.ES2020, ...rest };
+    }
+    get default() {
+        return this.__init2();
+    }
+}
+function getOptions(point) {
+    return new GetOptions(point);
+}
+async function collections() {
+    const __config = await getConfig();
+    const points = __config.points;
+    const result = [];
+    for (const point of points) {
+        const __opts = getOptions(point);
+        const __deps = await generateDependencies(point.entry, __config.plugins);
+        const checked = await checks.init(__deps, __opts.esm);
+        if (!checked) {
+            ts.sys.exit(1);
         }
+        const c = {
+            fileName: point.entry,
+            exportPath: point.exportPath,
+            format: point.format,
+            rename: point.renameDuplicates,
+            outDir: point.outDir,
+            tsOptions: {
+                cjs: __opts.commonjs,
+                esm: __opts.esm,
+                default: __opts.default,
+            },
+            depFiles: __deps,
+            plugins: __config.plugins,
+        };
+        result.push(c);
     }
-    console.info(tcolor.cyan("Finished Bundle"));
+    return {
+        points: result,
+        allowUpdatePackageJson: __config.allowUpdatePackageJson,
+    };
+}
+async function susee() {
+    console.info(`${tcolor.green("Start")} : ${tcolor.cyan("bundling")}`);
+    const collected = await collections();
+    await utilities.wait(1000);
+    const bundled = await bundle(collected);
+    await utilities.wait(1000);
+    const compiler = new Compiler(bundled);
+    await compiler.compile();
+    console.info(`${tcolor.green("End")} : ${tcolor.cyan("bundling")}`);
 }
 export { susee };
 //# sourceMappingURL=index.js.map