bunup 0.8.29 → 0.8.30

package/dist/cli/index.cjs

@@ -0,0 +1,2030 @@
+#!/usr/bin/env bun
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports2, module2) => {
+  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")
+    };
+  };
+  module2.exports = createColors();
+  module2.exports.createColors = createColors;
+});
+
+// src/logger.ts
+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);
+  }
+  space() {
+    if (silent)
+      return;
+    console.log("");
+  }
+  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);
+  }
+}
+function logTable(columns, data, footer) {
+  if (silent)
+    return;
+  const widths = {};
+  for (const col of columns) {
+    const headerLength = col.header.length;
+    const dataLengths = data.map((row) => row[col.header]?.length || 0);
+    const footerLength = footer ? footer[col.header]?.length || 0 : 0;
+    widths[col.header] = Math.max(headerLength, ...dataLengths, footerLength);
+  }
+  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 separator = columns.map((col) => "-".repeat(widths[col.header])).join(" | ");
+  console.log(import_picocolors.default.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(" | "));
+    console.log(rowStr);
+  }
+  console.log(import_picocolors.default.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(" | "));
+    console.log(footerRow);
+  }
+}
+var import_picocolors, silent = false, logger;
+var init_logger = __esm(() => {
+  import_picocolors = __toESM(require_picocolors());
+  logger = Logger.getInstance();
+});
+
+// src/errors.ts
+var import_picocolors2, BunupError, BunupBuildError, BunupDTSBuildError, BunupCLIError, BunupWatchError, BunupPluginError, parseErrorMessage = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}, KNOWN_ERRORS, handleError = (error, context) => {
+  const errorMessage = parseErrorMessage(error);
+  const contextPrefix = context ? `[${context}] ` : "";
+  let errorType = "UNKNOWN ERROR";
+  if (error instanceof BunupBuildError) {
+    errorType = "BUILD ERROR";
+  } else if (error instanceof BunupDTSBuildError) {
+    errorType = "DTS ERROR";
+  } else if (error instanceof BunupCLIError) {
+    errorType = "CLI ERROR";
+  } else if (error instanceof BunupWatchError) {
+    errorType = "WATCH ERROR";
+  } else if (error instanceof BunupPluginError) {
+    errorType = "PLUGIN ERROR";
+  } else if (error instanceof BunupError) {
+    errorType = "BUNUP ERROR";
+  }
+  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}`);
+  }
+  if (knownError) {
+    console.log(`
+`);
+    knownError.logSolution(errorMessage);
+    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")));
+  }
+}, handleErrorAndExit = (error, context) => {
+  handleError(error, context);
+  process.exit(1);
+};
+var init_errors = __esm(() => {
+  import_picocolors2 = __toESM(require_picocolors());
+  init_logger();
+  BunupError = class BunupError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "BunupError";
+    }
+  };
+  BunupBuildError = class BunupBuildError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupBuildError";
+    }
+  };
+  BunupDTSBuildError = class BunupDTSBuildError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupDTSBuildError";
+    }
+  };
+  BunupCLIError = class BunupCLIError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupCLIError";
+    }
+  };
+  BunupWatchError = class BunupWatchError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupWatchError";
+    }
+  };
+  BunupPluginError = class BunupPluginError extends BunupError {
+    constructor(message) {
+      super(message);
+      this.name = "BunupPluginError";
+    }
+  };
+  KNOWN_ERRORS = [
+    {
+      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' }"));
+      }
+    }
+  ];
+});
+
+// src/loaders.ts
+async function processLoadedConfigs(config, cwd, filter) {
+  return Array.isArray(config) && "root" in config[0] ? config.filter((c) => filter ? filter.includes(c.name) : true).map((c) => ({
+    rootDir: import_node_path.default.resolve(cwd, c.root),
+    options: addField(c.config, "name", c.name)
+  })) : [
+    {
+      rootDir: cwd,
+      options: config
+    }
+  ];
+}
+function addField(objectOrArray, field, value) {
+  return Array.isArray(objectOrArray) ? objectOrArray.map((o) => ({ ...o, [field]: value })) : { ...objectOrArray, [field]: value };
+}
+async function loadPackageJson(cwd = process.cwd()) {
+  const { config, filepath } = await import_coffi.loadConfig({
+    name: "package",
+    cwd,
+    extensions: [".json"]
+  });
+  return {
+    data: config,
+    path: filepath
+  };
+}
+var import_node_path, import_coffi;
+var init_loaders = __esm(() => {
+  import_node_path = __toESM(require("path"));
+  import_coffi = require("coffi");
+});
+
+// src/utils.ts
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+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 removeExtension(filePath) {
+  const basename = import_node_path2.default.basename(filePath);
+  const firstDotIndex = basename.indexOf(".");
+  if (firstDotIndex === -1) {
+    return filePath;
+  }
+  const nameWithoutExtensions = basename.slice(0, firstDotIndex);
+  const directory = import_node_path2.default.dirname(filePath);
+  return directory === "." ? nameWithoutExtensions : import_node_path2.default.join(directory, nameWithoutExtensions);
+}
+function isModulePackage(packageType) {
+  return packageType === "module";
+}
+function formatTime(ms) {
+  return ms >= 1000 ? `${(ms / 1000).toFixed(2)}s` : `${Math.round(ms)}ms`;
+}
+function getPackageDeps(packageJson) {
+  if (!packageJson)
+    return [];
+  return Array.from(new Set([
+    ...Object.keys(packageJson.dependencies || {}),
+    ...Object.keys(packageJson.peerDependencies || {})
+  ]));
+}
+function formatFileSize(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  if (i === 0)
+    return `${bytes} ${units[i]}`;
+  return `${(bytes / 1024 ** i).toFixed(2)} ${units[i]}`;
+}
+function getShortFilePath(filePath, maxLength = 3) {
+  const fileParts = filePath.split("/");
+  const shortPath = fileParts.slice(-maxLength).join("/");
+  return shortPath;
+}
+async function cleanOutDir(rootDir, outDir) {
+  const outDirPath = import_node_path2.default.join(rootDir, outDir);
+  try {
+    await import_promises.default.rm(outDirPath, { recursive: true, force: true });
+  } catch (error) {
+    throw new BunupBuildError(`Failed to clean output directory: ${error}`);
+  }
+  await import_promises.default.mkdir(outDirPath, { recursive: true });
+}
+function cleanPath(path3) {
+  let cleaned = import_node_path2.normalize(path3).replace(/\\/g, "/");
+  cleaned = cleaned.replace(/^[a-zA-Z]:\//, "");
+  cleaned = cleaned.replace(/^\/+/, "");
+  cleaned = cleaned.replace(/\/+/g, "/");
+  return cleaned;
+}
+function isDirectoryPath(filePath) {
+  return import_node_path2.default.extname(filePath) === "";
+}
+function pathExistsSync(filePath) {
+  try {
+    import_node_fs.default.accessSync(filePath);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function formatListWithAnd(arr) {
+  return new Intl.ListFormat("en", {
+    style: "long",
+    type: "conjunction"
+  }).format(arr);
+}
+async function getFilesFromGlobs(patterns, cwd) {
+  const includePatterns = patterns.filter((p) => !p.startsWith("!"));
+  const excludePatterns = patterns.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
+  const includedFiles = new Set;
+  for (const pattern of includePatterns) {
+    const glob = new Bun.Glob(pattern);
+    for await (const file of glob.scan(cwd)) {
+      includedFiles.add(file);
+    }
+  }
+  if (excludePatterns.length > 0) {
+    for (const pattern of excludePatterns) {
+      const glob = new Bun.Glob(pattern);
+      for await (const file of glob.scan(cwd)) {
+        includedFiles.delete(file);
+      }
+    }
+  }
+  return Array.from(includedFiles);
+}
+var import_node_fs, import_promises, import_node_path2;
+var init_utils = __esm(() => {
+  import_node_fs = __toESM(require("fs"));
+  import_promises = __toESM(require("fs/promises"));
+  import_node_path2 = __toESM(require("path"));
+  init_errors();
+});
+
+// src/cli/utils.ts
+function displayBunupGradientArt() {
+  const art = `
+\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D 
+\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551     
+\u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D     
+	`.trim();
+  const lines = art.split(`
+`);
+  logger.space();
+  for (const line of lines) {
+    logger.output(import_picocolors7.default.cyan(line));
+  }
+  logger.space();
+}
+var import_picocolors7;
+var init_utils2 = __esm(() => {
+  import_picocolors7 = __toESM(require_picocolors());
+  init_logger();
+});
+
+// src/cli/new.ts
+var exports_new = {};
+__export(exports_new, {
+  newProject: () => newProject
+});
+async function newProject() {
+  displayBunupGradientArt();
+  import_prompts.intro(import_picocolors8.default.bgCyan(import_picocolors8.default.black(" Scaffold a new project with Bunup ")));
+  const selectedTemplateDir = await import_prompts.select({
+    message: "Select a template",
+    options: TEMPLATES.map((template2) => ({
+      value: template2.dir,
+      label: import_picocolors8.default.blue(template2.name)
+    }))
+  });
+  const template = TEMPLATES.find((t) => t.dir === selectedTemplateDir);
+  if (!template) {
+    import_prompts.cancel("Invalid template");
+    process.exit(1);
+  }
+  const hasMonorepo = template.monorepoDir !== undefined;
+  const projectName = await import_prompts.text({
+    message: "Enter the project name",
+    placeholder: template.defaultName,
+    defaultValue: template.defaultName,
+    validate: (value) => {
+      if (!value) {
+        return "Project name is required";
+      }
+      if (value.includes(" ")) {
+        return "Project name cannot contain spaces";
+      }
+      if (pathExistsSync(getProjectPath(value))) {
+        return "Project already exists";
+      }
+    }
+  });
+  const projectPath = getProjectPath(projectName);
+  let useMonorepo = false;
+  let monorepoFirstPackageName;
+  if (hasMonorepo) {
+    useMonorepo = await import_prompts.confirm({
+      message: "Do you want to create a monorepo?",
+      initialValue: false
+    });
+    if (useMonorepo) {
+      monorepoFirstPackageName = await import_prompts.text({
+        message: "Enter the name of the first package",
+        placeholder: MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER,
+        defaultValue: MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER
+      });
+    }
+  }
+  const githubRepoInfo = await import_prompts.text({
+    message: "GitHub username and repo name (username/repo):",
+    placeholder: `${GITHUB_USERNAME_PLACEHOLDER}/${GITHUB_REPO_PLACEHOLDER}`,
+    defaultValue: `${GITHUB_USERNAME_PLACEHOLDER}/${GITHUB_REPO_PLACEHOLDER}`
+  });
+  const [githubUsername, githubRepoName] = githubRepoInfo.split("/");
+  await import_prompts.tasks([
+    {
+      title: "Creating project",
+      task: async () => {
+        const templatePath = useMonorepo ? template.monorepoDir : template.dir;
+        await import_giget.downloadTemplate(`github:${TEMPLATE_OWNER}/${TEMPLATE_REPO}/${templatePath}`, {
+          dir: projectPath
+        });
+        return "Template downloaded";
+      }
+    },
+    {
+      title: "Making the project yours",
+      task: async () => {
+        await import_replace_in_file.replaceInFile({
+          files: import_node_path8.default.join(projectPath, "**/*"),
+          from: [
+            new RegExp(GITHUB_REPO_PLACEHOLDER, "g"),
+            new RegExp(GITHUB_USERNAME_PLACEHOLDER, "g"),
+            new RegExp(template.defaultName, "g")
+          ],
+          to: [githubRepoName, githubUsername, projectName],
+          ignore: ["node_modules", "dist", "bun.lock"]
+        });
+        if (useMonorepo && monorepoFirstPackageName) {
+          await import_replace_in_file.replaceInFile({
+            files: import_node_path8.default.join(projectPath, "**/*"),
+            from: [new RegExp(MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER, "g")],
+            to: [monorepoFirstPackageName],
+            ignore: ["node_modules", "dist", "bun.lock"]
+          });
+          import_node_fs2.renameSync(import_node_path8.default.join(projectPath, MONOREPO_PACKAGES_DIR, MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER), import_node_path8.default.join(projectPath, MONOREPO_PACKAGES_DIR, monorepoFirstPackageName));
+        }
+      }
+    }
+  ]);
+  import_prompts.outro(`
+		${import_picocolors8.default.green("\u2728 Project scaffolded successfully! \u2728")} 
+	    
+		${import_picocolors8.default.bold("Ready to launch your awesome new project?")}
+		
+		${import_picocolors8.default.cyan("cd")} ${projectName}
+		${import_picocolors8.default.cyan("bun install")}
+		${import_picocolors8.default.cyan("bun run dev")}
+		
+		${import_picocolors8.default.dim("Learn more:")} ${import_picocolors8.default.underline("https://bunup.dev/docs")}
+		
+		${import_picocolors8.default.yellow("Happy coding!")} \uD83D\uDE80
+		`);
+}
+function getProjectPath(projectName) {
+  return import_node_path8.default.join(process.cwd(), projectName);
+}
+var import_node_fs2, import_node_path8, import_prompts, import_giget, import_picocolors8, import_replace_in_file, TEMPLATE_OWNER = "arshad-yaseen", TEMPLATE_REPO = "bunup-new", GITHUB_USERNAME_PLACEHOLDER = "username", GITHUB_REPO_PLACEHOLDER = "repo-name", MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER = "package-1", MONOREPO_PACKAGES_DIR = "packages", TEMPLATES;
+var init_new = __esm(() => {
+  import_node_fs2 = require("fs");
+  import_node_path8 = __toESM(require("path"));
+  import_prompts = require("@clack/prompts");
+  import_giget = require("giget");
+  import_picocolors8 = __toESM(require_picocolors());
+  import_replace_in_file = require("replace-in-file");
+  init_utils();
+  init_utils2();
+  TEMPLATES = [
+    {
+      defaultName: "my-ts-lib",
+      name: "Typescript Library",
+      dir: "ts-lib",
+      monorepoDir: "ts-lib-monorepo"
+    },
+    {
+      defaultName: "my-react-lib",
+      name: "React Library",
+      dir: "react-lib"
+    }
+  ];
+});
+
+// src/cli/init.ts
+var exports_init = {};
+__export(exports_init, {
+  init: () => init
+});
+async function init() {
+  displayBunupGradientArt();
+  import_prompts2.intro(import_picocolors9.default.bgCyan(import_picocolors9.default.black(" Initialize bunup in an existing project ")));
+  const { path: packageJsonPath } = await loadPackageJson();
+  if (!packageJsonPath) {
+    import_prompts2.log.error("package.json not found");
+    process.exit(1);
+  }
+  const shouldSetupWorkspace = await promptForWorkspace();
+  if (shouldSetupWorkspace) {
+    await initializeWorkspace(packageJsonPath);
+  } else {
+    await initializeSinglePackage(packageJsonPath);
+  }
+  await import_prompts2.tasks([
+    {
+      title: "Installing bunup",
+      task: async () => {
+        await installBunup();
+        return "Bunup installed";
+      }
+    }
+  ]);
+  showSuccessOutro(shouldSetupWorkspace);
+}
+async function promptForWorkspace() {
+  return await import_prompts2.confirm({
+    message: "Do you want to setup a Bunup workspace? (for building multiple packages with one command)",
+    initialValue: false
+  });
+}
+async function initializeWorkspace(packageJsonPath) {
+  const workspacePackages = await collectWorkspacePackages();
+  const configMethod = await selectWorkspaceConfigurationMethod();
+  await generateWorkspaceConfiguration(configMethod, workspacePackages);
+  await handleWorkspaceBuildScripts(packageJsonPath);
+}
+async function initializeSinglePackage(packageJsonPath) {
+  const entryFiles = await collectEntryFiles();
+  const outputFormats = await selectOutputFormats();
+  const shouldGenerateDts = await promptForTypeScriptDeclarations(entryFiles);
+  const configMethod = await selectConfigurationMethod();
+  await generateConfiguration(configMethod, entryFiles, outputFormats, shouldGenerateDts, packageJsonPath);
+  await handleBuildScripts(packageJsonPath, entryFiles, outputFormats, shouldGenerateDts, configMethod);
+}
+async function collectWorkspacePackages() {
+  const packages = [];
+  while (true) {
+    const packageName = await import_prompts2.text({
+      message: packages.length > 0 ? "Enter the next package name:" : "Enter the first package name:",
+      placeholder: "core",
+      validate: (value) => {
+        if (!value)
+          return "Package name is required";
+        if (packages.some((pkg) => pkg.name === value))
+          return "Package name already exists";
+      }
+    });
+    const packageRoot = await import_prompts2.text({
+      message: `Enter the root directory for "${packageName}":`,
+      placeholder: `packages/${packageName}`,
+      defaultValue: `packages/${packageName}`,
+      validate: (value) => {
+        if (!value)
+          return "Package root is required";
+        if (!import_node_fs3.default.existsSync(value))
+          return "Package root directory does not exist";
+        if (!import_node_fs3.default.statSync(value).isDirectory())
+          return "Package root must be a directory";
+      }
+    });
+    const entryFiles = await collectEntryFilesForPackage(packageRoot, packageName);
+    const outputFormats = await selectOutputFormats();
+    const shouldGenerateDts = await promptForTypeScriptDeclarations(entryFiles);
+    packages.push({
+      name: packageName,
+      root: packageRoot,
+      entryFiles,
+      outputFormats,
+      shouldGenerateDts
+    });
+    const shouldAddMore = await import_prompts2.confirm({
+      message: "Do you want to add another package?",
+      initialValue: true
+    });
+    if (!shouldAddMore)
+      break;
+  }
+  return packages;
+}
+async function collectEntryFilesForPackage(packageRoot, packageName) {
+  const entryFiles = [];
+  while (true) {
+    const entryFile = await import_prompts2.text({
+      message: entryFiles.length > 0 ? `Where is the next entry file for "${packageName}"? (relative to ${packageRoot})` : `Where is the entry file for "${packageName}"? (relative to ${packageRoot})`,
+      placeholder: "src/index.ts",
+      defaultValue: "src/index.ts",
+      validate: (value) => {
+        if (!value)
+          return "Entry file is required";
+        const fullPath = import_node_path9.default.join(packageRoot, value);
+        if (!import_node_fs3.default.existsSync(fullPath))
+          return `Entry file does not exist at ${fullPath}`;
+        if (!import_node_fs3.default.statSync(fullPath).isFile())
+          return "Entry file must be a file";
+        if (entryFiles.includes(value))
+          return "You have already added this entry file";
+      }
+    });
+    entryFiles.push(entryFile);
+    const shouldAddMore = await import_prompts2.confirm({
+      message: "Do you want to add another entry file for this package?",
+      initialValue: false
+    });
+    if (!shouldAddMore)
+      break;
+  }
+  return entryFiles;
+}
+async function collectEntryFiles() {
+  const entryFiles = [];
+  while (true) {
+    const entryFile = await import_prompts2.text({
+      message: entryFiles.length > 0 ? "Where is your next entry file?" : "Where is your entry file?",
+      placeholder: "src/index.ts",
+      defaultValue: "src/index.ts",
+      validate: (value) => {
+        if (!value)
+          return "Entry file is required";
+        if (!import_node_fs3.default.existsSync(value))
+          return "Entry file does not exist";
+        if (!import_node_fs3.default.statSync(value).isFile())
+          return "Entry file must be a file";
+        if (entryFiles.includes(value))
+          return "You have already added this entry file";
+      }
+    });
+    entryFiles.push(entryFile);
+    const shouldAddMore = await import_prompts2.confirm({
+      message: "Do you want to add another entry file?",
+      initialValue: false
+    });
+    if (!shouldAddMore)
+      break;
+  }
+  return entryFiles;
+}
+async function selectOutputFormats() {
+  return await import_prompts2.multiselect({
+    message: "Select the output formats",
+    options: [
+      { value: "esm", label: "ESM (.mjs)" },
+      { value: "cjs", label: "CommonJS (.cjs)" },
+      { value: "iife", label: "IIFE (.global.js)" }
+    ],
+    initialValues: ["esm", "cjs"]
+  });
+}
+async function promptForTypeScriptDeclarations(entryFiles) {
+  const hasTypeScriptFiles = entryFiles.some((file) => file.endsWith(".ts") || file.endsWith(".tsx"));
+  if (!hasTypeScriptFiles)
+    return false;
+  return await import_prompts2.confirm({
+    message: "Generate TypeScript declarations?",
+    initialValue: true
+  });
+}
+async function selectWorkspaceConfigurationMethod() {
+  return await import_prompts2.select({
+    message: "How would you like to configure your workspace?",
+    options: [
+      { value: "ts", label: "bunup.config.ts", hint: "Recommended" },
+      { value: "js", label: "bunup.config.js" }
+    ],
+    initialValue: "ts"
+  });
+}
+async function selectConfigurationMethod() {
+  return await import_prompts2.select({
+    message: "How would you like to configure Bunup?",
+    options: [
+      { value: "ts", label: "bunup.config.ts", hint: "Recommended" },
+      { value: "js", label: "bunup.config.js" },
+      { value: "json", label: 'package.json "bunup" property' },
+      {
+        value: "none",
+        label: "No config file",
+        hint: "Configure via CLI only"
+      }
+    ],
+    initialValue: "ts"
+  });
+}
+async function generateWorkspaceConfiguration(configMethod, workspacePackages) {
+  const configContent = createWorkspaceConfigFileContent(workspacePackages);
+  await Bun.write(`bunup.config.${configMethod}`, configContent);
+}
+async function generateConfiguration(configMethod, entryFiles, outputFormats, shouldGenerateDts, packageJsonPath) {
+  if (configMethod === "none") {
+    import_prompts2.log.info("If you need more control (such as adding plugins or customizing output), you can always create a config file later.");
+    return;
+  }
+  if (configMethod === "ts" || configMethod === "js") {
+    await Bun.write(`bunup.config.${configMethod}`, createConfigFileContent(entryFiles, outputFormats, shouldGenerateDts));
+  } else if (configMethod === "json") {
+    const { data: packageJsonConfig } = await loadPackageJson();
+    const updatedConfig = {
+      ...packageJsonConfig,
+      bunup: createPackageJsonConfig(entryFiles, outputFormats, shouldGenerateDts)
+    };
+    await Bun.write(packageJsonPath, JSON.stringify(updatedConfig, null, 2));
+  }
+}
+async function handleWorkspaceBuildScripts(packageJsonPath) {
+  const { data: packageJsonConfig } = await loadPackageJson();
+  const existingScripts = packageJsonConfig?.scripts ?? {};
+  const newScripts = createWorkspaceBuildScripts();
+  const conflictingScripts = Object.keys(newScripts).filter((script) => existingScripts[script]);
+  if (conflictingScripts.length > 0) {
+    const shouldOverride = await import_prompts2.confirm({
+      message: `The ${formatListWithAnd(conflictingScripts)} ${conflictingScripts.length > 1 ? "scripts already exist" : "script already exists"} in package.json. Override ${conflictingScripts.length > 1 ? "them" : "it"}?`,
+      initialValue: true
+    });
+    if (!shouldOverride) {
+      import_prompts2.log.info("Skipped adding build scripts to avoid conflicts.");
+      return;
+    }
+  }
+  const updatedConfig = {
+    ...packageJsonConfig,
+    scripts: { ...existingScripts, ...newScripts }
+  };
+  await Bun.write(packageJsonPath, JSON.stringify(updatedConfig, null, 2));
+}
+async function handleBuildScripts(packageJsonPath, entryFiles, outputFormats, shouldGenerateDts, configMethod) {
+  const { data: packageJsonConfig } = await loadPackageJson();
+  const existingScripts = packageJsonConfig?.scripts ?? {};
+  const newScripts = createBuildScripts(entryFiles, outputFormats, shouldGenerateDts, configMethod);
+  const conflictingScripts = Object.keys(newScripts).filter((script) => existingScripts[script]);
+  if (conflictingScripts.length > 0) {
+    const shouldOverride = await import_prompts2.confirm({
+      message: `The ${formatListWithAnd(conflictingScripts)} ${conflictingScripts.length > 1 ? "scripts already exist" : "script already exists"} in package.json. Override ${conflictingScripts.length > 1 ? "them" : "it"}?`,
+      initialValue: true
+    });
+    if (!shouldOverride) {
+      import_prompts2.log.info("Skipped adding build scripts to avoid conflicts.");
+      return;
+    }
+  }
+  const updatedConfig = {
+    ...packageJsonConfig,
+    scripts: { ...existingScripts, ...newScripts }
+  };
+  await Bun.write(packageJsonPath, JSON.stringify(updatedConfig, null, 2));
+}
+function createWorkspaceConfigFileContent(workspacePackages) {
+  const packagesConfig = workspacePackages.map((pkg) => {
+    return `  {
+    name: '${pkg.name}',
+    root: '${pkg.root}',
+    config: {
+      entry: [${pkg.entryFiles.map((file) => `'${file}'`).join(", ")}],
+      format: [${pkg.outputFormats.map((format) => `'${format}'`).join(", ")}],${pkg.shouldGenerateDts ? `
+      dts: true,` : ""}
+    },
+  }`;
+  }).join(`,
+`);
+  return `import { defineWorkspace } from 'bunup'
+
+export default defineWorkspace([
+${packagesConfig}
+])
+`;
+}
+function createConfigFileContent(entryFiles, outputFormats, shouldGenerateDts) {
+  return `import { defineConfig } from 'bunup'
+
+export default defineConfig({
+	entry: [${entryFiles.map((file) => `'${file}'`).join(", ")}],
+	format: [${outputFormats.map((format) => `'${format}'`).join(", ")}],${shouldGenerateDts ? `
+	dts: true,` : ""}
+})
+`;
+}
+function createPackageJsonConfig(entryFiles, outputFormats, shouldGenerateDts) {
+  return {
+    entry: entryFiles,
+    format: outputFormats,
+    ...shouldGenerateDts && { dts: true }
+  };
+}
+function createWorkspaceBuildScripts() {
+  return {
+    build: "bunup",
+    dev: "bunup --watch"
+  };
+}
+function createBuildScripts(entryFiles, outputFormats, shouldGenerateDts, configMethod) {
+  const cliOptions = configMethod === "none" ? ` ${entryFiles.join(" ")} --format ${outputFormats.join(",")}${shouldGenerateDts ? " --dts" : ""}` : "";
+  return {
+    build: `bunup${cliOptions}`,
+    dev: `bunup${cliOptions} --watch`
+  };
+}
+function showSuccessOutro(isWorkspace) {
+  const buildCommand = isWorkspace ? `${import_picocolors9.default.cyan("bun run build")} - Build all packages in your workspace` : `${import_picocolors9.default.cyan("bun run build")} - Build your library`;
+  const devCommand = isWorkspace ? `${import_picocolors9.default.cyan("bun run dev")} - Start development mode (watches all packages)` : `${import_picocolors9.default.cyan("bun run dev")} - Start development mode`;
+  const filterCommand = isWorkspace ? `${import_picocolors9.default.cyan("bunup --filter core,utils")} - Build specific packages` : "";
+  import_prompts2.outro(`
+  ${import_picocolors9.default.green("\u2728 Bunup initialized successfully! \u2728")}
+  
+  ${buildCommand}
+  ${devCommand}${isWorkspace ? `
+  ${filterCommand}` : ""}
+  
+  ${import_picocolors9.default.dim("Learn more:")} ${import_picocolors9.default.underline("https://bunup.dev/docs/")}
+  
+  ${import_picocolors9.default.yellow("Happy building!")} \uD83D\uDE80
+  `);
+}
+async function installBunup() {
+  await import_tinyexec.exec("bun add -d bunup", [], {
+    nodeOptions: { shell: true, stdio: "pipe" }
+  });
+}
+var import_node_fs3, import_node_path9, import_prompts2, import_picocolors9, import_tinyexec;
+var init_init = __esm(() => {
+  import_node_fs3 = __toESM(require("fs"));
+  import_node_path9 = __toESM(require("path"));
+  import_prompts2 = require("@clack/prompts");
+  import_picocolors9 = __toESM(require_picocolors());
+  import_tinyexec = require("tinyexec");
+  init_loaders();
+  init_utils();
+  init_utils2();
+});
+
+// src/cli/index.ts
+var exports_cli = {};
+module.exports = __toCommonJS(exports_cli);
+var import_tinyexec2 = require("tinyexec");
+// package.json
+var version = "0.8.29";
+
+// src/cli/index.ts
+init_errors();
+init_logger();
+
+// src/cli/options.ts
+var import_picocolors3 = __toESM(require_picocolors());
+
+// src/constants/index.ts
+var BUNUP_CLI_OPTIONS_URL = "https://bunup.dev/docs/guide/cli-options";
+
+// src/cli/options.ts
+init_errors();
+init_logger();
+function booleanHandler(optionName) {
+  return (value, options) => {
+    options[optionName] = value === true || value === "true";
+  };
+}
+function stringHandler(optionName) {
+  return (value, options) => {
+    if (typeof value === "string") {
+      options[optionName] = value;
+    } else {
+      throw new BunupCLIError(`Option --${optionName} requires a string value`);
+    }
+  };
+}
+function arrayHandler(optionName) {
+  return (value, options) => {
+    if (typeof value === "string") {
+      options[optionName] = value.split(",");
+    } else {
+      throw new BunupCLIError(`Option --${optionName} requires a string value`);
+    }
+  };
+}
+function booleanOrStringHandler(optionName) {
+  return (value, options) => {
+    if (typeof value === "boolean") {
+      options[optionName] = value;
+    } else if (typeof value === "string") {
+      if (value.toLowerCase() === "true" || value.toLowerCase() === "false") {
+        options[optionName] = value.toLowerCase() === "true";
+      } else {
+        options[optionName] = value;
+      }
+    } else {
+      throw new BunupCLIError(`Option --${optionName} requires a boolean or string value`);
+    }
+  };
+}
+function showHelp() {
+  console.log(`
+Bunup - \u26A1\uFE0F A blazing-fast build tool for your libraries built with Bun.
+`);
+  console.log("For more information on available options, visit:");
+  console.log(`${import_picocolors3.default.cyan(import_picocolors3.default.underline(BUNUP_CLI_OPTIONS_URL))}
+`);
+  process.exit(0);
+}
+function showVersion() {
+  console.log(version);
+  process.exit(0);
+}
+var optionConfigs = {
+  name: { flags: ["n", "name"], handler: stringHandler("name") },
+  format: {
+    flags: ["f", "format"],
+    handler: arrayHandler("format")
+  },
+  outDir: { flags: ["o", "out-dir"], handler: stringHandler("outDir") },
+  minify: { flags: ["m", "minify"], handler: booleanHandler("minify") },
+  watch: { flags: ["w", "watch"], handler: booleanHandler("watch") },
+  dts: { flags: ["d", "dts"], handler: booleanHandler("dts") },
+  banner: { flags: ["bn", "banner"], handler: stringHandler("banner") },
+  footer: { flags: ["ft", "footer"], handler: stringHandler("footer") },
+  external: { flags: ["e", "external"], handler: arrayHandler("external") },
+  sourcemap: {
+    flags: ["sm", "sourcemap"],
+    handler: booleanOrStringHandler("sourcemap")
+  },
+  target: { flags: ["t", "target"], handler: stringHandler("target") },
+  minifyWhitespace: {
+    flags: ["mw", "minify-whitespace"],
+    handler: booleanHandler("minifyWhitespace")
+  },
+  minifyIdentifiers: {
+    flags: ["mi", "minify-identifiers"],
+    handler: booleanHandler("minifyIdentifiers")
+  },
+  minifySyntax: {
+    flags: ["ms", "minify-syntax"],
+    handler: booleanHandler("minifySyntax")
+  },
+  clean: { flags: ["c", "clean"], handler: booleanHandler("clean") },
+  splitting: {
+    flags: ["s", "splitting"],
+    handler: booleanHandler("splitting")
+  },
+  noExternal: {
+    flags: ["ne", "no-external"],
+    handler: arrayHandler("noExternal")
+  },
+  preferredTsconfigPath: {
+    flags: ["tsconfig", "preferred-tsconfig-path"],
+    handler: stringHandler("preferredTsconfigPath")
+  },
+  bytecode: {
+    flags: ["bc", "bytecode"],
+    handler: booleanHandler("bytecode")
+  },
+  silent: { flags: ["silent"], handler: booleanHandler("silent") },
+  config: { flags: ["config"], handler: stringHandler("config") },
+  publicPath: {
+    flags: ["pp", "public-path"],
+    handler: stringHandler("publicPath")
+  },
+  env: { flags: ["env"], handler: stringHandler("env") },
+  onSuccess: {
+    flags: ["onSuccess"],
+    handler: stringHandler("onSuccess")
+  },
+  filter: { flags: ["filter"], handler: arrayHandler("filter") },
+  new: { flags: ["new"], handler: booleanHandler("new") },
+  init: { flags: ["init"], handler: booleanHandler("init") },
+  entry: {
+    flags: ["entry"],
+    handler: (value, options, subPath) => {
+      if (typeof value !== "string") {
+        throw new BunupCLIError(`Entry${subPath ? ` --entry.${subPath}` : ""} requires a string value`);
+      }
+      const entries = Array.isArray(options.entry) ? [...options.entry] : [];
+      if (subPath) {
+        logger.warn(`Subpath '${subPath}' provided via --entry.${subPath}, but object entry format is not supported. Adding entry as string.`);
+      }
+      if (entries.includes(value)) {
+        logger.warn(`Duplicate entry '${value}' provided. Skipping.`);
+      } else {
+        entries.push(value);
+      }
+      options.entry = entries;
+    }
+  },
+  resolveDts: {
+    flags: ["rd", "resolve-dts"],
+    handler: (value, options) => {
+      if (!options.dts)
+        options.dts = {};
+      if (typeof options.dts === "boolean")
+        options.dts = {};
+      if (typeof value === "string") {
+        if (value === "true" || value === "false") {
+          options.dts.resolve = value === "true";
+        } else {
+          options.dts.resolve = value.split(",");
+        }
+      } else {
+        options.dts.resolve = true;
+      }
+    }
+  },
+  help: { flags: ["h", "help"], handler: () => showHelp() },
+  version: { flags: ["v", "version"], handler: () => showVersion() }
+};
+var flagToHandler = {};
+for (const config of Object.values(optionConfigs)) {
+  for (const flag of config.flags) {
+    flagToHandler[flag] = config.handler;
+  }
+}
+function parseCliOptions(argv) {
+  const options = {};
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      let key;
+      let value;
+      if (arg.includes("=")) {
+        const [keyPart, valuePart] = arg.slice(2).split("=", 2);
+        key = keyPart;
+        value = valuePart;
+      } else {
+        key = arg.slice(2);
+        const nextArg = argv[i + 1];
+        value = nextArg && !nextArg.startsWith("-") ? nextArg : true;
+        if (typeof value === "string")
+          i++;
+      }
+      if (key.includes(".")) {
+        const [mainOption, subPath] = key.split(".", 2);
+        const handler = flagToHandler[mainOption];
+        if (handler) {
+          handler(value, options, subPath);
+        } else {
+          throw new BunupCLIError(`Unknown option: --${key}`);
+        }
+      } else {
+        const handler = flagToHandler[key];
+        if (handler) {
+          handler(value, options);
+        } else {
+          throw new BunupCLIError(`Unknown option: --${key}`);
+        }
+      }
+    } else if (arg.startsWith("-")) {
+      const key = arg.slice(1);
+      const nextArg = argv[i + 1];
+      const value = nextArg && !nextArg.startsWith("-") ? nextArg : true;
+      if (typeof value === "string")
+        i++;
+      const handler = flagToHandler[key];
+      if (handler) {
+        handler(value, options);
+      } else {
+        throw new BunupCLIError(`Unknown option: -${key}`);
+      }
+    } else {
+      optionConfigs.entry.handler(arg, options, undefined);
+    }
+  }
+  return options;
+}
+
+// src/cli/index.ts
+var import_coffi2 = require("coffi");
+var import_picocolors10 = __toESM(require_picocolors());
+
+// src/build.ts
+var import_node_path6 = __toESM(require("path"));
+var import_bun_dts = require("bun-dts");
+init_errors();
+init_loaders();
+init_logger();
+
+// src/constants/re.ts
+var JS_RE = /\.(js|jsx|cjs|mjs)$/;
+var TS_RE = /\.(ts|tsx|mts|cts)$/;
+var DTS_RE = /\.(d\.(ts|mts|cts))$/;
+var JS_TS_RE = new RegExp(`${JS_RE.source}|${TS_RE.source}`);
+var JS_DTS_RE = new RegExp(`${JS_RE.source}|${DTS_RE.source}`);
+var CSS_RE = /\.(css)$/;
+
+// src/plugins/built-in/node/shims.ts
+function shims() {
+  return {
+    type: "bun",
+    name: "shims",
+    plugin: {
+      name: "bunup:shims",
+      setup(build) {
+        const isNodeCompatibleTarget = build.config.target === "node" || build.config.target === "bun";
+        const isEsm = build.config.format === "esm";
+        const isCjs = build.config.format === "cjs";
+        if (!isNodeCompatibleTarget || !isEsm && !isCjs) {
+          return;
+        }
+        build.config.define = {
+          ...build.config.define,
+          ...isCjs && {
+            "import.meta.url": "importMetaUrl"
+          }
+        };
+        build.onLoad({ filter: JS_TS_RE }, async ({ path: path2 }) => {
+          const content = await Bun.file(path2).text();
+          let shimCode = "";
+          if (isEsm && (/\b__dirname\b/.test(content) || /\b__filename\b/.test(content))) {
+            shimCode = `import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+`;
+          }
+          if (isCjs && /\bimport\.meta\.url\b/.test(content)) {
+            shimCode = `import { pathToFileURL } from 'url';
+
+const importMetaUrl = pathToFileURL(__filename).href;
+
+`;
+          }
+          if (!shimCode)
+            return;
+          const lines = content.split(`
+`);
+          const firstLine = lines[0];
+          const restLines = lines.slice(1);
+          return {
+            contents: [firstLine, shimCode, ...restLines].join(`
+`)
+          };
+        });
+      }
+    }
+  };
+}
+// src/plugins/built-in/productivity/exports.ts
+init_logger();
+init_utils();
+function exports2(options = {}) {
+  return {
+    type: "bunup",
+    name: "exports",
+    hooks: {
+      onBuildDone: async ({ output, options: buildOptions, meta }) => {
+        if (!meta.packageJson.path || !meta.packageJson.data) {
+          return;
+        }
+        try {
+          const { exportsField, entryPoints } = generateExportsFields(output.files);
+          const files = Array.isArray(meta.packageJson.data.files) ? [
+            ...new Set([
+              ...meta.packageJson.data.files,
+              buildOptions.outDir
+            ])
+          ] : [buildOptions.outDir];
+          const mergedExports = { ...exportsField };
+          if (options.extraExports) {
+            for (const [key, value] of Object.entries(options.extraExports)) {
+              if (typeof value === "string") {
+                mergedExports[key] = value;
+              } else {
+                const existingExport = mergedExports[key];
+                if (typeof existingExport === "object" && existingExport !== null) {
+                  mergedExports[key] = {
+                    ...existingExport,
+                    ...value
+                  };
+                } else {
+                  mergedExports[key] = value;
+                }
+              }
+            }
+          }
+          const newPackageJson = {
+            name: meta.packageJson.data.name,
+            description: meta.packageJson.data.description,
+            version: meta.packageJson.data.version,
+            type: meta.packageJson.data.type,
+            private: meta.packageJson.data.private,
+            files,
+            ...entryPoints,
+            exports: mergedExports
+          };
+          for (const key in meta.packageJson.data) {
+            if (Object.prototype.hasOwnProperty.call(meta.packageJson.data, key) && !Object.prototype.hasOwnProperty.call(newPackageJson, key)) {
+              newPackageJson[key] = meta.packageJson.data[key];
+            }
+          }
+          await Bun.write(meta.packageJson.path, JSON.stringify(newPackageJson, null, 2));
+          logger.cli("Updated package.json with exports");
+        } catch {
+          logger.error("Failed to update package.json");
+        }
+      }
+    }
+  };
+}
+function generateExportsFields(files) {
+  const exportsField = {};
+  const entryPoints = {};
+  const filteredFiles = filterFiles(files);
+  for (const file of filteredFiles) {
+    const exportType = formatToExportField(file.format, file.dts);
+    const relativePath = `./${cleanPath(file.relativePathToRootDir)}`;
+    const exportKey = getExportKey(cleanPath(file.relativePathToOutputDir));
+    exportsField[exportKey] = {
+      ...exportsField[exportKey],
+      [exportType]: relativePath
+    };
+  }
+  for (const field of Object.keys(exportsField["."] ?? {})) {
+    const entryPoint = exportFieldToEntryPoint(field);
+    entryPoints[entryPoint] = exportsField["."][field];
+  }
+  return { exportsField, entryPoints };
+}
+function filterFiles(files) {
+  return files.filter((file) => JS_DTS_RE.test(file.fullPath) && file.kind === "entry-point");
+}
+function getExportKey(relativePathToOutputDir) {
+  const pathSegments = cleanPath(removeExtension(relativePathToOutputDir)).split("/");
+  if (pathSegments.length === 1 && pathSegments[0].startsWith("index")) {
+    return ".";
+  }
+  return `./${pathSegments.filter((p) => !p.startsWith("index")).join("/")}`;
+}
+function exportFieldToEntryPoint(exportField) {
+  return exportField === "types" ? "types" : exportField === "require" ? "main" : "module";
+}
+function formatToExportField(format, dts) {
+  return dts ? "types" : format === "esm" ? "import" : "require";
+}
+// src/plugins/built-in/css/inject-styles.ts
+var import_node_path3 = __toESM(require("path"));
+init_logger();
+
+// src/plugins/utils.ts
+var import_picocolors4 = __toESM(require_picocolors());
+init_errors();
+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 });
+    }
+  }
+}
+async function getPackageForPlugin(name, pluginName) {
+  let pkg;
+  try {
+    pkg = await import(name);
+  } catch {
+    throw new BunupPluginError(`[${import_picocolors4.default.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${import_picocolors4.default.blue(`bun add ${name} --dev`)}`);
+  }
+  return pkg;
+}
+
+// src/plugins/built-in/css/inject-styles.ts
+function injectStyles(options) {
+  const { inject, ...transformOptions } = options ?? {};
+  return {
+    type: "bun",
+    name: "inject-styles",
+    plugin: {
+      name: "bunup:inject-styles",
+      async setup(build) {
+        const lightningcss = await getPackageForPlugin("lightningcss", "inject-styles");
+        build.onResolve({ filter: /^__inject-style$/ }, () => {
+          return {
+            path: "__inject-style",
+            namespace: "__inject-style"
+          };
+        });
+        build.onLoad({ filter: /^__inject-style$/, namespace: "__inject-style" }, () => {
+          return {
+            contents: `
+                      export default function injectStyle(css) {
+                        if (!css || typeof document === 'undefined') return
+                      
+                        const head = document.head || document.getElementsByTagName('head')[0]
+                        const style = document.createElement('style')
+                        head.appendChild(style)
+
+                        if (style.styleSheet) {
+                          style.styleSheet.cssText = css
+                        } else {
+                          style.appendChild(document.createTextNode(css))
+                        }
+                      }
+                      `,
+            loader: "js"
+          };
+        });
+        build.onLoad({ filter: CSS_RE }, async (args) => {
+          const source = await Bun.file(args.path).text();
+          const { code, warnings } = lightningcss.transform({
+            ...transformOptions,
+            filename: import_node_path3.default.basename(args.path),
+            code: Buffer.from(source),
+            minify: transformOptions.minify ?? (build.config.minify === true || typeof build.config.minify === "object" && build.config.minify.whitespace)
+          });
+          for (const warning of warnings) {
+            logger.warn(warning.message);
+          }
+          const stringifiedCode = JSON.stringify(code.toString());
+          const js = inject ? await inject(stringifiedCode, args.path) : `import injectStyle from '__inject-style';injectStyle(${stringifiedCode})`;
+          return {
+            contents: js,
+            loader: "js"
+          };
+        });
+      }
+    }
+  };
+}
+// src/plugins/built-in/productivity/copy.ts
+var import_node_path4 = require("path");
+var import_node_path5 = require("path");
+init_utils();
+function copy(patterns, outPath) {
+  return {
+    type: "bunup",
+    name: "copy",
+    hooks: {
+      onBuildDone: async ({ options, meta }) => {
+        const destinationPath = outPath || options.outDir;
+        for (const pattern of patterns) {
+          const glob = new Bun.Glob(pattern);
+          for await (const filePath of glob.scan({
+            cwd: meta.rootDir,
+            dot: true
+          })) {
+            const sourceFile = Bun.file(import_node_path4.join(meta.rootDir, filePath));
+            await Bun.write(outPath && isDirectoryPath(outPath) ? import_node_path4.join(destinationPath, import_node_path5.basename(filePath)) : destinationPath, sourceFile);
+          }
+        }
+      }
+    }
+  };
+}
+// src/plugins/internal/report.ts
+var import_picocolors5 = __toESM(require_picocolors());
+init_logger();
+init_logger();
+init_utils();
+function report() {
+  return {
+    type: "bunup",
+    name: "report",
+    hooks: {
+      onBuildDone: async ({ options, output }) => {
+        if (options.watch)
+          return;
+        const files = await Promise.all(output.files.map(async (file) => {
+          const name = file.relativePathToRootDir;
+          const size = Bun.file(file.fullPath).size;
+          const gzipSize = Bun.gzipSync(new Uint8Array(await Bun.file(file.fullPath).arrayBuffer())).length;
+          const formattedGzipSize = formatFileSize(gzipSize);
+          return {
+            name,
+            size,
+            formattedSize: formatFileSize(size),
+            gzipSize,
+            formattedGzipSize
+          };
+        }));
+        const totalSize = files.reduce((sum, file) => sum + file.size, 0);
+        const formattedTotalSize = formatFileSize(totalSize);
+        const totalGzipSize = files.reduce((sum, file) => sum + (file.gzipSize || 0), 0);
+        const formattedTotalGzipSize = formatFileSize(totalGzipSize);
+        const columns = [
+          { header: "File", align: "left", color: import_picocolors5.default.blue },
+          { header: "Size", align: "right", color: import_picocolors5.default.green },
+          {
+            header: "Gzip",
+            align: "right",
+            color: import_picocolors5.default.magenta
+          }
+        ];
+        const data = files.map((file) => {
+          return {
+            File: file.name,
+            Size: file.formattedSize,
+            Gzip: file.formattedGzipSize
+          };
+        });
+        const footer = {
+          File: "Total",
+          Size: formattedTotalSize,
+          Gzip: formattedTotalGzipSize
+        };
+        logger.space();
+        logTable(columns, data, footer);
+        logger.space();
+      }
+    }
+  };
+}
+// 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
+init_utils();
+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?.filter((p) => p.name !== "report") ?? [],
+      useClient(),
+      report()
+    ]
+  };
+}
+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;
+}
+var DEFAULT_ENTRY_NAMING = "[dir]/[name].[ext]";
+function getResolvedNaming(naming, fmt, packageType) {
+  const resolvedNaming = typeof naming === "object" ? { entry: DEFAULT_ENTRY_NAMING, ...naming } : naming ?? DEFAULT_ENTRY_NAMING;
+  const replaceExt = (pattern) => pattern.replace(".[ext]", getDefaultJsOutputExtension(fmt, packageType));
+  if (typeof resolvedNaming === "string") {
+    return replaceExt(resolvedNaming);
+  }
+  return {
+    ...resolvedNaming,
+    entry: replaceExt(resolvedNaming.entry)
+  };
+}
+function getResolvedEnv(env) {
+  return typeof env === "string" ? env : undefined;
+}
+
+// src/helpers/external.ts
+init_utils();
+function getPackageDepsPatterns(packageJson) {
+  return getPackageDeps(packageJson).map((dep) => new RegExp(`^${dep}($|\\/|\\\\)`));
+}
+function matchesPattern(path4, pattern) {
+  return typeof pattern === "string" ? pattern === path4 : pattern.test(path4);
+}
+function isExternal(path4, options, packageJson) {
+  const packageDepsPatterns = getPackageDepsPatterns(packageJson);
+  const matchesExternalPattern = packageDepsPatterns.some((pattern) => pattern.test(path4)) || options.external?.some((pattern) => matchesPattern(path4, pattern));
+  const isExcludedFromExternal = options.noExternal?.some((pattern) => matchesPattern(path4, 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/build.ts
+init_utils();
+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 packageType = packageJson.data?.type;
+  const plugins = [
+    externalOptionPlugin(options, packageJson.data),
+    ...filterBunupBunPlugins(options.plugins).map((p) => p.plugin)
+  ];
+  if (options.dts) {
+    const { resolve, entry, splitting } = typeof options.dts === "object" ? options.dts : {};
+    let entrypoints2;
+    if (entry) {
+      entrypoints2 = await getFilesFromGlobs(ensureArray(entry), rootDir);
+    }
+    if (Array.isArray(entrypoints2) && !entrypoints2.length) {
+      throw new BunupDTSBuildError("The dts entrypoints you provided do not exist. Please make sure the entrypoints point to valid files.");
+    }
+    plugins.push(import_bun_dts.dts({
+      resolve,
+      preferredTsConfigPath: options.preferredTsconfigPath,
+      entry: entrypoints2,
+      cwd: rootDir,
+      splitting,
+      onDeclarationsGenerated({ results, buildConfig }) {
+        for (const result of results) {
+          logger.progress("DTS", `${options.outDir}/${result.outputPath}`, {
+            identifier: options.name
+          });
+          const fullPath = import_node_path6.default.join(rootDir, options.outDir, result.outputPath);
+          if (buildConfig.format) {
+            buildOutput.files.push({
+              fullPath,
+              relativePathToRootDir: getRelativePathToRootDir(fullPath, rootDir),
+              relativePathToOutputDir: result.outputPath,
+              dts: true,
+              format: buildConfig.format,
+              kind: result.kind
+            });
+          }
+        }
+      }
+    }));
+  }
+  const entrypoints = await getFilesFromGlobs(ensureArray(options.entry), rootDir);
+  if (!entrypoints.length) {
+    throw new BunupBuildError("The entrypoints you provided do not exist. Please make sure the entrypoints point to valid files.");
+  }
+  const buildPromises = options.format.flatMap(async (fmt) => {
+    const result = await Bun.build({
+      entrypoints: entrypoints.map((file) => `${rootDir}/${file}`),
+      format: fmt,
+      naming: getResolvedNaming(options.naming, fmt, packageType),
+      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") {
+        throw new BunupBuildError(log.message);
+      }
+      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,
+        relativePathToOutputDir: getRelativePathToOutputDir(relativePathToRootDir, options.outDir),
+        dts: false,
+        format: fmt,
+        kind: file.kind
+      });
+    }
+  });
+  await Promise.all(buildPromises);
+  await runPluginBuildDoneHooks(bunupPlugins, options, buildOutput, {
+    packageJson,
+    rootDir
+  });
+  if (options.onSuccess) {
+    await options.onSuccess(options);
+  }
+}
+function getRelativePathToRootDir(filePath, rootDir) {
+  return cleanPath(filePath).replace(`${cleanPath(rootDir)}/`, "");
+}
+function getRelativePathToOutputDir(relativePathToRootDir, outDir) {
+  return cleanPath(relativePathToRootDir).replace(`${cleanPath(outDir)}/`, "");
+}
+
+// src/cli/index.ts
+init_loaders();
+init_utils();
+
+// src/watch.ts
+var import_node_path7 = __toESM(require("path"));
+var import_picocolors6 = __toESM(require_picocolors());
+init_errors();
+init_logger();
+init_utils();
+async function watch(partialOptions, rootDir) {
+  const watchPaths = new Set;
+  const options = createBuildOptions(partialOptions);
+  const uniqueEntries = new Set(options.entry);
+  for (const entry of uniqueEntries) {
+    const entryPath = import_node_path7.default.resolve(rootDir, entry);
+    const parentDir = import_node_path7.default.dirname(entryPath);
+    watchPaths.add(parentDir);
+  }
+  const chokidar = await import("chokidar");
+  const watcher = chokidar.watch(Array.from(watchPaths), {
+    ignoreInitial: true,
+    ignorePermissionErrors: true,
+    ignored: [
+      /[\\/]\.git[\\/]/,
+      /[\\/]node_modules[\\/]/,
+      import_node_path7.default.join(rootDir, options.outDir)
+    ]
+  });
+  let isRebuilding = false;
+  const triggerRebuild = async (initial = false) => {
+    if (isRebuilding) {
+      return;
+    }
+    isRebuilding = true;
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      const start = performance.now();
+      await build(options, rootDir);
+      if (!initial) {
+        logger.cli(`\uD83D\uDCE6 Rebuild finished in ${import_picocolors6.default.green(formatTime(performance.now() - start))}`);
+      }
+    } catch (error) {
+      handleError(error);
+    } finally {
+      isRebuilding = false;
+    }
+  };
+  watcher.on("change", (filePath) => {
+    const changedFile = import_node_path7.default.relative(rootDir, filePath);
+    logger.cli(`File changed: ${changedFile}`, {
+      muted: true,
+      once: changedFile
+    });
+    triggerRebuild();
+  });
+  watcher.on("error", (error) => {
+    throw new BunupWatchError(`Watcher error: ${parseErrorMessage(error)}`);
+  });
+  await triggerRebuild(true);
+}
+
+// src/cli/index.ts
+async function main(args = Bun.argv.slice(2)) {
+  const cliOptions = parseCliOptions(args);
+  if (cliOptions.new) {
+    const { newProject: newProject2 } = await Promise.resolve().then(() => (init_new(), exports_new));
+    await newProject2();
+    return;
+  }
+  if (cliOptions.init) {
+    const { init: init2 } = await Promise.resolve().then(() => (init_init(), exports_init));
+    await init2();
+    return;
+  }
+  setSilent(cliOptions.silent);
+  const cwd = process.cwd();
+  const { config, filepath } = await import_coffi2.loadConfig({
+    name: "bunup.config",
+    extensions: [".ts", ".js", ".mjs", ".cjs"],
+    maxDepth: 1,
+    preferredPath: cliOptions.config,
+    packageJsonProperty: "bunup"
+  });
+  const configsToProcess = !config ? [{ rootDir: cwd, options: cliOptions }] : await processLoadedConfigs(config, cwd, cliOptions.filter);
+  logger.cli(`Using bunup v${version} and bun v${Bun.version}`, {
+    muted: true
+  });
+  if (filepath) {
+    logger.cli(`Using ${getShortFilePath(filepath, 2)}`, {
+      muted: true
+    });
+  }
+  const startTime = performance.now();
+  logger.cli("Build started");
+  await Promise.all(configsToProcess.flatMap(({ options, rootDir }) => {
+    const optionsArray = ensureArray(options);
+    return optionsArray.map(async (o) => {
+      const partialOptions = {
+        ...o,
+        ...removeCliOnlyOptions(cliOptions)
+      };
+      if (partialOptions.watch) {
+        await watch(partialOptions, rootDir);
+      } else {
+        await build(partialOptions, rootDir);
+      }
+    });
+  }));
+  const buildTimeMs = performance.now() - startTime;
+  const timeDisplay = formatTime(buildTimeMs);
+  logger.cli(`\u26A1\uFE0F Build completed in ${import_picocolors10.default.green(timeDisplay)}`);
+  if (cliOptions.watch) {
+    logger.cli("\uD83D\uDC40 Watching for file changes");
+  }
+  if (cliOptions.onSuccess) {
+    logger.cli(`Running command: ${cliOptions.onSuccess}`, {
+      muted: true
+    });
+    await import_tinyexec2.exec(cliOptions.onSuccess, [], {
+      nodeOptions: { shell: true, stdio: "inherit" }
+    });
+  }
+  if (!cliOptions.watch) {
+    process.exit(process.exitCode ?? 0);
+  }
+}
+function removeCliOnlyOptions(options) {
+  return {
+    ...options,
+    onSuccess: undefined,
+    config: undefined,
+    filter: undefined,
+    new: undefined,
+    init: undefined
+  };
+}
+main().catch((error) => handleErrorAndExit(error));
+})