bunchee 5.2.0-beta.0 → 5.2.0

package/dist/index.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var fsp = require('fs/promises');
 var fs = require('fs');
 var path = require('path');
-var perf_hooks = require('perf_hooks');
-var module$1 = require('module');
+require('pretty-bytes');
 var require$$0 = require('tty');
+var module$1 = require('module');
+var rollup = require('rollup');
 var pluginWasm = require('@rollup/plugin-wasm');
 var rollupPluginSwc3 = require('rollup-plugin-swc3');
 var commonjs = require('@rollup/plugin-commonjs');
@@ -16,8 +17,6 @@ var preserveDirectives = require('rollup-preserve-directives');
 var MagicString = require('magic-string');
 var CleanCSS = require('clean-css');
 var pluginutils = require('@rollup/pluginutils');
-var prettyBytes = require('pretty-bytes');
-var rollup = require('rollup');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -31,7 +30,6 @@ var replace__default = /*#__PURE__*/_interopDefault(replace);
 var preserveDirectives__default = /*#__PURE__*/_interopDefault(preserveDirectives);
 var MagicString__default = /*#__PURE__*/_interopDefault(MagicString);
 var CleanCSS__default = /*#__PURE__*/_interopDefault(CleanCSS);
-var prettyBytes__default = /*#__PURE__*/_interopDefault(prettyBytes);
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -86,6 +84,25 @@ picocolors.exports.createColors = createColors;
 var picocolorsExports = picocolors.exports;
 var pc = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
 
+const defaultColorFn = (text)=>text;
+function color(prefixColor) {
+    return pc.isColorSupported ? pc[prefixColor] : defaultColorFn;
+}
+const logger = {
+    log (...arg) {
+        console.log(...arg);
+    },
+    warn (...arg) {
+        console.warn(color('yellow')('⚠️'), ...arg);
+    },
+    error (...arg) {
+        console.error(color('red')('⨯'), ...arg);
+    },
+    info (...arg) {
+        console.log(color('green')('✓'), ...arg);
+    }
+};
+
 const availableExtensions = new Set([
     'js',
     'cjs',
@@ -147,25 +164,6 @@ const DEFAULT_TS_CONFIG = {
 };
 const BINARY_TAG = '$binary';
 
-const defaultColorFn = (text)=>text;
-function color(prefixColor) {
-    return pc.isColorSupported ? pc[prefixColor] : defaultColorFn;
-}
-const logger = {
-    log (...arg) {
-        console.log(...arg);
-    },
-    warn (...arg) {
-        console.warn(color('yellow')('⚠️'), ...arg);
-    },
-    error (...arg) {
-        console.error(color('red')('⨯'), ...arg);
-    },
-    info (...arg) {
-        console.log(color('green')('✓'), ...arg);
-    }
-};
-
 function exit(err) {
     logger.error(err);
     process.exit(1);
@@ -286,866 +284,949 @@ function isBinExportPath(exportPath) {
     return exportPath === BINARY_TAG || exportPath.startsWith(BINARY_TAG + '/');
 }
 
-const memoize = (fn, cacheKey, cacheArg)=>{
-    const cache = cacheArg || new Map();
-    return (...args)=>{
-        const key = cacheKey ? typeof cacheKey === 'function' ? cacheKey(...args) : cacheKey : JSON.stringify({
-            args
-        });
-        const existing = cache.get(key);
-        if (existing !== undefined) {
-            return existing;
-        }
-        const result = fn(...args);
-        cache.set(key, result);
-        return result;
-    };
-};
-const memoizeByKey = (fn)=>{
-    const cache = new Map();
-    return (cacheKey)=>memoize(fn, cacheKey, cache);
-};
-
-let hasLoggedTsWarning = false;
-function resolveTypescript(cwd) {
-    let ts;
-    const m = new module$1.Module('', undefined);
-    m.paths = module$1.Module._nodeModulePaths(cwd);
-    try {
-        // Bun does not yet support the `Module` class properly.
-        if (typeof (m == null ? void 0 : m.require) === 'undefined') {
-            const tsPath = require.resolve('typescript', {
-                paths: [
-                    cwd
-                ]
-            });
-            ts = require(tsPath);
+function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exportToDist) {
+    // End of searching, export value is file path.
+    // <export key>: <export value> (string)
+    if (typeof exportValue === 'string') {
+        const composedTypes = new Set(exportTypes);
+        const exportType = exportKey.startsWith('.') ? 'default' : exportKey;
+        composedTypes.add(exportType);
+        const exportInfo = exportToDist.get(mapExportFullPath(currentPath));
+        const exportCondition = Array.from(composedTypes).join('.');
+        if (!exportInfo) {
+            const outputConditionPair = [
+                exportValue,
+                exportCondition
+            ];
+            addToExportDistMap(exportToDist, currentPath, [
+                outputConditionPair
+            ], runtimeExportConventions.has(exportType) ? exportType : undefined);
         } else {
-            ts = m.require('typescript');
+            exportInfo.push([
+                exportValue,
+                exportCondition
+            ]);
         }
-    } catch (e) {
-        console.error(e);
-        if (!hasLoggedTsWarning) {
-            hasLoggedTsWarning = true;
-            exit('Could not load TypeScript compiler. Try to install `typescript` as dev dependency');
+        return;
+    }
+    const exportKeys = Object.keys(exportValue);
+    for (const exportKey of exportKeys){
+        // Clone the set to avoid modifying the parent set
+        const childExports = new Set(exportTypes);
+        // Normalize child export value to a map
+        const childExportValue = exportValue[exportKey];
+        // Visit export path: ./subpath, ./subpath2, ...
+        if (exportKey.startsWith('.')) {
+            const childPath = joinRelativePath(currentPath, exportKey);
+            collectExportPath(childExportValue, exportKey, childPath, childExports, exportToDist);
+        } else {
+            // Visit export type: import, require, ...
+            childExports.add(exportKey);
+            collectExportPath(childExportValue, exportKey, currentPath, childExports, exportToDist);
         }
     }
-    return ts;
 }
-function resolveTsConfigHandler(cwd, tsconfig = 'tsconfig.json') {
-    let tsCompilerOptions = {};
-    let tsConfigPath;
-    tsConfigPath = path.resolve(cwd, tsconfig);
-    if (fileExists(tsConfigPath)) {
-        // Use the original ts handler to avoid memory leak
-        const ts = resolveTypescript(cwd);
-        const basePath = tsConfigPath ? path.dirname(tsConfigPath) : cwd;
-        const tsconfigJSON = ts.readConfigFile(tsConfigPath, ts.sys.readFile).config;
-        tsCompilerOptions = ts.parseJsonConfigFileContent(tsconfigJSON, ts.sys, basePath).options;
+const mapExportFullPath = (exportPath)=>exportPath === '.' ? './index' : exportPath;
+function addToExportDistMap(exportToDist, exportPath, outputConditionPairs, specialExportType) {
+    const fullPath = mapExportFullPath(exportPath);
+    // + (specialExportType ? '.' + specialExportType : '')
+    const existingExportInfo = exportToDist.get(fullPath);
+    if (!existingExportInfo) {
+        exportToDist.set(fullPath, outputConditionPairs);
     } else {
-        return null;
+        existingExportInfo.push(...outputConditionPairs);
     }
-    return {
-        tsCompilerOptions,
-        tsConfigPath
-    };
 }
-const resolveTsConfig = memoizeByKey(resolveTsConfigHandler)();
-async function convertCompilerOptions(cwd, json) {
-    // Use the original ts handler to avoid memory leak
-    const ts = resolveTypescript(cwd);
-    return ts.convertCompilerOptionsFromJson(json, './');
+/**
+ * parseExports - parse package.exports field and other fields like main,module to a map
+ *
+ * map from export path to output path and export conditions
+ *
+ * exportToDist: {
+ *  './index': { development: ..., default: ... }
+ *  './index.react-server': { development: ..., default: ... }
+ * }
+ */ function parseExports(pkg) {
+    var _pkg_exports;
+    const exportsField = (_pkg_exports = pkg.exports) != null ? _pkg_exports : {};
+    var _pkg_bin;
+    const bins = (_pkg_bin = pkg.bin) != null ? _pkg_bin : {};
+    const exportToDist = new Map();
+    const isEsmPkg = isESModulePackage(pkg.type);
+    const defaultCondition = isEsmPkg ? 'import' : 'require';
+    let currentPath = '.';
+    if (typeof exportsField === 'string') {
+        const outputConditionPair = [
+            exportsField,
+            defaultCondition
+        ];
+        addToExportDistMap(exportToDist, currentPath, [
+            outputConditionPair
+        ]);
+    } else {
+        // keys means unknown if they're relative path or export type
+        const exportConditionKeys = Object.keys(exportsField);
+        for (const exportKey of exportConditionKeys){
+            const exportValue = exportsField[exportKey];
+            const exportTypes = new Set();
+            const isExportPath = exportKey.startsWith('.');
+            const childPath = isExportPath ? joinRelativePath(currentPath, exportKey) : currentPath;
+            if (!isExportPath) {
+                exportTypes.add(exportKey);
+            }
+            collectExportPath(exportValue, exportKey, childPath, exportTypes, exportToDist);
+        }
+    }
+    if (typeof bins === 'string') {
+        const outputConditionPair = [
+            bins,
+            defaultCondition
+        ];
+        addToExportDistMap(exportToDist, BINARY_TAG, [
+            outputConditionPair
+        ]);
+    } else {
+        for (const binName of Object.keys(bins)){
+            const binDistPath = bins[binName];
+            const exportType = getExportTypeFromFile(binDistPath, pkg.type);
+            const exportPath = path.posix.join(BINARY_TAG, binName);
+            const outputConditionPair = [
+                binDistPath,
+                exportType
+            ];
+            addToExportDistMap(exportToDist, exportPath, [
+                outputConditionPair
+            ]);
+        }
+    }
+    // Handle package.json global exports fields
+    if (pkg.main || pkg.module || pkg.types) {
+        const mainExportPath = pkg.main;
+        const moduleExportPath = pkg.module;
+        const typesEntryPath = pkg.types;
+        addToExportDistMap(exportToDist, './index', [
+            Boolean(mainExportPath) && [
+                mainExportPath,
+                getMainFieldExportType(pkg)
+            ],
+            Boolean(moduleExportPath) && [
+                moduleExportPath,
+                'module'
+            ],
+            Boolean(typesEntryPath) && [
+                typesEntryPath,
+                'types'
+            ]
+        ].filter(Boolean));
+    }
+    return exportToDist;
 }
-async function writeDefaultTsconfig(tsConfigPath) {
-    await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
-    logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
+function isEsmExportName(name, ext) {
+    return [
+        'import',
+        'module'
+    ].includes(name) || ext === 'mjs';
 }
-
-const FILENAME_REGEX = /__filename/;
-const DIRNAME_REGEX = /__dirname/;
-const GLOBAL_REQUIRE_REGEX = /require(\.resolve)?\(/;
-const PolyfillComment = '/** rollup-private-do-not-use-esm-shim-polyfill */';
-const createESMShim = ({ filename, dirname, globalRequire })=>{
-    const useNodeUrl = filename || dirname;
-    const useNodePath = dirname;
-    const useNodeModule = globalRequire;
-    return `\
-${PolyfillComment}
-${useNodeUrl ? `import __node_cjsUrl from 'node:url'` : ''};
-${useNodePath ? `import __node_cjsPath from 'node:path';` : ''}
-${useNodeModule ? `import __node_cjsModule from 'node:module';` : ''}
-${useNodeUrl ? 'const __filename = __node_cjsUrl.fileURLToPath(import.meta.url);' : ''}
-${useNodePath ? 'const __dirname = __node_cjsPath.dirname(__filename);' : ''}
-${useNodeModule ? 'const require = __node_cjsModule.createRequire(import.meta.url);' : ''}
-`.trim() + '\n';
-};
-function esmShim() {
-    return {
-        name: 'esm-shim',
-        transform: {
-            order: 'post',
-            handler (code, id) {
-                const ext = path.extname(id);
-                if (!availableESExtensionsRegex.test(ext) || code.includes(PolyfillComment)) {
-                    return null;
-                }
-                let hasFilename = false;
-                let hasDirname = false;
-                let hasGlobalRequire = false;
-                if (FILENAME_REGEX.test(code)) {
-                    hasFilename = true;
-                }
-                if (DIRNAME_REGEX.test(code)) {
-                    hasDirname = true;
-                }
-                if (GLOBAL_REQUIRE_REGEX.test(code)) {
-                    hasGlobalRequire = true;
-                }
-                if (!hasFilename && !hasDirname && !hasGlobalRequire) {
-                    return null;
-                }
-                const magicString = new MagicString__default.default(code);
-                let ast = null;
-                try {
-                    // rollup 2 built-in parser doesn't have `allowShebang`, we need to use the sliced code here. Hence the `magicString.toString()`
-                    ast = this.parse(magicString.toString(), {
-                        allowReturnOutsideFunction: true
-                    });
-                } catch (e) {
-                    console.warn(e);
-                    return null;
-                }
-                if (ast.type !== 'Program') {
-                    return null;
-                }
-                let lastImportNode = null;
-                for (const node of ast.body){
-                    if (node.type === 'ImportDeclaration') {
-                        lastImportNode = node;
-                        continue;
-                    }
-                }
-                let end = 0;
-                if (lastImportNode) {
-                    end = lastImportNode.end;
-                } else {
-                    end = ast.body.length > 0 ? ast.body[0].end : 0;
-                }
-                magicString.appendRight(end, '\n' + createESMShim({
-                    filename: hasFilename,
-                    dirname: hasDirname,
-                    globalRequire: hasGlobalRequire
-                }));
-                return {
-                    code: magicString.toString(),
-                    map: magicString.generateMap({
-                        hires: true
-                    })
-                };
-            }
-        }
-    };
+function isCjsExportName(pkg, exportCondition, ext) {
+    const isESModule = isESModulePackage(pkg.type);
+    const isCjsCondition = [
+        'require',
+        'main'
+    ].includes(exportCondition);
+    const isNotEsmExportName = !isEsmExportName(exportCondition, ext);
+    return !isESModule && isNotEsmExportName && (ext !== 'mjs' || isCjsCondition) || ext === 'cjs';
 }
-
-const helpers = {
-    cssImport: {
-        // have to assign r.type = 'text/css' to make it work in Safari
-        global: `\
-function __insertCSS(code) {
-  if (!code || typeof document == 'undefined') return
-  let head = document.head || document.getElementsByTagName('head')[0]
-  let style = document.createElement('style')
-  style.type = 'text/css'
-  head.appendChild(style)
-  ;style.styleSheet ? (style.styleSheet.cssText = code) : style.appendChild(document.createTextNode(code))
+function getFileExportType(composedTypes) {
+    return composedTypes.split('.').pop();
 }
-`,
-        create (code) {
-            return `__insertCSS(${JSON.stringify(code)});`;
+function getExportsDistFilesOfCondition(pkg, parsedExportCondition, cwd, dts) {
+    const dist = [];
+    const exportConditionNames = Object.keys(parsedExportCondition.export);
+    const uniqueFiles = new Set();
+    for (const exportCondition of exportConditionNames){
+        const exportType = getFileExportType(exportCondition);
+        // Filter out non-types field when generating types jobs
+        if (dts && exportType !== 'types') {
+            continue;
         }
-    },
-    cssAssertionImport: {
-        global: '',
-        create (code) {
-            return `\
-const sheet = new CSSStyleSheet()
-sheet.replaceSync(${JSON.stringify(code)})
-export default sheet`;
+        // Filter out types field when generating asset jobs
+        if (!dts && exportType === 'types') {
+            continue;
+        }
+        const filePath = parsedExportCondition.export[exportCondition];
+        const ext = path.extname(filePath).slice(1);
+        const relativePath = parsedExportCondition.export[exportCondition];
+        const distFile = path.resolve(cwd, relativePath);
+        const format = isCjsExportName(pkg, exportCondition, ext) ? 'cjs' : 'esm';
+        if (uniqueFiles.has(distFile)) {
+            continue;
         }
+        uniqueFiles.add(distFile);
+        dist.push({
+            format,
+            file: distFile,
+            exportCondition
+        });
     }
-};
-const cleanCssInstance = new CleanCSS__default.default({});
-function minify(code) {
-    return cleanCssInstance.minify(code).styles;
+    return dist;
 }
-function inlineCss(options) {
-    const cssIds = new Set();
-    var _options_exclude;
-    const filter = pluginutils.createFilter([
-        '**/*.css'
-    ], (_options_exclude = options.exclude) != null ? _options_exclude : []);
-    // Follow up for rollup 4 for better support of assertion support https://github.com/rollup/rollup/issues/4818
-    return {
-        name: 'inline-css',
-        transform: {
-            order: 'post',
-            handler (code, id) {
-                if (!filter(id)) return;
-                if (options.skip) return '';
-                const cssCode = minify(code);
-                cssIds.add(id);
-                return {
-                    code: helpers.cssImport.create(cssCode),
-                    map: {
-                        mappings: ''
-                    }
-                };
-            }
-        },
-        renderChunk: {
-            order: 'pre',
-            handler (code) {
-                const dependenciesIds = this.getModuleIds();
-                let foundCss = false;
-                for (const depId of dependenciesIds){
-                    if (depId && cssIds.has(depId)) {
-                        foundCss = true;
-                        break;
-                    }
-                }
-                if (!foundCss) return;
-                return {
-                    code: `${helpers.cssImport.global}\n${code}`,
-                    map: {
-                        mappings: ''
-                    }
-                };
-            }
-        }
-    };
+function getExportFileTypePath(absoluteJsBundlePath) {
+    const dirName = path.dirname(absoluteJsBundlePath);
+    const baseName = baseNameWithoutExtension(absoluteJsBundlePath);
+    const ext = path.extname(absoluteJsBundlePath).slice(1);
+    const typeExtension = dtsExtensionsMap[ext];
+    return path.join(dirName, baseName + '.' + typeExtension);
 }
-
-function rawContent({ exclude }) {
-    const filter = pluginutils.createFilter([
-        '**/*.data',
-        '**/*.txt'
-    ], exclude);
-    return {
-        name: 'string',
-        transform (code, id) {
-            if (filter(id)) {
-                return {
-                    code: `const data = ${JSON.stringify(code)};\nexport default data;`,
-                    map: null
-                };
-            }
-            return null;
-        }
-    };
+function getExportTypeFromFile(filename, pkgType) {
+    const isESModule = isESModulePackage(pkgType);
+    const isCjsExt = filename.endsWith('.cjs');
+    const isEsmExt = filename.endsWith('.mjs');
+    const exportType = isEsmExt ? 'import' : isCjsExt ? 'require' : isESModule ? 'import' : 'require';
+    return exportType;
 }
 
 function relativify(path) {
     return path.startsWith('.') ? path : `./${path}`;
 }
 
-// Alias entries to import path
-// e.g.
-// For a resolved file, if it's one of the entries,
-// aliases it as export path, such as <absolute file> -> <pkg>/<export path>
-function aliasEntries({ entry, entries, entriesAlias, format, dts, cwd }) {
-    const entryAliasWithoutSelf = {
-        ...entriesAlias,
-        [entry]: null
-    };
-    const pathToRelativeDistMap = new Map();
-    for (const [, exportCondition] of Object.entries(entries)){
-        const exportDistMaps = exportCondition.export;
-        if (dts) {
-            var _Object_entries_find;
-            // Search types + [format] condition from entries map
-            // e.g. import.types, require.types
-            const typeCond = (_Object_entries_find = Object.entries(exportDistMaps).find(([composedKey, cond])=>{
-                const typesSet = new Set(composedKey.split('.'));
-                const formatCond = format === 'cjs' ? 'require' : 'import';
-                const isMatchedCond = typesSet.has(formatCond) || !typesSet.has('import') && !typesSet.has('require');
-                return typesSet.has('types') && isMatchedCond && cond != null;
-            })) == null ? void 0 : _Object_entries_find[1];
-            if (typeCond) {
-                pathToRelativeDistMap.set(exportCondition.source, typeCond);
+// shared.ts -> ./shared
+// shared.<export condition>.ts -> ./shared
+// index.ts -> ./index
+// index.development.ts -> ./index.development
+function sourceFilenameToExportFullPath(filename) {
+    const baseName = baseNameWithoutExtension(filename);
+    let exportPath = baseName;
+    return relativify(exportPath);
+}
+async function collectEntriesFromParsedExports(cwd, parsedExportsInfo, sourceFile) {
+    const entries = {};
+    if (sourceFile) {
+        const defaultExport = parsedExportsInfo.get('./index')[0];
+        entries['./index'] = {
+            source: sourceFile,
+            name: '.',
+            export: {
+                default: defaultExport[0]
             }
-        }
+        };
     }
-    return {
-        name: 'alias',
-        resolveId: {
-            async handler (source, importer, options) {
-                const resolved = await this.resolve(source, importer, options);
-                if (resolved != null) {
-                    if (dts) {
-                        // For types, generate relative path to the other type files,
-                        // this will be compatible for the node10 ts module resolution.
-                        const resolvedDist = pathToRelativeDistMap.get(resolved.id);
-                        const entryDist = pathToRelativeDistMap.get(entry);
-                        if (resolved.id !== entry && entryDist && resolvedDist) {
-                            const absoluteEntryDist = path__default.default.resolve(cwd, entryDist);
-                            const absoluteResolvedDist = path__default.default.resolve(cwd, resolvedDist);
-                            const filePathBase = path__default.default.relative(path__default.default.dirname(absoluteEntryDist), absoluteResolvedDist);
-                            const relativePath = relativify(filePathBase);
-                            return {
-                                id: relativePath,
-                                external: true
-                            };
-                        }
-                    } else {
-                        const aliasedId = entryAliasWithoutSelf[resolved.id];
-                        if (aliasedId != null) {
-                            return {
-                                id: aliasedId
-                            };
-                        }
-                    }
-                }
-                return null;
-            }
+    // Find source files
+    const { bins, exportsEntries } = await collectSourceEntriesFromExportPaths(path.join(cwd, SRC), parsedExportsInfo);
+    // A mapping between each export path and its related special export conditions,
+    // excluding the 'default' export condition.
+    // { './index' => Set('development', 'edge-light') }
+    const pathSpecialConditionsMap = {};
+    for (const [exportPath] of exportsEntries){
+        const normalizedExportPath = stripSpecialCondition(exportPath);
+        if (!pathSpecialConditionsMap[normalizedExportPath]) {
+            pathSpecialConditionsMap[normalizedExportPath] = new Set();
         }
-    };
-}
-
-function prependDirectives() {
-    return {
-        name: 'prependDirective',
-        transform: {
-            order: 'post',
-            handler (code, id) {
-                var _moduleInfo_meta;
-                const moduleInfo = this.getModuleInfo(id);
-                if (moduleInfo == null ? void 0 : (_moduleInfo_meta = moduleInfo.meta) == null ? void 0 : _moduleInfo_meta.preserveDirectives) {
-                    const firstDirective = moduleInfo.meta.preserveDirectives.directives[0];
-                    if (firstDirective) {
-                        const directive = firstDirective.value;
-                        const directiveCode = `'${directive}';`;
-                        return directiveCode + '\n' + code;
-                    }
-                }
-                return null;
-            }
+        const exportType = getExportTypeFromExportPath(exportPath);
+        if (exportType !== 'default') {
+            pathSpecialConditionsMap[normalizedExportPath].add(exportType);
         }
-    };
-}
-
-const prependShebang = (entry)=>({
-        name: 'prependShebang',
-        transform: (code, id)=>{
-            if (id !== entry) return;
-            const shebang = '#!/usr/bin/env node\n';
-            if (code.startsWith(shebang)) return;
-            const magicString = new MagicString__default.default(code);
-            magicString.prepend(shebang);
-            return {
-                code: magicString.toString(),
-                map: magicString.generateMap({
-                    hires: true
-                })
-            };
+    }
+    // Traverse source files and try to match the entries
+    // Find exports from parsed exports info
+    // entryExportPath can be: './index', './index.development', './shared.edge-light', etc.
+    for (const [entryExportPath, sourceFilesMap] of exportsEntries){
+        const normalizedExportPath = stripSpecialCondition(entryExportPath);
+        const entryExportPathType = getExportTypeFromExportPath(entryExportPath);
+        const outputExports = parsedExportsInfo.get(normalizedExportPath);
+        if (!outputExports) {
+            continue;
         }
-    });
-
-function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exportToDist) {
-    // End of searching, export value is file path.
-    // <export key>: <export value> (string)
-    if (typeof exportValue === 'string') {
-        const composedTypes = new Set(exportTypes);
-        const exportType = exportKey.startsWith('.') ? 'default' : exportKey;
-        composedTypes.add(exportType);
-        const exportInfo = exportToDist.get(mapExportFullPath(currentPath));
-        const exportCondition = Array.from(composedTypes).join('.');
-        if (!exportInfo) {
-            const outputConditionPair = [
-                exportValue,
-                exportCondition
-            ];
-            addToExportDistMap(exportToDist, currentPath, [
-                outputConditionPair
-            ], runtimeExportConventions.has(exportType) ? exportType : undefined);
-        } else {
-            exportInfo.push([
-                exportValue,
-                exportCondition
-            ]);
+        for (const [outputPath, outputComposedExportType] of outputExports){
+            // export type can be: default, development, react-server, etc.
+            const matchedExportType = getSpecialExportTypeFromComposedExportPath(outputComposedExportType);
+            const specialSet = pathSpecialConditionsMap[normalizedExportPath];
+            const hasSpecialEntry = specialSet.has(matchedExportType);
+            const sourceFile = sourceFilesMap[matchedExportType] || sourceFilesMap.default;
+            if (!sourceFile) {
+                continue;
+            }
+            if (!entries[entryExportPath]) {
+                entries[entryExportPath] = {
+                    source: sourceFile,
+                    name: normalizedExportPath,
+                    export: {}
+                };
+            } else if (matchedExportType === entryExportPathType) {
+                entries[entryExportPath].source = sourceFile;
+            }
+            // output exports match
+            if (matchedExportType === entryExportPathType || !hasSpecialEntry && matchedExportType !== 'default') {
+                // When we dealing with special export conditions, we need to make sure
+                // the outputs won't override the default export output paths.
+                // e.g. We have './index' -> { default: 'index.js', development: 'index.development.js' };
+                // When we generate './index.react-server' -> { 'react-server': 'index.react-server.js' },
+                // Normalize the entryExportPath to './index' first and check if it already exists with output paths.
+                const normalizedEntryExportPath = stripSpecialCondition(entryExportPath);
+                if (// The entry already exists, e.g. normalize './index.react-server' to './index'
+                entries[normalizedEntryExportPath] && // Is special export condition
+                entryExportPathType !== 'default' && // The extracted special condition is not the current loop one.
+                entryExportPathType !== matchedExportType) {
+                    continue;
+                }
+                const exportMap = entries[entryExportPath].export;
+                exportMap[outputComposedExportType] = outputPath;
+            }
         }
-        return;
     }
-    const exportKeys = Object.keys(exportValue);
-    for (const exportKey of exportKeys){
-        // Clone the set to avoid modifying the parent set
-        const childExports = new Set(exportTypes);
-        // Normalize child export value to a map
-        const childExportValue = exportValue[exportKey];
-        // Visit export path: ./subpath, ./subpath2, ...
-        if (exportKey.startsWith('.')) {
-            const childPath = joinRelativePath(currentPath, exportKey);
-            collectExportPath(childExportValue, exportKey, childPath, childExports, exportToDist);
-        } else {
-            // Visit export type: import, require, ...
-            childExports.add(exportKey);
-            collectExportPath(childExportValue, exportKey, currentPath, childExports, exportToDist);
+    // Handling binaries
+    for (const [exportPath, sourceFile] of bins){
+        const outputExports = parsedExportsInfo.get(exportPath);
+        if (!outputExports) {
+            continue;
+        }
+        for (const [outputPath, exportType] of outputExports){
+            entries[exportPath] = {
+                source: sourceFile,
+                name: exportPath,
+                export: {
+                    [exportType]: outputPath
+                }
+            };
         }
     }
+    return entries;
 }
-const mapExportFullPath = (exportPath)=>exportPath === '.' ? './index' : exportPath;
-function addToExportDistMap(exportToDist, exportPath, outputConditionPairs, specialExportType) {
-    const fullPath = mapExportFullPath(exportPath);
-    // + (specialExportType ? '.' + specialExportType : '')
-    const existingExportInfo = exportToDist.get(fullPath);
-    if (!existingExportInfo) {
-        exportToDist.set(fullPath, outputConditionPairs);
-    } else {
-        existingExportInfo.push(...outputConditionPairs);
-    }
+// ./index -> default
+// ./index.development -> development
+// ./index.react-server -> react-server
+function getExportTypeFromExportPath(exportPath) {
+    // Skip the first two segments: `.` and `index`
+    const exportTypes = exportPath.split('.').slice(2);
+    return getExportTypeFromExportTypesArray(exportTypes);
 }
-/**
- * parseExports - parse package.exports field and other fields like main,module to a map
- *
- * map from export path to output path and export conditions
- *
- * exportToDist: {
- *  './index': { development: ..., default: ... }
- *  './index.react-server': { development: ..., default: ... }
- * }
- */ function parseExports(pkg) {
-    var _pkg_exports;
-    const exportsField = (_pkg_exports = pkg.exports) != null ? _pkg_exports : {};
-    var _pkg_bin;
-    const bins = (_pkg_bin = pkg.bin) != null ? _pkg_bin : {};
-    const exportToDist = new Map();
-    const isEsmPkg = isESModulePackage(pkg.type);
-    const defaultCondition = isEsmPkg ? 'import' : 'require';
-    let currentPath = '.';
-    if (typeof exportsField === 'string') {
-        const outputConditionPair = [
-            exportsField,
-            defaultCondition
-        ];
-        addToExportDistMap(exportToDist, currentPath, [
-            outputConditionPair
-        ]);
-    } else {
-        // keys means unknown if they're relative path or export type
-        const exportConditionKeys = Object.keys(exportsField);
-        for (const exportKey of exportConditionKeys){
-            const exportValue = exportsField[exportKey];
-            const exportTypes = new Set();
-            const isExportPath = exportKey.startsWith('.');
-            const childPath = isExportPath ? joinRelativePath(currentPath, exportKey) : currentPath;
-            if (!isExportPath) {
-                exportTypes.add(exportKey);
-            }
-            collectExportPath(exportValue, exportKey, childPath, exportTypes, exportToDist);
+function getSpecialExportTypeFromComposedExportPath(composedExportType) {
+    const exportTypes = composedExportType.split('.');
+    for (const exportType of exportTypes){
+        if (specialExportConventions.has(exportType)) {
+            return exportType;
         }
     }
-    if (typeof bins === 'string') {
-        const outputConditionPair = [
-            bins,
-            defaultCondition
-        ];
-        addToExportDistMap(exportToDist, BINARY_TAG, [
-            outputConditionPair
-        ]);
-    } else {
-        for (const binName of Object.keys(bins)){
-            const binDistPath = bins[binName];
-            const exportType = getExportTypeFromFile(binDistPath, pkg.type);
-            const exportPath = path.posix.join(BINARY_TAG, binName);
-            const outputConditionPair = [
-                binDistPath,
-                exportType
-            ];
-            addToExportDistMap(exportToDist, exportPath, [
-                outputConditionPair
-            ]);
+    return 'default';
+}
+function getExportTypeFromExportTypesArray(types) {
+    let exportType = 'default';
+    new Set(types).forEach((value)=>{
+        if (specialExportConventions.has(value)) {
+            exportType = value;
+        } else if (value === 'import' || value === 'require' || value === 'types') {
+            exportType = value;
+        }
+    });
+    return exportType;
+}
+// ./index -> .
+// ./index.development -> .
+// ./index.react-server -> .
+// ./shared -> ./shared
+// ./shared.development -> ./shared
+// $binary -> $binary
+// $binary/index -> $binary
+// $binary/foo -> $binary/foo
+function normalizeExportPath(exportPath) {
+    if (exportPath.startsWith(BINARY_TAG)) {
+        if (exportPath === `${BINARY_TAG}/index`) {
+            exportPath = BINARY_TAG;
         }
+        return exportPath;
     }
-    // Handle package.json global exports fields
-    if (pkg.main || pkg.module || pkg.types) {
-        const mainExportPath = pkg.main;
-        const moduleExportPath = pkg.module;
-        const typesEntryPath = pkg.types;
-        addToExportDistMap(exportToDist, './index', [
-            Boolean(mainExportPath) && [
-                mainExportPath,
-                getMainFieldExportType(pkg)
-            ],
-            Boolean(moduleExportPath) && [
-                moduleExportPath,
-                'module'
-            ],
-            Boolean(typesEntryPath) && [
-                typesEntryPath,
-                'types'
-            ]
-        ].filter(Boolean));
+    const baseName = exportPath.split('.').slice(0, 2).join('.');
+    if (baseName === './index') {
+        return '.';
     }
-    return exportToDist;
-}
-function isEsmExportName(name, ext) {
-    return [
-        'import',
-        'module'
-    ].includes(name) || ext === 'mjs';
-}
-function isCjsExportName(pkg, exportCondition, ext) {
-    const isESModule = isESModulePackage(pkg.type);
-    const isCjsCondition = [
-        'require',
-        'main'
-    ].includes(exportCondition);
-    const isNotEsmExportName = !isEsmExportName(exportCondition, ext);
-    return !isESModule && isNotEsmExportName && (ext !== 'mjs' || isCjsCondition) || ext === 'cjs';
+    return baseName;
 }
-function getFileExportType(composedTypes) {
-    return composedTypes.split('.').pop();
+// ./index.react-server -> ./index
+function stripSpecialCondition(exportPath) {
+    return exportPath.split('.').slice(0, 2).join('.');
 }
-function getExportsDistFilesOfCondition(pkg, parsedExportCondition, cwd, dts) {
-    const dist = [];
-    const exportConditionNames = Object.keys(parsedExportCondition.export);
-    const uniqueFiles = new Set();
-    for (const exportCondition of exportConditionNames){
-        const exportType = getFileExportType(exportCondition);
-        // Filter out non-types field when generating types jobs
-        if (dts && exportType !== 'types') {
-            continue;
-        }
-        // Filter out types field when generating asset jobs
-        if (!dts && exportType === 'types') {
-            continue;
+async function collectSourceEntriesByExportPath(sourceFolderPath, originalSubpath, bins, exportsEntries) {
+    const isBinaryPath = isBinExportPath(originalSubpath);
+    const subpath = originalSubpath.replace(BINARY_TAG, 'bin');
+    const absoluteDirPath = path__default.default.join(sourceFolderPath, subpath);
+    const isDirectory = fs__default.default.existsSync(absoluteDirPath) ? (await fsp__default.default.stat(absoluteDirPath)).isDirectory() : false;
+    if (isDirectory) {
+        if (isBinaryPath) {
+            const binDirentList = await fsp__default.default.readdir(absoluteDirPath, {
+                withFileTypes: true
+            });
+            for (const binDirent of binDirentList){
+                if (binDirent.isFile()) {
+                    const binFileAbsolutePath = path__default.default.join(absoluteDirPath, binDirent.name);
+                    if (fs__default.default.existsSync(binFileAbsolutePath)) {
+                        bins.set(normalizeExportPath(originalSubpath), binFileAbsolutePath);
+                    }
+                }
+            }
+        } else {
+            // Search folder/index.<ext> convention entries
+            for (const extension of availableExtensions){
+                const indexAbsoluteFile = path__default.default.join(absoluteDirPath, `index.${extension}`);
+                // Search folder/index.<special type>.<ext> convention entries
+                for (const specialExportType of runtimeExportConventions){
+                    const indexSpecialAbsoluteFile = path__default.default.join(absoluteDirPath, `index.${specialExportType}.${extension}`);
+                    if (fs__default.default.existsSync(indexSpecialAbsoluteFile)) {
+                        // Add special export path
+                        // { ./<export path>.<special cond>: { <special cond>: 'index.<special cond>.<ext>' } }
+                        const exportPath = relativify(subpath);
+                        const specialExportPath = exportPath + '.' + specialExportType;
+                        const sourceFilesMap = exportsEntries.get(specialExportPath) || {};
+                        sourceFilesMap[specialExportType] = indexSpecialAbsoluteFile;
+                        exportsEntries.set(specialExportPath, sourceFilesMap);
+                    }
+                }
+                if (fs__default.default.existsSync(indexAbsoluteFile) && !isTestFile(indexAbsoluteFile)) {
+                    const exportPath = relativify(subpath);
+                    const sourceFilesMap = exportsEntries.get(exportPath) || {};
+                    const exportType = getExportTypeFromExportPath(exportPath);
+                    sourceFilesMap[exportType] = indexAbsoluteFile;
+                    exportsEntries.set(exportPath, sourceFilesMap);
+                    break;
+                }
+            }
         }
-        const filePath = parsedExportCondition.export[exportCondition];
-        const ext = path.extname(filePath).slice(1);
-        const relativePath = parsedExportCondition.export[exportCondition];
-        const distFile = path.resolve(cwd, relativePath);
-        const format = isCjsExportName(pkg, exportCondition, ext) ? 'cjs' : 'esm';
-        if (uniqueFiles.has(distFile)) {
-            continue;
+    } else {
+        // subpath could be a file
+        const dirName = path.dirname(subpath);
+        const baseName = path.basename(subpath);
+        // Read current file's directory
+        const dirPath = path__default.default.join(sourceFolderPath, dirName);
+        if (!fs__default.default.existsSync(dirPath)) {
+            return;
         }
-        uniqueFiles.add(distFile);
-        dist.push({
-            format,
-            file: distFile,
-            exportCondition
+        const dirents = await fsp__default.default.readdir(dirPath, {
+            withFileTypes: true
         });
+        for (const dirent of dirents){
+            // index.development.js -> index.development
+            const direntBaseName = baseNameWithoutExtension(dirent.name);
+            const ext = path.extname(dirent.name).slice(1);
+            if (!dirent.isFile() || direntBaseName !== baseName || !availableExtensions.has(ext)) {
+                continue;
+            }
+            if (isTestFile(dirent.name)) {
+                continue;
+            }
+            const sourceFileAbsolutePath = path__default.default.join(dirPath, dirent.name);
+            if (isBinaryPath) {
+                bins.set(originalSubpath, sourceFileAbsolutePath);
+            } else {
+                let sourceFilesMap = exportsEntries.get(originalSubpath) || {};
+                const exportType = getExportTypeFromExportPath(originalSubpath);
+                sourceFilesMap[exportType] = sourceFileAbsolutePath;
+                if (specialExportConventions.has(exportType)) {
+                    // e.g. ./foo/index.react-server -> ./foo/index
+                    const fallbackExportPath = sourceFilenameToExportFullPath(originalSubpath);
+                    const fallbackSourceFilesMap = exportsEntries.get(fallbackExportPath) || {};
+                    sourceFilesMap = {
+                        ...fallbackSourceFilesMap,
+                        ...sourceFilesMap
+                    };
+                }
+                exportsEntries.set(originalSubpath, sourceFilesMap);
+            }
+        }
     }
-    return dist;
 }
-function getExportFileTypePath(absoluteJsBundlePath) {
-    const dirName = path.dirname(absoluteJsBundlePath);
-    const baseName = baseNameWithoutExtension(absoluteJsBundlePath);
-    const ext = path.extname(absoluteJsBundlePath).slice(1);
-    const typeExtension = dtsExtensionsMap[ext];
-    return path.join(dirName, baseName + '.' + typeExtension);
-}
-function getExportTypeFromFile(filename, pkgType) {
-    const isESModule = isESModulePackage(pkgType);
-    const isCjsExt = filename.endsWith('.cjs');
-    const isEsmExt = filename.endsWith('.mjs');
-    const exportType = isEsmExt ? 'import' : isCjsExt ? 'require' : isESModule ? 'import' : 'require';
-    return exportType;
-}
-
 /**
- * @return {Record<string, string>} env { 'process.env.<key>': '<value>' }
- */ function getDefinedInlineVariables(envs, parsedExportCondition) {
-    if (!envs.includes('NODE_ENV')) {
-        envs.push('NODE_ENV');
-    }
-    const envVars = envs.reduce((acc, key)=>{
-        const value = process.env[key];
-        if (typeof value !== 'undefined') {
-            acc['process.env.' + key] = JSON.stringify(value);
+ * exportsEntries {
+ *   "./index" => {
+ *      "development" => source"
+ *      "react-server" => "source"
+ *   },
+ *  "./index.react-server" => {
+ *      "development" => source"
+ *      "react-server" => "source"
+ *   }
+ *  }
+ */ async function collectSourceEntriesFromExportPaths(sourceFolderPath, parsedExportsInfo) {
+    const bins = new Map();
+    const exportsEntries = new Map();
+    for (const [exportPath, exportInfo] of parsedExportsInfo.entries()){
+        const specialConditions = new Set();
+        for (const [_, composedExportType] of exportInfo){
+            const specialExportType = getSpecialExportTypeFromComposedExportPath(composedExportType);
+            if (specialExportType !== 'default') {
+                specialConditions.add(specialExportType);
+            }
         }
-        return acc;
-    }, {});
-    const exportConditionNames = Object.keys(parsedExportCondition.export).reduce((acc, key)=>{
-        // key could be 'require' or 'import.development' etc.
-        const exportTypes = key.split('.');
-        for (const exportType of exportTypes){
-            acc.add(exportType);
+        await collectSourceEntriesByExportPath(sourceFolderPath, exportPath, bins, exportsEntries);
+        for (const specialCondition of specialConditions){
+            await collectSourceEntriesByExportPath(sourceFolderPath, exportPath + '.' + specialCondition, bins, exportsEntries);
         }
-        return acc;
-    }, new Set());
-    // For development and production convention, we override the NODE_ENV value
-    if (exportConditionNames.has('development')) {
-        envVars['process.env.NODE_ENV'] = JSON.stringify('development');
-    } else if (exportConditionNames.has('production')) {
-        envVars['process.env.NODE_ENV'] = JSON.stringify('production');
-    }
-    if (exportConditionNames.has('edge-light')) {
-        envVars['EdgeRuntime'] = JSON.stringify('edge-runtime');
     }
-    return envVars;
+    return {
+        bins,
+        exportsEntries
+    };
 }
 
-// shared.ts -> ./shared
-// shared.<export condition>.ts -> ./shared
-// index.ts -> ./index
-// index.development.ts -> ./index.development
-function sourceFilenameToExportFullPath(filename) {
-    const baseName = baseNameWithoutExtension(filename);
-    let exportPath = baseName;
-    return relativify(exportPath);
-}
-async function collectEntriesFromParsedExports(cwd, parsedExportsInfo, sourceFile) {
-    const entries = {};
-    if (sourceFile) {
-        const defaultExport = parsedExportsInfo.get('./index')[0];
-        entries['./index'] = {
-            source: sourceFile,
-            name: '.',
-            export: {
-                default: defaultExport[0]
+// Example: @foo/bar -> bar
+const removeScope = (exportPath)=>exportPath.replace(/^@[^/]+\//, '');
+function createOutputState({ entries }) {
+    const sizeStats = new Map();
+    const uniqFiles = new Set();
+    function addSize({ fileName, size, sourceFileName, exportPath }) {
+        if (!sizeStats.has(exportPath)) {
+            sizeStats.set(exportPath, []);
+        }
+        const distFilesStats = sizeStats.get(exportPath);
+        if (!uniqFiles.has(fileName)) {
+            uniqFiles.add(fileName);
+            if (distFilesStats) {
+                distFilesStats.push([
+                    fileName,
+                    sourceFileName,
+                    size
+                ]);
             }
-        };
+        }
     }
-    // Find source files
-    const { bins, exportsEntries } = await collectSourceEntriesFromExportPaths(path.join(cwd, SRC), parsedExportsInfo);
-    // A mapping between each export path and its related special export conditions,
-    // excluding the 'default' export condition.
-    // { './index' => Set('development', 'edge-light') }
-    const pathSpecialConditionsMap = {};
-    for (const [exportPath] of exportsEntries){
-        const normalizedExportPath = stripSpecialCondition(exportPath);
-        if (!pathSpecialConditionsMap[normalizedExportPath]) {
-            pathSpecialConditionsMap[normalizedExportPath] = new Set();
+    const reversedMapping = new Map();
+    Object.entries(entries).forEach(([resolvedExportName, entry])=>{
+        reversedMapping.set(entry.source, resolvedExportName);
+    });
+    return {
+        plugin: (cwd)=>{
+            return {
+                name: 'collect-sizes',
+                writeBundle (options, bundle) {
+                    const dir = options.dir || path__default.default.dirname(options.file);
+                    Object.entries(bundle).forEach(([fileName, chunk])=>{
+                        const filePath = path__default.default.join(dir, fileName);
+                        if (chunk.type !== 'chunk') {
+                            return;
+                        }
+                        if (!chunk.isEntry) {
+                            return;
+                        }
+                        const size = chunk.code.length;
+                        const sourceFileName = chunk.facadeModuleId || '';
+                        const exportPath = removeScope(reversedMapping.get(sourceFileName) || '.');
+                        addSize({
+                            fileName: path__default.default.isAbsolute(cwd) ? path__default.default.relative(cwd, filePath) : filePath,
+                            size,
+                            sourceFileName,
+                            exportPath
+                        });
+                    });
+                }
+            };
+        },
+        getSizeStats () {
+            return sizeStats;
         }
-        const exportType = getExportTypeFromExportPath(exportPath);
-        if (exportType !== 'default') {
-            pathSpecialConditionsMap[normalizedExportPath].add(exportType);
+    };
+}
+
+const memoize = (fn, cacheKey, cacheArg)=>{
+    const cache = cacheArg || new Map();
+    return (...args)=>{
+        const key = cacheKey ? typeof cacheKey === 'function' ? cacheKey(...args) : cacheKey : JSON.stringify({
+            args
+        });
+        const existing = cache.get(key);
+        if (existing !== undefined) {
+            return existing;
         }
-    }
-    // Traverse source files and try to match the entries
-    // Find exports from parsed exports info
-    // entryExportPath can be: './index', './index.development', './shared.edge-light', etc.
-    for (const [entryExportPath, sourceFilesMap] of exportsEntries){
-        const normalizedExportPath = stripSpecialCondition(entryExportPath);
-        const entryExportPathType = getExportTypeFromExportPath(entryExportPath);
-        const outputExports = parsedExportsInfo.get(normalizedExportPath);
-        if (!outputExports) {
-            continue;
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    };
+};
+const memoizeByKey = (fn)=>{
+    const cache = new Map();
+    return (cacheKey)=>memoize(fn, cacheKey, cache);
+};
+
+let hasLoggedTsWarning = false;
+function resolveTypescript(cwd) {
+    let ts;
+    const m = new module$1.Module('', undefined);
+    m.paths = module$1.Module._nodeModulePaths(cwd);
+    try {
+        // Bun does not yet support the `Module` class properly.
+        if (typeof (m == null ? void 0 : m.require) === 'undefined') {
+            const tsPath = require.resolve('typescript', {
+                paths: [
+                    cwd
+                ]
+            });
+            ts = require(tsPath);
+        } else {
+            ts = m.require('typescript');
         }
-        for (const [outputPath, outputComposedExportType] of outputExports){
-            // export type can be: default, development, react-server, etc.
-            const matchedExportType = getSpecialExportTypeFromComposedExportPath(outputComposedExportType);
-            const specialSet = pathSpecialConditionsMap[normalizedExportPath];
-            const hasSpecialEntry = specialSet.has(matchedExportType);
-            const sourceFile = sourceFilesMap[matchedExportType] || sourceFilesMap.default;
-            if (!sourceFile) {
-                continue;
-            }
-            if (!entries[entryExportPath]) {
-                entries[entryExportPath] = {
-                    source: sourceFile,
-                    name: normalizedExportPath,
-                    export: {}
+    } catch (e) {
+        console.error(e);
+        if (!hasLoggedTsWarning) {
+            hasLoggedTsWarning = true;
+            exit('Could not load TypeScript compiler. Try to install `typescript` as dev dependency');
+        }
+    }
+    return ts;
+}
+function resolveTsConfigHandler(cwd, tsconfig = 'tsconfig.json') {
+    let tsCompilerOptions = {};
+    let tsConfigPath;
+    tsConfigPath = path.resolve(cwd, tsconfig);
+    if (fileExists(tsConfigPath)) {
+        // Use the original ts handler to avoid memory leak
+        const ts = resolveTypescript(cwd);
+        const basePath = tsConfigPath ? path.dirname(tsConfigPath) : cwd;
+        const tsconfigJSON = ts.readConfigFile(tsConfigPath, ts.sys.readFile).config;
+        tsCompilerOptions = ts.parseJsonConfigFileContent(tsconfigJSON, ts.sys, basePath).options;
+    } else {
+        return null;
+    }
+    return {
+        tsCompilerOptions,
+        tsConfigPath
+    };
+}
+const resolveTsConfig = memoizeByKey(resolveTsConfigHandler)();
+async function convertCompilerOptions(cwd, json) {
+    // Use the original ts handler to avoid memory leak
+    const ts = resolveTypescript(cwd);
+    return ts.convertCompilerOptionsFromJson(json, './');
+}
+async function writeDefaultTsconfig(tsConfigPath) {
+    await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
+    logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
+}
+
+const FILENAME_REGEX = /__filename/;
+const DIRNAME_REGEX = /__dirname/;
+const GLOBAL_REQUIRE_REGEX = /require(\.resolve)?\(/;
+const PolyfillComment = '/** rollup-private-do-not-use-esm-shim-polyfill */';
+const createESMShim = ({ filename, dirname, globalRequire })=>{
+    const useNodeUrl = filename || dirname;
+    const useNodePath = dirname;
+    const useNodeModule = globalRequire;
+    return `\
+${PolyfillComment}
+${useNodeUrl ? `import __node_cjsUrl from 'node:url'` : ''};
+${useNodePath ? `import __node_cjsPath from 'node:path';` : ''}
+${useNodeModule ? `import __node_cjsModule from 'node:module';` : ''}
+${useNodeUrl ? 'const __filename = __node_cjsUrl.fileURLToPath(import.meta.url);' : ''}
+${useNodePath ? 'const __dirname = __node_cjsPath.dirname(__filename);' : ''}
+${useNodeModule ? 'const require = __node_cjsModule.createRequire(import.meta.url);' : ''}
+`.trim() + '\n';
+};
+function esmShim() {
+    return {
+        name: 'esm-shim',
+        transform: {
+            order: 'post',
+            handler (code, id) {
+                const ext = path.extname(id);
+                if (!availableESExtensionsRegex.test(ext) || code.includes(PolyfillComment)) {
+                    return null;
+                }
+                let hasFilename = false;
+                let hasDirname = false;
+                let hasGlobalRequire = false;
+                if (FILENAME_REGEX.test(code)) {
+                    hasFilename = true;
+                }
+                if (DIRNAME_REGEX.test(code)) {
+                    hasDirname = true;
+                }
+                if (GLOBAL_REQUIRE_REGEX.test(code)) {
+                    hasGlobalRequire = true;
+                }
+                if (!hasFilename && !hasDirname && !hasGlobalRequire) {
+                    return null;
+                }
+                const magicString = new MagicString__default.default(code);
+                let ast = null;
+                try {
+                    // rollup 2 built-in parser doesn't have `allowShebang`, we need to use the sliced code here. Hence the `magicString.toString()`
+                    ast = this.parse(magicString.toString(), {
+                        allowReturnOutsideFunction: true
+                    });
+                } catch (e) {
+                    console.warn(e);
+                    return null;
+                }
+                if (ast.type !== 'Program') {
+                    return null;
+                }
+                let lastImportNode = null;
+                for (const node of ast.body){
+                    if (node.type === 'ImportDeclaration') {
+                        lastImportNode = node;
+                        continue;
+                    }
+                }
+                let end = 0;
+                if (lastImportNode) {
+                    end = lastImportNode.end;
+                } else {
+                    end = ast.body.length > 0 ? ast.body[0].end : 0;
+                }
+                magicString.appendRight(end, '\n' + createESMShim({
+                    filename: hasFilename,
+                    dirname: hasDirname,
+                    globalRequire: hasGlobalRequire
+                }));
+                return {
+                    code: magicString.toString(),
+                    map: magicString.generateMap({
+                        hires: true
+                    })
                 };
-            } else if (matchedExportType === entryExportPathType) {
-                entries[entryExportPath].source = sourceFile;
-            }
-            // output exports match
-            if (matchedExportType === entryExportPathType || !hasSpecialEntry && matchedExportType !== 'default') {
-                const exportMap = entries[entryExportPath].export;
-                exportMap[outputComposedExportType] = outputPath;
             }
         }
-    }
-    // Handling binaries
-    for (const [exportPath, sourceFile] of bins){
-        const outputExports = parsedExportsInfo.get(exportPath);
-        if (!outputExports) {
-            continue;
-        }
-        for (const [outputPath, exportType] of outputExports){
-            entries[exportPath] = {
-                source: sourceFile,
-                name: exportPath,
-                export: {
-                    [exportType]: outputPath
-                }
-            };
-        }
-    }
-    return entries;
-}
-// ./index -> default
-// ./index.development -> development
-// ./index.react-server -> react-server
-function getExportTypeFromExportPath(exportPath) {
-    // Skip the first two segments: `.` and `index`
-    const exportTypes = exportPath.split('.').slice(2);
-    return getExportTypeFromExportTypesArray(exportTypes);
+    };
 }
-function getSpecialExportTypeFromComposedExportPath(composedExportType) {
-    const exportTypes = composedExportType.split('.');
-    for (const exportType of exportTypes){
-        if (specialExportConventions.has(exportType)) {
-            return exportType;
-        }
-    }
-    return 'default';
+
+const helpers = {
+    cssImport: {
+        // have to assign r.type = 'text/css' to make it work in Safari
+        global: `\
+function __insertCSS(code) {
+  if (!code || typeof document == 'undefined') return
+  let head = document.head || document.getElementsByTagName('head')[0]
+  let style = document.createElement('style')
+  style.type = 'text/css'
+  head.appendChild(style)
+  ;style.styleSheet ? (style.styleSheet.cssText = code) : style.appendChild(document.createTextNode(code))
 }
-function getExportTypeFromExportTypesArray(types) {
-    let exportType = 'default';
-    new Set(types).forEach((value)=>{
-        if (specialExportConventions.has(value)) {
-            exportType = value;
-        } else if (value === 'import' || value === 'require' || value === 'types') {
-            exportType = value;
+`,
+        create (code) {
+            return `__insertCSS(${JSON.stringify(code)});`;
         }
-    });
-    return exportType;
-}
-// ./index -> .
-// ./index.development -> .
-// ./index.react-server -> .
-// ./shared -> ./shared
-// ./shared.development -> ./shared
-// $binary -> $binary
-// $binary/index -> $binary
-// $binary/foo -> $binary/foo
-function normalizeExportPath(exportPath) {
-    if (exportPath.startsWith(BINARY_TAG)) {
-        if (exportPath === `${BINARY_TAG}/index`) {
-            exportPath = BINARY_TAG;
+    },
+    cssAssertionImport: {
+        global: '',
+        create (code) {
+            return `\
+const sheet = new CSSStyleSheet()
+sheet.replaceSync(${JSON.stringify(code)})
+export default sheet`;
         }
-        return exportPath;
-    }
-    const baseName = exportPath.split('.').slice(0, 2).join('.');
-    if (baseName === './index') {
-        return '.';
     }
-    return baseName;
-}
-// ./index.react-server -> ./index
-function stripSpecialCondition(exportPath) {
-    return exportPath.split('.').slice(0, 2).join('.');
+};
+const cleanCssInstance = new CleanCSS__default.default({});
+function minify(code) {
+    return cleanCssInstance.minify(code).styles;
 }
-async function collectSourceEntriesByExportPath(sourceFolderPath, originalSubpath, bins, exportsEntries) {
-    const isBinaryPath = isBinExportPath(originalSubpath);
-    const subpath = originalSubpath.replace(BINARY_TAG, 'bin');
-    const absoluteDirPath = path__default.default.join(sourceFolderPath, subpath);
-    const isDirectory = fs__default.default.existsSync(absoluteDirPath) ? (await fsp__default.default.stat(absoluteDirPath)).isDirectory() : false;
-    if (isDirectory) {
-        if (isBinaryPath) {
-            const binDirentList = await fsp__default.default.readdir(absoluteDirPath, {
-                withFileTypes: true
-            });
-            for (const binDirent of binDirentList){
-                if (binDirent.isFile()) {
-                    const binFileAbsolutePath = path__default.default.join(absoluteDirPath, binDirent.name);
-                    if (fs__default.default.existsSync(binFileAbsolutePath)) {
-                        bins.set(normalizeExportPath(originalSubpath), binFileAbsolutePath);
+function inlineCss(options) {
+    const cssIds = new Set();
+    var _options_exclude;
+    const filter = pluginutils.createFilter([
+        '**/*.css'
+    ], (_options_exclude = options.exclude) != null ? _options_exclude : []);
+    // Follow up for rollup 4 for better support of assertion support https://github.com/rollup/rollup/issues/4818
+    return {
+        name: 'inline-css',
+        transform: {
+            order: 'post',
+            handler (code, id) {
+                if (!filter(id)) return;
+                if (options.skip) return '';
+                const cssCode = minify(code);
+                cssIds.add(id);
+                return {
+                    code: helpers.cssImport.create(cssCode),
+                    map: {
+                        mappings: ''
                     }
-                }
+                };
             }
-        } else {
-            // Search folder/index.<ext> convention entries
-            for (const extension of availableExtensions){
-                const indexAbsoluteFile = path__default.default.join(absoluteDirPath, `index.${extension}`);
-                // Search folder/index.<special type>.<ext> convention entries
-                for (const specialExportType of runtimeExportConventions){
-                    const indexSpecialAbsoluteFile = path__default.default.join(absoluteDirPath, `index.${specialExportType}.${extension}`);
-                    if (fs__default.default.existsSync(indexSpecialAbsoluteFile)) {
-                        // Add special export path
-                        // { ./<export path>.<special cond>: { <special cond>: 'index.<special cond>.<ext>' } }
-                        const exportPath = relativify(subpath);
-                        const specialExportPath = exportPath + '.' + specialExportType;
-                        const sourceFilesMap = exportsEntries.get(specialExportPath) || {};
-                        sourceFilesMap[specialExportType] = indexSpecialAbsoluteFile;
-                        exportsEntries.set(specialExportPath, sourceFilesMap);
+        },
+        renderChunk: {
+            order: 'pre',
+            handler (code) {
+                const dependenciesIds = this.getModuleIds();
+                let foundCss = false;
+                for (const depId of dependenciesIds){
+                    if (depId && cssIds.has(depId)) {
+                        foundCss = true;
+                        break;
                     }
                 }
-                if (fs__default.default.existsSync(indexAbsoluteFile) && !isTestFile(indexAbsoluteFile)) {
-                    const exportPath = relativify(subpath);
-                    const sourceFilesMap = exportsEntries.get(exportPath) || {};
-                    const exportType = getExportTypeFromExportPath(exportPath);
-                    sourceFilesMap[exportType] = indexAbsoluteFile;
-                    exportsEntries.set(exportPath, sourceFilesMap);
-                    break;
-                }
+                if (!foundCss) return;
+                return {
+                    code: `${helpers.cssImport.global}\n${code}`,
+                    map: {
+                        mappings: ''
+                    }
+                };
+            }
+        }
+    };
+}
+
+function rawContent({ exclude }) {
+    const filter = pluginutils.createFilter([
+        '**/*.data',
+        '**/*.txt'
+    ], exclude);
+    return {
+        name: 'string',
+        transform (code, id) {
+            if (filter(id)) {
+                return {
+                    code: `const data = ${JSON.stringify(code)};\nexport default data;`,
+                    map: null
+                };
             }
+            return null;
         }
-    } else {
-        // subpath could be a file
-        const dirName = path.dirname(subpath);
-        const baseName = path.basename(subpath);
-        // Read current file's directory
-        const dirPath = path__default.default.join(sourceFolderPath, dirName);
-        if (!fs__default.default.existsSync(dirPath)) {
-            return;
-        }
-        const dirents = await fsp__default.default.readdir(dirPath, {
-            withFileTypes: true
-        });
-        for (const dirent of dirents){
-            // index.development.js -> index.development
-            const direntBaseName = baseNameWithoutExtension(dirent.name);
-            const ext = path.extname(dirent.name).slice(1);
-            if (!dirent.isFile() || direntBaseName !== baseName || !availableExtensions.has(ext)) {
-                continue;
+    };
+}
+
+function findJsBundlePathCallback({ format, bundlePath, conditionNames }) {
+    const hasCondition = bundlePath != null;
+    const formatCond = format === 'cjs' ? 'require' : 'import';
+    const isTypesCondName = conditionNames.has('types');
+    const isMatchedFormat = conditionNames.has(formatCond);
+    return isMatchedFormat && !isTypesCondName && hasCondition;
+}
+function findTypesFileCallback({ format, bundlePath, conditionNames }) {
+    const hasCondition = bundlePath != null;
+    const formatCond = format ? format === 'cjs' ? 'require' : 'import' : null;
+    const isTypesCondName = conditionNames.has('types');
+    return isTypesCondName && hasCondition && (formatCond ? conditionNames.has(formatCond) : true);
+}
+// Alias entry key to dist bundle path
+function aliasEntries({ entry: sourceFilePath, entries, format, dts, cwd }) {
+    // <imported source file path>: <relative path to source's bundle>
+    const sourceToRelativeBundleMap = new Map();
+    for (const [, exportCondition] of Object.entries(entries)){
+        const exportDistMaps = exportCondition.export;
+        const exportMapEntries = Object.entries(exportDistMaps).map(([composedKey, bundlePath])=>({
+                conditionNames: new Set(composedKey.split('.')),
+                bundlePath,
+                format
+            }));
+        let matchedBundlePath;
+        if (dts) {
+            var _exportMapEntries_find;
+            // Find the type with format condition first
+            matchedBundlePath = (_exportMapEntries_find = exportMapEntries.find(findTypesFileCallback)) == null ? void 0 : _exportMapEntries_find.bundlePath;
+            // If theres no format specific types such as import.types or require.types,
+            // fallback to the general types file.
+            if (!matchedBundlePath) {
+                var _exportMapEntries_find1;
+                matchedBundlePath = (_exportMapEntries_find1 = exportMapEntries.find((item)=>{
+                    return findTypesFileCallback({
+                        ...item,
+                        format: undefined
+                    });
+                })) == null ? void 0 : _exportMapEntries_find1.bundlePath;
             }
-            if (isTestFile(dirent.name)) {
-                continue;
+        } else {
+            var _exportMapEntries_find2;
+            matchedBundlePath = (_exportMapEntries_find2 = exportMapEntries.find(findJsBundlePathCallback)) == null ? void 0 : _exportMapEntries_find2.bundlePath;
+        }
+        if (matchedBundlePath) {
+            if (!sourceToRelativeBundleMap.has(exportCondition.source)) sourceToRelativeBundleMap.set(exportCondition.source, matchedBundlePath);
+        }
+    }
+    return {
+        name: 'alias',
+        resolveId: {
+            async handler (source, importer, options) {
+                const resolved = await this.resolve(source, importer, options);
+                if (resolved != null) {
+                    // For types, generate relative path to the other type files,
+                    // this will be compatible for the node10 ts module resolution.
+                    const srcBundle = sourceToRelativeBundleMap.get(sourceFilePath);
+                    // Resolved module bundle path
+                    const resolvedModuleBundle = sourceToRelativeBundleMap.get(resolved.id);
+                    if (resolved.id !== sourceFilePath && srcBundle && resolvedModuleBundle) {
+                        const absoluteBundlePath = path__default.default.resolve(cwd, srcBundle);
+                        const absoluteImportBundlePath = path__default.default.resolve(cwd, resolvedModuleBundle);
+                        const filePathBase = path__default.default.relative(path__default.default.dirname(absoluteBundlePath), absoluteImportBundlePath);
+                        const relativePath = relativify(filePathBase);
+                        return {
+                            id: relativePath,
+                            external: true
+                        };
+                    }
+                }
+                return null;
             }
-            const sourceFileAbsolutePath = path__default.default.join(dirPath, dirent.name);
-            if (isBinaryPath) {
-                bins.set(originalSubpath, sourceFileAbsolutePath);
-            } else {
-                let sourceFilesMap = exportsEntries.get(originalSubpath) || {};
-                const exportType = getExportTypeFromExportPath(originalSubpath);
-                sourceFilesMap[exportType] = sourceFileAbsolutePath;
-                if (specialExportConventions.has(exportType)) {
-                    // e.g. ./foo/index.react-server -> ./foo/index
-                    const fallbackExportPath = sourceFilenameToExportFullPath(originalSubpath);
-                    const fallbackSourceFilesMap = exportsEntries.get(fallbackExportPath) || {};
-                    sourceFilesMap = {
-                        ...fallbackSourceFilesMap,
-                        ...sourceFilesMap
-                    };
+        }
+    };
+}
+
+function prependDirectives() {
+    return {
+        name: 'prependDirective',
+        transform: {
+            order: 'post',
+            handler (code, id) {
+                var _moduleInfo_meta;
+                const moduleInfo = this.getModuleInfo(id);
+                if (moduleInfo == null ? void 0 : (_moduleInfo_meta = moduleInfo.meta) == null ? void 0 : _moduleInfo_meta.preserveDirectives) {
+                    const firstDirective = moduleInfo.meta.preserveDirectives.directives[0];
+                    if (firstDirective) {
+                        const directive = firstDirective.value;
+                        const directiveCode = `'${directive}';`;
+                        return directiveCode + '\n' + code;
+                    }
                 }
-                exportsEntries.set(originalSubpath, sourceFilesMap);
+                return null;
             }
         }
-    }
+    };
 }
+
+const prependShebang = (entry)=>({
+        name: 'prependShebang',
+        transform: (code, id)=>{
+            if (id !== entry) return;
+            const shebang = '#!/usr/bin/env node\n';
+            if (code.startsWith(shebang)) return;
+            const magicString = new MagicString__default.default(code);
+            magicString.prepend(shebang);
+            return {
+                code: magicString.toString(),
+                map: magicString.generateMap({
+                    hires: true
+                })
+            };
+        }
+    });
+
 /**
- * exportsEntries {
- *   "./index" => {
- *      "development" => source"
- *      "react-server" => "source"
- *   },
- *  "./index.react-server" => {
- *      "development" => source"
- *      "react-server" => "source"
- *   }
- *  }
- */ async function collectSourceEntriesFromExportPaths(sourceFolderPath, parsedExportsInfo) {
-    const bins = new Map();
-    const exportsEntries = new Map();
-    for (const [exportPath, exportInfo] of parsedExportsInfo.entries()){
-        const specialConditions = new Set();
-        for (const [_, composedExportType] of exportInfo){
-            const specialExportType = getSpecialExportTypeFromComposedExportPath(composedExportType);
-            if (specialExportType !== 'default') {
-                specialConditions.add(specialExportType);
-            }
+ * @return {Record<string, string>} env { 'process.env.<key>': '<value>' }
+ */ function getDefinedInlineVariables(envs, parsedExportCondition) {
+    if (!envs.includes('NODE_ENV')) {
+        envs.push('NODE_ENV');
+    }
+    const envVars = envs.reduce((acc, key)=>{
+        const value = process.env[key];
+        if (typeof value !== 'undefined') {
+            acc['process.env.' + key] = JSON.stringify(value);
         }
-        await collectSourceEntriesByExportPath(sourceFolderPath, exportPath, bins, exportsEntries);
-        for (const specialCondition of specialConditions){
-            await collectSourceEntriesByExportPath(sourceFolderPath, exportPath + '.' + specialCondition, bins, exportsEntries);
+        return acc;
+    }, {});
+    const exportConditionNames = Object.keys(parsedExportCondition.export).reduce((acc, key)=>{
+        // key could be 'require' or 'import.development' etc.
+        const exportTypes = key.split('.');
+        for (const exportType of exportTypes){
+            acc.add(exportType);
         }
+        return acc;
+    }, new Set());
+    // For development and production convention, we override the NODE_ENV value
+    if (exportConditionNames.has('development')) {
+        envVars['process.env.NODE_ENV'] = JSON.stringify('development');
+    } else if (exportConditionNames.has('production')) {
+        envVars['process.env.NODE_ENV'] = JSON.stringify('production');
     }
-    return {
-        bins,
-        exportsEntries
-    };
+    if (exportConditionNames.has('edge-light')) {
+        envVars['EdgeRuntime'] = JSON.stringify('edge-runtime');
+    }
+    return envVars;
 }
 
 function getModuleLayer(moduleMeta) {
@@ -1218,22 +1299,6 @@ async function createDtsPlugin(tsCompilerOptions, tsConfigPath, cwd) {
 // Avoid create multiple dts plugins instance and parsing the same tsconfig multi times,
 // This will avoid memory leak and performance issue.
 const memoizeDtsPluginByKey = memoizeByKey(createDtsPlugin);
-/**
- * return {
- *   <absolute source path>: <pkg>/<export>
- * }
- */ function getReversedAlias({ entries, name }) {
-    const alias = {};
-    for (const [entryExportPath, exportCondition] of Object.entries(entries)){
-        const normalizedExportPath = normalizeExportPath(entryExportPath);
-        // entryExportPath format: ./index, ./shared, etc.
-        const specialExportType = getSpecialExportTypeFromComposedExportPath(entryExportPath);
-        if (specialExportType === 'default') {
-            alias[exportCondition.source] = path.posix.join(name || '', normalizedExportPath);
-        }
-    }
-    return alias;
-}
 async function buildInputConfig(entry, bundleConfig, exportCondition, buildContext, dts) {
     var _bundleConfig_file, _bundleConfig_file1;
     const { entries, pkg, cwd, tsOptions: { tsConfigPath, tsCompilerOptions }, pluginContext } = buildContext;
@@ -1287,7 +1352,6 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
     const aliasPlugin = aliasEntries({
         entry,
         entries,
-        entriesAlias: pluginContext.entriesAlias,
         format: aliasFormat,
         dts,
         cwd
@@ -1576,122 +1640,6 @@ async function buildConfig(bundleConfig, exportCondition, pluginContext, bundleE
     return Promise.all(outputConfigs);
 }
 
-// Example: @foo/bar -> bar
-const removeScope = (exportPath)=>exportPath.replace(/^@[^/]+\//, '');
-function createOutputState({ entries }) {
-    const sizeStats = new Map();
-    const uniqFiles = new Set();
-    function addSize({ fileName, size, sourceFileName, exportPath }) {
-        if (!sizeStats.has(exportPath)) {
-            sizeStats.set(exportPath, []);
-        }
-        const distFilesStats = sizeStats.get(exportPath);
-        if (!uniqFiles.has(fileName)) {
-            uniqFiles.add(fileName);
-            if (distFilesStats) {
-                distFilesStats.push([
-                    fileName,
-                    sourceFileName,
-                    size
-                ]);
-            }
-        }
-    }
-    const reversedMapping = new Map();
-    Object.entries(entries).forEach(([resolvedExportName, entry])=>{
-        reversedMapping.set(entry.source, resolvedExportName);
-    });
-    return {
-        plugin: (cwd)=>{
-            return {
-                name: 'collect-sizes',
-                writeBundle (options, bundle) {
-                    const dir = options.dir || path__default.default.dirname(options.file);
-                    Object.entries(bundle).forEach(([fileName, chunk])=>{
-                        const filePath = path__default.default.join(dir, fileName);
-                        if (chunk.type !== 'chunk') {
-                            return;
-                        }
-                        if (!chunk.isEntry) {
-                            return;
-                        }
-                        const size = chunk.code.length;
-                        const sourceFileName = chunk.facadeModuleId || '';
-                        const exportPath = removeScope(reversedMapping.get(sourceFileName) || '.');
-                        addSize({
-                            fileName: path__default.default.isAbsolute(cwd) ? path__default.default.relative(cwd, filePath) : filePath,
-                            size,
-                            sourceFileName,
-                            exportPath
-                        });
-                    });
-                }
-            };
-        },
-        getSizeStats () {
-            return sizeStats;
-        }
-    };
-}
-function isTypeFile(filename) {
-    return filename.endsWith('.d.ts') || filename.endsWith('.d.mts') || filename.endsWith('.d.cts');
-}
-function normalizeExportName(exportName) {
-    const isBinary = isBinExportPath(exportName);
-    let result = exportName;
-    if (isBinary) {
-        result = (exportName.replace(new RegExp(`^\\${BINARY_TAG}\\/?`), '') || '.') + ' (bin)';
-    } else {
-        const normalizedExportPath = normalizeExportPath(exportName);
-        const specialConditionName = getSpecialExportTypeFromComposedExportPath(exportName);
-        result = normalizedExportPath + (specialConditionName !== 'default' ? ` (${specialConditionName})` : '');
-    }
-    return result;
-}
-function logOutputState(sizeCollector) {
-    const stats = sizeCollector.getSizeStats();
-    if (stats.size === 0) {
-        logger.warn('No build info can be logged');
-        return;
-    }
-    const allFileNameLengths = Array.from(stats.values()).flat(1).map(([filename])=>filename.length);
-    const maxFilenameLength = Math.max(...allFileNameLengths);
-    const statsArray = [
-        ...stats.entries()
-    ].sort(([a], [b])=>{
-        const comp = normalizeExportPath(a).length - normalizeExportPath(b).length;
-        return comp === 0 ? a.localeCompare(b) : comp;
-    });
-    const maxLengthOfExportName = Math.max(...statsArray.map(([exportName])=>normalizeExportName(exportName).length));
-    console.log(pc.underline('Exports'), ' '.repeat(Math.max(maxLengthOfExportName - 'Exports'.length, 0)), pc.underline('File'), ' '.repeat(Math.max(maxFilenameLength - 'File'.length, 0)), pc.underline('Size'));
-    statsArray.forEach(([exportName, filesList])=>{
-        // sort by file type, first js files then types, js/mjs/cjs are prioritized than .d.ts/.d.mts/.d.cts
-        filesList.sort(([a], [b])=>{
-            const aIsType = isTypeFile(a);
-            const bIsType = isTypeFile(b);
-            if (aIsType && bIsType) {
-                return 0;
-            }
-            if (aIsType) {
-                return 1;
-            }
-            if (bIsType) {
-                return -1;
-            }
-            return 0;
-        }).forEach((item, index)=>{
-            const [filename, , size] = item;
-            const normalizedExportName = normalizeExportName(exportName);
-            const prefix = index === 0 ? normalizedExportName : ' '.repeat(normalizedExportName.length);
-            const filenamePadding = ' '.repeat(Math.max(maxLengthOfExportName, 'Exports'.length) - normalizedExportName.length);
-            const isType = isTypeFile(filename);
-            const sizePadding = ' '.repeat(Math.max(maxFilenameLength, 'File'.length) - filename.length);
-            const prettiedSize = prettyBytes__default.default(size);
-            console.log(prefix, filenamePadding, `${pc[isType ? 'dim' : 'bold'](filename)}`, sizePadding, prettiedSize);
-        });
-    });
-}
-
 async function createAssetRollupJobs(options, buildContext, bundleJobOptions) {
     const { isFromCli, generateTypes } = bundleJobOptions;
     const assetsConfigs = await buildEntryConfig(options, buildContext, {
@@ -1756,6 +1704,7 @@ function hasMultiEntryExport(exportPaths) {
     return exportKeys.length > 0 && exportKeys.every((name)=>name.startsWith('.'));
 }
 async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
+    var _options__callbacks_onBuildStart, _options__callbacks, _options__callbacks_onBuildEnd, _options__callbacks1;
     const cwd = path.resolve(process.cwd(), _cwd || '');
     assignDefault(options, 'format', 'esm');
     assignDefault(options, 'minify', false);
@@ -1827,13 +1776,9 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
         await writeDefaultTsconfig(tsConfigPath);
         hasTsConfig = true;
     }
-    const sizeCollector = createOutputState({
+    const outputState = createOutputState({
         entries
     });
-    const entriesAlias = getReversedAlias({
-        entries,
-        name: pkg.name
-    });
     const buildContext = {
         entries,
         pkg,
@@ -1841,68 +1786,18 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
         tsOptions: defaultTsOptions,
         useTypeScript: hasTsConfig,
         pluginContext: {
-            outputState: sizeCollector,
-            moduleDirectiveLayerMap: new Map(),
-            entriesAlias
+            outputState,
+            moduleDirectiveLayerMap: new Map()
         }
     };
+    (_options__callbacks = options._callbacks) == null ? void 0 : (_options__callbacks_onBuildStart = _options__callbacks.onBuildStart) == null ? void 0 : _options__callbacks_onBuildStart.call(_options__callbacks, buildContext);
     const generateTypes = hasTsConfig && options.dts !== false;
     const rollupJobsOptions = {
         isFromCli,
         generateTypes
     };
     const assetJobs = await createAssetRollupJobs(options, buildContext, rollupJobsOptions);
-    if (assetJobs.length === 0) {
-        logger.warn('The "src" directory does not contain any entry files. ' + 'For proper usage, please refer to the following link: ' + 'https://github.com/huozhi/bunchee#usage');
-    }
-    if (options.watch) {
-        logWatcherBuildTime(assetJobs);
-    } else {
-        logOutputState(sizeCollector);
-    }
-    return;
-}
-function logWatcherBuildTime(result) {
-    let watcherCounter = 0;
-    let startTime = 0;
-    result.map((watcher)=>{
-        function start() {
-            if (watcherCounter === 0) startTime = perf_hooks.performance.now();
-            watcherCounter++;
-        }
-        function end() {
-            watcherCounter--;
-            if (watcherCounter === 0) {
-                logger.info(`Build in ${(perf_hooks.performance.now() - startTime).toFixed(2)}ms`);
-            }
-        }
-        watcher.on('event', (event)=>{
-            switch(event.code){
-                case 'ERROR':
-                    {
-                        logError(event.error);
-                        break;
-                    }
-                case 'START':
-                    {
-                        start();
-                        break;
-                    }
-                case 'END':
-                    {
-                        end();
-                        break;
-                    }
-            }
-        });
-    });
-}
-function logError(error) {
-    if (!error) return;
-    // logging source code in format
-    if (error.frame) {
-        process.stderr.write(error.frame + '\n');
-    }
+    (_options__callbacks1 = options._callbacks) == null ? void 0 : (_options__callbacks_onBuildEnd = _options__callbacks1.onBuildEnd) == null ? void 0 : _options__callbacks_onBuildEnd.call(_options__callbacks1, assetJobs);
 }
 
 exports.bundle = bundle;