susee 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -6,100 +6,44 @@ 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";
+//src/lib/bundle/bundleCreator.ts
+/**
+ * Creates a BundleCreator function that transforms a DepsFile with a given BundleVisitor and typescript compiler options.
+ * @param {BundleVisitor} bundleVisitor - a BundleVisitor function that takes a context, depsTree, sourceFile, and any number of arguments.
+ * @param {ts.CompilerOptions} compilerOptions - typescript compiler options.
+ * @param {...any} args - any number of arguments to pass to the BundleVisitor function.
+ * @returns {BundleCreator} a BundleCreator function that takes a DepsFile and returns a transformed DepsFile.
+ */
+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);
-            };
+            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 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);
-            };
-            return (rootNode) => ts.visitNode(rootNode, visitor);
-        };
-        let _content = transformFunction(transformer, sourceFile, compilerOptions);
-        _content = _content.replace(/^s*;\s*$/gm, "").trim();
-        return { file, content: _content };
-    };
-}
-function mergeImports(imports) {
+};
+//src/lib/bundle/mergeImportsStatement.ts
+function mergeImportsStatement(imports) {
     const importMap = new Map();
     const typeImportMap = new Map();
     const defaultImports = new Map();
     const typeDefaultImports = new Map();
     const namespaceImports = new Map();
+    // Parse each import statement
     for (const importStr of imports) {
         const importMatch = importStr.match(/import\s+(?:type\s+)?(?:(.*?)\s+from\s+)?["']([^"']+)["'];?/);
         if (!importMatch)
@@ -108,6 +52,7 @@ function mergeImports(imports) {
         const isTypeImport = importStr.includes("import type");
         const modulePath = _modulePath;
         if (!importClause) {
+            // Default import or side-effect import
             const defaultMatch = importStr.match(/import\s+(?:type\s+)?(\w+)/);
             if (defaultMatch) {
                 const importName = defaultMatch[1];
@@ -119,6 +64,7 @@ function mergeImports(imports) {
             continue;
         }
         if (importClause.startsWith("{")) {
+            // Named imports: import { a, b } from 'module'
             const targetMap = isTypeImport ? typeImportMap : importMap;
             if (!targetMap.has(modulePath))
                 targetMap.set(modulePath, new Set());
@@ -127,9 +73,11 @@ function mergeImports(imports) {
                 .split(",")
                 .map((s) => s.trim())
                 .filter(Boolean);
+            // biome-ignore  lint/suspicious/useIterableCallbackReturn : just add name for names each
             names.forEach((name) => targetMap.get(modulePath)?.add(name));
         }
         else if (importClause.startsWith("* as")) {
+            // Namespace import: import * as name from 'module'
             const namespaceMatch = importClause.match(/\*\s+as\s+(\w+)/);
             if (namespaceMatch) {
                 const namespaceName = namespaceMatch[1];
@@ -139,6 +87,7 @@ function mergeImports(imports) {
             }
         }
         else {
+            // Default import: import name from 'module'
             const targetMap = isTypeImport ? typeDefaultImports : defaultImports;
             if (!targetMap.has(modulePath))
                 targetMap.set(modulePath, new Set());
@@ -146,8 +95,10 @@ function mergeImports(imports) {
         }
     }
     const mergedImports = [];
+    // Process named imports - remove type imports that have regular imports
     for (const [modulePath, regularNames] of importMap) {
         const typeNames = typeImportMap.get(modulePath) || new Set();
+        // Only include type names that don't have regular imports
         const finalNames = new Set([...regularNames]);
         for (const typeName of typeNames) {
             if (!regularNames.has(typeName)) {
@@ -159,14 +110,17 @@ function mergeImports(imports) {
             mergedImports.push(`import { ${importNames} } from "${modulePath}";`);
         }
     }
+    // Add remaining type-only imports (where no regular imports exist for the module)
     for (const [modulePath, typeNames] of typeImportMap) {
         if (!importMap.has(modulePath) && typeNames.size > 0) {
             const importNames = Array.from(typeNames).sort().join(", ");
             mergedImports.push(`import type { ${importNames} } from "${modulePath}";`);
         }
     }
+    // Process default imports - remove type default imports that have regular default imports
     for (const [modulePath, regularDefaultNames] of defaultImports) {
         const typeDefaultNames = typeDefaultImports.get(modulePath) || new Set();
+        // Only include type default names that don't have regular default imports
         const finalNames = new Set([...regularDefaultNames]);
         for (const typeName of typeDefaultNames) {
             if (!regularDefaultNames.has(typeName)) {
@@ -178,12 +132,14 @@ function mergeImports(imports) {
             mergedImports.push(`import ${importNames} from "${modulePath}";`);
         }
     }
+    // Add remaining type-only default imports
     for (const [modulePath, typeDefaultNames] of typeDefaultImports) {
         if (!defaultImports.has(modulePath) && typeDefaultNames.size > 0) {
             const importNames = Array.from(typeDefaultNames).join(", ");
             mergedImports.push(`import type ${importNames} from "${modulePath}";`);
         }
     }
+    // Process namespace imports
     for (const [modulePath, names] of namespaceImports) {
         if (names.size > 0) {
             const importNames = Array.from(names).join(", ");
@@ -192,8 +148,852 @@ function mergeImports(imports) {
     }
     return mergedImports.sort();
 }
-async function bundler({ depsFiles, compilerOptions, renameDuplicates, }) {
-    const reName = renameDuplicates ?? true;
+//src/lib/bundle/visitors/anonymousCallExpression.ts
+/**
+ * A BundleVisitor that updates the call expression, property access expression, and new expression
+ * with the anonymous default import name.
+ */
+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);
+                }
+            }
+            // for export specifier it is focus on entry file
+        }
+        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;
+};
+//src/lib/bundle/visitors/visitorHelpers.ts
+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;
+}
+//src/lib/bundle/visitors/anonymousExport.ts
+const prefixKey = "AnonymousName";
+const genName = uniqueName().setPrefix({ key: prefixKey, value: "a_" });
+/**
+ * A BundleVisitor that updates the call expression, property access expression, and new expression
+ * with the anonymous default import name.
+ */
+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;
+};
+//src/lib/bundle/visitors/anonymousImport.ts
+/**
+ * A BundleVisitor that updates the import declaration, property access expression, and new expression
+ * with the anonymous default import name.
+ */
+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();
+            // check only import default expression
+            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;
+};
+//src/lib/bundle/visitors/duplicateCallExpression.ts
+/**
+ * A BundleVisitor that updates the call expression, property access expression, and new expression
+ * with the anonymous default import name.
+ */
+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;
+                    //flag.push(new_name);
+                }
+                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);
+                }
+            }
+        }
+        /* ----------------------Returns for visitor function------------------------------- */
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+//src/lib/bundle/visitors/duplicateCollection.ts
+/**
+ * A BundleVisitor that updates the collection (variable, function, class, etc)
+ * declaration with the anonymous default import name.
+ *
+ * @param {BundleVisitor} context - The BundleVisitor context.
+ * @param {DepsTree} depsTree - The deps tree object.
+ * @param {SourceFile} sourceFile - The source file object.
+ * @param {DuplicatesNameMap} namesMap - The DuplicatesNameMap object.
+ * @return {NodeVisit} visit - The NodeVisit function.
+ */
+const duplicateCollectionVisitor = (context, depsTree, _sourceFile, namesMap) => {
+    //const { factory } = context;
+    const visit = (node, isGlobalScope = true) => {
+        // Global declarations များကိုသာ collect လုပ်မယ်
+        if (isGlobalScope) {
+            // Variable statements (const, let, var)
+            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 {
+                            // biome-ignore  lint/style/noNonNullAssertion : !namesMap.has($name) before
+                            namesMap.get($name).add({ file: depsTree.file });
+                        }
+                    }
+                });
+            }
+            // Function, Class, Enum, Interface, Type declarations
+            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 {
+                        // biome-ignore  lint/style/noNonNullAssertion : !namesMap.has($name) before
+                        namesMap.get($name).add({ file: depsTree.file });
+                    }
+                }
+            }
+        }
+        // Local scope ထဲရောက်သွားတဲ့ node တွေအတွက် recursive visit
+        if (ts.isBlock(node) ||
+            ts.isFunctionDeclaration(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isArrowFunction(node) ||
+            ts.isMethodDeclaration(node) ||
+            ts.isClassDeclaration(node)) {
+            // Local scope ထဲကို ဝင်သွားပြီဆိုတာနဲ့ isGlobalScope = false
+            if (ts.isBlock(node)) {
+                ts.visitNodes(node.statements, (child) => visit(child, false));
+            }
+            else {
+                ts.forEachChild(node, (child) => {
+                    visit(child, false);
+                });
+            }
+        }
+        else {
+            // Global scope ထဲဆက်ရှိနေတဲ့ node တွေအတွက်
+            return ts.visitEachChild(node, (child) => visit(child, isGlobalScope), context);
+        }
+        /* ----------------------Returns for visitNode function------------------------------- */
+        return node;
+    };
+    return visit;
+};
+//src/lib/bundle/visitors/duplicateExportExpression.ts
+/**
+ * A BundleVisitor that updates the call expression, property access expression, and new expression
+ * with the anonymous default import name.
+ */
+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));
+                }
+            }
+        }
+        /* ----------------------Returns for visitor function------------------------------- */
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+//src/lib/bundle/visitors/duplicateImportExpression.ts
+/**
+ * A BundleVisitor that updates the import declaration, property access expression, and new expression
+ * with the anonymous default import name.
+ *
+ * @param {BundleVisitor} context - The BundleVisitor context.
+ * @param {DepsTree} depsTree - The deps tree object.
+ * @param {SourceFile} sourceFile - The source file object.
+ * @param {NamesSets} exportNameMap - The export name map object.
+ * @param {NamesSets} importNameMap - The import name map object.
+ * @return {NodeVisit} visit - The NodeVisit function.
+ */
+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());
+            }
+            // import default expression
+            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);
+                }
+            }
+            // import name , `import{ ... }`
+            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);
+            }
+        } //&&
+        /* ----------------------Returns for visitor function------------------------------- */
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+//src/lib/bundle/visitors/duplicateUpdate.ts
+const dupName = uniqueName().setPrefix({
+    key: "DuplicatesNames",
+    value: "d_",
+});
+/**
+ * A BundleVisitor that updates the variable declaration, function declaration, and class declaration
+ * with the duplicates name.
+ *
+ * @param {BundleVisitor} context - The BundleVisitor context.
+ * @param {DepsTree} depsTree - The deps tree object.
+ * @param {SourceFile} sourceFile - The source file object.
+ * @param {DuplicatesNameMap} namesMap - The DuplicatesNameMap object.
+ * @param {NamesSets} callNameMap - The NamesSets object.
+ * @return {NodeVisit} visit - The NodeVisit function.
+ */
+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;
+                    // biome-ignore  lint/style/noNonNullAssertion : namesMap.has(base) before that get just only size
+                    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;
+                // biome-ignore  lint/style/noNonNullAssertion : namesMap.has(base) before that get just only size
+                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;
+                // biome-ignore  lint/style/noNonNullAssertion : namesMap.has(base) before that get just only size
+                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);
+                }
+            }
+        }
+        /* ----------------------Returns for visitor function------------------------------- */
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+//src/lib/bundle/visitors/removeExports.ts
+/**
+ * A BundleVisitor that removes all exports from the given source file.
+ * It does so by stripping "export" modifiers from function, class, interface, type alias, enum, and variable declarations,
+ * and by removing "export { foo }" and "export default" declarations entirely.
+ */
+const removeExportsVisitor = (context) => {
+    const { factory } = context;
+    const visit = (node) => {
+        // --- Case 1: Strip "export" modifiers ---
+        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 the node has an export modifier, remove it.
+                    // If the node is a function, class, interface, type alias, enum or variable declaration,
+                    // update the declaration by removing the export modifier.
+                    if (ts.isFunctionDeclaration(node)) {
+                        return factory.updateFunctionDeclaration(node, modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body);
+                    } // function
+                    if (ts.isClassDeclaration(node)) {
+                        return factory.updateClassDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
+                    } // class
+                    if (ts.isInterfaceDeclaration(node)) {
+                        return factory.updateInterfaceDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
+                    } // interface
+                    if (ts.isTypeAliasDeclaration(node)) {
+                        return factory.updateTypeAliasDeclaration(node, modifiers, node.name, node.typeParameters, node.type);
+                    } // types
+                    if (ts.isEnumDeclaration(node)) {
+                        return factory.updateEnumDeclaration(node, modifiers, node.name, node.members);
+                    } //enum
+                    if (ts.isVariableStatement(node)) {
+                        return factory.updateVariableStatement(node, modifiers, node.declarationList);
+                    } // vars
+                } //--
+            } // --- Case 1
+        }
+        // --- Case 2: Remove "export { foo }" entirely ---
+        if (ts.isExportDeclaration(node)) {
+            // If the node is an export declaration, remove it.
+            return factory.createEmptyStatement();
+        }
+        // --- Case 3: Handle "export default ..." ---
+        if (ts.isExportAssignment(node)) {
+            const expr = node.expression;
+            // export default Foo;   -> remove line
+            if (ts.isIdentifier(expr)) {
+                return factory.createEmptyStatement();
+            }
+        }
+        // --------- Visitor Return ------------------//
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+//src/lib/bundle/visitors/removeImports.ts
+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;
+}
+/**
+ * A BundleVisitor that removes import declarations and import equals declarations from a TypeScript program.
+ * The visitor collects the names of type-only import-equals and emits a named/default type import if the type-only import-equals is not a namespace-type alias.
+ * The visitor also collects the names of type-only imports of namespace-type aliases and emits a namespace type import if the type-only import-equals is not a namespace-type alias.
+ */
+const removeImportsVisitor = (context, depsTree, sourceFile, removedStatements) => {
+    // Pre-scan: collect names of type-only import-equals (these are namespace-type aliases)
+    // import type NameSpace = require("foo")
+    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,
+        };
+        // --- Case: TypeReference with QualifiedName (collect type usage)
+        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 this qualified name refers to a type-only import-equals alias, DO NOT rewrite.
+            // Rewriting (Foo.Bar -> Bar) was intended to support converting to named imports,
+            // but for type-only namespace imports we will emit `import type * as Foo from "..."`.
+            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)) {
+            // --- Case 1: Import declarations
+            const text = node.getText(sourceFile);
+            removedStatements.push(text);
+            return factory.createEmptyStatement();
+        }
+        //--- Case 2: Import equals declarations
+        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 this import-equals was a type-only namespace alias, emit a namespace type import
+                    if (typeOnlyImportEquals.has(obj.importedString)) {
+                        t = `import type * as ${obj.importedString} from "${obj.source}";`;
+                    }
+                    else {
+                        // otherwise try to emit a named/default type import (existing behavior)
+                        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}";`;
+            }
+            // removed
+            if (t) {
+                removedStatements.push(t);
+                return factory.createEmptyStatement();
+            }
+        }
+        // --- Case 3: Require imports
+        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") {
+                    // imported from
+                    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();
+                    }
+                }
+            }
+        }
+        // --------- Visitor Return ------------------//
+        return ts.visitEachChild(node, visit, context);
+    };
+    return visit;
+};
+//src/lib/bundle/index.ts
+// ------------------------------------------------------------------------------------//
+/**
+ * Bundles a TypeScript project into a single file.
+ * This function takes a {@link CollatedPoint} object as input and returns a {@link BundleResultPoint} object.
+ * The function applies the following steps:
+ * 1. Call dependency plugins.
+ * 2. Handle duplicates.
+ * 3. Handling anonymous imports and exports.
+ * 4. Remove Imports.
+ * 5. Remove Exports from dependencies only.
+ * 6. Handle imported statements.
+ * 7. Create final content.
+ * 8. Call pre-process plugins.
+ * 9. Returns.
+ * @param {CollatedPoint} point - A {@link CollatedPoint} object.
+ * @returns {Promise<BundleResultPoint>} - A promise resolves with a {@link BundleResultPoint} object.
+ */
+async function bundler(point) {
+    let depsFiles = point.depFiles;
+    const reName = point.rename;
+    const compilerOptions = point.tsOptions.default;
+    const plugins = point.plugins;
+    // construct maps
     const namesMap = new Map();
     const callNameMap = [];
     const importNameMap = [];
@@ -201,30 +1001,156 @@ async function bundler({ depsFiles, compilerOptions, renameDuplicates, }) {
     const exportDefaultExportNameMap = [];
     const exportDefaultImportNameMap = [];
     let removedStatements = [];
-    if (reName) {
-        depsFiles = await duplicateHandlers.renamed(depsFiles, namesMap, callNameMap, importNameMap, exportNameMap, compilerOptions);
-    }
-    else {
-        depsFiles = await duplicateHandlers.notRenamed(depsFiles, namesMap, compilerOptions);
+    const duplicate = async (reName) => {
+        if (reName) {
+            // order is important here
+            const re_name = resolves([
+                // collector
+                [bundleCreator, duplicateCollectionVisitor, compilerOptions, namesMap],
+                // update
+                [
+                    bundleCreator,
+                    duplicateUpdateVisitor,
+                    compilerOptions,
+                    namesMap,
+                    callNameMap,
+                ],
+                // call exp
+                [
+                    bundleCreator,
+                    duplicateCallExpressionVisitor,
+                    compilerOptions,
+                    callNameMap,
+                    importNameMap,
+                ],
+                // export exp
+                [
+                    bundleCreator,
+                    duplicateExportExpressionVisitor,
+                    compilerOptions,
+                    importNameMap,
+                    exportNameMap,
+                ],
+                // import exp
+                [
+                    bundleCreator,
+                    duplicateImportExpressionVisitor,
+                    compilerOptions,
+                    exportNameMap,
+                    importNameMap,
+                ],
+                // export exp again
+                [
+                    bundleCreator,
+                    duplicateExportExpressionVisitor,
+                    compilerOptions,
+                    importNameMap,
+                    exportNameMap,
+                ],
+                // export exp again
+                [
+                    bundleCreator,
+                    duplicateExportExpressionVisitor,
+                    compilerOptions,
+                    importNameMap,
+                    exportNameMap,
+                ],
+            ]); // re_name
+            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([
+                // collector
+                [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 :`);
+                    // biome-ignore lint/suspicious/useIterableCallbackReturn : just log warn
+                    files.forEach((f) => console.warn(`  - ${f.file}`));
+                }
+            });
+            await utilities.wait(1000);
+            if (_err) {
+                process.exit(1);
+            }
+        }
+    };
+    // 1. Call dependency plugins
+    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);
+                }
+            }
+        }
+    } //--
+    await utilities.wait(1000);
+    // 2. Handle duplicates
+    await duplicate(reName);
+    // 3. Handling anonymous imports and exports
+    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);
+    // 4. Remove Imports
     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);
+    // 5. Remove Exports from dependencies only
     const removeExports = resolves([
-        [removeExportExpressionHandler, compilerOptions],
+        [bundleCreator, removeExportsVisitor, compilerOptions],
     ]);
     const removeExport = await removeExports.concurrent();
+    // not remove exports from entry file
     const deps_files = depsFiles.slice(0, -1).map(removeExport[0]);
     const mainFile = depsFiles.slice(-1);
+    // 6. Handle imported statements
+    // filter removed statements , that not from local like `./` or `../`
     const regexp = /["']((?!\.\/|\.\.\/)[^"']+)["']/;
     removedStatements = removedStatements.filter((i) => regexp.test(i));
-    removedStatements = mergeImports(removedStatements);
+    removedStatements = mergeImportsStatement(removedStatements);
+    // 7. Create final content
+    // make sure all imports are at the top of file
     const importStatements = removedStatements.join("\n").trim();
     const depFilesContent = deps_files
         .map((i) => {
@@ -240,80 +1166,48 @@ 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);
+    // text join order is important here
+    let content = `${importStatements}\n${depFilesContent}\n${mainFileContent}`;
+    // 8. Call pre-process plugins
+    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);
+        }
+    } //--
+    // 9. Returns
+    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) => {
+//src/lib/compile/host.ts
+/**
+ * Creates a ts.CompilerHost that can be used with the typescript compiler.
+ * This host is designed to be used with in-memory compilation and will
+ * return the source file for the given fileName and will write all output
+ * files to the createdFiles object.
+ * @param {string} sourceCode - the source code to compile
+ * @param {string} fileName - the name of the file to compile
+ * @returns {{createdFiles: Record<string, string>, host: ts.CompilerHost}}
+ */
+function createHost(sourceCode, fileName) {
     const createdFiles = {};
     const host = {
         getSourceFile: (file, languageVersion) => {
@@ -335,80 +1229,129 @@ 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);
+//src/lib/compile/package.ts
+const isCjs = (files) => files.commonjs && files.commonjsTypes;
+const isEsm = (files) => files.esm && files.esmTypes;
+/**
+ * Builds a package exports mapping for the given output files and export path.
+ *
+ * Produces the appropriate export shape based on whether CommonJS and/or ESM
+ * artifacts are present, including their default entry points and type
+ * definitions. If neither format is available, returns an empty object.
+ *
+ * @param files - The build output file paths for CommonJS/ESM and their types.
+ * @param exportPath - The subpath export key (e.g. "." or "./feature").
+ * @returns A {@link Exports} object describing the package exports map.
+ */
+function getExports(files, exportPath) {
+    return isCjs(files) && isEsm(files)
+        ? {
+            [exportPath]: {
+                import: {
+                    types: `./${path.relative(process.cwd(), files.esmTypes)}`,
+                    default: `./${path.relative(process.cwd(), files.esm)}`,
+                },
+                require: {
+                    types: `./${path.relative(process.cwd(), files.commonjsTypes)}`,
+                    default: `./${path.relative(process.cwd(), files.commonjs)}`,
+                },
+            },
+        }
+        : isCjs(files) && !isEsm(files)
+            ? {
+                [exportPath]: {
+                    require: {
+                        types: `./${path.relative(process.cwd(), files.commonjsTypes)}`,
+                        default: `./${path.relative(process.cwd(), files.commonjs)}`,
+                    },
+                },
+            }
+            : !isCjs(files) && isEsm(files)
+                ? {
+                    [exportPath]: {
+                        import: {
+                            types: `./${path.relative(process.cwd(), files.esmTypes)}`,
+                            default: `./${path.relative(process.cwd(), files.esm)}`,
+                        },
+                    },
+                }
+                : {};
 }
-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,
-        })));
+/**
+ * Writes an updated `package.json` based on output files and export path.
+ *
+ * Determines module type (ESM/CommonJS), adjusts `main`, `module`, `types`,
+ * and `exports` fields, and preserves other existing fields from the
+ * current `package.json`.
+ *
+ * @param files - The generated output files used to populate entry points.
+ * @param exportPath - The export path for subpath exports; "." denotes main export.
+ */
+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);
+//src/lib/compile/index.ts
+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 +1361,49 @@ 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`));
+        // init
+        const fileName = point.fileName;
+        const sourceCode = point.bundledContent;
+        const format = point.format;
+        const plugins = point.plugins;
+        const compilerOptions = point.tsOptions.cjs;
+        // create host
         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,61 +1413,121 @@ 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`));
+        // init
+        const fileName = point.fileName;
+        const sourceCode = point.bundledContent;
+        const format = point.format;
+        const plugins = point.plugins;
+        const compilerOptions = point.tsOptions.esm;
+        // create host
         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`));
+    }
+    /**
+     * Compile bundled code for each entry point.
+     * This function will iterate through each entry point and compile code according to the format specified.
+     * If the format is "commonjs", it will compile the code into commonjs format.
+     * If the format is "esm", it will compile the code into esm format.
+     * If the format is "both", it will compile the code into both commonjs and esm formats.
+     * If the allowUpdatePackageJson flag is set to true, it will update the package.json according to the compiled file paths.
+     */
+    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) {
+//src/lib/init/checks.ts
+var checks;
+(function (checks) {
+    /**
+     * Checks the given dependencies for type errors. If any type errors are found,
+     * an error message is printed to the console and the process exits with a code of 1.
+     * @param dep The dependencies to check for type errors
+     * @param compilerOptions The compiler options to use when checking for type errors
+     * @returns true if no type errors are found, false otherwise
+     */
+    function typesCheck(dep, compilerOptions) {
         if (!compilerOptions.noCheck) {
-            const filePaths = deps.map((i) => i.file);
+            const filePaths = dep.map((i) => i.file);
             let _err = false;
+            // Create program
             const program = ts.createProgram(filePaths, compilerOptions);
+            // Check each file individually for immediate feedback
             for (const filePath of filePaths) {
                 const sourceFile = program.getSourceFile(filePath);
                 if (!sourceFile) {
@@ -552,28 +1556,25 @@ 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) {
+    }
+    /**
+     * Check the module type of the given dependencies.
+     * @param _dep The dependencies to check for module type
+     * @returns true if all dependencies are ESM, false otherwise
+     */
+    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 {
+                // Create a TypeScript source file
                 const sourceFile = ts.createSourceFile(dep.file, dep.content, ts.ScriptTarget.Latest, true);
                 let hasESMImports = false;
                 let hasCommonJS = false;
+                // Walk through the AST to detect module syntax
                 function walk(node) {
+                    // Check for ESM import/export syntax
                     if (ts.isImportDeclaration(node) ||
                         ts.isImportEqualsDeclaration(node) ||
                         ts.isExportDeclaration(node) ||
@@ -581,6 +1582,7 @@ const depsCheck = {
                         ts.isExportAssignment(node)) {
                         hasESMImports = true;
                     }
+                    // Check for export modifier on declarations
                     if ((ts.isVariableStatement(node) ||
                         ts.isFunctionDeclaration(node) ||
                         ts.isInterfaceDeclaration(node) ||
@@ -590,6 +1592,7 @@ const depsCheck = {
                         node.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword)) {
                         hasESMImports = true;
                     }
+                    // Check for CommonJS require/exports
                     if (ts.isCallExpression(node)) {
                         if (ts.isIdentifier(node.expression) &&
                             node.expression.text === "require" &&
@@ -597,6 +1600,7 @@ const depsCheck = {
                             hasCommonJS = true;
                         }
                     }
+                    // Check for module.exports or exports.xxx
                     if (ts.isPropertyAccessExpression(node)) {
                         const text = node.getText(sourceFile);
                         if (text.startsWith("module.exports") ||
@@ -604,9 +1608,11 @@ const depsCheck = {
                             hasCommonJS = true;
                         }
                     }
+                    // Continue walking the AST
                     ts.forEachChild(node, walk);
                 }
                 walk(sourceFile);
+                // Determine the module format based on what we found
                 if (hasESMImports && !hasCommonJS) {
                     _esmCount++;
                 }
@@ -614,15 +1620,16 @@ const depsCheck = {
                     cjsCount++;
                 }
                 else if (hasESMImports && hasCommonJS) {
+                    // Mixed - probably ESM with dynamic imports or similar
                     _esmCount++;
                 }
             }
             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 +1638,31 @@ 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 = {}));
+//src/lib/init/config.ts
+// -------------
 const getConfigPath = () => {
     const fileNames = ["susee.config.ts", "susee.config.js", "susee.config.mjs"];
     let configFile;
@@ -763,24 +1675,25 @@ const getConfigPath = () => {
     }
     return configFile;
 };
+//---------
 function checkEntries(entries) {
     if (entries.length < 1) {
         console.error(tcolor.magenta(`No entry found in susee.config file, at least one entry required`));
         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) {
@@ -790,6 +1703,11 @@ function checkEntries(entries) {
         }
     }
 }
+/**
+ * Get SuSee configuration from susee.config file (susee.config.ts, susee.config.js, susee.config.mjs)
+ * @returns {Promise<ConfigReturns>} - SuSee configuration
+ * @throws {Error} - when no susee.config file found
+ */
 async function getConfig() {
     const configPath = getConfigPath();
     if (configPath === undefined) {
@@ -800,151 +1718,236 @@ 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,
+            // TODO check for defined out dir here or in config.ts
+            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)}`,
-                        },
-                    },
-                }
-                : {};
+//src/lib/init/deps.ts
+//---------------
+async function fileSizes(path) {
+    const s = await fs.promises.stat(path);
+    const logical = s.size; // bytes in file
+    const allocated = s.blocks !== null ? s.blocks * 512 : null; // bytes actually allocated (POSIX)
+    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;
+    }
+};
+/**
+ * Generate dependencies graph for given entry file.
+ *
+ * This function will return an array of dependencies file objects.
+ * Each object will contain the following properties:
+ * - file: path to the file
+ * - content: content of the file
+ * - length: length of the content in bytes
+ * - includeDefExport: whether the file includes export default or export = statement
+ * - size: an object containing the following properties:
+ *   - logical: size of the file in bytes
+ *   - allocated: size of the file in bytes on disk
+ *   - utf8: size of the file in bytes when encoded in utf8
+ *   - buffBytes: size of the file in bytes when encoded in buffer
+ *
+ * @param {string} entryFile - path to the entry file
+ * @param {SuseePlugins} plugins - array of plugins
+ * @returns {Promise<DepsFiles>}
+ */
+async function generateDependencies(entryFile, plugins) {
+    const deps = await dependencies(entryFile);
+    const sorted = deps.sort(); // get dependencies graph
+    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));
+    // call dependency plugins
+    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,
+//src/lib/init/tsCompilerOptions.ts
+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;
+        // normalize types into an array
+        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();
+    }
+}
+/**
+ * Returns an instance of GetOptions, which provides various methods
+ * to generate different sets of compiler options based on the
+ * given Point.
+ *
+ * @param {Point} point - The point to generate compiler options for.
+ * @returns {GetOptions}
+ */
+function getOptions(point) {
+    return new GetOptions(point);
+}
+//src/lib/init/index.ts
+/**
+ * This function takes a susee configuration object and returns a promise that resolves with a `CollatedReturn` object.
+ * The function iterates over the `points` array in the susee configuration object.
+ * For each point, it generates the dependencies using the `generateDependencies` function.
+ * It then checks if the dependencies are valid using the `checks.init` function.
+ * If the dependencies are invalid, it exits the process with code 1.
+ * If the dependencies are valid, it constructs a `CollatedPoint` object and adds it to the result array.
+ * Finally, it returns a `CollatedReturn` object with the result array and the `allowUpdatePackageJson` flag.
+ */
+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,
+    };
+}
+//src/index.ts
+/**
+ * Bundles a TypeScript project into a single file.
+ * The function takes a {@link SuSeeConfig} object as input and returns a promise resolves with a bundled result.
+ * The function applies the following steps:
+ * 1. Call dependency plugins.
+ * 2. Handle duplicates.
+ * 3. Handling anonymous imports and exports.
+ * 4. Remove Imports.
+ * 5. Remove Exports from dependencies only.
+ * 6. Handle imported statements.
+ * 7. Create final content.
+ * 8. Call pre-process plugins.
+ * 9. Returns.
+ */
+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