susee 0.1.2 → 0.1.3

package/dist/index.mjs

@@ -15,6 +15,14 @@ import transformFunction from "@suseejs/transformer";
 import ts from "typescript";
 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);
@@ -28,12 +36,14 @@ const bundleCreator = (bundleVisitor, compilerOptions, ...args) => {
         return { content: _content, ...rest };
     };
 };
+//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)
@@ -42,6 +52,7 @@ function mergeImportsStatement(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];
@@ -53,6 +64,7 @@ function mergeImportsStatement(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());
@@ -61,9 +73,11 @@ function mergeImportsStatement(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];
@@ -73,6 +87,7 @@ function mergeImportsStatement(imports) {
             }
         }
         else {
+            // Default import: import name from 'module'
             const targetMap = isTypeImport ? typeDefaultImports : defaultImports;
             if (!targetMap.has(modulePath))
                 targetMap.set(modulePath, new Set());
@@ -80,8 +95,10 @@ function mergeImportsStatement(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)) {
@@ -93,14 +110,17 @@ function mergeImportsStatement(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)) {
@@ -112,12 +132,14 @@ function mergeImportsStatement(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(", ");
@@ -126,6 +148,11 @@ function mergeImportsStatement(imports) {
     }
     return mergedImports.sort();
 }
+//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) => {
@@ -155,6 +182,7 @@ const anonymousCallExpressionVisitor = (context, depsTree, _sourceFile, exportDe
                     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)) {
@@ -169,6 +197,7 @@ const anonymousCallExpressionVisitor = (context, depsTree, _sourceFile, exportDe
     };
     return visit;
 };
+//src/lib/bundle/visitors/visitorHelpers.ts
 const normalizePathKey = (filePath) => {
     const parsed = path.parse(filePath);
     let noExt = path.join(parsed.dir, parsed.name);
@@ -224,8 +253,13 @@ function uniqueName() {
     };
     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) => {
@@ -335,17 +369,23 @@ const anonymousExportVisitor = (context, depsTree, sourceFile, exportDefaultExpo
                 });
                 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);
@@ -365,6 +405,11 @@ const anonymousImportVisitor = (context, depsTree, sourceFile, exportDefaultExpo
     };
     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) => {
@@ -379,6 +424,7 @@ const duplicateCallExpressionVisitor = (context, depsTree, _sourceFile, callName
                 }
                 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);
@@ -419,13 +465,28 @@ const duplicateCallExpressionVisitor = (context, depsTree, _sourceFile, callName
                 }
             }
         }
+        /* ----------------------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)) {
@@ -434,11 +495,13 @@ const duplicateCollectionVisitor = (context, depsTree, _sourceFile, namesMap) =>
                             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) ||
@@ -450,17 +513,20 @@ const duplicateCollectionVisitor = (context, depsTree, _sourceFile, namesMap) =>
                         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));
             }
@@ -471,12 +537,19 @@ const duplicateCollectionVisitor = (context, depsTree, _sourceFile, namesMap) =>
             }
         }
         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) => {
@@ -525,10 +598,23 @@ const duplicateExportExpressionVisitor = (context, depsTree, _sourceFile, callNa
                 }
             }
         }
+        /* ----------------------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) => {
@@ -539,6 +625,7 @@ const duplicateImportExpressionVisitor = (context, depsTree, sourceFile, exportN
                 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);
@@ -552,6 +639,7 @@ const duplicateImportExpressionVisitor = (context, depsTree, sourceFile, exportN
                     return factory.updateImportDeclaration(node, node.modifiers, newImportClause, node.moduleSpecifier, node.attributes);
                 }
             }
+            // import name , `import{ ... }`
             if (baseNames.length > 0 &&
                 node.importClause &&
                 node.importClause.namedBindings &&
@@ -572,15 +660,28 @@ const duplicateImportExpressionVisitor = (context, depsTree, sourceFile, exportN
                 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) => {
@@ -588,6 +689,7 @@ const duplicateUpdateVisitor = (context, depsTree, _sourceFile, namesMap, callNa
             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 });
@@ -602,6 +704,7 @@ const duplicateUpdateVisitor = (context, depsTree, _sourceFile, namesMap, callNa
         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 });
@@ -612,6 +715,7 @@ const duplicateUpdateVisitor = (context, depsTree, _sourceFile, namesMap, callNa
         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 });
@@ -619,13 +723,21 @@ const duplicateUpdateVisitor = (context, depsTree, _sourceFile, namesMap, callNa
                 }
             }
         }
+        /* ----------------------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) ||
@@ -637,40 +749,49 @@ const removeExportsVisitor = (context) => {
                 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 = [];
@@ -682,7 +803,14 @@ function findProperty(node) {
     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) {
@@ -704,6 +832,7 @@ const removeImportsVisitor = (context, depsTree, sourceFile, removedStatements)
             importedString: undefined,
             importedObject: undefined,
         };
+        // --- Case: TypeReference with QualifiedName (collect type usage)
         if (ts.isTypeReferenceNode(node) &&
             ts.isQualifiedName(node.typeName) &&
             ts.isIdentifier(node.typeName.left) &&
@@ -717,17 +846,23 @@ const removeImportsVisitor = (context, depsTree, sourceFile, removedStatements)
             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;
@@ -747,10 +882,12 @@ const removeImportsVisitor = (context, depsTree, sourceFile, removedStatements)
             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}";`;
                         }
@@ -771,11 +908,13 @@ const removeImportsVisitor = (context, depsTree, sourceFile, removedStatements)
             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) {
@@ -784,6 +923,7 @@ const removeImportsVisitor = (context, depsTree, sourceFile, removedStatements)
                     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;
@@ -825,15 +965,35 @@ const removeImportsVisitor = (context, depsTree, sourceFile, removedStatements)
                 }
             }
         }
+        // --------- 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 = [];
@@ -843,8 +1003,11 @@ async function bundler(point) {
     let removedStatements = [];
     const duplicate = async (reName) => {
         if (reName) {
+            // order is important here
             const re_name = resolves([
+                // collector
                 [bundleCreator, duplicateCollectionVisitor, compilerOptions, namesMap],
+                // update
                 [
                     bundleCreator,
                     duplicateUpdateVisitor,
@@ -852,6 +1015,7 @@ async function bundler(point) {
                     namesMap,
                     callNameMap,
                 ],
+                // call exp
                 [
                     bundleCreator,
                     duplicateCallExpressionVisitor,
@@ -859,6 +1023,7 @@ async function bundler(point) {
                     callNameMap,
                     importNameMap,
                 ],
+                // export exp
                 [
                     bundleCreator,
                     duplicateExportExpressionVisitor,
@@ -866,6 +1031,7 @@ async function bundler(point) {
                     importNameMap,
                     exportNameMap,
                 ],
+                // import exp
                 [
                     bundleCreator,
                     duplicateImportExpressionVisitor,
@@ -873,6 +1039,7 @@ async function bundler(point) {
                     exportNameMap,
                     importNameMap,
                 ],
+                // export exp again
                 [
                     bundleCreator,
                     duplicateExportExpressionVisitor,
@@ -880,6 +1047,7 @@ async function bundler(point) {
                     importNameMap,
                     exportNameMap,
                 ],
+                // export exp again
                 [
                     bundleCreator,
                     duplicateExportExpressionVisitor,
@@ -887,7 +1055,7 @@ async function bundler(point) {
                     importNameMap,
                     exportNameMap,
                 ],
-            ]);
+            ]); // re_name
             const re_name_call = await re_name.concurrent();
             for (const call of re_name_call) {
                 await utilities.wait(500);
@@ -897,6 +1065,7 @@ async function bundler(point) {
         else {
             let _err = false;
             const un_rename = resolves([
+                // collector
                 [bundleCreator, duplicateCollectionVisitor, compilerOptions, namesMap],
             ]);
             const un_rename_call = await un_rename.concurrent();
@@ -906,6 +1075,7 @@ async function bundler(point) {
                 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}`));
                 }
             });
@@ -915,6 +1085,7 @@ async function bundler(point) {
             }
         }
     };
+    // 1. Call dependency plugins
     if (plugins.length) {
         for (let plugin of plugins) {
             plugin = typeof plugin === "function" ? plugin() : plugin;
@@ -927,9 +1098,11 @@ async function bundler(point) {
                 }
             }
         }
-    }
+    } //--
     await utilities.wait(1000);
+    // 2. Handle duplicates
     await duplicate(reName);
+    // 3. Handling anonymous imports and exports
     const anonymous = resolves([
         [
             bundleCreator,
@@ -956,21 +1129,28 @@ async function bundler(point) {
         depsFiles = depsFiles.map(call);
     }
     await utilities.wait(1000);
+    // 4. Remove Imports
     const removeImports = resolves([
         [bundleCreator, removeImportsVisitor, compilerOptions, removedStatements],
     ]);
     const removeImport = await removeImports.concurrent();
     depsFiles = depsFiles.map(removeImport[0]);
     await utilities.wait(500);
+    // 5. Remove Exports from dependencies only
     const removeExports = resolves([
         [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 = 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) => {
@@ -987,7 +1167,9 @@ async function bundler(point) {
         .join("\n")
         .trim();
     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;
@@ -1000,7 +1182,8 @@ async function bundler(point) {
                 }
             }
         }
-    }
+    } //--
+    // 9. Returns
     return { bundledContent: content, ...point };
 }
 async function bundle(object) {
@@ -1014,6 +1197,16 @@ async function bundle(object) {
         allowUpdatePackageJson: object.allowUpdatePackageJson,
     };
 }
+//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 = {
@@ -1037,19 +1230,31 @@ function createHost(sourceCode, fileName) {
     };
     return { createdFiles, host };
 }
+//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: {
-                    default: `./${path.relative(process.cwd(), files.esm)}`,
                     types: `./${path.relative(process.cwd(), files.esmTypes)}`,
+                    default: `./${path.relative(process.cwd(), files.esm)}`,
                 },
                 require: {
-                    default: `./${path.relative(process.cwd(), files.commonjs)}`,
                     types: `./${path.relative(process.cwd(), files.commonjsTypes)}`,
+                    default: `./${path.relative(process.cwd(), files.commonjs)}`,
                 },
             },
         }
@@ -1057,8 +1262,8 @@ function getExports(files, exportPath) {
             ? {
                 [exportPath]: {
                     require: {
-                        default: `./${path.relative(process.cwd(), files.commonjs)}`,
                         types: `./${path.relative(process.cwd(), files.commonjsTypes)}`,
+                        default: `./${path.relative(process.cwd(), files.commonjs)}`,
                     },
                 },
             }
@@ -1066,13 +1271,23 @@ function getExports(files, exportPath) {
                 ? {
                     [exportPath]: {
                         import: {
-                            default: `./${path.relative(process.cwd(), files.esm)}`,
                             types: `./${path.relative(process.cwd(), files.esmTypes)}`,
+                            default: `./${path.relative(process.cwd(), files.esm)}`,
                         },
                     },
                 }
                 : {};
 }
+/**
+ * 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 !== ".") {
@@ -1125,6 +1340,7 @@ async function writePackage(files, exportPath) {
     };
     utilities.writeCompileFile(pkgFile, JSON.stringify(pkgJson, null, 2));
 }
+//src/lib/compile/index.ts
 function splitCamelCase(str) {
     const splitString = str
         .replace(/([a-z])([A-Z])/g, "$1 $2")
@@ -1153,17 +1369,20 @@ class Compiler {
         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 (plugins.length) {
                 for (let plugin of plugins) {
                     plugin = typeof plugin === "function" ? plugin() : plugin;
@@ -1206,11 +1425,13 @@ class Compiler {
         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;
@@ -1230,6 +1451,7 @@ class Compiler {
                     }
                 }
             }
+            // ------------------------------------------
             if (this._isUpdate()) {
                 if (outName.match(/.js/g)) {
                     this.files.esm = outName.replace(/.js/g, ".mjs");
@@ -1252,6 +1474,14 @@ class Compiler {
         });
         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);
@@ -1281,13 +1511,23 @@ class Compiler {
         }
     }
 }
+//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 = 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) {
@@ -1317,16 +1557,24 @@ var checks;
             }
         }
     }
+    /**
+     * 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 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) ||
@@ -1334,6 +1582,7 @@ var checks;
                         ts.isExportAssignment(node)) {
                         hasESMImports = true;
                     }
+                    // Check for export modifier on declarations
                     if ((ts.isVariableStatement(node) ||
                         ts.isFunctionDeclaration(node) ||
                         ts.isInterfaceDeclaration(node) ||
@@ -1343,6 +1592,7 @@ var checks;
                         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" &&
@@ -1350,6 +1600,7 @@ var checks;
                             hasCommonJS = true;
                         }
                     }
+                    // Check for module.exports or exports.xxx
                     if (ts.isPropertyAccessExpression(node)) {
                         const text = node.getText(sourceFile);
                         if (text.startsWith("module.exports") ||
@@ -1357,9 +1608,11 @@ var checks;
                             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++;
                 }
@@ -1367,6 +1620,7 @@ var checks;
                     cjsCount++;
                 }
                 else if (hasESMImports && hasCommonJS) {
+                    // Mixed - probably ESM with dynamic imports or similar
                     _esmCount++;
                 }
             }
@@ -1407,6 +1661,8 @@ var checks;
     }
     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;
@@ -1419,6 +1675,7 @@ 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`));
@@ -1446,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) {
@@ -1465,6 +1727,7 @@ async function getConfig() {
             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);
@@ -1475,10 +1738,12 @@ async function getConfig() {
         allowUpdatePackageJson: config.allowUpdatePackageJson ?? true,
     };
 }
+//src/lib/init/deps.ts
+//---------------
 async function fileSizes(path) {
     const s = await fs.promises.stat(path);
-    const logical = s.size;
-    const allocated = s.blocks !== null ? s.blocks * 512 : null;
+    const logical = s.size; // bytes in file
+    const allocated = s.blocks !== null ? s.blocks * 512 : null; // bytes actually allocated (POSIX)
     return { logical, allocated };
 }
 const checkExport = (str, file) => {
@@ -1492,9 +1757,28 @@ const checkExport = (str, file) => {
         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();
+    const sorted = deps.sort(); // get dependencies graph
     let depsFiles = [];
     await utilities.wait(1000);
     for (const dep of sorted) {
@@ -1517,6 +1801,7 @@ async function generateDependencies(entryFile, plugins) {
         };
         depsFiles.push(_files);
     }
+    // call dependency plugins
     if (plugins.length) {
         for (const plugin of plugins) {
             const _plug = typeof plugin === "function" ? plugin() : plugin;
@@ -1533,6 +1818,7 @@ async function generateDependencies(entryFile, plugins) {
     }
     return depsFiles;
 }
+//src/lib/init/tsCompilerOptions.ts
 class GetOptions {
     constructor(point) {
         this._point = point;
@@ -1554,6 +1840,7 @@ class GetOptions {
     __init2() {
         this.__init();
         let { types, lib, ...restOptions } = this._options;
+        // normalize types into an array
         if (types) {
             if (!types.includes("node")) {
                 types = ["node", ...types];
@@ -1584,9 +1871,27 @@ class GetOptions {
         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;
@@ -1619,6 +1924,21 @@ async function collections() {
         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();