bunup 0.8.30 → 0.8.32

package/dist/index.d.ts

@@ -1,361 +1,4 @@
-import _Bun from "bun";
-type PackageJson = {
-	/** The parsed content of the package.json file */
-	data: Record<string, any> | null
-	/** The path to the package.json file */
-	path: string | null
-};
-/**
-* Represents a Bun plugin that can be used with Bunup
-*/
-type BunupBunPlugin = {
-	/** Identifies this as a native Bun plugin */
-	type: "bun"
-	/** Optional name for the plugin */
-	name?: string
-	/** The actual Bun plugin implementation */
-	plugin: BunPlugin
-};
-/**
-* Represents the meta data of the build
-*/
-type BuildMeta = {
-	/** The package.json file */
-	packageJson: PackageJson
-	/** The root directory of the build */
-	rootDir: string
-};
-type BuildOutputFile = {
-	/** The kind of the file */
-	kind: "entry-point" | "chunk" | "asset" | "sourcemap" | "bytecode"
-	/** Path to the generated file */
-	fullPath: string
-	/** Path to the generated file relative to the root directory */
-	relativePathToRootDir: string
-	/** Path to the generated file relative to the output directory */
-	relativePathToOutputDir: string
-	/** Whether the file is a dts file */
-	dts: boolean
-	/** The format of the output file */
-	format: Format
-};
-/**
-* Represents the output of a build operation
-*/
-type BuildOutput = {
-	/** Array of generated files with their paths and contents */
-	files: BuildOutputFile[]
-};
-/**
-* Context provided to build hooks
-*/
-type BuildContext = {
-	/** The build options that were used */
-	options: BuildOptions
-	/** The output of the build */
-	output: BuildOutput
-	/** The meta data of the build */
-	meta: BuildMeta
-};
-/**
-* Hooks that can be implemented by Bunup plugins
-*/
-type BunupPluginHooks = {
-	/**
-	* Called when a build is successfully completed
-	* @param ctx Build context containing options and output
-	*/
-	onBuildDone?: (ctx: BuildContext) => MaybePromise<void>
-	/**
-	* Called before a build starts
-	* @param options Build options that will be used
-	*/
-	onBuildStart?: (options: BuildOptions) => MaybePromise<void>
-};
-/**
-* Represents a Bunup-specific plugin
-*/
-type BunupPlugin = {
-	/** Identifies this as a Bunup-specific plugin */
-	type: "bunup"
-	/** Optional name for the plugin */
-	name?: string
-	/** The hooks implemented by this plugin */
-	hooks: BunupPluginHooks
-};
-/**
-* Union type representing all supported plugin types
-*/
-type Plugin = BunupBunPlugin | BunupPlugin;
-type Loader = NonNullable<BunBuildOptions["loader"]>[string];
-type Define = BunBuildOptions["define"];
-type Sourcemap = BunBuildOptions["sourcemap"];
-type Format = Exclude<BunBuildOptions["format"], undefined>;
-type Target = BunBuildOptions["target"];
-type External = (string | RegExp)[];
-type Env = BunBuildOptions["env"] | Record<string, string>;
-type DtsResolve = boolean | (string | RegExp)[];
-type Naming = string | {
-	entry?: string
-	chunk?: string
-	asset?: string
-};
-type DtsOptions = {
-	/**
-	* Entry point files for TypeScript declaration file generation
-	*
-	* If not specified, the main entry points will be used for declaration file generation.
-	*
-	* @see https://bunup.dev/docs/guide/typescript-declarations#custom-entry-points
-	* @see https://bunup.dev/docs/guide/typescript-declarations#named-entries
-	*/
-	entry?: string | string[]
-	/**
-	* Resolve external types used in dts files from node_modules
-	*/
-	resolve?: DtsResolve
-	/**
-	* Whether to split declaration files when multiple entrypoints import the same files,
-	* modules, or share types. When enabled, shared types will be extracted to separate
-	* .d.ts files, and other declaration files will import these shared files.
-	*
-	* This helps reduce bundle size by preventing duplication of type definitions
-	* across multiple entrypoints.
-	*
-	* This option is enabled by default if splitting is enabled in the Bun build config or format is esm.
-	*/
-	splitting?: boolean
-};
-interface BuildOptions {
-	/**
-	* Name of the build configuration
-	* Used for logging and identification purposes
-	*/
-	name?: string;
-	/**
-	* Entry point files for the build
-	*
-	* This can be:
-	* - A string path to a file
-	* - An array of file paths
-	*
-	* @see https://bunup.dev/docs/#entry-points
-	*/
-	entry: string | string[];
-	/**
-	* Output directory for the bundled files
-	* Defaults to 'dist' if not specified
-	*/
-	outDir: string;
-	/**
-	* Output formats for the bundle
-	* Can include 'esm', 'cjs', and/or 'iife'
-	* Defaults to ['cjs'] if not specified
-	*/
-	format: Format[];
-	/**
-	* Whether to enable all minification options
-	* When true, enables minifyWhitespace, minifyIdentifiers, and minifySyntax
-	*/
-	minify?: boolean;
-	/**
-	* Whether to enable code splitting
-	* Defaults to true for ESM format, false for CJS format
-	*/
-	splitting?: boolean;
-	naming?: Naming;
-	/**
-	* Whether to minify whitespace in the output
-	* Removes unnecessary whitespace to reduce file size
-	*/
-	minifyWhitespace?: boolean;
-	/**
-	* Whether to minify identifiers in the output
-	* Renames variables and functions to shorter names
-	*/
-	minifyIdentifiers?: boolean;
-	/**
-	* Whether to minify syntax in the output
-	* Optimizes code structure for smaller file size
-	*/
-	minifySyntax?: boolean;
-	/**
-	* Whether to watch for file changes and rebuild automatically
-	*/
-	watch?: boolean;
-	/**
-	* Whether to generate TypeScript declaration files (.d.ts)
-	* When set to true, generates declaration files for all entry points
-	* Can also be configured with DtsOptions for more control
-	*/
-	dts?: boolean | DtsOptions;
-	/**
-	* Path to a preferred tsconfig.json file to use for declaration generation
-	*
-	* If not specified, the tsconfig.json in the project root will be used.
-	* This option allows you to use a different TypeScript configuration
-	* specifically for declaration file generation.
-	*
-	* @example
-	* preferredTsconfigPath: './tsconfig.build.json'
-	*/
-	preferredTsconfigPath?: string;
-	/**
-	* External packages that should not be bundled
-	* Useful for dependencies that should be kept as external imports
-	*/
-	external?: External;
-	/**
-	* Packages that should be bundled even if they are in external
-	* Useful for dependencies that should be included in the bundle
-	*/
-	noExternal?: External;
-	/**
-	* The target environment for the bundle
-	* Can be 'browser', 'bun', 'node', etc.
-	* Defaults to 'node' if not specified
-	*/
-	target?: Target;
-	/**
-	* Whether to clean the output directory before building
-	* When true, removes all files in the outDir before starting a new build
-	* Defaults to true if not specified
-	*/
-	clean?: boolean;
-	/**
-	* Specifies the type of sourcemap to generate
-	* Can be 'none', 'linked', 'external', or 'inline'
-	* Can also be a boolean - when true, it will use 'inline'
-	*
-	* @see https://bun.sh/docs/bundler#sourcemap
-	*
-	* @default 'none'
-	*
-	* @example
-	* sourcemap: 'linked'
-	* // or
-	* sourcemap: true // equivalent to 'inline'
-	*/
-	sourcemap?: Sourcemap;
-	define?: Define;
-	/**
-	* A callback function that runs after the build process completes
-	* This can be used for custom post-build operations like copying files,
-	* running additional tools, or logging build information
-	*
-	* If watch mode is enabled, this callback runs after each rebuild
-	*
-	* @param options The build options that were used
-	*/
-	onSuccess?: (options: Partial<BuildOptions>) => MaybePromise<void>;
-	banner?: string;
-	/**
-	* A footer to be added to the final bundle, this can be something like a comment block for a license or just a fun easter egg.
-	*
-	* @see https://bun.sh/docs/bundler#footer
-	*
-	* @example
-	* footer: '// built with love in SF'
-	*/
-	footer?: string;
-	/**
-	* Remove function calls from a bundle. For example, `drop: ["console"]` will remove all calls to `console.log`. Arguments to calls will also be removed, regardless of if those arguments may have side effects. Dropping `debugger` will remove all `debugger` statements.
-	*
-	* @see https://bun.sh/docs/bundler#drop
-	*
-	* @example
-	* drop: ["console", "debugger", "anyIdentifier.or.propertyAccess"]
-	*/
-	drop?: string[];
-	/**
-	* A map of file extensions to [built-in loader names](https://bun.sh/docs/bundler/loaders#built-in-loaders). This can be used to quickly customize how certain files are loaded.
-	*
-	* @see https://bun.sh/docs/bundler#loader
-	*
-	* @example
-	* loader: {
-	*   ".png": "dataurl",
-	*   ".txt": "file",
-	* }
-	*/
-	loader?: Record<string, Loader>;
-	/**
-	* Generate bytecode for the output. This can dramatically improve cold start times, but will make the final output larger and slightly increase memory usage.
-	*
-	* Bytecode is currently only supported for CommonJS (format: "cjs").
-	*
-	* Must be target: "bun"
-	*
-	* @see https://bun.sh/docs/bundler#bytecode
-	*
-	* @default false
-	*/
-	bytecode?: boolean;
-	/**
-	* Disable logging during the build process. When set to true, no logs will be printed to the console.
-	*
-	* @default false
-	*/
-	silent?: boolean;
-	/**
-	* You can specify a prefix to be added to specific import paths in your bundled code
-	*
-	* Used for assets, external modules, and chunk files when splitting is enabled
-	*
-	* @see https://bunup.dev/docs#public-path for more information
-	*
-	* @example
-	* publicPath: 'https://cdn.example.com/'
-	*/
-	publicPath?: string;
-	/**
-	* Controls how environment variables are handled during bundling.
-	*
-	* Can be one of:
-	* - `"inline"`: Replaces all `process.env.FOO` references in your code with the actual values
-	*   of those environment variables at the time the build runs.
-	* - `"disable"`: Disables environment variable injection entirely, leaving `process.env.*` as-is.
-	* - A string ending in `*`: Only inlines environment variables matching the given prefix.
-	*   For example, `"MY_PUBLIC_*"` will inline variables like `MY_PUBLIC_API_URL`.
-	* - An object of key-value pairs: Replaces both `process.env.KEY` and `import.meta.env.KEY`
-	*   with the provided values, regardless of the runtime environment.
-	*
-	* Note: Values are injected at build time. Secrets or private keys should be excluded
-	* from inlining when targeting browser environments.
-	*
-	* @see https://bun.sh/docs/bundler#env to learn more about inline, disable, prefix, and object modes
-	*
-	* @example
-	* // Inline all environment variables available at build time
-	* env: "inline"
-	*
-	* // Disable all environment variable injection
-	* env: "disable"
-	*
-	* // Only inline environment variables with a specific prefix
-	* env: "PUBLIC_*"
-	*
-	* // Provide specific environment variables manually
-	* env: { API_URL: "https://api.example.com", DEBUG: "false" }
-	*/
-	env?: Env;
-	plugins?: Plugin[];
-}
-type MaybePromise<T> = Promise<T> | T;
-type WithOptional<
-	T,
-	K extends keyof T
-> = Omit<T, K> & Partial<Pick<T, K>>;
-type Arrayable<T> = T | T[];
-type Bun = typeof _Bun;
-type BunBuildOptions = Parameters<Bun["build"]>[0];
-type BunPlugin = Exclude<BunBuildOptions["plugins"], undefined>[number];
-type DefineConfigItem = Omit<WithOptional<BuildOptions, "outDir" | "format">, "watch">;
-type DefineWorkspaceItem = {
-	name: string
-	root: string
-	config: DefineConfigItem | DefineConfigItem[]
-};
+import { Arrayable, BuildOptions, DefineConfigItem, DefineWorkspaceItem, Plugin } from "./chunk-8sqm3fje";
 declare function defineConfig(options: Arrayable<DefineConfigItem>): Arrayable<DefineConfigItem>;
 declare function defineWorkspace(options: DefineWorkspaceItem[]): DefineWorkspaceItem[];
 declare function build(partialOptions: Partial<BuildOptions>, rootDir?: string): Promise<void>;

package/dist/index.js

@@ -15,7 +15,6 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -28,77 +27,8 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// 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/logger.ts
+import pc from "picocolors";
 function setSilent(value) {
   silent = value ?? false;
 }
@@ -107,23 +37,23 @@ 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;
+  cliColor = pc.blue;
+  mutedColor = pc.dim;
+  infoColor = pc.cyan;
+  warnColor = pc.yellow;
+  errorColor = pc.red;
+  defaultColor = pc.white;
   progressFgColorMap = {
-    ESM: import_picocolors.default.yellow,
-    CJS: import_picocolors.default.green,
-    IIFE: import_picocolors.default.magenta,
-    DTS: import_picocolors.default.blue
+    ESM: pc.yellow,
+    CJS: pc.green,
+    IIFE: pc.magenta,
+    DTS: pc.blue
   };
   progressIdentifierBgColorMap = {
-    ESM: import_picocolors.default.bgYellow,
-    CJS: import_picocolors.default.bgGreen,
-    IIFE: import_picocolors.default.bgMagenta,
-    DTS: import_picocolors.default.bgBlue
+    ESM: pc.bgYellow,
+    CJS: pc.bgGreen,
+    IIFE: pc.bgMagenta,
+    DTS: pc.bgBlue
   };
   labels = {
     cli: "CLI",
@@ -159,7 +89,7 @@ class Logger {
   }) {
     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} `))}` : "";
+    const identifierPart = identifier ? `   ${bgColor(pc.black(` ${identifier} `))}` : "";
     return `${fgColor(label)} ${padding}${formattedMessage}${identifierPart}`;
   }
   output(message, options = {}, logFn = console.log) {
@@ -174,7 +104,7 @@ class Logger {
   cli(message, options = {}) {
     const formattedMessage = this.formatMessage({
       fgColor: this.cliColor,
-      bgColor: import_picocolors.default.bgBlue,
+      bgColor: pc.bgBlue,
       label: this.labels.cli,
       message,
       identifier: options.identifier,
@@ -185,7 +115,7 @@ class Logger {
   info(message, options = {}) {
     const formattedMessage = this.formatMessage({
       fgColor: this.infoColor,
-      bgColor: import_picocolors.default.bgCyan,
+      bgColor: pc.bgCyan,
       label: this.labels.info,
       message,
       identifier: options.identifier,
@@ -196,7 +126,7 @@ class Logger {
   warn(message, options = {}) {
     const formattedMessage = this.formatMessage({
       fgColor: this.warnColor,
-      bgColor: import_picocolors.default.bgYellow,
+      bgColor: pc.bgYellow,
       label: this.labels.warn,
       message,
       identifier: options.identifier,
@@ -207,7 +137,7 @@ class Logger {
   error(message, options = {}) {
     const formattedMessage = this.formatMessage({
       fgColor: this.errorColor,
-      bgColor: import_picocolors.default.bgRed,
+      bgColor: pc.bgRed,
       label: this.labels.error,
       message,
       identifier: options.identifier,
@@ -232,7 +162,7 @@ class Logger {
       if (label.includes(key))
         return colorFn;
     }
-    return import_picocolors.default.bgWhite;
+    return pc.bgWhite;
   }
   progress(label, message, options = {}) {
     const fgColor = this.getProgressFgColor(label);
@@ -261,36 +191,36 @@ function logTable(columns, data, footer) {
   const pad = (str, width, align) => {
     return align === "left" ? str.padEnd(width) : str.padStart(width);
   };
-  const headerRow = columns.map((col) => pad(col.header, widths[col.header], col.align)).join(import_picocolors.default.gray(" | "));
-  console.log(import_picocolors.default.gray(headerRow));
+  const headerRow = columns.map((col) => pad(col.header, widths[col.header], col.align)).join(pc.gray(" | "));
+  console.log(pc.gray(headerRow));
   const separator = columns.map((col) => "-".repeat(widths[col.header])).join(" | ");
-  console.log(import_picocolors.default.gray(separator));
+  console.log(pc.gray(separator));
   for (const row of data) {
     const rowStr = columns.map((col) => {
       const value = row[col.header] || "";
       const padded = pad(value, widths[col.header], col.align);
       return col.color ? col.color(padded) : padded;
-    }).join(import_picocolors.default.gray(" | "));
+    }).join(pc.gray(" | "));
     console.log(rowStr);
   }
-  console.log(import_picocolors.default.gray(separator));
+  console.log(pc.gray(separator));
   if (footer) {
     const footerRow = columns.map((col) => {
       const value = footer[col.header] || "";
       const padded = pad(value, widths[col.header], col.align);
       return padded;
-    }).join(import_picocolors.default.gray(" | "));
+    }).join(pc.gray(" | "));
     console.log(footerRow);
   }
 }
-var import_picocolors, silent = false, logger;
+var silent = false, logger;
 var init_logger = __esm(() => {
-  import_picocolors = __toESM(require_picocolors(), 1);
   logger = Logger.getInstance();
 });
 
 // src/errors.ts
-var import_picocolors2, BunupError, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, BunupPluginError, parseErrorMessage = (error) => {
+import pc2 from "picocolors";
+var BunupError, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, BunupPluginError, parseErrorMessage = (error) => {
   if (error instanceof Error) {
     return error.message;
   }
@@ -314,7 +244,7 @@ var import_picocolors2, BunupError, BunupBuildError, BunupDTSBuildError, BunupCL
   }
   const knownError = KNOWN_ERRORS.find((error2) => error2.pattern.test(errorMessage) && (error2.errorType === errorType || !error2.errorType));
   if (!knownError && errorType) {
-    console.error(`${import_picocolors2.default.red(errorType)} ${contextPrefix}${errorMessage}`);
+    console.error(`${pc2.red(errorType)} ${contextPrefix}${errorMessage}`);
   }
   if (knownError) {
     console.log(`
@@ -323,14 +253,13 @@ var import_picocolors2, BunupError, BunupBuildError, BunupDTSBuildError, BunupCL
     console.log(`
 `);
   } else {
-    console.error(import_picocolors2.default.dim(import_picocolors2.default.white("If you think this is a bug, please open an issue at: ") + import_picocolors2.default.cyan("https://github.com/arshad-yaseen/bunup/issues/new")));
+    console.error(pc2.dim(pc2.white("If you think this is a bug, please open an issue at: ") + pc2.cyan("https://github.com/arshad-yaseen/bunup/issues/new")));
   }
 }, handleErrorAndExit = (error, context) => {
   handleError(error, context);
   process.exit(1);
 };
 var init_errors = __esm(() => {
-  import_picocolors2 = __toESM(require_picocolors(), 1);
   init_logger();
   BunupError = class BunupError extends Error {
     constructor(message) {
@@ -373,8 +302,8 @@ var init_errors = __esm(() => {
       pattern: /Could not resolve: "bun"/i,
       errorType: "BUILD ERROR",
       logSolution: () => {
-        logger.error(import_picocolors2.default.white("You're trying to build a project that uses Bun. ") + import_picocolors2.default.white("Please set the target option to ") + import_picocolors2.default.cyan("`bun`") + import_picocolors2.default.white(`.
-`) + import_picocolors2.default.white("Example: ") + import_picocolors2.default.green("`bunup --target bun`") + import_picocolors2.default.white(" or in config: ") + import_picocolors2.default.green("{ target: 'bun' }"));
+        logger.error(pc2.white("You're trying to build a project that uses Bun. ") + pc2.white("Please set the target option to ") + pc2.cyan("`bun`") + pc2.white(`.
+`) + pc2.white("Example: ") + pc2.green("`bunup --target bun`") + pc2.white(" or in config: ") + pc2.green("{ target: 'bun' }"));
       }
     }
   ];
@@ -700,8 +629,8 @@ import path3 from "path";
 init_logger();
 
 // src/plugins/utils.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
 init_errors();
+import pc3 from "picocolors";
 function filterBunupBunPlugins(plugins) {
   if (!plugins)
     return [];
@@ -735,7 +664,7 @@ async function getPackageForPlugin(name, pluginName) {
   try {
     pkg = await import(name);
   } catch {
-    throw new BunupPluginError(`[${import_picocolors3.default.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${import_picocolors3.default.blue(`bun add ${name} --dev`)}`);
+    throw new BunupPluginError(`[${pc3.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${pc3.blue(`bun add ${name} --dev`)}`);
   }
   return pkg;
 }
@@ -824,10 +753,10 @@ function copy(patterns, outPath) {
   };
 }
 // src/plugins/internal/report.ts
-var import_picocolors4 = __toESM(require_picocolors(), 1);
 init_logger();
 init_logger();
 init_utils();
+import pc4 from "picocolors";
 function report() {
   return {
     type: "bunup",
@@ -854,12 +783,12 @@ function report() {
         const totalGzipSize = files.reduce((sum, file) => sum + (file.gzipSize || 0), 0);
         const formattedTotalGzipSize = formatFileSize(totalGzipSize);
         const columns = [
-          { header: "File", align: "left", color: import_picocolors4.default.blue },
-          { header: "Size", align: "right", color: import_picocolors4.default.green },
+          { header: "File", align: "left", color: pc4.blue },
+          { header: "Size", align: "right", color: pc4.green },
           {
             header: "Gzip",
             align: "right",
-            color: import_picocolors4.default.magenta
+            color: pc4.magenta
           }
         ];
         const data = files.map((file) => {