susee 1.6.2 → 2.0.0

package/dist/index.mjs

@@ -1,3436 +0,0 @@
-/*! *****************************************************************************
-Copyright (c) Pho Thin Mg <phothinmg@disroot.org>
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-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 fs from "node:fs";
-import module from "node:module";
-import path from "node:path";
-import process from "node:process";
-import readline from "node:readline/promises";
-import tcolor from "@suseejs/color";
-import ts6 from "@suseejs/ts6";
-//src/helpers/files.ts
-var files;
-(function (files_1) {
-    const root = process.cwd();
-    function resolvePath(pathStr) {
-        return path.resolve(root, pathStr);
-    }
-    files_1.resolvePath = resolvePath;
-    function relativePath(pathStr) {
-        return path.relative(root, pathStr);
-    }
-    files_1.relativePath = relativePath;
-    function joinPath(...paths) {
-        return path.join(...paths);
-    }
-    files_1.joinPath = joinPath;
-    function existsPath(pathStr) {
-        return fs.existsSync(resolvePath(pathStr));
-    }
-    files_1.existsPath = existsPath;
-    async function deleteFile(filePath) {
-        if (existsPath(filePath)) {
-            await fs.promises.unlink(filePath);
-        }
-    }
-    files_1.deleteFile = deleteFile;
-    async function readFile(filePath) {
-        if (!existsPath(filePath)) {
-            console.error(tcolor.magenta(`> ${filePath} does not exists `));
-            process.exit(1);
-        }
-        filePath = resolvePath(filePath);
-        const readContent = await fs.promises.readFile(filePath);
-        return {
-            str: readContent.toString("utf8"),
-            bytes: readContent.byteLength,
-        };
-    }
-    files_1.readFile = readFile;
-    async function readJsonFile(filePath) {
-        const read = await readFile(filePath);
-        return JSON.parse(read.str);
-    }
-    files_1.readJsonFile = readJsonFile;
-    async function createDirectory(dirPath) {
-        dirPath = resolvePath(dirPath);
-        if (!existsPath(dirPath)) {
-            await fs.promises.mkdir(dirPath, { recursive: true });
-        }
-    }
-    files_1.createDirectory = createDirectory;
-    function parentPath(filePath) {
-        return path.dirname(resolvePath(filePath));
-    }
-    files_1.parentPath = parentPath;
-    async function writeFile(filePath, content) {
-        if (existsPath(filePath))
-            await deleteFile(filePath);
-        await createDirectory(parentPath(filePath));
-        filePath = resolvePath(filePath);
-        await fs.promises.writeFile(filePath, content);
-    }
-    files_1.writeFile = writeFile;
-    async function clearFolder(folderPath) {
-        folderPath = resolvePath(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,
-            })));
-        }
-        catch (error) {
-            // biome-ignore lint/suspicious/noExplicitAny: error code
-            if (error.code !== "ENOENT") {
-                throw error;
-            }
-        }
-    }
-    files_1.clearFolder = clearFolder;
-    // -------------------------------------------------------------------------------------------//
-    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: {
-                        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 writePackageJson(files, exportPath) {
-        let isMain = true;
-        if (exportPath !== ".") {
-            isMain = false;
-        }
-        const pkgFile = resolvePath("package.json");
-        const pkgtext = await readJsonFile(pkgFile);
-        let { name, version, description, main, module, type, types, exports, ...rest } = pkgtext;
-        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) },
-            };
-        }
-        const pkgJson = {
-            name,
-            version,
-            description,
-            type,
-            ..._main,
-            ..._types,
-            ..._module,
-            ..._exports,
-            ...rest,
-        };
-        await writeFile(pkgFile, JSON.stringify(pkgJson, null, 2));
-    }
-    files_1.writePackageJson = writePackageJson;
-})(files || (files = {}));
-//src/helpers/utilities.ts
-var utils;
-(function (utils) {
-    let checks;
-    (function (checks) {
-        checks.moduleType = (content, file) => {
-            let _esmCount = 0;
-            let cjsCount = 0;
-            let unknownCount = 0;
-            const sourceFile = ts6.createSourceFile(file, content, ts6.ScriptTarget.Latest, true);
-            try {
-                let hasESMImports = false;
-                let hasCommonJS = false;
-                // Walk through the AST to detect module syntax
-                function walk(node) {
-                    // Check for ESM import/export syntax
-                    if (ts6.isImportDeclaration(node) ||
-                        ts6.isImportEqualsDeclaration(node) ||
-                        ts6.isExportDeclaration(node) ||
-                        ts6.isExportSpecifier(node) ||
-                        ts6.isExportAssignment(node)) {
-                        hasESMImports = true;
-                    }
-                    // Check for export modifier on declarations
-                    if ((ts6.isVariableStatement(node) ||
-                        ts6.isFunctionDeclaration(node) ||
-                        ts6.isInterfaceDeclaration(node) ||
-                        ts6.isTypeAliasDeclaration(node) ||
-                        ts6.isEnumDeclaration(node) ||
-                        ts6.isClassDeclaration(node)) &&
-                        node.modifiers?.some((mod) => mod.kind === ts6.SyntaxKind.ExportKeyword)) {
-                        hasESMImports = true;
-                    }
-                    // Check for CommonJS require/exports
-                    if (ts6.isCallExpression(node)) {
-                        if (ts6.isIdentifier(node.expression) &&
-                            node.expression.text === "require" &&
-                            node.arguments.length > 0) {
-                            hasCommonJS = true;
-                        }
-                    }
-                    // Check for module.exports or exports.xxx
-                    if (ts6.isPropertyAccessExpression(node)) {
-                        const text = node.getText(sourceFile);
-                        if (text.startsWith("module.exports") ||
-                            text.startsWith("exports.")) {
-                            hasCommonJS = true;
-                        }
-                    }
-                    // Continue walking the AST
-                    ts6.forEachChild(node, walk);
-                } //---
-                walk(sourceFile);
-                // Determine the module format based on what we found
-                if (hasESMImports && !hasCommonJS) {
-                    _esmCount++;
-                }
-                else if (hasCommonJS && !hasESMImports) {
-                    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 ${file} : \n ${error}`));
-                unknownCount++;
-            }
-            if (unknownCount > 0) {
-                console.error(tcolor.magenta(`Error checking module format.`));
-                ts6.sys.exit(1);
-            }
-            return {
-                isCommonJs: cjsCount > 0,
-                isEsm: _esmCount > 0,
-            };
-        };
-        /**
-         * Checks if the given code string contains JSX syntax.
-         * @param code The content of the file as a string.
-         * @returns true if the file contains JSX, false otherwise.
-         */
-        function isJsxContent(code) {
-            const sourceFile = ts6.createSourceFile("file.tsx", code, ts6.ScriptTarget.Latest, 
-            /*setParentNodes*/ true, ts6.ScriptKind.TSX);
-            let containsJsx = false;
-            function visitor(node) {
-                // Check for JSX Elements, Self Closing Elements, or JSX Fragments
-                if (ts6.isJsxElement(node) ||
-                    ts6.isJsxSelfClosingElement(node) ||
-                    ts6.isJsxFragment(node)) {
-                    containsJsx = true;
-                    return;
-                }
-                ts6.forEachChild(node, visitor);
-            }
-            visitor(sourceFile);
-            return containsJsx;
-        }
-        checks.isJsxContent = isJsxContent;
-        /**
-         * Checks if a given node is inside a namespace declaration.
-         * It does this by traversing up the parent nodes until it finds a module declaration with the namespace flag set.
-         * @param n The node to check.
-         * @returns true if the node is inside a namespace declaration, false otherwise.
-         */
-        checks.isInsideNamespace = (n) => {
-            let current = n.parent;
-            while (current) {
-                if (ts6.isModuleDeclaration(current) &&
-                    current.flags === ts6.NodeFlags.Namespace) {
-                    return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        };
-        /**
-         * Check if a given module is a Node.js built-in module.
-         * @param {string} input - The module to check.
-         * @returns {boolean} True if the module is a Node.js built-in module, false otherwise.
-         */
-        checks.isNodeBuiltinModule = (input) => {
-            const nodeModuleSpecifier = "node:";
-            const nodeBuiltinModules = new Set(module.builtinModules);
-            return (input.startsWith(nodeModuleSpecifier) || nodeBuiltinModules.has(input));
-        };
-    })(checks = utils.checks || (utils.checks = {})); // namespace checks
-    let promises;
-    (function (promises) {
-        function isPromiseFun(fun) {
-            return (Object.prototype.toString.call(fun) === "[object AsyncFunction]" ||
-                fun.constructor.name === "AsyncFunction");
-        }
-        function walkPromise(param) {
-            const fn = param[0];
-            const args = param.slice(1);
-            if (isPromiseFun(fn)) {
-                return async () => await fn(...args);
-            }
-            else {
-                return async () => fn(...args);
-            }
-        }
-        function resolve(params) {
-            const funs = params.map((w) => walkPromise(w));
-            const series = async () => {
-                const results = [];
-                for (const [index, task] of funs.entries()) {
-                    try {
-                        const result = await task();
-                        results.push(result);
-                    }
-                    catch (error) {
-                        console.error(`Error in task ${index + 1}`);
-                        throw error;
-                    }
-                }
-                return results;
-            };
-            const concurrent = async () => {
-                try {
-                    return await Promise.all(funs.map((f) => f()));
-                }
-                catch (error) {
-                    console.error("One of the functions rejected:", error);
-                    throw error;
-                }
-            };
-            const allSettled = async () => {
-                try {
-                    const settled = await Promise.allSettled(funs.map((f) => f()));
-                    const fulfilled = settled.filter((re) => re.status === "fulfilled");
-                    const rejected = settled.filter((re) => re.status === "rejected");
-                    if (rejected.length > 0) {
-                        console.warn("One of the functions rejected:", rejected[0]?.reason);
-                        process.exit(1);
-                    }
-                    return fulfilled.map((re) => re.value);
-                }
-                catch (error) {
-                    console.error("One of the functions rejected:", error);
-                    throw error;
-                }
-            };
-            return {
-                series: series,
-                concurrent: concurrent,
-                allSettled: allSettled,
-            };
-        }
-        promises.resolve = resolve;
-        async function run(fun, time, ...args) {
-            return new Promise((resolve, reject) => {
-                try {
-                    const t = time ? 0 : time;
-                    const result = fun(...args);
-                    setTimeout(() => resolve(result), t);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        }
-        promises.run = run;
-        // biome-ignore-end lint/suspicious/noExplicitAny: unknown
-    })(promises = utils.promises || (utils.promises = {})); // namespace promises
-    let gen;
-    (function (gen) {
-        gen.mergeStringArr = (input) => {
-            return input.reduce((prev, curr) => prev.concat(curr), []);
-        };
-        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;
-        }
-        gen.splitCamelCase = splitCamelCase;
-        function packageJson() {
-            const packageContent = fs.readFileSync(path.resolve(process.cwd(), "package.json"), "utf8");
-            const pkg = JSON.parse(packageContent);
-            const name = pkg.name ?? "";
-            const version = pkg.version ?? "";
-            /**
-             * Get package name and version
-             * @returns {string}
-             */
-            const pkgNameVersion = () => {
-                let pkg_nv = "";
-                if (name !== "" && version !== "") {
-                    pkg_nv = `${name}@${version}`;
-                }
-                else if (name !== "" && version === "") {
-                    pkg_nv = `${name}`;
-                }
-                else if (name === "" && version !== "") {
-                    pkg_nv = `the project@${version}`;
-                }
-                else {
-                    pkg_nv = "the project";
-                }
-                return pkg_nv;
-            };
-            const dependencies = () => {
-                const deps = Object.keys(pkg.dependencies ?? {});
-                const devDeps = Object.keys(pkg.devDependencies ?? {});
-                return [...deps, ...devDeps];
-            };
-            // -----------------------------------------
-            return { pkgNameVersion, dependencies };
-        }
-        gen.packageJson = packageJson;
-        /**
-         * Merge a list of import statements into a minimal set of import statements.
-         * The algorithm works by grouping imports by module path and then merging them into a single import statement.
-         * Type imports are processed first, and then regular imports are processed.
-         * The resulting import statements are sorted alphabetically by module path.
-         * @param imports - A list of import statements to merge.
-         * @returns A list of merged import statements.
-         */
-        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)
-                    continue;
-                const [, importClause, _modulePath] = importMatch;
-                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];
-                        const targetMap = isTypeImport
-                            ? typeDefaultImports
-                            : defaultImports;
-                        if (!targetMap.has(modulePath))
-                            targetMap.set(modulePath, new Set());
-                        targetMap.get(modulePath)?.add(importName);
-                    }
-                    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());
-                    const names = importClause
-                        .replace(/[{}]/g, "")
-                        .split(",")
-                        .map((s) => s.trim())
-                        .filter(Boolean);
-                    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];
-                        if (!namespaceImports.has(modulePath))
-                            namespaceImports.set(modulePath, new Set());
-                        namespaceImports.get(modulePath)?.add(namespaceName);
-                    }
-                }
-                else {
-                    // Default import: import name from 'module'
-                    const targetMap = isTypeImport ? typeDefaultImports : defaultImports;
-                    if (!targetMap.has(modulePath))
-                        targetMap.set(modulePath, new Set());
-                    targetMap.get(modulePath)?.add(importClause.trim());
-                }
-            }
-            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)) {
-                        finalNames.add(typeName);
-                    }
-                }
-                if (finalNames.size > 0) {
-                    const importNames = Array.from(finalNames).sort().join(", ");
-                    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)) {
-                        finalNames.add(typeName);
-                    }
-                }
-                if (finalNames.size > 0) {
-                    const importNames = Array.from(finalNames).join(", ");
-                    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(", ");
-                    mergedImports.push(`import * as ${importNames} from "${modulePath}";`);
-                }
-            }
-            return mergedImports.sort();
-        } //--
-        gen.mergeImportsStatement = mergeImportsStatement;
-        /**
-         * Applies a given transformer to a source file and returns the modified code.
-         * @param transformer A transformer factory that will be called with the source file.
-         * @param sourceFile The source file to which the transformer will be applied.
-         * @param compilerOptions Compiler options to use when applying the transformer.
-         * @returns The modified code after applying the transformer.
-         */
-        function transformFunction(transformer, sourceFile, compilerOptions) {
-            const transformationResult = ts6.transform(sourceFile, [transformer], compilerOptions);
-            const transformedSourceFile = transformationResult.transformed[0];
-            const printer = ts6.createPrinter({
-                newLine: ts6.NewLineKind.LineFeed,
-                removeComments: false,
-            });
-            const modifiedCode = printer.printFile(transformedSourceFile);
-            transformationResult.dispose();
-            return modifiedCode;
-        } //--
-        gen.transformFunction = transformFunction;
-        /**
-         * Finds all the properties accessed in the given node.
-         * @param {ts6.Node} node - The node to search through.
-         * @returns {string[]} - An array of all the properties accessed.
-         */
-        function findProperty(node) {
-            const properties = [];
-            function walk(n) {
-                if (ts6.isPropertyAccessExpression(n) &&
-                    ts6.isIdentifier(n.expression)) {
-                    properties.push(n.expression.text);
-                }
-                n.forEachChild(walk);
-            }
-            walk(node);
-            return properties;
-        }
-        gen.findProperty = findProperty;
-    })(gen = utils.gen || (utils.gen = {})); // namespace gen
-})(utils || (utils = {})); // namespace utils
-const getScopeNodeLabel = (sourceFile, node, index) => {
-    if (ts6.isModuleDeclaration(node)) {
-        return `namespace:${node.name.getText(sourceFile)}`;
-    }
-    if (ts6.isClassDeclaration(node)) {
-        return `class:${node.name?.text ?? `anonymous-${index}`}`;
-    }
-    if (ts6.isFunctionDeclaration(node) || ts6.isFunctionExpression(node)) {
-        return `function:${node.name?.text ?? `anonymous-${index}`}`;
-    }
-    if (ts6.isArrowFunction(node)) {
-        return `arrow:${index}`;
-    }
-    if (ts6.isMethodDeclaration(node)) {
-        return `method:${node.name.getText(sourceFile)}`;
-    }
-    if (ts6.isBlock(node)) {
-        return `block:${index}`;
-    }
-    return `${ts6.SyntaxKind[node.kind].toLowerCase()}:${index}`;
-};
-const getScopeKey = (file, scopeStack) => {
-    if (scopeStack.length === 0) {
-        return "global";
-    }
-    return `${file}::${scopeStack.join(" > ")}`;
-};
-const isScopeNode = (node) => ts6.isModuleDeclaration(node) ||
-    ts6.isClassDeclaration(node) ||
-    ts6.isFunctionDeclaration(node) ||
-    ts6.isFunctionExpression(node) ||
-    ts6.isArrowFunction(node) ||
-    ts6.isMethodDeclaration(node) ||
-    ts6.isBlock(node);
-const collectDeclarationNames = (node) => {
-    if (ts6.isVariableStatement(node)) {
-        return node.declarationList.declarations.flatMap((decl) => {
-            if (!ts6.isIdentifier(decl.name)) {
-                return [];
-            }
-            return [{ name: decl.name.text, positionNode: decl.name }];
-        });
-    }
-    if (ts6.isFunctionDeclaration(node) ||
-        ts6.isClassDeclaration(node) ||
-        ts6.isEnumDeclaration(node) ||
-        ts6.isInterfaceDeclaration(node) ||
-        ts6.isTypeAliasDeclaration(node)) {
-        if (node.name) {
-            return [{ name: node.name.text, positionNode: node.name }];
-        }
-    }
-    return [];
-};
-const collectDuplicateDeclarations = (deps, bundledSourceFile) => {
-    const duplicateNameMap = new Map();
-    const addDuplicateDeclaration = (scopeKey, name, file, sourceFile, positionNode) => {
-        const { line, character } = sourceFile.getLineAndCharacterOfPosition(positionNode.getStart(sourceFile));
-        const location = {
-            file,
-            line: line + 1,
-            column: character + 1,
-        };
-        const duplicateKey = `${scopeKey}::${name}`;
-        if (!duplicateNameMap.has(duplicateKey)) {
-            duplicateNameMap.set(duplicateKey, {
-                name,
-                locations: new Set([location]),
-            });
-            return;
-        }
-        duplicateNameMap.get(duplicateKey)?.locations.add(location);
-    };
-    const collectFile = (file, sourceFile, node, scopeStack = []) => {
-        const scopeKey = getScopeKey(file, scopeStack);
-        for (const declaration of collectDeclarationNames(node)) {
-            addDuplicateDeclaration(scopeKey, declaration.name, file, sourceFile, declaration.positionNode);
-        }
-        if (isScopeNode(node)) {
-            const nextScopeStack = [
-                ...scopeStack,
-                getScopeNodeLabel(sourceFile, node, node.getStart(sourceFile)),
-            ];
-            ts6.forEachChild(node, (child) => {
-                collectFile(file, sourceFile, child, nextScopeStack);
-            });
-            return;
-        }
-        ts6.forEachChild(node, (child) => {
-            collectFile(file, sourceFile, child, scopeStack);
-        });
-    };
-    for (const dep of deps) {
-        const sourceFile = bundledSourceFile(dep.file, dep.content);
-        collectFile(dep.file, sourceFile, sourceFile);
-    }
-    return duplicateNameMap;
-};
-const checkDuplicates = (tree, bundledSourceFile) => {
-    let _err = false;
-    const duplicateNameMap = collectDuplicateDeclarations(tree.depFiles, bundledSourceFile);
-    duplicateNameMap.forEach(({ name, locations }) => {
-        if (locations.size > 1) {
-            _err = true;
-            console.warn(tcolor.yellow("[susee:error]"));
-            console.warn("  Duplicate declarations found in your dependencies tree as follows:");
-            console.warn(`  - "${tcolor.magenta(name)}" declared in multiple files : `);
-            locations.forEach((f) => console.warn(`    - ${f.file}:${f.line}:${f.column}`));
-            console.info("Please rename these with different names to avoid duplicate declarations.");
-        }
-    });
-    if (_err) {
-        process.exit(1);
-    }
-    return tree;
-};
-//src/dependencies/graph.ts
-// ----------------------------------------------------Handlers------------------------------------------------------//
-function handleImports(node, processFn) {
-    // Handle : import declaration
-    if (ts6.isImportDeclaration(node) && node.moduleSpecifier) {
-        const moduleText = node.moduleSpecifier
-            .getText()
-            .replace(/^['"`]|['"`]$/g, "");
-        processFn(moduleText);
-        return;
-    } //--
-    // Recursively visit all children
-    ts6.forEachChild(node, (n) => handleImports(n, processFn));
-}
-function handleImportEqual(node, processFn) {
-    // Handle : import equal declaration
-    if (ts6.isImportEqualsDeclaration(node) &&
-        ts6.isExternalModuleReference(node.moduleReference) &&
-        ts6.isStringLiteral(node.moduleReference.expression)) {
-        const moduleText = node.moduleReference.expression.text;
-        processFn(moduleText);
-        return;
-    } //--
-    // Recursively visit all children
-    ts6.forEachChild(node, (n) => handleImportEqual(n, processFn));
-}
-function handleAwaitImport(node, processFn) {
-    // Handle : import equal declaration
-    if (ts6.isAwaitExpression(node) &&
-        ts6.isCallExpression(node.expression) &&
-        node.expression.expression.kind === ts6.SyntaxKind.ImportKeyword) {
-        const firstArg = node.expression.arguments[0];
-        if (firstArg && ts6.isStringLiteral(firstArg)) {
-            processFn(firstArg.text);
-        }
-        return;
-    } //--
-    // Recursively visit all children
-    ts6.forEachChild(node, (n) => handleAwaitImport(n, processFn));
-}
-function handleRequire(node, processFn) {
-    // Handle : require calls , `var foo = require("foo")`
-    // can't handle import equal statement like `import foo = require("foo")`
-    if (ts6.isCallExpression(node) &&
-        ts6.isIdentifier(node.expression) &&
-        node.expression.text === "require" &&
-        node.arguments.length > 0) {
-        // if expression callExpression node's text equal to require
-        // index 0 of arguments is moduleText
-        // I didn't use forEach or for-off loop to avoid multiple processing.
-        const firstArg = node.arguments[0];
-        if (firstArg && ts6.isStringLiteral(firstArg)) {
-            processFn(firstArg.text);
-        }
-        return; // Skip children for property access require calls
-    }
-    // Handle : property access like `var foo = require("foo").foo`
-    if (ts6.isPropertyAccessExpression(node) &&
-        ts6.isCallExpression(node.expression) &&
-        ts6.isIdentifier(node.expression.expression) &&
-        node.expression.expression.text === "require" &&
-        node.expression.arguments.length > 0) {
-        const firstArg = node.expression.arguments[0];
-        if (firstArg && ts6.isStringLiteral(firstArg)) {
-            processFn(firstArg.text);
-        }
-        return; // Skip children for property access require calls
-    }
-    // Recursively visit all children (except for require calls we already processed)
-    ts6.forEachChild(node, (n) => handleRequire(n, processFn));
-}
-function handlers(node, processFn) {
-    Promise.all([
-        handleImports(node, processFn),
-        handleRequire(node, processFn),
-        handleImportEqual(node, processFn),
-        handleAwaitImport(node, processFn),
-    ]);
-}
-// resolved extensions
-const allowedExtensions = new Set([
-    "js",
-    "cjs",
-    "mjs",
-    "ts",
-    "mts",
-    "cts",
-    "jsx",
-    "tsx",
-    "json",
-]);
-function isDir(filePath) {
-    try {
-        const stat = fs.lstatSync(filePath);
-        return stat.isDirectory();
-    }
-    catch (err) {
-        if (typeof err === "object" &&
-            err !== null &&
-            "code" in err &&
-            // biome-ignore lint/suspicious/noExplicitAny: for error log only
-            err.code === "ENOENT") {
-            return false;
-        }
-        throw err;
-    }
-}
-function getFileName(input) {
-    const namePart = path.basename(input).split(".")[0];
-    return namePart ? namePart.trim() : "";
-}
-function getExtensionName(input) {
-    return path.basename(input).split(".")[1]?.trim() || "";
-}
-function resolveExtension(filePath) {
-    let result;
-    let ext;
-    let isDirPath = false;
-    // If it's a directory, look for index file
-    if (isDir(filePath)) {
-        const files = fs.readdirSync(filePath);
-        const found = files.find((file) => getFileName(file) === "index" &&
-            allowedExtensions.has(getExtensionName(file)));
-        if (found) {
-            result = path.join(filePath, found);
-            ext = getExtensionName(found);
-            isDirPath = true;
-        }
-        else {
-            console.error(`${filePath} is a directory and no index file with JS/TS extension found.`); // ----------------------------------------------------------------------------------------------------------//
-            process.exit(1);
-        }
-    }
-    else {
-        // Not a directory: try to resolve extension
-        const dirName = path.dirname(filePath);
-        const baseName = path.basename(filePath);
-        const [fileName, extName = ""] = baseName.split(".");
-        // const files = fs.globSync(
-        //   `${dirName}/**/*.{js,cjs,mjs,ts,cts,mts,jsx,tsx}`
-        // );
-        const files = ts6.sys.readDirectory(dirName);
-        const match = files
-            .map((f) => {
-            const [name, ext = ""] = path.basename(f).split(".");
-            return { name, ext };
-        })
-            .find((f) => f.name === fileName && allowedExtensions.has(f.ext));
-        if (match) {
-            if (!extName) {
-                result = `${filePath}.${match.ext}`;
-                ext = match.ext;
-            }
-            else if (extName === match.ext) {
-                result = filePath;
-                ext = match.ext;
-            }
-            else {
-                const safeExtName = extName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-                result = filePath.replace(new RegExp(`\\.${safeExtName}$`), `.${match.ext}`);
-                ext = match.ext;
-            }
-        }
-        else {
-            // If not found, maybe it's a directory import (e.g. ./lib)
-            if (isDir(filePath)) {
-                const files = fs.readdirSync(filePath);
-                const found = files.find((file) => getFileName(file) === "index" &&
-                    allowedExtensions.has(getExtensionName(file)));
-                if (found) {
-                    result = path.join(filePath, found);
-                    ext = getExtensionName(found);
-                    isDirPath = true;
-                }
-            }
-        }
-    }
-    if (!(result && ext)) {
-        console.error(`When checking ${filePath}, it's not a file or file with unsupported extension`);
-        process.exit(1);
-    }
-    return { result, ext, isDirPath };
-}
-function collectDependencies(entry, collectedDependencies, root) {
-    const dependencies = [];
-    const visited = new Set();
-    const collectedNpmModules = [];
-    const collectedNodeModules = [];
-    const collectedWarning = [];
-    function visit(file, index) {
-        const absPath = path.resolve(root, file);
-        if (visited.has(absPath))
-            return;
-        visited.add(absPath);
-        const { result: checkedAbsPath } = resolveExtension(absPath);
-        if (!fs.existsSync(checkedAbsPath)) {
-            dependencies.push({
-                file: absPath,
-                index,
-                importFiles: [],
-            });
-            collectedWarning.push([`File not found: ${checkedAbsPath}`]);
-        }
-        const content = fs.readFileSync(checkedAbsPath, "utf8");
-        const sourceFile = ts6.createSourceFile(file, content, ts6.ScriptTarget.Latest, true);
-        const importFiles = [];
-        const warn = [];
-        const npmModules = [];
-        const nodeModules = [];
-        function processModule(moduleText) {
-            // Handle : Imported local dependencies of a file.
-            if (moduleText.startsWith(".") || moduleText.startsWith("..")) {
-                // Try to resolve as file or directory
-                const resolvedModulePath = path.resolve(path.dirname(checkedAbsPath), moduleText);
-                // biome-ignore lint/suspicious/noExplicitAny: just let
-                let resolved = {};
-                try {
-                    resolved = resolveExtension(resolvedModulePath);
-                }
-                catch {
-                    // fallback: treat as file with extension
-                    resolved = {
-                        result: resolvedModulePath,
-                        ext: path.extname(resolvedModulePath).slice(1),
-                        isDirPath: false,
-                    };
-                }
-                const relImport = path.relative(root, resolved.result);
-                importFiles.push(relImport);
-            }
-            // Handle : Imported dependencies of node builtin modules of a file.
-            else if (module.builtinModules.includes(moduleText)) {
-                nodeModules.push(moduleText);
-            }
-            // Handle : Imported npm dependencies of a file
-            // Handle : Imported npm dependencies of a file, by checking local package.json
-            // currently only check for these dependencies are  installed or not, depend on project's package.json
-            // TODO try for provide information such as exported files , to use in bundle process
-            else if (collectedDependencies.includes(moduleText)) {
-                npmModules.push(moduleText);
-            }
-            // Unknown dependencies
-            // local dependencies are checked before by resolveExtension function.
-            // TODO try for analyze these errors and provide analyzed report.
-            else {
-                warn.push(moduleText);
-            }
-        }
-        ts6.forEachChild(sourceFile, (node) => handlers(node, processModule));
-        dependencies.push({
-            file: absPath,
-            index,
-            importFiles,
-        });
-        collectedNpmModules.push(npmModules);
-        collectedNodeModules.push(nodeModules);
-        collectedWarning.push(warn);
-        importFiles.forEach((depFile) => visit(depFile, dependencies.length));
-    }
-    visit(entry, 0);
-    return {
-        dependencies,
-        collectedNodeModules,
-        collectedNpmModules,
-        collectedWarning,
-    };
-}
-//
-function getPackageJson() {
-    const packageContent = fs.readFileSync(path.resolve(process.cwd(), "package.json"), "utf8");
-    const pkg = JSON.parse(packageContent);
-    const deps = Object.keys(pkg.dependencies ?? {});
-    const devDeps = Object.keys(pkg.devDependencies ?? {});
-    return [...deps, ...devDeps];
-}
-// Topological sort of a directed acyclic graph (DAG)
-function topoSort(tree) {
-    const visited = new Set();
-    const sorted = [];
-    function visit(node) {
-        if (visited.has(node))
-            return;
-        visited.add(node);
-        (tree[node] || []).forEach(visit);
-        sorted.push(node);
-    }
-    Object.keys(tree).forEach(visit);
-    return sorted; // reverse for correct order
-}
-//  Create a dependency graph from a list of collected dependencies
-const createGraph = (deps) => {
-    const graph = {};
-    for (const dep of deps) {
-        const _name = path.relative(process.cwd(), dep.file);
-        graph[_name] = dep.importFiles;
-    }
-    return graph;
-};
-function generateGraph(entry) {
-    const root = process.cwd();
-    const collectedDependencies = getPackageJson();
-    const collectedData = collectDependencies(entry, collectedDependencies, root);
-    const graphObj = collectedData.dependencies;
-    const npmModules = utils.gen.mergeStringArr(collectedData.collectedNpmModules);
-    const nodeModules = utils.gen.mergeStringArr(collectedData.collectedNodeModules);
-    const warning = utils.gen.mergeStringArr(collectedData.collectedWarning);
-    const depsObj = createGraph(graphObj);
-    const sortedGraph = topoSort(depsObj);
-    return {
-        sort: () => sortedGraph,
-        npm: () => npmModules,
-        node: () => nodeModules,
-        deps: () => depsObj,
-        warn: () => warning,
-    };
-}
-//src/dependencies/index.ts
-async function generateDependencies(entry, bundledSourceFile) {
-    const graph = generateGraph(entry);
-    const sorted = graph.sort();
-    const npm = graph.npm();
-    const nodes = graph.node();
-    const warns = graph.warn();
-    const tree = {
-        entry,
-        npm,
-        nodes,
-        warns,
-        depFiles: [],
-    };
-    const entryBase = path.basename(entry);
-    for (const file of sorted) {
-        const fileBase = path.basename(file);
-        const fileExt = path.extname(file);
-        const read = await files.readFile(file);
-        const content = read.str;
-        const bytes = read.bytes;
-        const mt = utils.checks.moduleType(content, file);
-        const moduleType = fileExt === ".json" ? "json" : mt.isCommonJs ? "cjs" : "esm";
-        const isJsx = utils.checks.isJsxContent(content);
-        const isEntry = entryBase === fileBase;
-        tree.depFiles.push({
-            file,
-            content,
-            bytes,
-            moduleType,
-            fileExt: fileExt,
-            is_jsx: isJsx,
-            is_entry: isEntry,
-        });
-    }
-    return checkDuplicates(tree, bundledSourceFile);
-}
-//src/helpers/profile.ts
-const profileEnvName = "SUSEE_PROFILE";
-const isProfileEnabled = () => {
-    const value = process.env[profileEnvName];
-    return value === "1" || value === "true";
-};
-const setProfileEnabled = (enabled) => {
-    if (enabled) {
-        process.env[profileEnvName] = "1";
-        return;
-    }
-    delete process.env[profileEnvName];
-};
-const formatProfileMs = (start) => {
-    return `${(Number(process.hrtime.bigint() - start) / 1000000).toFixed(1)}ms`;
-};
-const logProfilePhase = (scope, phase, start) => {
-    if (!isProfileEnabled())
-        return;
-    console.log(`[SUSEE_PROFILE][${scope}] ${phase}: ${formatProfileMs(start)}`);
-};
-//src/bundler/lib/helpers.ts
-const isJSON = (tree) => {
-    const json = tree.depFiles.find((file) => file.fileExt === ".json" && file.moduleType === "json");
-    return !!json;
-};
-const jsonExtToTs = (file) => {
-    if (path.extname(file) === ".json") {
-        return file.replace(/.json/g, ".ts");
-    }
-    else {
-        return file;
-    }
-};
-const createBundledSourceFile = (file, content) => {
-    return ts6.createSourceFile(jsonExtToTs(file), content, ts6.ScriptTarget.Latest, true);
-};
-const transformBundledSource = (sourceFile, compilerOptions, transformer) => {
-    return utils.gen.transformFunction(transformer, sourceFile, compilerOptions);
-};
-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 (ts6.isStringLiteral(moduleSpecifier)) {
-        spec = moduleSpecifier.text;
-    }
-    else {
-        spec = moduleSpecifier.getText(sourceFile).replace(/^['"]|['"]$/g, "");
-    }
-    if (spec.startsWith(".") || spec.startsWith("/")) {
-        const baseDir = path.dirname(containingFile);
-        const resolved = path.isAbsolute(containingFile)
-            ? path.resolve(baseDir, spec)
-            : path.normalize(path.join(baseDir, spec));
-        return normalizePathKey(resolved);
-    }
-    return spec;
-};
-//src/bundler/lib/uniqueName.ts
-class UniqueName {
-    _storedPrefix;
-    constructor() {
-        this._storedPrefix = new Map();
-    }
-    setPrefix({ key, value }) {
-        if (this._storedPrefix.has(key)) {
-            const [_prefix, count] = this._storedPrefix.get(key);
-            this._storedPrefix.set(key, [value, count + 1]);
-        }
-        else {
-            this._storedPrefix.set(key, [value, 0]);
-        }
-        return this;
-    }
-    getName(key, input) {
-        const [prefix, count] = this._storedPrefix.get(key) || [];
-        const _name = prefix
-            ? `${prefix}${input}_${(count ?? 0) + 1}`
-            : `__susee__${input}_${(count ?? 0) + 1}`;
-        this._storedPrefix.set(key, [prefix ?? "__susee__", (count ?? 0) + 1]);
-        return _name;
-    }
-    getPrefix(key) {
-        const [prefix] = this._storedPrefix.get(key) || [];
-        return prefix;
-    }
-}
-const uniqueName = new UniqueName();
-//src/bundler/lib/anonymous.ts
-const anonymousExportNameMap = [];
-const anonymousImportNameMap = [];
-const anonymousPrefixKey = "AnonymousName";
-const createAnonymousNameGenerator = () => uniqueName.setPrefix({
-    key: anonymousPrefixKey,
-    value: "susee__anonymous__",
-});
-let anonymousName = createAnonymousNameGenerator();
-function anonymousCallExpressionHandler(compilerOptions) {
-    return ({ file, content, ...rest }) => {
-        const sourceFile = createBundledSourceFile(file, content);
-        const transformer = (context) => {
-            const { factory } = context;
-            function visitor(node) {
-                if (ts6.isCallExpression(node)) {
-                    if (ts6.isIdentifier(node.expression)) {
-                        const base = node.expression.text;
-                        const mapping = anonymousImportNameMap.find((m) => m.base === base && m.file === file);
-                        if (mapping) {
-                            return factory.updateCallExpression(node, factory.createIdentifier(mapping.newName), node.typeArguments, node.arguments);
-                        }
-                    }
-                }
-                else if (ts6.isPropertyAccessExpression(node)) {
-                    if (ts6.isIdentifier(node.expression)) {
-                        const base = node.expression.text;
-                        const mapping = anonymousImportNameMap.find((m) => m.base === base && m.file === file);
-                        if (mapping) {
-                            return factory.updatePropertyAccessExpression(node, factory.createIdentifier(mapping.newName), node.name);
-                        }
-                    }
-                }
-                else if (ts6.isNewExpression(node)) {
-                    if (ts6.isIdentifier(node.expression)) {
-                        const base = node.expression.text;
-                        const mapping = anonymousImportNameMap.find((m) => m.base === base && m.file === 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 (ts6.isExportSpecifier(node)) {
-                    if (ts6.isIdentifier(node.name)) {
-                        const base = node.name.text;
-                        const mapping = anonymousImportNameMap.find((m) => m.base === base && m.file === file);
-                        if (mapping) {
-                            return factory.updateExportSpecifier(node, node.isTypeOnly, node.propertyName, factory.createIdentifier(mapping.newName));
-                        }
-                    }
-                }
-                return ts6.visitEachChild(node, visitor, context);
-            }
-            return (rootNode) => ts6.visitNode(rootNode, visitor);
-        };
-        const _content = transformBundledSource(sourceFile, compilerOptions, transformer);
-        return { file, content: _content, ...rest };
-    };
-}
-//--
-function anonymousExportHandler(compilerOptions) {
-    return ({ file, content, ...rest }) => {
-        const sourceFile = createBundledSourceFile(file, content);
-        /**
-         * A transformer that handles anonymous default exports by assigning them a name
-         *
-         * @param {ts6.TransformationContext} context - transformation context
-         * @returns {ts6.Transformer<ts6.SourceFile>} - transformer
-         */
-        const transformer = (context) => {
-            const { factory } = context;
-            function visitor(node) {
-                const fileName = path.basename(file).split(".")[0];
-                if ((ts6.isFunctionDeclaration(node) || ts6.isClassDeclaration(node)) &&
-                    node.name === undefined) {
-                    let exp = false;
-                    let def = false;
-                    node.modifiers?.forEach((mod) => {
-                        if (mod.kind === ts6.SyntaxKind.ExportKeyword) {
-                            exp = true;
-                        }
-                        if (mod.kind === ts6.SyntaxKind.DefaultKeyword) {
-                            def = true;
-                        }
-                    });
-                    if (exp && def) {
-                        const base = anonymousName.getName(anonymousPrefixKey, fileName);
-                        anonymousExportNameMap.push({
-                            base,
-                            file: fileName,
-                            newName: base,
-                            isEd: true,
-                        });
-                        if (ts6.isFunctionDeclaration(node)) {
-                            return factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, factory.createIdentifier(base), node.typeParameters, node.parameters, node.type, node.body);
-                        }
-                        else if (ts6.isClassDeclaration(node)) {
-                            return factory.updateClassDeclaration(node, node.modifiers, factory.createIdentifier(base), node.typeParameters, node.heritageClauses, node.members);
-                        }
-                    }
-                }
-                else if (ts6.isExportAssignment(node) &&
-                    !node.isExportEquals &&
-                    node.name === undefined) {
-                    if (ts6.isArrowFunction(node.expression)) {
-                        const base = anonymousName.getName(anonymousPrefixKey, 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], ts6.NodeFlags.Const);
-                        const variableStatementNode = factory.createVariableStatement(node.expression.modifiers, variableDeclarationListNode);
-                        const exportAssignmentNode = factory.createExportAssignment(undefined, undefined, factory.createIdentifier(base));
-                        anonymousExportNameMap.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 (ts6.isObjectLiteralExpression(node.expression)) {
-                        const base = anonymousName.getName(anonymousPrefixKey, fileName);
-                        const variableDeclarationNode = factory.createVariableDeclaration(factory.createIdentifier(base), undefined, undefined, node.expression);
-                        const variableDeclarationListNode = factory.createVariableDeclarationList([variableDeclarationNode], ts6.NodeFlags.Const);
-                        const variableStatementNode = factory.createVariableStatement(undefined, variableDeclarationListNode);
-                        const exportAssignmentNode = factory.createExportAssignment(undefined, undefined, factory.createIdentifier(base));
-                        anonymousExportNameMap.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 (ts6.isArrayLiteralExpression(node.expression)) {
-                        const base = anonymousName.getName(anonymousPrefixKey, fileName);
-                        const arrayLiteralExpressionNode = factory.createArrayLiteralExpression(node.expression.elements, true);
-                        const variableDeclarationNode = factory.createVariableDeclaration(factory.createIdentifier(base), undefined, undefined, arrayLiteralExpressionNode);
-                        const variableDeclarationListNode = factory.createVariableDeclarationList([variableDeclarationNode], ts6.NodeFlags.Const);
-                        const variableStatementNode = factory.createVariableStatement(undefined, variableDeclarationListNode);
-                        const exportAssignmentNode = factory.createExportAssignment(undefined, undefined, factory.createIdentifier(base));
-                        anonymousExportNameMap.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 (ts6.isStringLiteral(node.expression)) {
-                        const base = anonymousName.getName(anonymousPrefixKey, fileName);
-                        const stringLiteralNode = factory.createStringLiteral(node.expression.text);
-                        const variableDeclarationNode = factory.createVariableDeclaration(factory.createIdentifier(base), undefined, undefined, stringLiteralNode);
-                        const variableDeclarationListNode = factory.createVariableDeclarationList([variableDeclarationNode], ts6.NodeFlags.Const);
-                        const variableStatementNode = factory.createVariableStatement(undefined, variableDeclarationListNode);
-                        const exportAssignmentNode = factory.createExportAssignment(undefined, undefined, factory.createIdentifier(base));
-                        anonymousExportNameMap.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 (ts6.isNumericLiteral(node.expression)) {
-                        const base = anonymousName.getName(anonymousPrefixKey, fileName);
-                        const numericLiteralNode = factory.createNumericLiteral(node.expression.text);
-                        const variableDeclarationNode = factory.createVariableDeclaration(factory.createIdentifier(base), undefined, undefined, numericLiteralNode);
-                        const variableDeclarationListNode = factory.createVariableDeclarationList([variableDeclarationNode], ts6.NodeFlags.Const);
-                        const variableStatementNode = factory.createVariableStatement(undefined, variableDeclarationListNode);
-                        const exportAssignmentNode = factory.createExportAssignment(undefined, undefined, factory.createIdentifier(base));
-                        anonymousExportNameMap.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 ts6.visitEachChild(node, visitor, context);
-            }
-            return (rootNode) => ts6.visitNode(rootNode, visitor);
-        };
-        const _content = transformBundledSource(sourceFile, compilerOptions, transformer);
-        return { file, content: _content, ...rest };
-    };
-}
-//--
-function anonymousImportHandler(compilerOptions) {
-    return ({ file, content, ...rest }) => {
-        const sourceFile = createBundledSourceFile(file, content);
-        const transformer = (context) => {
-            const { factory } = context;
-            function visitor(node) {
-                if (ts6.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 &&
-                        ts6.isIdentifier(node.importClause.name)) {
-                        const base = node.importClause.name.text.trim();
-                        const mapping = anonymousExportNameMap.find((v) => v.file === _name);
-                        if (mapping) {
-                            anonymousImportNameMap.push({
-                                base,
-                                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 ts6.visitEachChild(node, visitor, context);
-            }
-            return (rootNode) => ts6.visitNode(rootNode, visitor);
-        };
-        const _content = transformBundledSource(sourceFile, compilerOptions, transformer);
-        return { file, content: _content, ...rest };
-    };
-}
-//--
-function resetAnonymousState() {
-    anonymousExportNameMap.length = 0;
-    anonymousImportNameMap.length = 0;
-    anonymousName = createAnonymousNameGenerator();
-}
-const anonymousHandler = async (deps, compilerOptions) => {
-    resetAnonymousState();
-    const anonymous = utils.promises.resolve([
-        [anonymousExportHandler, compilerOptions],
-        [anonymousImportHandler, compilerOptions],
-        [anonymousCallExpressionHandler, compilerOptions],
-    ]);
-    const anons = await anonymous.concurrent();
-    for (const anon of anons) {
-        deps = deps.map(anon);
-    }
-    return deps;
-};
-//src/bundler/lib/exportDefault.ts
-const exportDefaultExportNameMap = [];
-const exportDefaultImportNameMap = [];
-const exportDefaultPrefixKey = "ExportDefault";
-const createExportDefaultNameGenerator = () => uniqueName.setPrefix({
-    key: exportDefaultPrefixKey,
-    value: "susee__exportDefault__",
-});
-let exportDefaultName = createExportDefaultNameGenerator();
-const toNameLookupKey = (file, base) => `${file}\u0000${base}`;
-const createNameLookup = (sets) => {
-    const lookup = new Map();
-    for (const set of sets) {
-        lookup.set(toNameLookupKey(set.file, set.base), set.newName);
-    }
-    return lookup;
-};
-const getMappedName = (lookup, file, base) => {
-    return lookup.get(toNameLookupKey(file, base));
-};
-const hasExportDefaultModifiers = (node) => {
-    let exp = false;
-    let def = false;
-    node.modifiers?.forEach((mod) => {
-        if (mod.kind === ts6.SyntaxKind.ExportKeyword) {
-            exp = true;
-        }
-        if (mod.kind === ts6.SyntaxKind.DefaultKeyword) {
-            def = true;
-        }
-    });
-    return exp && def;
-};
-const collectExportDefaultMappings = (deps) => {
-    for (const dep of deps) {
-        if (dep.fileExt === ".json" || dep.is_entry) {
-            continue;
-        }
-        const fileKey = getFileKey(dep.file);
-        const sourceFile = createBundledSourceFile(dep.file, dep.content);
-        for (const statement of sourceFile.statements) {
-            if ((ts6.isFunctionDeclaration(statement) ||
-                ts6.isClassDeclaration(statement)) &&
-                statement.name &&
-                ts6.isIdentifier(statement.name) &&
-                hasExportDefaultModifiers(statement)) {
-                const baseName = statement.name.text;
-                const newName = exportDefaultName.getName(exportDefaultPrefixKey, baseName);
-                exportDefaultExportNameMap.push({
-                    base: baseName,
-                    file: fileKey,
-                    newName,
-                    isEd: true,
-                });
-                break;
-            }
-            if (ts6.isExportAssignment(statement) &&
-                !statement.isExportEquals &&
-                ts6.isIdentifier(statement.expression)) {
-                const baseName = statement.expression.text;
-                const newName = exportDefaultName.getName(exportDefaultPrefixKey, baseName);
-                exportDefaultExportNameMap.push({
-                    base: baseName,
-                    file: fileKey,
-                    newName,
-                    isEd: true,
-                });
-                break;
-            }
-        }
-    }
-};
-// -----------------------
-function exportDefaultImportAndUsageHandler(compilerOptions) {
-    return ({ file, content, fileExt, ...rest }) => {
-        if (fileExt === ".json")
-            return { file, content, fileExt, ...rest };
-        const sourceFile = createBundledSourceFile(file, content);
-        const transformer = (context) => {
-            const { factory } = context;
-            const exportLookup = createNameLookup(exportDefaultExportNameMap);
-            const importLookup = new Map();
-            const resolveMappedName = (base) => importLookup.get(base);
-            const isDeclarationName = (node) => {
-                const parent = node.parent;
-                if ((ts6.isVariableDeclaration(parent) ||
-                    ts6.isFunctionDeclaration(parent) ||
-                    ts6.isClassDeclaration(parent) ||
-                    ts6.isParameter(parent) ||
-                    ts6.isTypeAliasDeclaration(parent) ||
-                    ts6.isInterfaceDeclaration(parent) ||
-                    ts6.isEnumDeclaration(parent) ||
-                    ts6.isImportClause(parent) ||
-                    ts6.isNamespaceImport(parent) ||
-                    ts6.isImportSpecifier(parent) ||
-                    ts6.isExportSpecifier(parent) ||
-                    ts6.isTypeParameterDeclaration(parent)) &&
-                    parent.name === node) {
-                    return true;
-                }
-                if ((ts6.isPropertyDeclaration(parent) ||
-                    ts6.isMethodDeclaration(parent)) &&
-                    parent.name === node) {
-                    return true;
-                }
-                return false;
-            };
-            function visitor(node) {
-                if (ts6.isImportDeclaration(node)) {
-                    const moduleKey = getModuleKeyFromSpecifier(node.moduleSpecifier, sourceFile, file);
-                    if (node.importClause?.name &&
-                        ts6.isIdentifier(node.importClause.name)) {
-                        const base = node.importClause.name.text.trim();
-                        const mappedName = getMappedName(exportLookup, moduleKey, base);
-                        if (mappedName) {
-                            importLookup.set(base, mappedName);
-                            exportDefaultImportNameMap.push({
-                                base,
-                                file,
-                                newName: mappedName,
-                                isEd: true,
-                            });
-                            const newImportClause = factory.updateImportClause(node.importClause, node.importClause.phaseModifier, factory.createIdentifier(mappedName), node.importClause.namedBindings);
-                            return factory.updateImportDeclaration(node, node.modifiers, newImportClause, node.moduleSpecifier, node.attributes);
-                        }
-                    }
-                }
-                if (ts6.isCallExpression(node)) {
-                    if (ts6.isIdentifier(node.expression)) {
-                        const newName = resolveMappedName(node.expression.text);
-                        if (newName) {
-                            return factory.updateCallExpression(node, factory.createIdentifier(newName), node.typeArguments, node.arguments);
-                        }
-                    }
-                }
-                else if (ts6.isPropertyAccessExpression(node)) {
-                    if (ts6.isIdentifier(node.expression)) {
-                        const newName = resolveMappedName(node.expression.text);
-                        if (newName) {
-                            return factory.updatePropertyAccessExpression(node, factory.createIdentifier(newName), node.name);
-                        }
-                    }
-                }
-                else if (ts6.isNewExpression(node)) {
-                    if (ts6.isIdentifier(node.expression)) {
-                        const newName = resolveMappedName(node.expression.text);
-                        if (newName) {
-                            return factory.updateNewExpression(node, factory.createIdentifier(newName), node.typeArguments, node.arguments);
-                        }
-                    }
-                    // for export specifier it is focus on entry file
-                }
-                else if (ts6.isExportSpecifier(node)) {
-                    if (ts6.isIdentifier(node.name)) {
-                        const newName = resolveMappedName(node.name.text);
-                        if (newName) {
-                            return factory.updateExportSpecifier(node, node.isTypeOnly, node.propertyName, factory.createIdentifier(newName));
-                        }
-                    }
-                }
-                else if (ts6.isIdentifier(node) && !isDeclarationName(node)) {
-                    if (ts6.isPropertyAccessExpression(node.parent) &&
-                        node.parent.name === node) {
-                        return node;
-                    }
-                    if (ts6.isPropertyAssignment(node.parent) &&
-                        node.parent.name === node) {
-                        return node;
-                    }
-                    const newName = resolveMappedName(node.text);
-                    if (newName) {
-                        if (ts6.isShorthandPropertyAssignment(node.parent) &&
-                            node.parent.name === node) {
-                            return factory.createPropertyAssignment(factory.createIdentifier(node.text), factory.createIdentifier(newName));
-                        }
-                        return factory.createIdentifier(newName);
-                    }
-                }
-                // return : visitor
-                return ts6.visitEachChild(node, visitor, context);
-            }
-            // return : transform
-            return (rootNode) => ts6.visitNode(rootNode, visitor);
-        };
-        const _content = transformBundledSource(sourceFile, compilerOptions, transformer);
-        // return : handler
-        return { file, content: _content, fileExt, ...rest };
-    };
-}
-//--
-function exportDefaultLocalHandler(compilerOptions) {
-    return ({ file, content, fileExt, is_entry, ...rest }) => {
-        if (fileExt === ".json")
-            return { file, content, fileExt, is_entry, ...rest };
-        const fileName = getFileKey(file);
-        // const exportLookup = createNameLookup(exportDefaultExportNameMap);
-        // const mappedName = getMappedName(exportLookup, fileName, fileName);
-        const localMapping = exportDefaultExportNameMap.find((n) => n.file === fileName);
-        if (is_entry || !localMapping)
-            return { file, content, fileExt, is_entry, ...rest };
-        const sourceFile = createBundledSourceFile(file, content);
-        const transformer = (context) => {
-            const { factory } = context;
-            const { base: baseName, newName } = localMapping;
-            const isDeclarationName = (node) => {
-                const parent = node.parent;
-                if ((ts6.isVariableDeclaration(parent) ||
-                    ts6.isFunctionDeclaration(parent) ||
-                    ts6.isClassDeclaration(parent) ||
-                    ts6.isParameter(parent) ||
-                    ts6.isTypeAliasDeclaration(parent) ||
-                    ts6.isInterfaceDeclaration(parent) ||
-                    ts6.isEnumDeclaration(parent) ||
-                    ts6.isImportClause(parent) ||
-                    ts6.isNamespaceImport(parent) ||
-                    ts6.isImportSpecifier(parent) ||
-                    ts6.isExportSpecifier(parent) ||
-                    ts6.isTypeParameterDeclaration(parent)) &&
-                    parent.name === node) {
-                    return true;
-                }
-                if ((ts6.isPropertyDeclaration(parent) ||
-                    ts6.isMethodDeclaration(parent)) &&
-                    parent.name === node) {
-                    return true;
-                }
-                return false;
-            };
-            function visitor(node) {
-                if (ts6.isExportAssignment(node) &&
-                    !node.isExportEquals &&
-                    ts6.isIdentifier(node.expression) &&
-                    node.expression.text === baseName) {
-                    return factory.updateExportAssignment(node, node.modifiers, factory.createIdentifier(newName));
-                }
-                if (ts6.isCallExpression(node)) {
-                    if (ts6.isIdentifier(node.expression) &&
-                        node.expression.text === baseName) {
-                        return factory.updateCallExpression(node, factory.createIdentifier(newName), node.typeArguments, node.arguments);
-                    }
-                }
-                else if (ts6.isPropertyAccessExpression(node)) {
-                    if (ts6.isIdentifier(node.expression) &&
-                        node.expression.text === baseName) {
-                        return factory.updatePropertyAccessExpression(node, factory.createIdentifier(newName), node.name);
-                    }
-                }
-                else if (ts6.isNewExpression(node)) {
-                    if (ts6.isIdentifier(node.expression) &&
-                        node.expression.text === baseName) {
-                        return factory.updateNewExpression(node, factory.createIdentifier(newName), node.typeArguments, node.arguments);
-                    }
-                }
-                else if (ts6.isIdentifier(node) &&
-                    node.text === baseName &&
-                    !isDeclarationName(node)) {
-                    if (ts6.isPropertyAccessExpression(node.parent) &&
-                        node.parent.name === node) {
-                        return node;
-                    }
-                    if (ts6.isPropertyAssignment(node.parent) &&
-                        node.parent.name === node) {
-                        return node;
-                    }
-                    if (ts6.isShorthandPropertyAssignment(node.parent) &&
-                        node.parent.name === node) {
-                        return factory.createPropertyAssignment(factory.createIdentifier(node.text), factory.createIdentifier(newName));
-                    }
-                    return factory.createIdentifier(newName);
-                }
-                if (ts6.isFunctionDeclaration(node) || ts6.isClassDeclaration(node)) {
-                    if (node.name &&
-                        ts6.isIdentifier(node.name) &&
-                        node.name.text === baseName) {
-                        if (ts6.isFunctionDeclaration(node)) {
-                            const visitedNode = ts6.visitEachChild(node, visitor, context);
-                            return factory.updateFunctionDeclaration(visitedNode, visitedNode.modifiers, visitedNode.asteriskToken, factory.createIdentifier(newName), visitedNode.typeParameters, visitedNode.parameters, visitedNode.type, visitedNode.body);
-                        }
-                        const visitedNode = ts6.visitEachChild(node, visitor, context);
-                        return factory.updateClassDeclaration(visitedNode, visitedNode.modifiers, factory.createIdentifier(newName), visitedNode.typeParameters, visitedNode.heritageClauses, visitedNode.members);
-                    }
-                }
-                else if (ts6.isVariableStatement(node)) {
-                    const declarations = node.declarationList.declarations;
-                    let changed = false;
-                    const updatedDeclarations = declarations.map((decl) => {
-                        if (ts6.isIdentifier(decl.name) && decl.name.text === baseName) {
-                            changed = true;
-                            return factory.updateVariableDeclaration(decl, factory.createIdentifier(newName), decl.exclamationToken, decl.type, decl.initializer);
-                        }
-                        return decl;
-                    });
-                    if (changed) {
-                        return factory.updateVariableStatement(node, node.modifiers, factory.updateVariableDeclarationList(node.declarationList, updatedDeclarations));
-                    }
-                }
-                return ts6.visitEachChild(node, visitor, context);
-            }
-            return (rootNode) => ts6.visitNode(rootNode, visitor);
-        };
-        const _content = transformBundledSource(sourceFile, compilerOptions, transformer);
-        return { file, content: _content, fileExt, is_entry, ...rest };
-    };
-}
-//--
-function resetExportDefaultState() {
-    exportDefaultExportNameMap.length = 0;
-    exportDefaultImportNameMap.length = 0;
-    exportDefaultName = createExportDefaultNameGenerator();
-}
-const exportDefaultHandler = async (deps, compilerOptions) => {
-    resetExportDefaultState();
-    collectExportDefaultMappings(deps);
-    deps = deps.map(exportDefaultLocalHandler(compilerOptions));
-    deps = deps.map(exportDefaultImportAndUsageHandler(compilerOptions));
-    return deps;
-};
-//src/bundler/lib/remove.ts
-const properties = [];
-const propertiesSet = new Set();
-const typeObj = {};
-const typesNames = new Set();
-function esmExportRemoveHandler(compilerOptions) {
-    return ({ file, content, ...rest }) => {
-        const sourceFile = createBundledSourceFile(file, content);
-        const transformer = (context) => {
-            const { factory } = context;
-            const visitor = (node) => {
-                // --- Case 1: Strip "export" modifiers ---
-                const inside_nameSpace = utils.checks.isInsideNamespace(node);
-                if (!inside_nameSpace) {
-                    if (ts6.isFunctionDeclaration(node) ||
-                        ts6.isClassDeclaration(node) ||
-                        ts6.isInterfaceDeclaration(node) ||
-                        ts6.isTypeAliasDeclaration(node) ||
-                        ts6.isEnumDeclaration(node) ||
-                        ts6.isVariableStatement(node)) {
-                        const modifiers = node.modifiers?.filter((m) => m.kind !== ts6.SyntaxKind.ExportKeyword &&
-                            m.kind !== ts6.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 (ts6.isFunctionDeclaration(node)) {
-                                return factory.updateFunctionDeclaration(node, modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body);
-                            } // function
-                            if (ts6.isClassDeclaration(node)) {
-                                return factory.updateClassDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
-                            } // class
-                            if (ts6.isInterfaceDeclaration(node)) {
-                                return factory.updateInterfaceDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
-                            } // interface
-                            if (ts6.isTypeAliasDeclaration(node)) {
-                                return factory.updateTypeAliasDeclaration(node, modifiers, node.name, node.typeParameters, node.type);
-                            } // types
-                            if (ts6.isEnumDeclaration(node)) {
-                                return factory.updateEnumDeclaration(node, modifiers, node.name, node.members);
-                            } //enum
-                            if (ts6.isVariableStatement(node)) {
-                                return factory.updateVariableStatement(node, modifiers, node.declarationList);
-                            } // vars
-                        } //--
-                    } // --- Case 1
-                }
-                // --- Case 2: Remove "export { foo }" entirely ---
-                if (ts6.isExportDeclaration(node)) {
-                    // If the node is an export declaration, remove it.
-                    return factory.createEmptyStatement();
-                }
-                // --- Case 3: Handle "export default ..." ---
-                if (ts6.isExportAssignment(node)) {
-                    const expr = node.expression;
-                    // export default Foo;   -> remove line
-                    if (ts6.isIdentifier(expr)) {
-                        return factory.createEmptyStatement();
-                    }
-                }
-                /* ----------------------Returns for visitor function------------------------------- */
-                return ts6.visitEachChild(node, visitor, context);
-            };
-            /* --------------------Returns for transformer function--------------------------------- */
-            return (rootNode) => ts6.visitNode(rootNode, visitor);
-        };
-        /* --------------------Returns for main handler function--------------------------------- */
-        const _content = transformBundledSource(sourceFile, compilerOptions, transformer);
-        return { file, content: _content, ...rest };
-    };
-}
-function importAllRemoveHandler(removedStatements, compilerOptions) {
-    return ({ file, content, ...rest }) => {
-        const sourceFile = createBundledSourceFile(file, content);
-        const isCommonJsFile = utils.checks.moduleType(content, file).isCommonJs;
-        const transformer = (context) => {
-            // 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 (ts6.isImportEqualsDeclaration(stmt) && stmt.isTypeOnly) {
-                    const moduleReference = stmt.moduleReference;
-                    if (ts6.isExternalModuleReference(moduleReference) &&
-                        ts6.isStringLiteral(moduleReference.expression)) {
-                        typeOnlyImportEquals.add(stmt.name.text);
-                    }
-                }
-            }
-            const { factory } = context;
-            const visitor = (node) => {
-                if (ts6.isPropertyAccessExpression(node) &&
-                    ts6.isIdentifier(node.expression)) {
-                    properties.push(node.expression.text);
-                    propertiesSet.add(node.expression.text);
-                }
-                const obj = {
-                    isNamespace: false,
-                    isTypeOnly: false,
-                    isTypeNamespace: false,
-                    source: "",
-                    importedString: undefined,
-                    importedObject: undefined,
-                };
-                // --- Case: TypeReference with QualifiedName (collect type usage)
-                if (ts6.isTypeReferenceNode(node) &&
-                    ts6.isQualifiedName(node.typeName) &&
-                    ts6.isIdentifier(node.typeName.left) &&
-                    ts6.isIdentifier(node.typeName.right)) {
-                    const left = node.typeName.left.text;
-                    const right = node.typeName.right.text;
-                    typesNames.add(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 (isCommonJsFile) {
-                        if (left !== "ts" && !typeOnlyImportEquals.has(left)) {
-                            return factory.updateTypeReferenceNode(node, factory.createIdentifier(right), undefined);
-                        }
-                    }
-                }
-                // ------------------------
-                if (ts6.isImportDeclaration(node)) {
-                    // --- Case 1: Import declarations
-                    const text = node.getText(sourceFile);
-                    removedStatements.push(text);
-                    return factory.createEmptyStatement();
-                }
-                //--- Case 2: Import equals declarations
-                if (ts6.isImportEqualsDeclaration(node)) {
-                    const name = node.name.text;
-                    const moduleReference = node.moduleReference;
-                    if (node.isTypeOnly) {
-                        obj.isTypeOnly = true;
-                    }
-                    obj.importedString = name;
-                    if (!obj.isTypeOnly) {
-                        if (propertiesSet.has(name)) {
-                            obj.isNamespace = true;
-                        }
-                    }
-                    if (ts6.isExternalModuleReference(moduleReference) &&
-                        ts6.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.has(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 (ts6.isVariableStatement(node)) {
-                    const decls = node.declarationList.declarations;
-                    if (decls.length === 1) {
-                        const decl = decls[0];
-                        if (decl.initializer &&
-                            ts6.isCallExpression(decl.initializer) &&
-                            ts6.isIdentifier(decl.initializer.expression) &&
-                            decl.initializer.expression.escapedText === "require") {
-                            // imported from
-                            const arg = decl.initializer.arguments[0];
-                            if (ts6.isStringLiteral(arg)) {
-                                obj.source = arg.text;
-                            }
-                            if (ts6.isIdentifier(decl.name)) {
-                                const _n = decl.name.text;
-                                obj.importedString = _n;
-                                if (propertiesSet.has(_n)) {
-                                    obj.isNamespace = true;
-                                }
-                            }
-                            else if (ts6.isObjectBindingPattern(decl.name)) {
-                                const _names = [];
-                                for (const ele of decl.name.elements) {
-                                    if (ts6.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();
-                            }
-                        }
-                    }
-                }
-                /* ----------------------Returns for visitor function------------------------------- */
-                return ts6.visitEachChild(node, visitor, context);
-            };
-            /* --------------------Returns for transformer function--------------------------------- */
-            return (rootNode) => ts6.visitNode(rootNode, visitor);
-        };
-        /* --------------------Returns for main handler function--------------------------------- */
-        const _content = transformBundledSource(sourceFile, compilerOptions, transformer);
-        return { file, content: _content, ...rest };
-    };
-}
-const removeHandlers = async (removedStatements, compilerOptions) => {
-    const resolved = utils.promises.resolve([
-        [importAllRemoveHandler, removedStatements, compilerOptions],
-        [esmExportRemoveHandler, compilerOptions],
-    ]);
-    return await resolved.series();
-};
-//src/bundler/lib/resolveJSON.ts
-const jsonPrefix = "__jsonModule__";
-const jsonModuleExportNameMap = [];
-const jsonModuleImportNameMap = [];
-const toIdentifier = (input) => {
-    const cleaned = input.replace(/[^A-Za-z0-9_$]/g, "_");
-    const startsValid = /^[A-Za-z_$]/.test(cleaned);
-    return `${jsonPrefix}${startsValid ? cleaned : `_${cleaned}`}`;
-};
-const toJsonModuleCode = (varName, content, file) => {
-    let parsed;
-    try {
-        parsed = JSON.parse(content);
-    }
-    catch {
-        throw new Error(`Invalid JSON syntax in dependency file: ${file}`);
-    }
-    const jsonObject = JSON.stringify(parsed);
-    return `const ${varName} = ${jsonObject};\nexport default ${varName}`;
-};
-const resolveJSONHandler = async (deps) => {
-    const scopedNameCount = new Map();
-    const nextDeps = deps.map((dep) => {
-        if (dep.moduleType !== "json" || dep.fileExt !== ".json") {
-            return dep;
-        }
-        const fileName = path.basename(dep.file).split(".")[0];
-        const fileKey = getFileKey(dep.file);
-        const keyName = toIdentifier(fileKey);
-        const count = scopedNameCount.get(keyName) ?? 0;
-        const jsonVarName = count === 0 ? keyName : `${keyName}_${count + 1}`;
-        scopedNameCount.set(keyName, count + 1);
-        jsonModuleExportNameMap.push({
-            base: jsonVarName,
-            file: fileName,
-            newName: jsonVarName,
-            isEd: true,
-        });
-        return {
-            ...dep,
-            content: toJsonModuleCode(jsonVarName, dep.content, dep.file),
-            moduleType: "esm",
-        };
-    });
-    return nextDeps;
-};
-//--
-function jsonModuleImportHandler(compilerOptions) {
-    return ({ file, content, fileExt, ...rest }) => {
-        const sourceFile = createBundledSourceFile(file, content);
-        const transformer = (context) => {
-            const { factory } = context;
-            function visitor(node) {
-                if (ts6.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 &&
-                        ts6.isIdentifier(node.importClause.name)) {
-                        const base = node.importClause.name.text.trim();
-                        const mapping = jsonModuleExportNameMap.find((v) => v.file === _name);
-                        if (mapping) {
-                            jsonModuleImportNameMap.push({
-                                base,
-                                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 ts6.visitEachChild(node, visitor, context);
-            }
-            return (rootNode) => ts6.visitNode(rootNode, visitor);
-        };
-        const _content = transformBundledSource(sourceFile, compilerOptions, transformer);
-        return { file, content: _content, fileExt, ...rest };
-    };
-}
-//--
-function jsonModuleCallExpressionHandler(compilerOptions) {
-    return ({ file, content, fileExt, ...rest }) => {
-        const sourceFile = createBundledSourceFile(file, content);
-        const transformer = (context) => {
-            const { factory } = context;
-            function visitor(node) {
-                if (ts6.isCallExpression(node)) {
-                    if (ts6.isIdentifier(node.expression)) {
-                        const base = node.expression.text;
-                        const mapping = jsonModuleImportNameMap.find((m) => m.base === base && m.file === file);
-                        if (mapping) {
-                            return factory.updateCallExpression(node, factory.createIdentifier(mapping.newName), node.typeArguments, node.arguments);
-                        }
-                    }
-                }
-                else if (ts6.isPropertyAccessExpression(node)) {
-                    if (ts6.isIdentifier(node.expression)) {
-                        const base = node.expression.text;
-                        const mapping = jsonModuleImportNameMap.find((m) => m.base === base && m.file === file);
-                        if (mapping) {
-                            return factory.updatePropertyAccessExpression(node, factory.createIdentifier(mapping.newName), node.name);
-                        }
-                    }
-                }
-                else if (ts6.isNewExpression(node)) {
-                    if (ts6.isIdentifier(node.expression)) {
-                        const base = node.expression.text;
-                        const mapping = jsonModuleImportNameMap.find((m) => m.base === base && m.file === 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 (ts6.isExportSpecifier(node)) {
-                    if (ts6.isIdentifier(node.name)) {
-                        const base = node.name.text;
-                        const mapping = jsonModuleImportNameMap.find((m) => m.base === base && m.file === file);
-                        if (mapping) {
-                            return factory.updateExportSpecifier(node, node.isTypeOnly, node.propertyName, factory.createIdentifier(mapping.newName));
-                        }
-                    }
-                }
-                return ts6.visitEachChild(node, visitor, context);
-            }
-            return (rootNode) => ts6.visitNode(rootNode, visitor);
-        };
-        const _content = transformBundledSource(sourceFile, compilerOptions, transformer);
-        return { file, content: _content, fileExt, ...rest };
-    };
-}
-//--
-async function jsonModuleHandlers(deps, compilerOptions) {
-    deps = await resolveJSONHandler(deps);
-    deps = deps.map((dep) => jsonModuleImportHandler(compilerOptions)(dep));
-    deps = deps.map((dep) => jsonModuleCallExpressionHandler(compilerOptions)(dep));
-    return deps;
-}
-function collectBindingNames(name, out) {
-    if (ts6.isIdentifier(name))
-        out.push(name.text);
-    else if (ts6.isObjectBindingPattern(name) ||
-        ts6.isArrayBindingPattern(name)) {
-        name.elements.forEach((el) => {
-            if (ts6.isBindingElement(el) && el.name)
-                collectBindingNames(el.name, out);
-        });
-    }
-}
-/**
- * Clear unused top-level declarations from a TypeScript source string.
- * - Removes only unused named import specifiers.
- * - Removes entire import declarations when an unused default or namespace import is present.
- * - Removes function and class declarations when their name is unused.
- * - Removes entire variable statements when none of the declared identifiers are used.
- *
- * Limitations: this works on a single-file basis and does not analyze cross-file usages.
- */
-function susee__anonymous__unusedCode_2(content, file, compilerOptions, options = { treatExportsAsUsed: true }) {
-    const sourceFile = createBundledSourceFile(file, content);
-    const defined = new Map();
-    const used = new Set();
-    const markDefined = (name, exported = false) => {
-        const prev = defined.get(name);
-        defined.set(name, { exported: !!prev?.exported || exported });
-    };
-    // First pass: collect defined names (imports, vars, funcs, classes) and used identifiers
-    const collect = (node) => {
-        // Definitions
-        if (ts6.isImportDeclaration(node) && node.importClause) {
-            const ic = node.importClause;
-            if (ic.name && ts6.isIdentifier(ic.name))
-                markDefined(ic.name.text, false);
-            if (ic.namedBindings) {
-                if (ts6.isNamedImports(ic.namedBindings)) {
-                    ic.namedBindings.elements.forEach((ele) => {
-                        if (ts6.isImportSpecifier(ele) && ts6.isIdentifier(ele.name))
-                            markDefined(ele.name.text, false);
-                    });
-                }
-                else if (ts6.isNamespaceImport(ic.namedBindings) &&
-                    ts6.isIdentifier(ic.namedBindings.name)) {
-                    markDefined(ic.namedBindings.name.text, false);
-                }
-            }
-        }
-        else if (ts6.isImportEqualsDeclaration(node) &&
-            ts6.isIdentifier(node.name)) {
-            markDefined(node.name.text, false);
-        }
-        else if (ts6.isVariableStatement(node)) {
-            const exported = node.modifiers?.some((m) => m.kind === ts6.SyntaxKind.ExportKeyword) ??
-                false;
-            node.declarationList.declarations.forEach((d) => {
-                collectBindingNames(d.name, []);
-                const names = [];
-                collectBindingNames(d.name, names);
-                names.forEach((n) => markDefined(n, exported));
-            });
-        }
-        else if (ts6.isFunctionDeclaration(node) &&
-            node.name &&
-            ts6.isIdentifier(node.name)) {
-            const exported = node.modifiers?.some((m) => m.kind === ts6.SyntaxKind.ExportKeyword) ??
-                false;
-            markDefined(node.name.text, exported);
-        }
-        else if (ts6.isClassDeclaration(node) &&
-            node.name &&
-            ts6.isIdentifier(node.name)) {
-            const exported = node.modifiers?.some((m) => m.kind === ts6.SyntaxKind.ExportKeyword) ??
-                false;
-            markDefined(node.name.text, exported);
-        }
-        // Usage: any identifier that is not a declaration name is considered a use
-        if (ts6.isIdentifier(node)) {
-            const parent = node.parent;
-            const isDeclarationName = (ts6.isVariableDeclaration(parent) && parent.name === node) ||
-                (ts6.isFunctionDeclaration(parent) && parent.name === node) ||
-                (ts6.isClassDeclaration(parent) && parent.name === node) ||
-                (ts6.isImportClause(parent) && parent.name === node) ||
-                (ts6.isImportSpecifier(parent) && parent.name === node) ||
-                (ts6.isNamespaceImport(parent) && parent.name === node) ||
-                (ts6.isBindingElement(parent) && parent.name === node) ||
-                (ts6.isParameter(parent) && parent.name === node);
-            if (!isDeclarationName)
-                used.add(node.text);
-        }
-        ts6.forEachChild(node, collect);
-    };
-    collect(sourceFile);
-    // Determine unused names
-    const unused = new Set();
-    defined.forEach((meta, name) => {
-        if (used.has(name))
-            return;
-        if (options.treatExportsAsUsed && meta.exported)
-            return;
-        unused.add(name);
-    });
-    // Transformer: remove nodes that are unused according to rules
-    const transformer = (context) => {
-        const visitor = (node) => {
-            // ImportDeclaration:
-            // - remove whole statement when default/namespace import is unused
-            // - otherwise remove only unused named specifiers
-            if (ts6.isImportDeclaration(node) && node.importClause) {
-                const ic = node.importClause;
-                const defaultName = ic.name && ts6.isIdentifier(ic.name) ? ic.name.text : undefined;
-                let namespaceName;
-                const namedElements = [];
-                if (ic.namedBindings) {
-                    if (ts6.isNamedImports(ic.namedBindings)) {
-                        ic.namedBindings.elements.forEach((ele) => {
-                            if (ts6.isImportSpecifier(ele) && ts6.isIdentifier(ele.name))
-                                namedElements.push(ele);
-                        });
-                    }
-                    else if (ts6.isNamespaceImport(ic.namedBindings) &&
-                        ts6.isIdentifier(ic.namedBindings.name)) {
-                        namespaceName = ic.namedBindings.name.text;
-                    }
-                }
-                const defaultUsed = defaultName ? !unused.has(defaultName) : false;
-                const namespaceUsed = namespaceName
-                    ? !unused.has(namespaceName)
-                    : false;
-                const keptNamed = namedElements.filter((ele) => !unused.has(ele.name.text));
-                if ((defaultName && !defaultUsed) ||
-                    (namespaceName && !namespaceUsed)) {
-                    return ts6.factory.createNotEmittedStatement(node);
-                }
-                if (namedElements.length > 0 &&
-                    keptNamed.length === 0 &&
-                    !defaultName) {
-                    return ts6.factory.createNotEmittedStatement(node);
-                }
-                if (keptNamed.length !== namedElements.length) {
-                    const newImportClause = ts6.factory.createImportClause(false, defaultName ? ts6.factory.createIdentifier(defaultName) : undefined, ts6.factory.createNamedImports(keptNamed));
-                    return ts6.factory.updateImportDeclaration(node, node.modifiers, newImportClause, node.moduleSpecifier, 
-                    // biome-ignore  lint/suspicious/noExplicitAny : ts
-                    node.assertClause);
-                }
-                return node;
-            }
-            // FunctionDeclaration / ClassDeclaration: remove if named and unused
-            if ((ts6.isFunctionDeclaration(node) || ts6.isClassDeclaration(node)) &&
-                node.name &&
-                ts6.isIdentifier(node.name)) {
-                if (unused.has(node.name.text))
-                    return ts6.factory.createNotEmittedStatement(node);
-                return node;
-            }
-            // VariableStatement: remove whole statement only if none of declared names are used
-            if (ts6.isVariableStatement(node)) {
-                const names = [];
-                node.declarationList.declarations.forEach((d) => collectBindingNames(d.name, names));
-                const anyUsed = names.some((n) => !unused.has(n));
-                if (!anyUsed)
-                    return ts6.factory.createNotEmittedStatement(node);
-                return node;
-            }
-            return ts6.visitEachChild(node, visitor, context);
-        };
-        return (root) => ts6.visitNode(root, visitor);
-    };
-    const output = transformBundledSource(sourceFile, compilerOptions, transformer);
-    return output;
-}
-//src/bundler/index.ts
-const logBundlerPhase = (entry, phase, start) => {
-    logProfilePhase(`bundler:${path.basename(entry)}`, phase, start);
-};
-async function bundler(entry, plugins = [], warning = false) {
-    const bundlerStart = process.hrtime.bigint();
-    let removedStatements = [];
-    const compilerOptions = ts6.getDefaultCompilerOptions();
-    let phaseStart = process.hrtime.bigint();
-    const tree = await generateDependencies(entry, createBundledSourceFile);
-    logBundlerPhase(entry, "generateDependencies", phaseStart);
-    // check for warning from generated dependencies graph
-    if (warning && tree.warns.length > 0) {
-        console.warn(tree.warns.join("\n"));
-        process.exit(1);
-    }
-    let depsFiles = tree.depFiles;
-    // 1. Resolve JSON Modules
-    if (isJSON(tree)) {
-        phaseStart = process.hrtime.bigint();
-        depsFiles = await jsonModuleHandlers(depsFiles, compilerOptions);
-        logBundlerPhase(entry, "resolveJSON", phaseStart);
-    }
-    // 2. Parse Dependency Plugins
-    if (plugins.length > 0) {
-        for (const plugin of plugins) {
-            const _plugin = typeof plugin === "function" ? plugin() : plugin;
-            if (_plugin.type === "dependency") {
-                phaseStart = process.hrtime.bigint();
-                if (_plugin.async) {
-                    depsFiles = await _plugin.func(depsFiles, compilerOptions);
-                }
-                else {
-                    depsFiles = _plugin.func(depsFiles, compilerOptions);
-                }
-                logBundlerPhase(entry, `dependencyPlugin:${_plugin.name ?? "anonymous"}`, phaseStart);
-            }
-        }
-    }
-    // 3. Check for commonjs modules
-    const isCommonjs = depsFiles.find((file) => file.moduleType === "cjs");
-    if (isCommonjs) {
-        console.error(`Bundler found commonjs module/modules in dependencies tree.Please use "@suseejs/commonjs-plugin" to solve it.`);
-        process.exit(1);
-    }
-    // 4.  Handling Export Default
-    phaseStart = process.hrtime.bigint();
-    depsFiles = await exportDefaultHandler(depsFiles, compilerOptions);
-    logBundlerPhase(entry, "exportDefault", phaseStart);
-    // 5. Handling Anonymous Imports/Exports
-    phaseStart = process.hrtime.bigint();
-    depsFiles = await anonymousHandler(depsFiles, compilerOptions);
-    logBundlerPhase(entry, "anonymous", phaseStart);
-    // 6. Duplicate top-level declarations are validated during dependency generation.
-    // Susee fails fast and asks callers to fix conflicting names in source files.
-    // 7. Handling  Remove Imports/Exports
-    phaseStart = process.hrtime.bigint();
-    const removed = await removeHandlers(removedStatements, compilerOptions);
-    // 7.1 Remove Imports
-    depsFiles = depsFiles.map(removed[0]);
-    // 7.2 Remove Exports
-    // Remove Exports from dependency files only
-    // not remove exports from entry file
-    const deps_files = depsFiles.slice(0, -1).map(removed[1]);
-    const mainFile = depsFiles.slice(-1);
-    logBundlerPhase(entry, "removeImportsExports", phaseStart);
-    // 8. Handling Imported Statements
-    // filter removed statements , that not from local like `./` or `../`
-    phaseStart = process.hrtime.bigint();
-    const regexp = /^\s*import(?:[\s\S]*?\sfrom\s+)?["']((?!\.{1,2}\/)[^"']+)["']/;
-    removedStatements = removedStatements.filter((i) => regexp.test(i));
-    removedStatements = utils.gen.mergeImportsStatement(removedStatements);
-    const importStatements = removedStatements.join("\n").trim();
-    logBundlerPhase(entry, "mergeImports", phaseStart);
-    // 9. Merge all content from dependencies tree
-    // 9.1 Merge dependency files content.
-    phaseStart = process.hrtime.bigint();
-    const depFilesContent = deps_files
-        .map((i) => {
-        const file = `//${path.relative(process.cwd(), i.file)}`;
-        return `${file}\n${i.content}`;
-    })
-        .join("\n")
-        .trim();
-    // 9.2 Create entry content
-    const mainFileContent = mainFile
-        .map((i) => {
-        const file = `//${path.relative(process.cwd(), i.file)}`;
-        return `${file}\n${i.content}`;
-    })
-        .join("\n")
-        .trim();
-    // 9.3 Merge all into one
-    // text join order is important here
-    // make sure all imports are at the top of file
-    let content = `${importStatements}\n${depFilesContent}\n${mainFileContent}`;
-    // some additional steps
-    // remove ";" that  are remain after removing imports
-    content = content.replace(/^s*;\s*$/gm, "").trim();
-    logBundlerPhase(entry, "mergeContent", phaseStart);
-    // clean unused code
-    phaseStart = process.hrtime.bigint();
-    content = susee__anonymous__unusedCode_2(content, tree.entry, compilerOptions);
-    logBundlerPhase(entry, "cleanUnusedCode", phaseStart);
-    // 10. Call pre-process plugins
-    if (plugins.length > 0) {
-        for (const plugin of plugins) {
-            const _plugin = typeof plugin === "function" ? plugin() : plugin;
-            if (_plugin.type === "pre-process") {
-                phaseStart = process.hrtime.bigint();
-                if (_plugin.async) {
-                    content = await _plugin.func(content, tree.entry);
-                }
-                else {
-                    content = _plugin.func(content, tree.entry);
-                }
-                logBundlerPhase(entry, `preProcessPlugin:${_plugin.name ?? "anonymous"}`, phaseStart);
-            }
-        }
-    }
-    logBundlerPhase(entry, "total", bundlerStart);
-    // Returns
-    return content;
-}
-async function bundle(entry) {
-    return await bundler(entry);
-}
-//package.json
-const __jsonModule__package = { "name": "susee", "version": "1.6.2", "description": "TypeScript-first bundler for library packages", "type": "module", "main": "dist/index.cjs", "types": "dist/index.d.cts", "module": "dist/index.mjs", "exports": { ".": { "import": { "types": "./dist/index.d.mts", "default": "./dist/index.mjs" }, "require": { "types": "./dist/index.d.cts", "default": "./dist/index.cjs" } } }, "bin": { "susee": "bin/susee" }, "scripts": { "build": "tsx build.ts", "lint": "biome lint ./src ./__tests__  --write", "fmt": "biome format --write", "test": "tsx --test", "hooks:install": "bash scripts/install-hooks.sh", "commit": "bash scripts/commit.sh", "v:patch": "npm version patch --no-git-tag-version", "v:minor": "npm version minor --no-git-tag-version", "v:major": "npm version major --no-git-tag-version" }, "keywords": ["bundler", "susee", "suseejs"], "author": "Pho Thin Mg <phothinmg@disroot.org> (https://phothinmg.github.io/)", "license": "Apache-2.0", "files": ["package.json", "README.md", "LICENSE", "dist/**/*", "bin/**/*"], "publishConfig": { "provenance": true, "access": "public" }, "repository": { "url": "git+https://github.com/phothinmg/susee.git", "type": "git" }, "homepage": "https://susee.js.org/", "bugs": { "url": "https://github.com/phothinmg/susee/issues" }, "dependencies": { "@suseejs/color": "^0.0.9", "@suseejs/ts6": "^1.0.0" }, "devDependencies": { "@biomejs/biome": "^2.4.12", "@suseejs/banner-text-plugin": "^0.0.9", "@suseejs/type": "^0.0.9", "@types/node": "^25.6.0", "tsx": "^4.23.1", "typescript": "^7.0.2" }, "allowScripts": { "esbuild@0.28.1": true }, "workspaces": ["susee-docs"] };
-/**
- * Finds the path of the susee.config file if it exists.
- * It checks for the existence of "susee.config.ts", "susee.config.js", and "susee.config.mjs" in the current working directory.
- * The first file found is returned.
- * @returns {string | undefined} - path to the susee.config file or undefined if it does not exist.
- */
-const getSuseeConfigPath = () => {
-    const fileNames = ["susee.config.ts", "susee.config.js", "susee.config.mjs"];
-    let configFile;
-    for (const file of fileNames) {
-        const _file = ts6.sys.resolvePath(file);
-        if (ts6.sys.fileExists(_file)) {
-            configFile = _file;
-            break;
-        }
-    }
-    return configFile;
-};
-/**
- * Checks if the given entries have at least one entry and if there are any duplicate export paths.
- * If there are no entries, it will exit with code 1 and print an error message.
- * If there are any duplicate export paths, it will exit with code 1 and print an error message.
- * It will also check if each entry file exists, if not, it will exit with code 1 and print an error message.
- * @param {EntryPoint[]} entries - array of entry points
- */
-function checkEntries(entries) {
-    if (entries.length < 1) {
-        console.error(tcolor.magenta(`No entry found in susee.config file or build options, at least one entry required`));
-        ts6.sys.exit(1);
-    }
-    const objectStore = {};
-    const duplicateExportPaths = [];
-    for (const obj of entries) {
-        const value = obj.exportPath;
-        if (objectStore[value]) {
-            duplicateExportPaths.push(`"${value}"`);
-        }
-        else {
-            objectStore[value] = true;
-        }
-    }
-    if (duplicateExportPaths.length > 0) {
-        console.error(tcolor.magenta(`Duplicate export paths/path (${duplicateExportPaths.join(",")}) found in your susee.config file or build options , that will error for bundled output`));
-        ts6.sys.exit(1);
-    }
-    for (const obj of entries) {
-        if (!ts6.sys.fileExists(ts6.sys.resolvePath(obj.entry))) {
-            console.error(tcolor.magenta(`Entry file ${obj.entry} dose not exists.`));
-            ts6.sys.exit(1);
-        }
-    }
-}
-/**
- * Generates normalized build options from the user config.
- * It validates entry points, applies default values, removes duplicate formats,
- * resolves the output directory for each export path, and keeps duplicate declaration handling fail-fast.
- * @param {SuSeeConfig} config - raw susee configuration object.
- * @returns {BuildOptions} normalized build options for the compiler.
- */
-function generateBuildOptions(config) {
-    const outDir = config.outDir ?? "dist";
-    const points = [];
-    checkEntries(config.entryPoints);
-    for (const ent of config.entryPoints) {
-        const entry = ent.entry;
-        const exportPath = ent.exportPath;
-        const format = ent.format
-            ? [...new Set(ent.format)]
-            : ["esm"];
-        const warning = ent.warning ?? false;
-        const plugins = ent.plugins ?? [];
-        const tsconfigFilePath = ent.tsconfigFilePath ?? undefined;
-        const outputDirectoryPath = ent.exportPath === "." ? outDir : `${outDir}${ent.exportPath.slice(1)}`;
-        points.push({
-            entry,
-            exportPath,
-            format,
-            plugins,
-            warning,
-            outputDirectoryPath,
-            tsconfigFilePath,
-        });
-    }
-    return {
-        buildEntryPoints: points,
-        updatePackage: config.allowUpdatePackageJson ?? false,
-        outDir,
-    };
-}
-/**
- * Loads the susee config file from the current working directory and converts it into build options.
- * If no supported config file is found, it returns `undefined`.
- * @returns {Promise<BuildOptions | undefined>} normalized build options or undefined when no config file exists.
- */
-async function finalSuseeConfig() {
-    const configPath = getSuseeConfigPath();
-    if (configPath) {
-        const _default = await import(configPath);
-        const config = _default.default;
-        return generateBuildOptions(config);
-    }
-}
-/**
- * Normalizes TypeScript compiler options when JSX compilation is requested.
- *
- * For JSX input, this validates that the source imports either React runtime
- * modules or the configured `jsxImportSource` runtime package. When validation
- * passes, it enables DOM libs and defaults `jsx` to `ReactJSX` if unset.
- *
- * @param {string} sourceCode - Source text to inspect for JSX runtime imports.
- * @param {ts6.CompilerOptions} compilerOptions - User-provided compiler options.
- * @param {boolean} isJsx - Whether JSX mode is enabled for this compilation.
- * @returns {ts6.CompilerOptions} Compiler options to pass into program creation.
- */
-function jsxCompilerOptions(sourceCode, compilerOptions, isJsx) {
-    if (!isJsx) {
-        return compilerOptions;
-    }
-    const reactRegexp = /import\s+(?:.*?)\s+from\s+(?:"react"|"react\/.*"|"react-dom\/.*"|"react-dom")/gm;
-    if (!reactRegexp.test(sourceCode)) {
-        if (!compilerOptions.jsxImportSource) {
-            console.error("[jsx-runtime-error]:\nJSX syntax found in bundled code,but its not react runtime,you need to be set jsxImportSource in tsconfig.");
-            process.exit(1);
-        }
-        const txt = compilerOptions.jsxImportSource;
-        const pattern = `import\\s+(?:.*?)\\s+from\\s+("${txt}"|"${txt}\\/.*")`;
-        const re = new RegExp(pattern, "gm");
-        if (!re.test(sourceCode)) {
-            console.error("[jsx-runtime-mismatch-error]:\nJSX syntax found in bundled code,but its not react runtime and jsx-runtime from bundled code and jsxImportSource from tsconfig are mismatched.`");
-            process.exit(1);
-        }
-    }
-    const { jsx, lib, ...rest } = compilerOptions;
-    const _jsx = jsx ?? ts6.JsxEmit.ReactJSX;
-    return {
-        lib: ["dom", "dom.iterable", "esnext"],
-        jsx: _jsx,
-        ...rest,
-    };
-}
-/**
- * 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) => {
-            if (file === fileName) {
-                return ts6.createSourceFile(file, sourceCode, languageVersion);
-            }
-            return undefined;
-        },
-        writeFile: (fileName, contents) => {
-            createdFiles[fileName] = contents;
-        },
-        getDefaultLibFileName: (options) => ts6.getDefaultLibFilePath(options),
-        getCurrentDirectory: () => "",
-        getDirectories: () => [],
-        fileExists: (file) => file === fileName,
-        readFile: (file) => (file === fileName ? sourceCode : undefined),
-        getCanonicalFileName: (file) => file,
-        useCaseSensitiveFileNames: () => true,
-        getNewLine: () => "\n",
-    };
-    return { createdFiles, host };
-}
-function suseeCompiler({ sourceCode, fileName, compilerOptions, isJsx = false, }) {
-    compilerOptions = jsxCompilerOptions(sourceCode, compilerOptions, isJsx);
-    // create host
-    const _host = createHost(sourceCode, fileName);
-    const createdFiles = _host.createdFiles;
-    const host = _host.host;
-    const program = ts6.createProgram([fileName], compilerOptions, host);
-    program.emit();
-    let dts;
-    let map;
-    let code = "";
-    let file_name = "";
-    let out_dir = "";
-    for (const key of Object.keys(createdFiles)) {
-        if (key.endsWith(".js"))
-            code = createdFiles[key];
-        if (key.endsWith(".d.ts"))
-            dts = createdFiles[key];
-        if (key.endsWith(".js.map"))
-            map = createdFiles[key];
-        file_name = path.basename(key).split(".")[0];
-        out_dir = path.dirname(key);
-    }
-    return { code, file_name, out_dir, dts, map };
-}
-//src/compiler/tsoptions.ts
-/**
- * Get the path of the configuration file.
- * If customConfigPath is provided and exists, use it.
- * If customConfigPath is not provided or does not exist, use the default configuration file.
- * @param {string | undefined} customConfigPath path of the custom configuration file.
- * @returns {string | undefined} path of the configuration file or undefined if customConfigPath does not exist.
- */
-function getTsConfigPath(customConfigPath) {
-    let config_path;
-    if (customConfigPath) {
-        if (!ts6.sys.fileExists(ts6.sys.resolvePath(customConfigPath))) {
-            console.error(`> ${tcolor.magenta(`Given custom file ${customConfigPath} does not exists`)}`);
-            ts6.sys.exit(1);
-        }
-        config_path = customConfigPath;
-        return config_path;
-    }
-    else {
-        config_path = ts6.findConfigFile(ts6.sys.getCurrentDirectory(), ts6.sys.fileExists);
-        return config_path;
-    }
-}
-/**
- * Get the TypeScript compiler options for susee bundler.
- * @param {string | undefined} customConfigPath path of the custom configuration file.
- */
-function getCompilerOptions(customConfigPath) {
-    let tsconfig_opts;
-    const config_path = getTsConfigPath(customConfigPath);
-    if (config_path) {
-        const config = ts6.readConfigFile(config_path, ts6.sys.readFile);
-        const basePath = path.dirname(config_path);
-        const parsed = ts6.parseJsonConfigFileContent(config.config, ts6.sys, basePath);
-        tsconfig_opts = { ...parsed.options };
-    }
-    const commonjs = (out_dir) => {
-        const _out = out_dir ? out_dir : "dist";
-        if (tsconfig_opts !== undefined) {
-            const { rootDir, outDir, module, allowJs, declarationDir, ...rest } = tsconfig_opts;
-            return {
-                outDir: _out,
-                module: ts6.ModuleKind.CommonJS,
-                allowJs: true,
-                ...rest,
-            };
-        }
-        else {
-            return {
-                outDir: _out,
-                module: ts6.ModuleKind.CommonJS,
-                target: ts6.ScriptTarget.Latest,
-            };
-        }
-    };
-    const esm = (out_dir) => {
-        const _out = out_dir ? out_dir : "dist";
-        if (tsconfig_opts !== undefined) {
-            const { rootDir, outDir, module, allowJs, declarationDir, ...rest } = tsconfig_opts;
-            return {
-                outDir: _out,
-                module: ts6.ModuleKind.ES2020,
-                allowJs: true,
-                ...rest,
-            };
-        }
-        else {
-            return {
-                outDir: _out,
-                module: ts6.ModuleKind.ES2020,
-                target: ts6.ScriptTarget.Latest,
-            };
-        }
-    };
-    const defaultOptions = ts6.getDefaultCompilerOptions;
-    return { commonjs, esm, defaultOptions };
-}
-//src/compiler/index.ts
-const logCompilerPhase = (entry, format, phase, start) => {
-    logProfilePhase(`compiler:${format}:${entry}`, phase, start);
-};
-/**
- * Compiler for the JavaScript API.
- * It bundles each configured entry point, emits CommonJS and ESM outputs,
- * and optionally updates package export metadata.
- */
-class Compiler {
-    _files;
-    _object;
-    _bundledCodeCache;
-    /**
-     * Creates a compiler instance with normalized build options.
-     * @param {BuildOptions} object - build options generated from the susee config.
-     */
-    constructor(object) {
-        this._object = object;
-        this._bundledCodeCache = new WeakMap();
-        this._files = {
-            commonjs: undefined,
-            commonjsTypes: undefined,
-            esm: undefined,
-            esmTypes: undefined,
-            main: undefined,
-            module: undefined,
-            types: undefined,
-        };
-    }
-    _update() {
-        return this._object.updatePackage;
-    }
-    async _bundle(point) {
-        let bundledCode = this._bundledCodeCache.get(point);
-        if (!bundledCode) {
-            bundledCode = bundler(point.entry, point.plugins, point.warning);
-            this._bundledCodeCache.set(point, bundledCode);
-        }
-        return bundledCode;
-    }
-    async _commonjs(point) {
-        const isMain = point.exportPath === ".";
-        const opts = getCompilerOptions(point.tsconfigFilePath);
-        const compilerOptions = opts.commonjs(point.outputDirectoryPath);
-        let phaseStart = process.hrtime.bigint();
-        const bundledCode = await this._bundle(point);
-        logCompilerPhase(point.entry, "commonjs", "bundle", phaseStart);
-        const is_jsx = utils.checks.isJsxContent(bundledCode);
-        phaseStart = process.hrtime.bigint();
-        const compiled = suseeCompiler({
-            sourceCode: bundledCode,
-            fileName: point.entry,
-            compilerOptions,
-            isJsx: is_jsx,
-        });
-        logCompilerPhase(point.entry, "commonjs", "typescriptEmit", phaseStart);
-        let compiledCode = compiled.code;
-        const mainFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.cjs`);
-        const dtsFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.d.cts`);
-        const mapFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.cjs.map`);
-        // replace source mapping url
-        compiledCode = compiledCode.replace(new RegExp(`${compiled.file_name}.js.map`, "gm"), `${compiled.file_name}.cjs.map`);
-        // call post-process plugin
-        if (point.plugins.length > 0) {
-            for (const plugin of point.plugins) {
-                const _plugin = typeof plugin === "function" ? plugin() : plugin;
-                if (_plugin.type === "post-process") {
-                    phaseStart = process.hrtime.bigint();
-                    if (_plugin.async) {
-                        compiledCode = await _plugin.func(compiledCode, point.entry);
-                    }
-                    else {
-                        compiledCode = _plugin.func(compiledCode, point.entry);
-                    }
-                    logCompilerPhase(point.entry, "commonjs", `postProcessPlugin:${_plugin.name ?? "anonymous"}`, phaseStart);
-                }
-            }
-        }
-        // if allow update create file object
-        if (this._update()) {
-            this._files.commonjs = mainFilePath;
-            if (compiled.dts) {
-                this._files.commonjsTypes = dtsFilePath;
-            }
-            if (isMain && point.format.includes("commonjs")) {
-                if (this._files.commonjs)
-                    this._files.main = this._files.commonjs;
-                if (this._files.commonjsTypes)
-                    this._files.types = this._files.commonjsTypes;
-            }
-        } //update
-        phaseStart = process.hrtime.bigint();
-        await files.writeFile(mainFilePath, compiledCode);
-        if (compiled.dts)
-            await files.writeFile(dtsFilePath, compiled.dts);
-        if (compiled.map)
-            await files.writeFile(mapFilePath, compiled.map);
-        logCompilerPhase(point.entry, "commonjs", "writeFiles", phaseStart);
-    }
-    async _esm(point) {
-        const isMain = point.exportPath === ".";
-        const opts = getCompilerOptions(point.tsconfigFilePath);
-        const compilerOptions = opts.esm(point.outputDirectoryPath);
-        let phaseStart = process.hrtime.bigint();
-        const bundledCode = await this._bundle(point);
-        logCompilerPhase(point.entry, "esm", "bundle", phaseStart);
-        const is_jsx = utils.checks.isJsxContent(bundledCode);
-        phaseStart = process.hrtime.bigint();
-        const compiled = suseeCompiler({
-            sourceCode: bundledCode,
-            fileName: point.entry,
-            compilerOptions,
-            isJsx: is_jsx,
-        });
-        logCompilerPhase(point.entry, "esm", "typescriptEmit", phaseStart);
-        let compiledCode = compiled.code;
-        const mainFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.mjs`);
-        const dtsFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.d.mts`);
-        const mapFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.mjs.map`);
-        // replace source mapping url
-        compiledCode = compiledCode.replace(new RegExp(`${compiled.file_name}.js.map`, "gm"), `${compiled.file_name}.mjs.map`);
-        // call post-process plugin
-        if (point.plugins.length > 0) {
-            for (const plugin of point.plugins) {
-                const _plugin = typeof plugin === "function" ? plugin() : plugin;
-                if (_plugin.type === "post-process") {
-                    phaseStart = process.hrtime.bigint();
-                    if (_plugin.async) {
-                        compiledCode = await _plugin.func(compiledCode, point.entry);
-                    }
-                    else {
-                        compiledCode = _plugin.func(compiledCode, point.entry);
-                    }
-                    logCompilerPhase(point.entry, "esm", `postProcessPlugin:${_plugin.name ?? "anonymous"}`, phaseStart);
-                }
-            }
-        }
-        if (this._update()) {
-            this._files.esm = mainFilePath;
-            if (compiled.dts) {
-                this._files.esmTypes = dtsFilePath;
-            }
-            if (isMain && this._files.esm) {
-                this._files.module = this._files.esm;
-            }
-        } //update
-        phaseStart = process.hrtime.bigint();
-        await files.writeFile(mainFilePath, compiledCode);
-        if (compiled.dts)
-            await files.writeFile(dtsFilePath, compiled.dts);
-        if (compiled.map)
-            await files.writeFile(mapFilePath, compiled.map);
-        logCompilerPhase(point.entry, "esm", "writeFiles", phaseStart);
-    }
-    /**
-     * Clears the output directory and compiles all configured entry points.
-     * It also updates package.json export fields when package updates are enabled.
-     * @returns {Promise<void>}
-     */
-    async compile() {
-        await files.clearFolder(this._object.outDir);
-        for (const point of this._object.buildEntryPoints) {
-            for (const format of point.format) {
-                switch (format) {
-                    case "commonjs":
-                        await this._commonjs(point);
-                        if (this._update()) {
-                            await files.writePackageJson(this._files, point.exportPath);
-                        }
-                        break;
-                    case "esm":
-                        await this._esm(point);
-                        if (this._update()) {
-                            await files.writePackageJson(this._files, point.exportPath);
-                        }
-                        break;
-                }
-            }
-        }
-    }
-}
-//src/cli/build.ts
-async function cliBuild() {
-    console.time(tcolor.cyan("[Build] "));
-    const buildOptions = await finalSuseeConfig();
-    if (!buildOptions) {
-        console.error(tcolor.magenta(`No susee.config file ("susee.config.ts", "susee.config.js", "susee.config.mjs") found`));
-        ts6.sys.exit(1);
-    }
-    const compiler = new Compiler(buildOptions);
-    await compiler.compile();
-    console.timeEnd(tcolor.cyan("[Build] "));
-}
-//src/cli/lib/fail.ts
-function fail(message) {
-    console.error(`${tcolor.magenta("[Error]")} : ${tcolor.gray(message)}`);
-    process.exit(1);
-}
-function isFile(entry) {
-    const exts = [".js", ".ts", ".mts", ".mjs", ".cjs", ".cts"];
-    return exts.includes(path.extname(entry));
-}
-// biome-ignore lint/suspicious/noExplicitAny: unknown
-function isEmptyObject(entry) {
-    return (typeof entry === "object" &&
-        !Array.isArray(entry) &&
-        Object.keys(entry).length === 0);
-}
-function parseBooleanFlag(flag, value) {
-    if (value === "true")
-        return true;
-    if (value === "false")
-        return false;
-    fail(`Type of ${flag} must be boolean.`);
-}
-// biome-ignore lint/suspicious/noExplicitAny: unknown
-function parseArgs(argv) {
-    const opts = {
-        entry: "",
-    };
-    for (let index = 0; index < argv.length; index += 1) {
-        const argument = argv[index];
-        if (index === 0 && !argument.startsWith("--") && isFile(argument)) {
-            opts.entry = argument;
-            continue;
-        }
-        const [flag, inlineValue] = argument.split("=", 2);
-        const nextValue = argv[index + 1];
-        const value = inlineValue ?? nextValue;
-        switch (flag) {
-            case "--entry":
-                if (!value || value.startsWith("--"))
-                    fail("Entry point required.");
-                if (opts.entry !== "" && isFile(opts.entry))
-                    fail("Entry point already exists.");
-                opts.entry = value;
-                if (inlineValue === undefined) {
-                    index += 1;
-                }
-                break;
-            case "--outdir":
-                if (!value || value.startsWith("--"))
-                    fail("Output directory required.");
-                opts.outDir = value;
-                if (inlineValue === undefined) {
-                    index += 1;
-                }
-                break;
-            case "--format":
-                if (value !== "cjs" && value !== "commonjs" && value !== "esm") {
-                    fail("Format must be cjs, commonjs, or esm.");
-                }
-                opts.format =
-                    value === "cjs"
-                        ? "commonjs"
-                        : value;
-                if (inlineValue === undefined) {
-                    index += 1;
-                }
-                break;
-            case "--tsconfig":
-                if (!value || value.startsWith("--"))
-                    fail("Tsconfig path required.");
-                opts.tsconfig = value;
-                if (inlineValue === undefined) {
-                    index += 1;
-                }
-                break;
-            case "--allow-update":
-                if (inlineValue !== undefined) {
-                    opts.allowUpdate = parseBooleanFlag("allow update", inlineValue);
-                }
-                else if (nextValue === "true" || nextValue === "false") {
-                    opts.allowUpdate = parseBooleanFlag("allow update", nextValue);
-                    index += 1;
-                }
-                else {
-                    opts.allowUpdate = true;
-                }
-                break;
-            case "--warning":
-                if (inlineValue !== undefined) {
-                    opts.warning = parseBooleanFlag("warning", inlineValue);
-                }
-                else if (nextValue === "true" || nextValue === "false") {
-                    opts.warning = parseBooleanFlag("warning", nextValue);
-                    index += 1;
-                }
-                else {
-                    opts.warning = true;
-                }
-                break;
-            case "--profile":
-                if (inlineValue !== undefined) {
-                    opts.profile = parseBooleanFlag("profile", inlineValue);
-                }
-                else if (nextValue === "true" || nextValue === "false") {
-                    opts.profile = parseBooleanFlag("profile", nextValue);
-                    index += 1;
-                }
-                else {
-                    opts.profile = true;
-                }
-                break;
-        }
-    }
-    if (isEmptyObject(opts) || opts.entry === "") {
-        fail("Entry point required");
-    }
-    return opts;
-}
-function getDefaultOptions(args) {
-    const entry = args.entry;
-    const outDir = args.outDir ?? "dist";
-    const format = args.format ?? "esm";
-    const tsconfig = args.tsconfig ?? undefined;
-    const allowUpdate = args.allowUpdate ?? false;
-    const warning = args.warning ?? false;
-    const profile = args.profile ?? false;
-    return {
-        entry,
-        outDir,
-        format,
-        tsconfig,
-        allowUpdate,
-        warning,
-        profile,
-        plugins: [],
-    };
-}
-//src/cli/cli.ts
-const logCliCompilerPhase = (entry, format, phase, start) => {
-    logProfilePhase(`compiler:${format}:${entry}`, phase, start);
-};
-class CliCompiler {
-    _files;
-    _update;
-    constructor() {
-        this._files = {
-            commonjs: undefined,
-            commonjsTypes: undefined,
-            esm: undefined,
-            esmTypes: undefined,
-            main: undefined,
-            module: undefined,
-            types: undefined,
-        };
-        this._update = false;
-    }
-    async _commonjs(opts) {
-        this._update = opts.allowUpdate;
-        const _opts = getCompilerOptions(opts.tsconfig);
-        const compilerOptions = _opts.commonjs(opts.outDir);
-        let phaseStart = process.hrtime.bigint();
-        const bundledCode = await bundler(opts.entry, opts.plugins, opts.warning);
-        logCliCompilerPhase(opts.entry, "commonjs", "bundle", phaseStart);
-        const is_jsx = utils.checks.isJsxContent(bundledCode);
-        phaseStart = process.hrtime.bigint();
-        const compiled = suseeCompiler({
-            sourceCode: bundledCode,
-            fileName: opts.entry,
-            compilerOptions,
-            isJsx: is_jsx,
-        });
-        logCliCompilerPhase(opts.entry, "commonjs", "typescriptEmit", phaseStart);
-        let compiledCode = compiled.code;
-        const mainFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.cjs`);
-        const dtsFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.d.cts`);
-        const mapFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.cjs.map`);
-        compiledCode = compiledCode.replace(new RegExp(`${compiled.file_name}.js.map`, "gm"), `${compiled.file_name}.cjs.map`);
-        // --
-        // call post-process plugin
-        if (opts.plugins.length > 0) {
-            for (const plugin of opts.plugins) {
-                const _plugin = typeof plugin === "function" ? plugin() : plugin;
-                if (_plugin.type === "post-process") {
-                    phaseStart = process.hrtime.bigint();
-                    if (_plugin.async) {
-                        compiledCode = await _plugin.func(compiledCode, opts.entry);
-                    }
-                    else {
-                        compiledCode = _plugin.func(compiledCode, opts.entry);
-                    }
-                    logCliCompilerPhase(opts.entry, "commonjs", `postProcessPlugin:${_plugin.name ?? "anonymous"}`, phaseStart);
-                }
-            }
-        } //-----------
-        if (this._update) {
-            this._files.commonjs = mainFilePath;
-            if (compiled.dts) {
-                this._files.commonjsTypes = dtsFilePath;
-            }
-            if (opts.format.includes("commonjs")) {
-                if (this._files.commonjs)
-                    this._files.main = this._files.commonjs;
-                if (this._files.commonjsTypes)
-                    this._files.types = this._files.commonjsTypes;
-            }
-        } //update
-        phaseStart = process.hrtime.bigint();
-        await files.writeFile(mainFilePath, compiledCode);
-        if (compiled.dts)
-            await files.writeFile(dtsFilePath, compiled.dts);
-        if (compiled.map)
-            await files.writeFile(mapFilePath, compiled.map);
-        logCliCompilerPhase(opts.entry, "commonjs", "writeFiles", phaseStart);
-    }
-    //-----------------------------------------------------------------//
-    async _esm(opts) {
-        this._update = opts.allowUpdate;
-        const _opts = getCompilerOptions(opts.tsconfig);
-        const compilerOptions = _opts.esm(opts.outDir);
-        let phaseStart = process.hrtime.bigint();
-        const bundledCode = await bundler(opts.entry, opts.plugins, opts.warning);
-        logCliCompilerPhase(opts.entry, "esm", "bundle", phaseStart);
-        const is_jsx = utils.checks.isJsxContent(bundledCode);
-        phaseStart = process.hrtime.bigint();
-        const compiled = suseeCompiler({
-            sourceCode: bundledCode,
-            fileName: opts.entry,
-            compilerOptions,
-            isJsx: is_jsx,
-        });
-        logCliCompilerPhase(opts.entry, "esm", "typescriptEmit", phaseStart);
-        let compiledCode = compiled.code;
-        const mainFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.mjs`);
-        const dtsFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.d.mts`);
-        const mapFilePath = files.joinPath(compiled.out_dir, `${compiled.file_name}.mjs.map`);
-        compiledCode = compiledCode.replace(new RegExp(`${compiled.file_name}.js.map`, "gm"), `${compiled.file_name}.mjs.map`);
-        // call post-process plugin
-        if (opts.plugins.length > 0) {
-            for (const plugin of opts.plugins) {
-                const _plugin = typeof plugin === "function" ? plugin() : plugin;
-                if (_plugin.type === "post-process") {
-                    phaseStart = process.hrtime.bigint();
-                    if (_plugin.async) {
-                        compiledCode = await _plugin.func(compiledCode, opts.entry);
-                    }
-                    else {
-                        compiledCode = _plugin.func(compiledCode, opts.entry);
-                    }
-                    logCliCompilerPhase(opts.entry, "esm", `postProcessPlugin:${_plugin.name ?? "anonymous"}`, phaseStart);
-                }
-            }
-        } //-----------
-        if (this._update) {
-            this._files.esm = mainFilePath;
-            if (compiled.dts) {
-                this._files.esmTypes = dtsFilePath;
-            }
-            if (this._files.esm) {
-                this._files.module = this._files.esm;
-            }
-        } //update
-        phaseStart = process.hrtime.bigint();
-        await files.writeFile(mainFilePath, compiledCode);
-        if (compiled.dts)
-            await files.writeFile(dtsFilePath, compiled.dts);
-        if (compiled.map)
-            await files.writeFile(mapFilePath, compiled.map);
-        logCliCompilerPhase(opts.entry, "esm", "writeFiles", phaseStart);
-    }
-    //--
-    async compile(opts) {
-        await files.clearFolder(opts.outDir);
-        switch (opts.format) {
-            case "commonjs":
-                await this._commonjs(opts);
-                if (this._update) {
-                    await files.writePackageJson(this._files, ".");
-                }
-                break;
-            case "esm":
-                await this._esm(opts);
-                if (this._update) {
-                    await files.writePackageJson(this._files, ".");
-                }
-                break;
-        }
-    }
-}
-const cliCompiler = new CliCompiler();
-//src/cli/lib/print_help.ts
-function printHelp() {
-    console.log(`Susee CLI.
-
-Usage:
-  susee                                 Build using susee.config.{ts,js,mjs}
-  susee init                            Generate susee.config.{ts,js,mjs}
-  susee --help                          Show this message
-  susee build <entry> [options]         Build from a single entry file
-
-Options:
-  --entry <path>                       Entry file (optional if provided as positional <entry>)
-  --outdir <path>                      Output directory
-  --format <cjs|commonjs|esm>          Output module format
-  --tsconfig <path>                    Custom tsconfig path
-  --allow-update[=true|false]          Enable/disable dependency update
-  --warning[=true|false]               Treat dependency graph warnings as fatal
-  --profile[=true|false]               Print bundler/compiler phase timings
-
-Notes:
-  Duplicate top-level declarations fail the build with file and location output.
-  Rename conflicting declarations in source files before bundling.
-
-Examples:
-  susee build src/index.ts --outdir dist
-  susee build src/index.ts --format commonjs
-  susee build --entry src/index.ts --format esm --tsconfig tsconfig.build.json
-  susee build src/index.ts --profile
-  susee --profile
-  
-`);
-}
-//src/cli/index.ts
-const tsFileText = `
-import type { SuSeeConfig } from "susee";
-
-const config: SuSeeConfig = {
-  // Array of entry point objects.
-  // ----------------------------
-  entryPoints: [
-    // You can add more entry points for different export paths.
-    // NOTE: duplicate export paths are not allowed.
-    // --------------------------------------------
-    {
-      // (required) Entry file path.
-      entry: "src/index.ts", // replace with your entry file
-      // (required) Export path for this entry.
-      exportPath: ".", // "." stands for the main export path and can be set to "./foo", "./bar", etc.
-      // (optional) Output module formats ["commonjs"] or ["esm", "commonjs"], default: ["esm"].
-      // Uncomment the following line to edit.
-      //format: ["esm"],
-			// Duplicate top-level declarations are checked during bundling.
-			// Rename conflicting declarations in source files before building.
-      // (optional) Custom tsconfig.json path, default: undefined.
-      // Uncomment the following line to edit.
-      //tsconfigFilePath: undefined,
-      // (optional) Array of susee plugins, default: [].
-      // Uncomment the following line to edit.
-      //plugins: [],
-      // (optional) Warning messages, if it true and warning message exist(1), default: false.
-      // Uncomment the following line to edit.
-      //warning: false,
-    },
-  ],
-  // NOTE: the following options apply to all entry points.
-  // ----------------------------------------------------------
-  // (optional) Output directory, default: dist.
-  // Uncomment the following line to edit.
-  //outDir: "dist",
-  // (optional) Allow susee to update your package.json, default: false.
-  // Uncomment the following line to edit.
-  //allowUpdatePackageJson: false,
-};
-
-export default config;
-`.trim();
-const jsFileText = `
-/**
- * @type {import("susee").SuSeeConfig}
- */
-const config = {
-  // Array of entry point objects.
-  // ----------------------------
-  entryPoints: [
-    // You can add more entry points for different export paths.
-    // NOTE: duplicate export paths are not allowed.
-    // --------------------------------------------
-    {
-      // (required) Entry file path.
-      entry: "src/index.ts", // replace with your entry file
-      // (required) Export path for this entry.
-      exportPath: ".", // "." stands for the main export path and can be set to "./foo", "./bar", etc.
-      // (optional) Output module formats ["commonjs"] or ["esm", "commonjs"], default: ["esm"].
-      // Uncomment the following line to edit.
-      //format: ["esm"],
-			// Duplicate top-level declarations are checked during bundling.
-			// Rename conflicting declarations in source files before building.
-      // (optional) Custom tsconfig.json path, default: undefined.
-      // Uncomment the following line to edit.
-      //tsconfigFilePath: undefined,
-      // (optional) Array of susee plugins, default: [].
-      // Uncomment the following line to edit.
-      //plugins: [],
-      // (optional) Warning messages, if it true and warning message exist(1), default: false.
-      // Uncomment the following line to edit.
-      //warning: false,
-    },
-  ],
-  // NOTE: the following options apply to all entry points.
-  // ----------------------------------------------------------
-  // (optional) Output directory, default: dist.
-  // Uncomment the following line to edit.
-  //outDir: "dist",
-  // (optional) Allow susee to update your package.json, default: false.
-  // Uncomment the following line to edit.
-  //allowUpdatePackageJson: false,
-};
-
-export default config;
-`.trim();
-async function getPackageType() {
-    const pkgPath = path.resolve(process.cwd(), "package.json");
-    const _pkg = await fs.promises.readFile(pkgPath, "utf8");
-    const pkg = JSON.parse(_pkg);
-    return __jsonModule__package.type === "module" ? "esm" : "commonjs";
-}
-async function cliInit() {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    console.log(`${tcolor.gray("┌")} ${tcolor.green("Welcome to Susee!")}`);
-    console.log("");
-    console.log(`${tcolor.gray("│")}`);
-    const is_ts = await rl.question(`${tcolor.cyan("◇")} Is TypeScript Project(y/n) : `);
-    const isTs = !!(is_ts === "y" || is_ts === "Y" || is_ts === "");
-    rl.close();
-    let configFile = "";
-    let str = "";
-    if (isTs) {
-        configFile = "susee.config.ts";
-        str = tsFileText;
-    }
-    else {
-        str = jsFileText;
-        const pkgType = await getPackageType();
-        switch (pkgType) {
-            case "commonjs":
-                configFile = "susee.config.mjs";
-                break;
-            case "esm":
-                configFile = "susee.config.js";
-                break;
-        }
-    }
-    const configFilePath = path.resolve(process.cwd(), configFile);
-    if (fs.existsSync(configFilePath))
-        await fs.promises.unlink(configFilePath);
-    await fs.promises.writeFile(configFilePath, str);
-    console.log("");
-    console.log(`${tcolor.gray("│")}`);
-    console.log("");
-    console.info(`${tcolor.gray("└")} Done! Susee config file ${tcolor.cyan(configFile)} is created at project root`);
-}
-function extractProfileFlag(args) {
-    const nextArgs = [];
-    let profile = false;
-    for (let index = 0; index < args.length; index += 1) {
-        const argument = args[index];
-        const [flag, inlineValue] = argument.split("=", 2);
-        if (flag !== "--profile") {
-            nextArgs.push(argument);
-            continue;
-        }
-        const nextValue = args[index + 1];
-        if (inlineValue !== undefined) {
-            profile = parseBooleanFlag("profile", inlineValue);
-            continue;
-        }
-        if (nextValue === "true" || nextValue === "false") {
-            profile = parseBooleanFlag("profile", nextValue);
-            index += 1;
-            continue;
-        }
-        profile = true;
-    }
-    return { args: nextArgs, profile };
-}
-async function suseeCliBuild() {
-    const rawArgs = process.argv.slice(2);
-    const { args, profile } = extractProfileFlag(rawArgs);
-    if (profile) {
-        setProfileEnabled(true);
-    }
-    if (args.length === 0) {
-        await cliBuild();
-    }
-    else if (args.length === 1) {
-        if (args[0] === "--version" || args[0] === "-v") {
-            console.log(tcolor.cyan(`susee v${__jsonModule__package.version}`));
-        }
-        if (args[0] === "--help" || args[0] === "-h") {
-            printHelp();
-        }
-        if (args[0] === "init") {
-            await cliInit();
-        }
-        if (args[0] === "build") {
-            printHelp();
-        }
-    }
-    else if (args.length > 1 &&
-        args[0] === "build" &&
-        (args[1] === "--help" || args[1] === "-h")) {
-        printHelp();
-    }
-    else if (args.length > 1 && args[0] === "build") {
-        const _r = parseArgs(args.slice(1));
-        const options = getDefaultOptions(_r);
-        await cliCompiler.compile(options);
-    }
-    else {
-        console.error("Unknown CLI usage");
-        process.exit(1);
-    }
-}
-if (import.meta.main) {
-    await suseeCliBuild();
-}
-//src/index.ts
-/**
- * Run a Susee build.
- *
- * Resolution order:
- * 1. Use `options` when provided.
- * 2. Otherwise try loading root config via `finalSuseeConfig()`.
- *
- * If neither source is available, this logs an error and exits with code 1.
- */
-async function build(options) {
-    console.time(tcolor.cyan("[Build] "));
-    let buildOptions = {};
-    const _buildOptions = await finalSuseeConfig();
-    if (!options && !_buildOptions) {
-        console.error(`${tcolor.magenta("[Error]")} : Required build options or susee config file at root.\n          Use ${tcolor.bold("npx susee init")} to create config file.`);
-        process.exit(1);
-    }
-    if (options) {
-        buildOptions = generateBuildOptions(options);
-    }
-    else if (_buildOptions) {
-        buildOptions = _buildOptions;
-    }
-    const compiler = new Compiler(buildOptions);
-    await compiler.compile();
-    console.timeEnd(tcolor.cyan("[Build] "));
-}
-export { build, bundle as suseeBundler, suseeCliBuild };
-//# sourceMappingURL=index.mjs.map