bunup 0.8.2 → 0.8.4

package/dist/index.js

@@ -1,6 +1,655 @@
-"use client";
 // @bun
-var dr=Object.create;var{getPrototypeOf:ur,defineProperty:F,getOwnPropertyNames:lr}=Object;var Cr=Object.prototype.hasOwnProperty;var Y=(n,r,g)=>{g=n!=null?dr(ur(n)):{};let e=r||!n||!n.__esModule?F(g,"default",{value:n,enumerable:!0}):g;for(let b of lr(n))if(!Cr.call(e,b))F(e,b,{get:()=>n[b],enumerable:!0});return e};var cr=(n,r)=>()=>(r||n((r={exports:{}}).exports,r),r.exports);var S=cr((Gr,O)=>{var E=process||{},G=E.argv||[],R=E.env||{},wr=!(!!R.NO_COLOR||G.includes("--no-color"))&&(!!R.FORCE_COLOR||G.includes("--color")||E.platform==="win32"||(E.stdout||{}).isTTY&&R.TERM!=="dumb"||!!R.CI),Mr=(n,r,g=n)=>(e)=>{let b=""+e,x=b.indexOf(r,n.length);return~x?n+Rr(b,r,g,x)+r:n+b+r},Rr=(n,r,g,e)=>{let b="",x=0;do b+=n.substring(x,e)+g,x=e+r.length,e=n.indexOf(r,x);while(~e);return b+n.substring(x)},N=(n=wr)=>{let r=n?Mr:()=>String;return{isColorSupported:n,reset:r("\x1B[0m","\x1B[0m"),bold:r("\x1B[1m","\x1B[22m","\x1B[22m\x1B[1m"),dim:r("\x1B[2m","\x1B[22m","\x1B[22m\x1B[2m"),italic:r("\x1B[3m","\x1B[23m"),underline:r("\x1B[4m","\x1B[24m"),inverse:r("\x1B[7m","\x1B[27m"),hidden:r("\x1B[8m","\x1B[28m"),strikethrough:r("\x1B[9m","\x1B[29m"),black:r("\x1B[30m","\x1B[39m"),red:r("\x1B[31m","\x1B[39m"),green:r("\x1B[32m","\x1B[39m"),yellow:r("\x1B[33m","\x1B[39m"),blue:r("\x1B[34m","\x1B[39m"),magenta:r("\x1B[35m","\x1B[39m"),cyan:r("\x1B[36m","\x1B[39m"),white:r("\x1B[37m","\x1B[39m"),gray:r("\x1B[90m","\x1B[39m"),bgBlack:r("\x1B[40m","\x1B[49m"),bgRed:r("\x1B[41m","\x1B[49m"),bgGreen:r("\x1B[42m","\x1B[49m"),bgYellow:r("\x1B[43m","\x1B[49m"),bgBlue:r("\x1B[44m","\x1B[49m"),bgMagenta:r("\x1B[45m","\x1B[49m"),bgCyan:r("\x1B[46m","\x1B[49m"),bgWhite:r("\x1B[47m","\x1B[49m"),blackBright:r("\x1B[90m","\x1B[39m"),redBright:r("\x1B[91m","\x1B[39m"),greenBright:r("\x1B[92m","\x1B[39m"),yellowBright:r("\x1B[93m","\x1B[39m"),blueBright:r("\x1B[94m","\x1B[39m"),magentaBright:r("\x1B[95m","\x1B[39m"),cyanBright:r("\x1B[96m","\x1B[39m"),whiteBright:r("\x1B[97m","\x1B[39m"),bgBlackBright:r("\x1B[100m","\x1B[49m"),bgRedBright:r("\x1B[101m","\x1B[49m"),bgGreenBright:r("\x1B[102m","\x1B[49m"),bgYellowBright:r("\x1B[103m","\x1B[49m"),bgBlueBright:r("\x1B[104m","\x1B[49m"),bgMagentaBright:r("\x1B[105m","\x1B[49m"),bgCyanBright:r("\x1B[106m","\x1B[49m"),bgWhiteBright:r("\x1B[107m","\x1B[49m")}};O.exports=N();O.exports.createColors=N});function fr(n){return n}function Br(n){return n}import Or from"path";import{generateDts as Sr,logIsolatedDeclarationErrors as $r}from"bun-dts";var Er=Y(S(),1);var i=Y(S(),1),A=!1;function H(n){A=n??!1}class l{static instance;loggedOnceMessages=new Set;MAX_LABEL_LENGTH=3;cliColor=i.default.blue;mutedColor=i.default.dim;infoColor=i.default.cyan;warnColor=i.default.yellow;errorColor=i.default.red;defaultColor=i.default.white;progressFgColorMap={ESM:i.default.yellow,CJS:i.default.green,IIFE:i.default.magenta,DTS:i.default.blue};progressIdentifierBgColorMap={ESM:i.default.bgYellow,CJS:i.default.bgGreen,IIFE:i.default.bgMagenta,DTS:i.default.bgBlue};labels={cli:"CLI",info:"INFO",warn:"WARN",error:"ERROR"};constructor(){}static getInstance(){if(!l.instance)l.instance=new l;return l.instance}dispose(){this.loggedOnceMessages.clear()}shouldLog(n){if(!n?.once)return!0;if(this.loggedOnceMessages.has(n.once))return!1;return this.loggedOnceMessages.add(n.once),!0}formatMessage({fgColor:n,bgColor:r,label:g,message:e,identifier:b,muted:x}){let s=" ".repeat(Math.max(0,this.MAX_LABEL_LENGTH-g.length)),d=x?this.mutedColor(e):e,I=b?`   ${r(i.default.black(` ${b} `))}`:"";return`${n(g)} ${s}${d}${I}`}output(n,r={},g=console.log){if(A||!this.shouldLog(r))return;if(r.verticalSpace)g("");if(g(n),r.verticalSpace)g("")}cli(n,r={}){let g=this.formatMessage({fgColor:this.cliColor,bgColor:i.default.bgBlue,label:this.labels.cli,message:n,identifier:r.identifier,muted:r.muted});this.output(g,r)}info(n,r={}){let g=this.formatMessage({fgColor:this.infoColor,bgColor:i.default.bgCyan,label:this.labels.info,message:n,identifier:r.identifier,muted:r.muted});this.output(g,r)}warn(n,r={}){let g=this.formatMessage({fgColor:this.warnColor,bgColor:i.default.bgYellow,label:this.labels.warn,message:n,identifier:r.identifier,muted:r.muted});this.output(g,r,console.warn)}error(n,r={}){let g=this.formatMessage({fgColor:this.errorColor,bgColor:i.default.bgRed,label:this.labels.error,message:n,identifier:r.identifier,muted:r.muted});this.output(g,r,console.error)}getProgressFgColor(n){for(let[r,g]of Object.entries(this.progressFgColorMap))if(n.includes(r))return g;return this.defaultColor}getProgressBgColor(n){for(let[r,g]of Object.entries(this.progressIdentifierBgColorMap))if(n.includes(r))return g;return i.default.bgWhite}progress(n,r,g={}){let e=this.getProgressFgColor(n),b=this.getProgressBgColor(n),x=this.formatMessage({fgColor:e,bgColor:b,label:n,message:r,identifier:g.identifier,muted:g.muted});this.output(x,g)}}var o=l.getInstance();class K extends Error{constructor(n){super(n);this.name="BunupError"}}class B extends K{constructor(n){super(n);this.name="BunupBuildError"}}import U from"fs/promises";import X,{normalize as Xr}from"path";function _(n,r){switch(n){case"esm":return h(r)?".js":".mjs";case"cjs":return h(r)?".cjs":".js";case"iife":return".global.js"}}function j(n,r){switch(n){case"esm":return h(r)?".d.ts":".d.mts";case"cjs":return h(r)?".d.cts":".d.ts";case"iife":return".global.d.ts"}}function q(n){return n.replace(X.extname(n),"")}function Q(n){return n.replace(/\\/g,"/")}function h(n){return n==="module"}function Z(n){if(!n)return[];return Array.from(new Set([...Object.keys(n.dependencies||{}),...Object.keys(n.peerDependencies||{})]))}function z(n,r=3){return n.split("/").slice(-r).join("/")}async function V(n,r){let g=X.join(n,r);try{await U.rm(g,{recursive:!0,force:!0})}catch(e){throw new B(`Failed to clean output directory: ${e}`)}await U.mkdir(g,{recursive:!0})}function $(n){if(typeof n==="string")return[{entry:n,outputBasePath:T(n)}];if(typeof n==="object"&&!Array.isArray(n))return Object.entries(n).map(([r,g])=>({entry:g,outputBasePath:r}));return n.map((r)=>({entry:r,outputBasePath:T(r)}))}function T(n){let r=Q(q(n)).split("/");return r.length>1?r.slice(1).join("/"):r.join("/")}function v(n,r){return{entry:`[dir]/${n}${r}`,chunk:`${n}-[hash].[ext]`,asset:`${n}-[name]-[hash].[ext]`}}import{loadConfig as hr}from"coffi";async function p(n){let{config:r,filepath:g}=await hr({name:"package",cwd:n,extensions:[".json"]});return{data:r,path:g}}function D(){return{type:"bunup",name:"use-client",hooks:{onBuildDone:async({output:n})=>{for(let r of n.files){let g=await Bun.file(r.fullPath).text();if(g.includes(''))g=g.replaceAll('',""),g=`
-${g}`;await Bun.write(r.fullPath,g)}}}}}var Ir={entry:[],format:["cjs"],outDir:"dist",target:"node",clean:!0};function k(n){let r={...Ir,...n};return{...r,plugins:[...r.plugins??[],D()]}}function J(n){let{minify:r,minifyWhitespace:g,minifyIdentifiers:e,minifySyntax:b}=n,x=r===!0;return{whitespace:g??x,identifiers:e??x,syntax:b??x}}function a(n,r){return r==="cjs"?n:void 0}function y(n){if(n===!0)return"inline";return typeof n==="string"?n:void 0}function P(n,r){return{...typeof r==="object"&&Object.keys(r).reduce((g,e)=>{let b=JSON.stringify(r[e]);return g[`process.env.${e}`]=b,g[`import.meta.env.${e}`]=b,g},{}),...n}}function rr(n,r){return n===void 0?r==="esm":n}function nr(n){return typeof n==="string"?n:void 0}function Lr(n){return Z(n).map((r)=>new RegExp(`^${r}($|\\/|\\\\)`))}function er(n,r){return typeof r==="string"?r===n:r.test(n)}function gr(n,r,g){let b=Lr(g).some((s)=>s.test(n))||r.external?.some((s)=>er(n,s)),x=r.noExternal?.some((s)=>er(n,s));return b&&!x}function br(n,r){return{name:"bunup:external-option-plugin",setup(g){g.onResolve({filter:/.*/},(e)=>{let b=e.path;if(gr(b,n,r))return{path:b,external:!0};return null})}}}function ir(n){if(!n)return[];return n.filter((r)=>r.type==="bun")}function xr(n){if(!n)return[];return n.filter((r)=>r.type==="bunup")}async function mr(n,r){if(!n)return;for(let g of n)if(g.hooks.onBuildStart)await g.hooks.onBuildStart(r)}async function sr(n,r,g,e){if(!n)return;for(let b of n)if(b.hooks.onBuildDone)await b.hooks.onBuildDone({options:r,output:g,meta:e})}async function Wr(n,r=process.cwd()){let g={files:[]},e=k(n);if(!e.entry||e.entry.length===0||!e.outDir)throw new B("Nothing to build. Please make sure you have provided a proper bunup configuration or cli arguments.");if(e.clean)V(r,e.outDir);H(e.silent);let b=await p(r);if(b.data&&b.path)o.cli(`Using ${z(b.path,2)}`,{muted:!0,identifier:e.name,once:`${b.path}:${e.name}`});let x=xr(e.plugins);await mr(x,e);let s=$(e.entry),d=b.data?.type,I=[br(e,b.data),...ir(e.plugins).map((C)=>C.plugin)];if(!e.dtsOnly){let C=e.format.flatMap((t)=>s.map(async({entry:w,outputBasePath:M})=>{let c=e.outputExtension?.({format:t,packageType:d,options:e,entry:w}).js??_(t,d),f=await Bun.build({entrypoints:[`${r}/${w}`],format:t,naming:v(M,c),splitting:rr(e.splitting,t),bytecode:a(e.bytecode,t),define:P(e.define,e.env),minify:J(e),outdir:`${r}/${e.outDir}`,target:e.target,sourcemap:y(e.sourcemap),loader:e.loader,drop:e.drop,banner:e.banner,footer:e.footer,publicPath:e.publicPath,env:nr(e.env),plugins:I,throw:!1});for(let m of f.logs){if(m.level==="error")throw console.log(`
-`),console.log(m),console.log(`
-`),new Error;if(m.level==="warning")o.warn(m.message);else if(m.level==="info")o.info(m.message)}for(let m of f.outputs){let u=tr(m.path,r);if(m.kind==="entry-point")o.progress(t.toUpperCase(),u,{identifier:e.name});g.files.push({fullPath:m.path,relativePathToRootDir:u,dts:!1,entry:w,outputBasePath:M,format:t})}}));await Promise.all(C)}if(e.dts===!0||typeof e.dts==="object"||e.dtsOnly){let C=typeof e.dts==="object"&&"resolve"in e.dts?e.dts.resolve:void 0,t=typeof e.dts==="object"&&"entry"in e.dts?e.dts.entry:void 0,M=(t?$(t):s).map(async({entry:c,outputBasePath:f})=>{let m=await Sr(c,{cwd:r,preferredTsConfigPath:e.preferredTsconfigPath,resolve:C});for(let u of e.format){let or=e.outputExtension?.({format:u,packageType:d,options:e,entry:c}).dts??j(u,d),L=Or.join(r,e.outDir,`${f}${or}`),W=tr(L,r);if(g.files.push({fullPath:L,relativePathToRootDir:W,dts:!0,entry:c,outputBasePath:f,format:u}),m.errors.length>0)$r(m.errors,{warnInsteadOfError:e.watch,shouldExit:!0});await Bun.write(L,m.dts),o.progress("DTS",W,{identifier:e.name})}});await Promise.all(M)}if(await sr(x,e,g,{packageJson:b}),e.onSuccess)await e.onSuccess(e)}function tr(n,r){return n.replace(`${r}/`,"")}export{Br as defineWorkspace,fr as defineConfig,Wr as build};
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
+// src/define.ts
+function defineConfig(options) {
+  return options;
+}
+function defineWorkspace(options) {
+  return options;
+}
+// src/build.ts
+import path2 from "path";
+import { generateDts, logIsolatedDeclarationErrors } from "bun-dts";
+
+// src/errors.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+
+// src/logger.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var silent = false;
+function setSilent(value) {
+  silent = value ?? false;
+}
+
+class Logger {
+  static instance;
+  loggedOnceMessages = new Set;
+  MAX_LABEL_LENGTH = 3;
+  cliColor = import_picocolors.default.blue;
+  mutedColor = import_picocolors.default.dim;
+  infoColor = import_picocolors.default.cyan;
+  warnColor = import_picocolors.default.yellow;
+  errorColor = import_picocolors.default.red;
+  defaultColor = import_picocolors.default.white;
+  progressFgColorMap = {
+    ESM: import_picocolors.default.yellow,
+    CJS: import_picocolors.default.green,
+    IIFE: import_picocolors.default.magenta,
+    DTS: import_picocolors.default.blue
+  };
+  progressIdentifierBgColorMap = {
+    ESM: import_picocolors.default.bgYellow,
+    CJS: import_picocolors.default.bgGreen,
+    IIFE: import_picocolors.default.bgMagenta,
+    DTS: import_picocolors.default.bgBlue
+  };
+  labels = {
+    cli: "CLI",
+    info: "INFO",
+    warn: "WARN",
+    error: "ERROR"
+  };
+  constructor() {}
+  static getInstance() {
+    if (!Logger.instance) {
+      Logger.instance = new Logger;
+    }
+    return Logger.instance;
+  }
+  dispose() {
+    this.loggedOnceMessages.clear();
+  }
+  shouldLog(options) {
+    if (!options?.once)
+      return true;
+    if (this.loggedOnceMessages.has(options.once))
+      return false;
+    this.loggedOnceMessages.add(options.once);
+    return true;
+  }
+  formatMessage({
+    fgColor,
+    bgColor,
+    label,
+    message,
+    identifier,
+    muted
+  }) {
+    const padding = " ".repeat(Math.max(0, this.MAX_LABEL_LENGTH - label.length));
+    const formattedMessage = muted ? this.mutedColor(message) : message;
+    const identifierPart = identifier ? `   ${bgColor(import_picocolors.default.black(` ${identifier} `))}` : "";
+    return `${fgColor(label)} ${padding}${formattedMessage}${identifierPart}`;
+  }
+  output(message, options = {}, logFn = console.log) {
+    if (silent || !this.shouldLog(options))
+      return;
+    if (options.verticalSpace)
+      logFn("");
+    logFn(message);
+    if (options.verticalSpace)
+      logFn("");
+  }
+  cli(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      fgColor: this.cliColor,
+      bgColor: import_picocolors.default.bgBlue,
+      label: this.labels.cli,
+      message,
+      identifier: options.identifier,
+      muted: options.muted
+    });
+    this.output(formattedMessage, options);
+  }
+  info(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      fgColor: this.infoColor,
+      bgColor: import_picocolors.default.bgCyan,
+      label: this.labels.info,
+      message,
+      identifier: options.identifier,
+      muted: options.muted
+    });
+    this.output(formattedMessage, options);
+  }
+  warn(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      fgColor: this.warnColor,
+      bgColor: import_picocolors.default.bgYellow,
+      label: this.labels.warn,
+      message,
+      identifier: options.identifier,
+      muted: options.muted
+    });
+    this.output(formattedMessage, options, console.warn);
+  }
+  error(message, options = {}) {
+    const formattedMessage = this.formatMessage({
+      fgColor: this.errorColor,
+      bgColor: import_picocolors.default.bgRed,
+      label: this.labels.error,
+      message,
+      identifier: options.identifier,
+      muted: options.muted
+    });
+    this.output(formattedMessage, options, console.error);
+  }
+  getProgressFgColor(label) {
+    for (const [key, colorFn] of Object.entries(this.progressFgColorMap)) {
+      if (label.includes(key))
+        return colorFn;
+    }
+    return this.defaultColor;
+  }
+  getProgressBgColor(label) {
+    for (const [key, colorFn] of Object.entries(this.progressIdentifierBgColorMap)) {
+      if (label.includes(key))
+        return colorFn;
+    }
+    return import_picocolors.default.bgWhite;
+  }
+  progress(label, message, options = {}) {
+    const fgColor = this.getProgressFgColor(label);
+    const bgColor = this.getProgressBgColor(label);
+    const formattedMessage = this.formatMessage({
+      fgColor,
+      bgColor,
+      label,
+      message,
+      identifier: options.identifier,
+      muted: options.muted
+    });
+    this.output(formattedMessage, options);
+  }
+}
+var logger = Logger.getInstance();
+
+// src/errors.ts
+class BunupError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BunupError";
+  }
+}
+
+class BunupBuildError extends BunupError {
+  constructor(message) {
+    super(message);
+    this.name = "BunupBuildError";
+  }
+}
+
+// src/utils.ts
+import fs from "fs/promises";
+import path, { normalize } from "path";
+function getDefaultJsOutputExtension(format, packageType) {
+  switch (format) {
+    case "esm":
+      return isModulePackage(packageType) ? ".js" : ".mjs";
+    case "cjs":
+      return isModulePackage(packageType) ? ".cjs" : ".js";
+    case "iife":
+      return ".global.js";
+  }
+}
+function getDefaultDtsOutputExtension(format, packageType) {
+  switch (format) {
+    case "esm":
+      return isModulePackage(packageType) ? ".d.ts" : ".d.mts";
+    case "cjs":
+      return isModulePackage(packageType) ? ".d.cts" : ".d.ts";
+    case "iife":
+      return ".global.d.ts";
+  }
+}
+function removeExtension(filePath) {
+  return filePath.replace(path.extname(filePath), "");
+}
+function cleanPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function isModulePackage(packageType) {
+  return packageType === "module";
+}
+function getPackageDeps(packageJson) {
+  if (!packageJson)
+    return [];
+  return Array.from(new Set([
+    ...Object.keys(packageJson.dependencies || {}),
+    ...Object.keys(packageJson.peerDependencies || {})
+  ]));
+}
+function getShortFilePath(filePath, maxLength = 3) {
+  const fileParts = filePath.split("/");
+  const shortPath = fileParts.slice(-maxLength).join("/");
+  return shortPath;
+}
+async function cleanOutDir(rootDir, outDir) {
+  const outDirPath = path.join(rootDir, outDir);
+  try {
+    await fs.rm(outDirPath, { recursive: true, force: true });
+  } catch (error) {
+    throw new BunupBuildError(`Failed to clean output directory: ${error}`);
+  }
+  await fs.mkdir(outDirPath, { recursive: true });
+}
+
+// src/helpers/entry.ts
+function getProcessableEntries(entry) {
+  if (typeof entry === "string") {
+    return [
+      {
+        entry,
+        outputBasePath: getEntryOutputBasePath(entry)
+      }
+    ];
+  }
+  if (typeof entry === "object" && !Array.isArray(entry)) {
+    return Object.entries(entry).map(([name, path2]) => ({
+      entry: path2,
+      outputBasePath: name
+    }));
+  }
+  return entry.map((_entry) => ({
+    entry: _entry,
+    outputBasePath: getEntryOutputBasePath(_entry)
+  }));
+}
+function getEntryOutputBasePath(entry) {
+  const pathSegments = cleanPath(removeExtension(entry)).split("/");
+  return pathSegments.length > 1 ? pathSegments.slice(1).join("/") : pathSegments.join("/");
+}
+function getResolvedNaming(outputBasePath, extension) {
+  return {
+    entry: `[dir]/${outputBasePath}${extension}`,
+    chunk: `${outputBasePath}-[hash].[ext]`,
+    asset: `${outputBasePath}-[name]-[hash].[ext]`
+  };
+}
+
+// src/loaders.ts
+import { loadConfig } from "coffi";
+async function loadPackageJson(cwd) {
+  const { config, filepath } = await loadConfig({
+    name: "package",
+    cwd,
+    extensions: [".json"]
+  });
+  return {
+    data: config,
+    path: filepath
+  };
+}
+
+// src/plugins/internal/use-client.ts
+function useClient() {
+  return {
+    type: "bunup",
+    name: "use-client",
+    hooks: {
+      onBuildDone: async ({ output }) => {
+        for (const file of output.files) {
+          let text = await Bun.file(file.fullPath).text();
+          const hasUseClient = text.split(`
+`).some((line) => line.trim().startsWith(`"use client";`));
+          if (hasUseClient) {
+            text = text.replaceAll(`"use client";`, "");
+            text = `"use client";
+${text}`;
+          }
+          await Bun.write(file.fullPath, text);
+        }
+      }
+    }
+  };
+}
+
+// src/options.ts
+var DEFAULT_OPTIONS = {
+  entry: [],
+  format: ["cjs"],
+  outDir: "dist",
+  target: "node",
+  clean: true
+};
+function createBuildOptions(partialOptions) {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...partialOptions
+  };
+  return {
+    ...options,
+    plugins: [...options.plugins ?? [], useClient()]
+  };
+}
+function getResolvedMinify(options) {
+  const { minify, minifyWhitespace, minifyIdentifiers, minifySyntax } = options;
+  const defaultValue = minify === true;
+  return {
+    whitespace: minifyWhitespace ?? defaultValue,
+    identifiers: minifyIdentifiers ?? defaultValue,
+    syntax: minifySyntax ?? defaultValue
+  };
+}
+function getResolvedBytecode(bytecode, format) {
+  return format === "cjs" ? bytecode : undefined;
+}
+function getResolvedSourcemap(sourcemap) {
+  if (sourcemap === true) {
+    return "inline";
+  }
+  return typeof sourcemap === "string" ? sourcemap : undefined;
+}
+function getResolvedDefine(define, env) {
+  return {
+    ...typeof env === "object" && Object.keys(env).reduce((acc, key) => {
+      const value = JSON.stringify(env[key]);
+      acc[`process.env.${key}`] = value;
+      acc[`import.meta.env.${key}`] = value;
+      return acc;
+    }, {}),
+    ...define
+  };
+}
+function getResolvedSplitting(splitting, format) {
+  return splitting === undefined ? format === "esm" : splitting;
+}
+function getResolvedEnv(env) {
+  return typeof env === "string" ? env : undefined;
+}
+
+// src/helpers/external.ts
+function getPackageDepsPatterns(packageJson) {
+  return getPackageDeps(packageJson).map((dep) => new RegExp(`^${dep}($|\\/|\\\\)`));
+}
+function matchesPattern(path2, pattern) {
+  return typeof pattern === "string" ? pattern === path2 : pattern.test(path2);
+}
+function isExternal(path2, options, packageJson) {
+  const packageDepsPatterns = getPackageDepsPatterns(packageJson);
+  const matchesExternalPattern = packageDepsPatterns.some((pattern) => pattern.test(path2)) || options.external?.some((pattern) => matchesPattern(path2, pattern));
+  const isExcludedFromExternal = options.noExternal?.some((pattern) => matchesPattern(path2, pattern));
+  return matchesExternalPattern && !isExcludedFromExternal;
+}
+
+// src/plugins/internal/external-option.ts
+function externalOptionPlugin(options, packageJson) {
+  return {
+    name: "bunup:external-option-plugin",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        const importPath = args.path;
+        if (isExternal(importPath, options, packageJson)) {
+          return {
+            path: importPath,
+            external: true
+          };
+        }
+        return null;
+      });
+    }
+  };
+}
+
+// src/plugins/utils.ts
+function filterBunupBunPlugins(plugins) {
+  if (!plugins)
+    return [];
+  return plugins.filter((p) => p.type === "bun");
+}
+function filterBunupPlugins(plugins) {
+  if (!plugins)
+    return [];
+  return plugins.filter((p) => p.type === "bunup");
+}
+async function runPluginBuildStartHooks(bunupPlugins, options) {
+  if (!bunupPlugins)
+    return;
+  for (const plugin of bunupPlugins) {
+    if (plugin.hooks.onBuildStart) {
+      await plugin.hooks.onBuildStart(options);
+    }
+  }
+}
+async function runPluginBuildDoneHooks(bunupPlugins, options, output, meta) {
+  if (!bunupPlugins)
+    return;
+  for (const plugin of bunupPlugins) {
+    if (plugin.hooks.onBuildDone) {
+      await plugin.hooks.onBuildDone({ options, output, meta });
+    }
+  }
+}
+
+// src/build.ts
+async function build(partialOptions, rootDir = process.cwd()) {
+  const buildOutput = {
+    files: []
+  };
+  const options = createBuildOptions(partialOptions);
+  if (!options.entry || options.entry.length === 0 || !options.outDir) {
+    throw new BunupBuildError("Nothing to build. Please make sure you have provided a proper bunup configuration or cli arguments.");
+  }
+  if (options.clean) {
+    cleanOutDir(rootDir, options.outDir);
+  }
+  setSilent(options.silent);
+  const packageJson = await loadPackageJson(rootDir);
+  if (packageJson.data && packageJson.path) {
+    logger.cli(`Using ${getShortFilePath(packageJson.path, 2)}`, {
+      muted: true,
+      identifier: options.name,
+      once: `${packageJson.path}:${options.name}`
+    });
+  }
+  const bunupPlugins = filterBunupPlugins(options.plugins);
+  await runPluginBuildStartHooks(bunupPlugins, options);
+  const processableEntries = getProcessableEntries(options.entry);
+  const packageType = packageJson.data?.type;
+  const plugins = [
+    externalOptionPlugin(options, packageJson.data),
+    ...filterBunupBunPlugins(options.plugins).map((p) => p.plugin)
+  ];
+  if (!options.dtsOnly) {
+    const buildPromises = options.format.flatMap((fmt) => processableEntries.map(async ({ entry, outputBasePath }) => {
+      const extension = options.outputExtension?.({
+        format: fmt,
+        packageType,
+        options,
+        entry
+      }).js ?? getDefaultJsOutputExtension(fmt, packageType);
+      const result = await Bun.build({
+        entrypoints: [`${rootDir}/${entry}`],
+        format: fmt,
+        naming: getResolvedNaming(outputBasePath, extension),
+        splitting: getResolvedSplitting(options.splitting, fmt),
+        bytecode: getResolvedBytecode(options.bytecode, fmt),
+        define: getResolvedDefine(options.define, options.env),
+        minify: getResolvedMinify(options),
+        outdir: `${rootDir}/${options.outDir}`,
+        target: options.target,
+        sourcemap: getResolvedSourcemap(options.sourcemap),
+        loader: options.loader,
+        drop: options.drop,
+        banner: options.banner,
+        footer: options.footer,
+        publicPath: options.publicPath,
+        env: getResolvedEnv(options.env),
+        plugins,
+        throw: false
+      });
+      for (const log of result.logs) {
+        if (log.level === "error") {
+          console.log(`
+`);
+          console.log(log);
+          console.log(`
+`);
+          throw new Error;
+        }
+        if (log.level === "warning")
+          logger.warn(log.message);
+        else if (log.level === "info")
+          logger.info(log.message);
+      }
+      for (const file of result.outputs) {
+        const relativePathToRootDir = getRelativePathToRootDir(file.path, rootDir);
+        if (file.kind === "entry-point") {
+          logger.progress(fmt.toUpperCase(), relativePathToRootDir, {
+            identifier: options.name
+          });
+        }
+        buildOutput.files.push({
+          fullPath: file.path,
+          relativePathToRootDir,
+          dts: false,
+          entry,
+          outputBasePath,
+          format: fmt
+        });
+      }
+    }));
+    await Promise.all(buildPromises);
+  }
+  if (options.dts === true || typeof options.dts === "object" || options.dtsOnly) {
+    const dtsResolve = typeof options.dts === "object" && "resolve" in options.dts ? options.dts.resolve : undefined;
+    const dtsEntry = typeof options.dts === "object" && "entry" in options.dts ? options.dts.entry : undefined;
+    const processableDtsEntries = dtsEntry ? getProcessableEntries(dtsEntry) : processableEntries;
+    const dtsPromises = processableDtsEntries.map(async ({ entry, outputBasePath }) => {
+      const result = await generateDts(entry, {
+        cwd: rootDir,
+        preferredTsConfigPath: options.preferredTsconfigPath,
+        resolve: dtsResolve
+      });
+      for (const fmt of options.format) {
+        const extension = options.outputExtension?.({
+          format: fmt,
+          packageType,
+          options,
+          entry
+        }).dts ?? getDefaultDtsOutputExtension(fmt, packageType);
+        const filePath = path2.join(rootDir, options.outDir, `${outputBasePath}${extension}`);
+        const relativePathToRootDir = getRelativePathToRootDir(filePath, rootDir);
+        buildOutput.files.push({
+          fullPath: filePath,
+          relativePathToRootDir,
+          dts: true,
+          entry,
+          outputBasePath,
+          format: fmt
+        });
+        if (result.errors.length > 0) {
+          logIsolatedDeclarationErrors(result.errors, {
+            warnInsteadOfError: options.watch,
+            shouldExit: true
+          });
+        }
+        await Bun.write(filePath, result.dts);
+        logger.progress("DTS", relativePathToRootDir, {
+          identifier: options.name
+        });
+      }
+    });
+    await Promise.all(dtsPromises);
+  }
+  await runPluginBuildDoneHooks(bunupPlugins, options, buildOutput, {
+    packageJson
+  });
+  if (options.onSuccess) {
+    await options.onSuccess(options);
+  }
+}
+function getRelativePathToRootDir(filePath, rootDir) {
+  return filePath.replace(`${rootDir}/`, "");
+}
+export {
+  defineWorkspace,
+  defineConfig,
+  build
+};