@suseejs/duplicates 0.1.2 → 0.1.3

package/dist/index.mjs

@@ -1,60 +1,22 @@
 // cSpell:disable
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import path from "node:path";
 import resolves from "@phothinmaung/resolves";
 import transformFunction from "@suseejs/transformer";
+import utilities from "@suseejs/utils";
 import ts from "typescript";
-/**
- * Returns an object with methods to generate unique names based on a prefix.
- * The `setPrefix` method sets a prefix for the generated names.
- * The `getName` method generates a unique name based on the prefix and an input string.
- * The `getPrefix` method returns the prefix associated with a key.
- * If a prefix is set multiple times, an error will be thrown.
- */
-function uniqueName() {
-    var storedPrefix = new Map();
-    var obj = {
-        setPrefix: function (_a) {
-            var key = _a.key, value = _a.value;
-            var names = [];
-            var _fix;
+// construct maps
+const namesMap = new Map();
+const callNameMap = [];
+const importNameMap = [];
+const exportNameMap = [];
+function __uniqueName() {
+    const storedPrefix = new Map();
+    const obj = {
+        setPrefix({ key, value }) {
+            const names = [];
+            let _fix;
             if (storedPrefix.has(key)) {
-                console.warn("".concat(key, " already exist"));
+                console.warn(`${key} already exist`);
                 throw new Error();
             }
             else {
@@ -62,16 +24,16 @@ function uniqueName() {
                 storedPrefix.set(key, value);
             }
             function getName(input) {
-                var length = names.length;
-                var _name = _fix
-                    ? "".concat(_fix).concat(input, "_").concat(length + 1)
-                    : "$nyein".concat(input, "_").concat(length + 1);
+                const length = names.length;
+                const _name = _fix
+                    ? `${_fix}${input}_${length + 1}`
+                    : `$nyein${input}_${length + 1}`;
                 names.push(_name);
                 return _name;
             }
-            return { getName: getName };
+            return { getName };
         },
-        getPrefix: function (key) {
+        getPrefix(key) {
             if (storedPrefix.has(key)) {
                 return storedPrefix.get(key);
             }
@@ -79,21 +41,21 @@ function uniqueName() {
     };
     return obj;
 }
-var dupName = uniqueName().setPrefix({
+const dupName = __uniqueName().setPrefix({
     key: "DuplicatesNames",
-    value: "d_",
+    value: "__duplicatesNames__",
 });
-var normalizePathKey = function (filePath) {
-    var parsed = path.parse(filePath);
-    var noExt = path.join(parsed.dir, parsed.name);
+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);
 };
-var getFileKey = function (filePath) { return normalizePathKey(filePath); };
-var getModuleKeyFromSpecifier = function (moduleSpecifier, sourceFile, containingFile) {
-    var spec = "";
+const getFileKey = (filePath) => normalizePathKey(filePath);
+const getModuleKeyFromSpecifier = (moduleSpecifier, sourceFile, containingFile) => {
+    let spec = "";
     if (ts.isStringLiteral(moduleSpecifier)) {
         spec = moduleSpecifier.text;
     }
@@ -101,31 +63,23 @@ var getModuleKeyFromSpecifier = function (moduleSpecifier, sourceFile, containin
         spec = moduleSpecifier.getText(sourceFile).replace(/^['"]|['"]$/g, "");
     }
     if (spec.startsWith(".") || spec.startsWith("/")) {
-        var baseDir = path.dirname(containingFile);
+        const baseDir = path.dirname(containingFile);
         return normalizePathKey(path.resolve(baseDir, spec));
     }
     return spec;
 };
-/**
- * A bundle handler that transforms call expression in a given source file.
- * @param callNameMap - A mapping of base names to new names for call expressions.
- * @param importNameMap - A mapping of base names to new names for import expressions.
- * @param compilerOptions - The compiler options for the TypeScript compiler.
- * @return A new source file with transformed call expressions.
- */
-var callExpression = function (callNameMap, importNameMap, compilerOptions) {
-    return function (_a) {
-        var file = _a.file, content = _a.content;
-        var sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
-        var transformer = function (context) {
-            var factory = context.factory;
-            var visitor = function (node) {
+const callExpression = (compilerOptions) => {
+    return ({ file, content, ...rest }) => {
+        const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+        const transformer = (context) => {
+            const { factory } = context;
+            const visitor = (node) => {
                 if (ts.isCallExpression(node)) {
                     if (ts.isIdentifier(node.expression)) {
-                        var base_1 = node.expression.text;
-                        var new_name = null;
-                        var mapping = callNameMap.find(function (m) { return m.base === base_1 && m.file === file; });
-                        var importMapping = importNameMap.find(function (m) { return m.base === base_1 && m.file === file; });
+                        const base = node.expression.text;
+                        let new_name = null;
+                        const mapping = callNameMap.find((m) => m.base === base && m.file === file);
+                        const importMapping = importNameMap.find((m) => m.base === base && m.file === file);
                         if (mapping) {
                             new_name = mapping.newName;
                         }
@@ -140,10 +94,10 @@ var callExpression = function (callNameMap, importNameMap, compilerOptions) {
                 }
                 else if (ts.isPropertyAccessExpression(node)) {
                     if (ts.isIdentifier(node.expression)) {
-                        var base_2 = node.expression.text;
-                        var new_name = null;
-                        var mapping = callNameMap.find(function (m) { return m.base === base_2 && m.file === file; });
-                        var importMapping = importNameMap.find(function (m) { return m.base === base_2 && m.file === file; });
+                        const base = node.expression.text;
+                        let new_name = null;
+                        const mapping = callNameMap.find((m) => m.base === base && m.file === file);
+                        const importMapping = importNameMap.find((m) => m.base === base && m.file === file);
                         if (mapping) {
                             new_name = mapping.newName;
                         }
@@ -157,10 +111,10 @@ var callExpression = function (callNameMap, importNameMap, compilerOptions) {
                 }
                 else if (ts.isNewExpression(node)) {
                     if (ts.isIdentifier(node.expression)) {
-                        var base_3 = node.expression.text;
-                        var new_name = null;
-                        var mapping = callNameMap.find(function (m) { return m.base === base_3 && m.file === file; });
-                        var importMapping = importNameMap.find(function (m) { return m.base === base_3 && m.file === file; });
+                        const base = node.expression.text;
+                        let new_name = null;
+                        const mapping = callNameMap.find((m) => m.base === base && m.file === file);
+                        const importMapping = importNameMap.find((m) => m.base === base && m.file === file);
                         if (mapping) {
                             new_name = mapping.newName;
                         }
@@ -176,39 +130,28 @@ var callExpression = function (callNameMap, importNameMap, compilerOptions) {
                 return ts.visitEachChild(node, visitor, context);
             }; // visitor;
             /* --------------------Returns for transformer function--------------------------------- */
-            return function (rootNode) { return ts.visitNode(rootNode, visitor); };
+            return (rootNode) => ts.visitNode(rootNode, visitor);
         }; // transformer;
         /* --------------------Returns for main handler function--------------------------------- */
-        var _content = transformFunction(transformer, sourceFile, compilerOptions);
-        return { file: file, content: _content };
+        const _content = transformFunction(transformer, sourceFile, compilerOptions);
+        return { file, content: _content, ...rest };
     }; // returns
 };
-/**
- * A bundle handler that renames the exported expression according to the given maps.
- * It will traverse the given source file and rename the exported expression if a mapping is found.
- *
- * @param callNameMap - A map of base names to new names for function calls.
- * @param importNameMap - A map of base names to new names for import expressions.
- * @param exportNameMap - A map of base names to new names for export expressions.
- * @param compilerOptions - The options for the TypeScript compiler.
- * @returns A bundle handler that takes a source file and returns a new source file with the renamed exported expressions.
- */
-var exportExpression = function (callNameMap, importNameMap, exportNameMap, compilerOptions) {
-    return function (_a) {
-        var file = _a.file, content = _a.content;
-        var sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
-        var transformer = function (context) {
-            var factory = context.factory;
-            var visitor = function (node) {
+const exportExpression = (compilerOptions) => {
+    return ({ file, content, ...rest }) => {
+        const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+        const transformer = (context) => {
+            const { factory } = context;
+            const visitor = (node) => {
                 if (ts.isExportSpecifier(node)) {
                     if (ts.isIdentifier(node.name)) {
-                        var base_4 = node.name.text;
-                        var new_name = null;
-                        var mapping = callNameMap.find(function (m) { return m.base === base_4 && m.file === file; });
-                        var importMapping = importNameMap.find(function (m) { return m.base === base_4 && m.file === file; });
+                        const base = node.name.text;
+                        let new_name = null;
+                        const mapping = callNameMap.find((m) => m.base === base && m.file === file);
+                        const importMapping = importNameMap.find((m) => m.base === base && m.file === file);
                         if (mapping) {
                             exportNameMap.push({
-                                base: base_4,
+                                base,
                                 file: getFileKey(file),
                                 newName: mapping.newName,
                             });
@@ -223,15 +166,15 @@ var exportExpression = function (callNameMap, importNameMap, exportNameMap, comp
                     }
                 }
                 else if (ts.isExportAssignment(node)) {
-                    var expr = node.expression;
+                    const expr = node.expression;
                     if (ts.isIdentifier(expr)) {
-                        var base_5 = expr.text;
-                        var new_name = null;
-                        var mapping = callNameMap.find(function (m) { return m.base === base_5 && m.file === file; });
-                        var importMapping = importNameMap.find(function (m) { return m.base === base_5 && m.file === file; });
+                        const base = expr.text;
+                        let new_name = null;
+                        const mapping = callNameMap.find((m) => m.base === base && m.file === file);
+                        const importMapping = importNameMap.find((m) => m.base === base && m.file === file);
                         if (mapping) {
                             exportNameMap.push({
-                                base: base_5,
+                                base,
                                 file: getFileKey(file),
                                 newName: mapping.newName,
                             });
@@ -249,49 +192,38 @@ var exportExpression = function (callNameMap, importNameMap, exportNameMap, comp
                 return ts.visitEachChild(node, visitor, context);
             }; // visitor;
             /* --------------------Returns for transformer function--------------------------------- */
-            return function (rootNode) { return ts.visitNode(rootNode, visitor); };
+            return (rootNode) => ts.visitNode(rootNode, visitor);
         }; // transformer;
         /* --------------------Returns for main handler function--------------------------------- */
-        var _content = transformFunction(transformer, sourceFile, compilerOptions);
-        return { file: file, content: _content };
+        const _content = transformFunction(transformer, sourceFile, compilerOptions);
+        return { file, content: _content, ...rest };
     }; // returns
 };
-/**
- * A bundle handler that transforms import expressions in a given source file.
- * @param exportNameMap - A mapping of base names to new names for export expressions.
- * @param importNameMap - A mapping of base names to new names for import expressions.
- * @param compilerOptions - The compiler options for the TypeScript compiler.
- * @return A new source file with transformed import expressions.
- */
-var importExpression = function (exportNameMap, importNameMap, compilerOptions) {
-    return function (_a) {
-        var file = _a.file, content = _a.content;
-        var sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
-        var transformer = function (context) {
-            var factory = context.factory;
-            var visitor = function (node) {
-                var _a, _b;
+const importExpression = (compilerOptions) => {
+    return ({ file, content, ...rest }) => {
+        const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+        const transformer = (context) => {
+            const { factory } = context;
+            const visitor = (node) => {
                 if (ts.isImportDeclaration(node)) {
-                    var moduleKey_1 = getModuleKeyFromSpecifier(node.moduleSpecifier, sourceFile, file);
-                    var baseNames = [];
-                    if (((_a = node.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings) &&
+                    const moduleKey = getModuleKeyFromSpecifier(node.moduleSpecifier, sourceFile, file);
+                    let baseNames = [];
+                    if (node.importClause?.namedBindings &&
                         ts.isNamedImports(node.importClause.namedBindings)) {
-                        baseNames = node.importClause.namedBindings.elements.map(function (el) {
-                            return el.name.text.trim();
-                        });
+                        baseNames = node.importClause.namedBindings.elements.map((el) => el.name.text.trim());
                     }
                     // import default expression
-                    if (((_b = node.importClause) === null || _b === void 0 ? void 0 : _b.name) &&
+                    if (node.importClause?.name &&
                         ts.isIdentifier(node.importClause.name)) {
-                        var base_6 = node.importClause.name.text.trim();
-                        var mapping = exportNameMap.find(function (m) { return m.base === base_6 && m.file === moduleKey_1; });
+                        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: file,
+                                file,
                                 newName: mapping.newName,
                             });
-                            var newImportClause = factory.updateImportClause(node.importClause, node.importClause.phaseModifier, factory.createIdentifier(mapping.newName), node.importClause.namedBindings);
+                            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);
                         }
                     }
@@ -300,20 +232,20 @@ var importExpression = function (exportNameMap, importNameMap, compilerOptions)
                         node.importClause &&
                         node.importClause.namedBindings &&
                         ts.isNamedImports(node.importClause.namedBindings)) {
-                        var updatedElements = node.importClause.namedBindings.elements.map(function (el) {
-                            var mapping = exportNameMap.find(function (m) { return m.base === el.name.text.trim() && m.file === moduleKey_1; });
+                        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: file,
+                                    file,
                                     newName: mapping.newName,
                                 });
                                 return factory.updateImportSpecifier(el, el.isTypeOnly, el.propertyName, factory.createIdentifier(mapping.newName));
                             }
                             return el;
                         });
-                        var newNamedImports = factory.updateNamedImports(node.importClause.namedBindings, updatedElements);
-                        var newImportClause = factory.updateImportClause(node.importClause, node.importClause.phaseModifier, node.importClause.name, newNamedImports);
+                        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);
                     }
                 } //&&
@@ -321,42 +253,31 @@ var importExpression = function (exportNameMap, importNameMap, compilerOptions)
                 return ts.visitEachChild(node, visitor, context);
             }; // visitor;
             /* --------------------Returns for transformer function--------------------------------- */
-            return function (rootNode) { return ts.visitNode(rootNode, visitor); };
+            return (rootNode) => ts.visitNode(rootNode, visitor);
         }; // transformer;
         /* --------------------Returns for main handler function--------------------------------- */
-        var _content = transformFunction(transformer, sourceFile, compilerOptions);
-        return { file: file, content: _content };
+        const _content = transformFunction(transformer, sourceFile, compilerOptions);
+        return { file, content: _content, ...rest };
     }; // returns
 };
-/**
- * A bundle handler that collects information about the usage of given names in a given source file.
- * It will traverse the given source file and collect information about the usage of given names.
- * The information will be stored in a namesMap.
- * @param namesMap - A map of base names to new names for function calls, import expressions, and export expressions.
- * @param compilerOptions - The options for the TypeScript compiler.
- * @return A new source file with collected information.
- */
-var collector = function (namesMap, compilerOptions) {
-    return function (_a) {
-        var file = _a.file, content = _a.content;
-        var sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
-        var transformer = function (context) {
-            function visitNode(node, isGlobalScope) {
-                var _a;
-                if (isGlobalScope === void 0) { isGlobalScope = true; }
+const collector = (compilerOptions) => {
+    return ({ file, content, ...rest }) => {
+        const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+        const transformer = (context) => {
+            function visitNode(node, isGlobalScope = true) {
                 // Global declarations များကိုသာ collect လုပ်မယ်
                 if (isGlobalScope) {
                     // Variable statements (const, let, var)
                     if (ts.isVariableStatement(node)) {
-                        node.declarationList.declarations.forEach(function (decl) {
+                        node.declarationList.declarations.forEach((decl) => {
                             if (ts.isIdentifier(decl.name)) {
-                                var $name = decl.name.text;
+                                const $name = decl.name.text;
                                 if (!namesMap.has($name)) {
-                                    namesMap.set($name, new Set([{ file: file }]));
+                                    namesMap.set($name, new Set([{ file }]));
                                 }
                                 else {
                                     // biome-ignore  lint/style/noNonNullAssertion : !namesMap.has($name) before
-                                    namesMap.get($name).add({ file: file });
+                                    namesMap.get($name).add({ file });
                                 }
                             }
                         });
@@ -367,14 +288,14 @@ var collector = function (namesMap, compilerOptions) {
                         ts.isEnumDeclaration(node) ||
                         ts.isInterfaceDeclaration(node) ||
                         ts.isTypeAliasDeclaration(node)) {
-                        var $name = (_a = node.name) === null || _a === void 0 ? void 0 : _a.text;
+                        const $name = node.name?.text;
                         if ($name) {
                             if (!namesMap.has($name)) {
-                                namesMap.set($name, new Set([{ file: file }]));
+                                namesMap.set($name, new Set([{ file }]));
                             }
                             else {
                                 // biome-ignore  lint/style/noNonNullAssertion : !namesMap.has($name) before
-                                namesMap.get($name).add({ file: file });
+                                namesMap.get($name).add({ file });
                             }
                         }
                     }
@@ -388,79 +309,69 @@ var collector = function (namesMap, compilerOptions) {
                     ts.isClassDeclaration(node)) {
                     // Local scope ထဲကို ဝင်သွားပြီဆိုတာနဲ့ isGlobalScope = false
                     if (ts.isBlock(node)) {
-                        ts.visitNodes(node.statements, function (child) { return visitNode(child, false); });
+                        ts.visitNodes(node.statements, (child) => visitNode(child, false));
                     }
                     else {
-                        ts.forEachChild(node, function (child) {
+                        ts.forEachChild(node, (child) => {
                             visitNode(child, false);
                         });
                     }
                 }
                 else {
                     // Global scope ထဲဆက်ရှိနေတဲ့ node တွေအတွက်
-                    return ts.visitEachChild(node, function (child) { return visitNode(child, isGlobalScope); }, context);
+                    return ts.visitEachChild(node, (child) => visitNode(child, isGlobalScope), context);
                 }
                 /* ----------------------Returns for visitNode function------------------------------- */
                 return node;
             } // visitNode
             /* --------------------Returns for transformer function--------------------------------- */
-            return function (rootNode) { return visitNode(rootNode, true); };
+            return (rootNode) => visitNode(rootNode, true);
         }; // transformer;
         /* --------------------Returns for main handler function--------------------------------- */
-        var _content = transformFunction(transformer, sourceFile, compilerOptions);
-        return { file: file, content: _content };
+        const _content = transformFunction(transformer, sourceFile, compilerOptions);
+        return { file, content: _content, ...rest };
     }; // returns
 };
-/**
- * A bundle handler that updates the given source file based on the given namesMap and callNameMap.
- * It will traverse the given source file and update the names of the exported expressions, call expressions, and import expressions if a mapping is found in the callNameMap.
- * The updated source file will be returned.
- * @param namesMap - A map of base names to new names for function calls, import expressions, and export expressions.
- * @param callNameMap - A map of base names to new names for call expressions.
- * @param compilerOptions - The options for the TypeScript compiler.
- * @returns A new source file with updated names.
- */
-var updater = function (namesMap, callNameMap, compilerOptions) {
-    return function (_a) {
-        var file = _a.file, content = _a.content;
-        var sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
-        var transformer = function (context) {
-            var factory = context.factory;
-            var visitor = function (node) {
+const updater = (compilerOptions) => {
+    return ({ file, content, ...rest }) => {
+        const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+        const transformer = (context) => {
+            const { factory } = context;
+            const visitor = (node) => {
                 if (ts.isVariableStatement(node)) {
-                    var newDeclarations = node.declarationList.declarations.map(function (decl) {
+                    const newDeclarations = node.declarationList.declarations.map((decl) => {
                         if (ts.isIdentifier(decl.name)) {
-                            var base = decl.name.text;
+                            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) {
-                                var newName = dupName.getName(base);
-                                callNameMap.push({ base: base, file: file, newName: newName });
+                                const newName = dupName.getName(base);
+                                callNameMap.push({ base, file, newName });
                                 return factory.updateVariableDeclaration(decl, factory.createIdentifier(newName), decl.exclamationToken, decl.type, decl.initializer);
                             }
                         }
                         return decl;
                     });
-                    var newDeclList = factory.updateVariableDeclarationList(node.declarationList, newDeclarations);
+                    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)) {
-                        var base = node.name.text;
+                        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) {
-                            var newName = dupName.getName(base);
-                            callNameMap.push({ base: base, file: file, newName: newName });
+                            const newName = dupName.getName(base);
+                            callNameMap.push({ base, 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)) {
-                        var base = node.name.text;
+                        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) {
-                            var newName = dupName.getName(base);
-                            callNameMap.push({ base: base, file: file, newName: newName });
+                            const newName = dupName.getName(base);
+                            callNameMap.push({ base, file, newName });
                             return factory.updateClassDeclaration(node, node.modifiers, factory.createIdentifier(newName), node.typeParameters, node.heritageClauses, node.members);
                         }
                     }
@@ -469,17 +380,14 @@ var updater = function (namesMap, callNameMap, compilerOptions) {
                 return ts.visitEachChild(node, visitor, context);
             }; // visitor;
             /* --------------------Returns for transformer function--------------------------------- */
-            return function (rootNode) { return ts.visitNode(rootNode, visitor); };
+            return (rootNode) => ts.visitNode(rootNode, visitor);
         }; // transformer;
         /* --------------------Returns for main handler function--------------------------------- */
-        var _content = transformFunction(transformer, sourceFile, compilerOptions);
-        return { file: file, content: _content };
+        const _content = transformFunction(transformer, sourceFile, compilerOptions);
+        return { file, content: _content, ...rest };
     }; // returns
 };
-var wait = function (time) {
-    return new Promise(function (resolve) { return setTimeout(resolve, time); });
-};
-var duplicateHandlers = {
+const duplicateHandlers = {
     /**
      * A bundle handler that takes a list of source files and transforms them into renamed source files.
      * The transformation is done in a series of steps, each step transforms the source files based on the given maps.
@@ -492,43 +400,23 @@ var duplicateHandlers = {
      * @param compilerOptions - The options for the TypeScript compiler.
      * @returns A list of transformed source files.
      */
-    renamed: function (deps, namesMap, callNameMap, importNameMap, exportNameMap, compilerOptions) { return __awaiter(void 0, void 0, Promise, function () {
-        var duplicates, duplicate, _i, duplicate_1, func;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    duplicates = resolves([
-                        [collector, namesMap, compilerOptions],
-                        [updater, namesMap, callNameMap, compilerOptions],
-                        [callExpression, callNameMap, importNameMap, compilerOptions],
-                        [
-                            exportExpression,
-                            callNameMap,
-                            importNameMap,
-                            exportNameMap,
-                            compilerOptions,
-                        ],
-                        [importExpression, exportNameMap, importNameMap, compilerOptions],
-                        [callExpression, callNameMap, importNameMap, compilerOptions],
-                        [
-                            exportExpression,
-                            callNameMap,
-                            importNameMap,
-                            exportNameMap,
-                            compilerOptions,
-                        ],
-                    ]);
-                    return [4 /*yield*/, duplicates.concurrent()];
-                case 1:
-                    duplicate = _a.sent();
-                    for (_i = 0, duplicate_1 = duplicate; _i < duplicate_1.length; _i++) {
-                        func = duplicate_1[_i];
-                        deps = deps.map(func);
-                    }
-                    return [2 /*return*/, deps];
-            }
-        });
-    }); },
+    renamed: async (deps, compilerOptions) => {
+        // order is important here
+        const duplicates = resolves([
+            [collector, compilerOptions],
+            [updater, compilerOptions],
+            [callExpression, compilerOptions],
+            [exportExpression, compilerOptions],
+            [importExpression, compilerOptions],
+            [callExpression, compilerOptions],
+            [exportExpression, compilerOptions],
+        ]);
+        const duplicate = await duplicates.concurrent();
+        for (const func of duplicate) {
+            deps = deps.map(func);
+        }
+        return deps;
+    },
     /**
      * A bundle handler that takes a list of source files and checks if they have been renamed correctly.
      * If a source file has not been renamed, an error will be thrown.
@@ -537,38 +425,26 @@ var duplicateHandlers = {
      * @param compilerOptions - The options for the TypeScript compiler.
      * @returns A list of source files that have been renamed correctly.
      */
-    notRenamed: function (deps, namesMap, compilerOptions) { return __awaiter(void 0, void 0, Promise, function () {
-        var _err, duplicates, duplicate;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _err = false;
-                    duplicates = resolves([[collector, namesMap, compilerOptions]]);
-                    return [4 /*yield*/, duplicates.concurrent()];
-                case 1:
-                    duplicate = _a.sent();
-                    deps.map(duplicate[0]);
-                    return [4 /*yield*/, wait(1000)];
-                case 2:
-                    _a.sent();
-                    namesMap.forEach(function (files, name) {
-                        if (files.size > 1) {
-                            _err = true;
-                            console.warn("Name -> ".concat(name, " declared in multiple files :"));
-                            // biome-ignore lint/suspicious/useIterableCallbackReturn : just log warn
-                            files.forEach(function (f) { return console.warn("  - ".concat(f.file)); });
-                        }
-                    });
-                    return [4 /*yield*/, wait(500)];
-                case 3:
-                    _a.sent();
-                    if (_err) {
-                        process.exit(1);
-                    }
-                    return [2 /*return*/, deps];
+    notRenamed: async (deps, compilerOptions) => {
+        let _err = false;
+        const duplicates = resolves([[collector, namesMap, compilerOptions]]);
+        const duplicate = await duplicates.concurrent();
+        deps.map(duplicate[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(500);
+        if (_err) {
+            process.exit(1);
+        }
+        return deps;
+    },
 };
 export default duplicateHandlers;
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.mjs.map