bunup 0.8.28 → 0.8.29

package/dist/cli.js

@@ -1,1816 +0,0 @@
-#!/usr/bin/env bun
-// @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-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);
-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
-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(), 1);
-  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(), 1);
-  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/utils.ts
-import fsSync from "fs";
-import fs from "fs/promises";
-import path, { normalize } from "path";
-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 getDefaultDtsOutputExtension(format, packageType) {
-  switch (format) {
-    case "esm":
-      return isModulePackage(packageType) ? ".d.ts" : ".d.mts";
-    case "cjs":
-      return isModulePackage(packageType) ? ".d.cts" : ".d.ts";
-    case "iife":
-      return ".global.d.ts";
-  }
-}
-function getBaseFileName(filePath) {
-  const filename = path.basename(filePath);
-  const extension = path.extname(filename);
-  return extension ? filename.slice(0, -extension.length) : filename;
-}
-function removeExtension(filePath) {
-  return filePath.replace(path.extname(filePath), "");
-}
-function cleanPath(filePath) {
-  return filePath.replace(/\\/g, "/");
-}
-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 = path.join(rootDir, outDir);
-  try {
-    await fs.rm(outDirPath, { recursive: true, force: true });
-  } catch (error) {
-    throw new BunupBuildError(`Failed to clean output directory: ${error}`);
-  }
-  await fs.mkdir(outDirPath, { recursive: true });
-}
-function pathExistsSync(filePath) {
-  try {
-    fsSync.accessSync(filePath);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-function formatListWithAnd(arr) {
-  return new Intl.ListFormat("en", {
-    style: "long",
-    type: "conjunction"
-  }).format(arr);
-}
-var init_utils = __esm(() => {
-  init_errors();
-});
-
-// src/loaders.ts
-import path2 from "path";
-import { loadConfig } from "coffi";
-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: path2.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 loadConfig({
-    name: "package",
-    cwd,
-    extensions: [".json"]
-  });
-  return {
-    data: config,
-    path: filepath
-  };
-}
-var init_loaders = () => {};
-
-// 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(), 1);
-  init_logger();
-});
-
-// src/cli/new.ts
-var exports_new = {};
-__export(exports_new, {
-  newProject: () => newProject
-});
-import { renameSync } from "fs";
-import path5 from "path";
-import {
-  cancel,
-  confirm,
-  intro,
-  outro,
-  select,
-  tasks,
-  text
-} from "@clack/prompts";
-import { downloadTemplate } from "giget";
-import { replaceInFile } from "replace-in-file";
-async function newProject() {
-  displayBunupGradientArt();
-  intro(import_picocolors8.default.bgCyan(import_picocolors8.default.black(" Scaffold a new project with Bunup ")));
-  const selectedTemplateDir = await 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) {
-    cancel("Invalid template");
-    process.exit(1);
-  }
-  const hasMonorepo = template.monorepoDir !== undefined;
-  const projectName = await 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 confirm({
-      message: "Do you want to create a monorepo?",
-      initialValue: false
-    });
-    if (useMonorepo) {
-      monorepoFirstPackageName = await text({
-        message: "Enter the name of the first package",
-        placeholder: MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER,
-        defaultValue: MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER
-      });
-    }
-  }
-  const githubRepoInfo = await 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 tasks([
-    {
-      title: "Creating project",
-      task: async () => {
-        const templatePath = useMonorepo ? template.monorepoDir : template.dir;
-        await downloadTemplate(`github:${TEMPLATE_OWNER}/${TEMPLATE_REPO}/${templatePath}`, {
-          dir: projectPath
-        });
-        return "Template downloaded";
-      }
-    },
-    {
-      title: "Making the project yours",
-      task: async () => {
-        await replaceInFile({
-          files: path5.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 replaceInFile({
-            files: path5.join(projectPath, "**/*"),
-            from: [new RegExp(MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER, "g")],
-            to: [monorepoFirstPackageName],
-            ignore: ["node_modules", "dist", "bun.lock"]
-          });
-          renameSync(path5.join(projectPath, MONOREPO_PACKAGES_DIR, MONOREPO_FIRST_PACKAGE_NAME_PLACEHOLDER), path5.join(projectPath, MONOREPO_PACKAGES_DIR, monorepoFirstPackageName));
-        }
-      }
-    }
-  ]);
-  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 path5.join(process.cwd(), projectName);
-}
-var import_picocolors8, 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_picocolors8 = __toESM(require_picocolors(), 1);
-  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
-});
-import fs2 from "fs";
-import path6 from "path";
-import {
-  confirm as confirm2,
-  intro as intro2,
-  log,
-  multiselect,
-  outro as outro2,
-  select as select2,
-  tasks as tasks2,
-  text as text2
-} from "@clack/prompts";
-import { exec } from "tinyexec";
-async function init() {
-  displayBunupGradientArt();
-  intro2(import_picocolors9.default.bgCyan(import_picocolors9.default.black(" Initialize bunup in an existing project ")));
-  const { path: packageJsonPath } = await loadPackageJson();
-  if (!packageJsonPath) {
-    log.error("package.json not found");
-    process.exit(1);
-  }
-  const shouldSetupWorkspace = await promptForWorkspace();
-  if (shouldSetupWorkspace) {
-    await initializeWorkspace(packageJsonPath);
-  } else {
-    await initializeSinglePackage(packageJsonPath);
-  }
-  await tasks2([
-    {
-      title: "Installing bunup",
-      task: async () => {
-        await installBunup();
-        return "Bunup installed";
-      }
-    }
-  ]);
-  showSuccessOutro(shouldSetupWorkspace);
-}
-async function promptForWorkspace() {
-  return await confirm2({
-    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 text2({
-      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 text2({
-      message: `Enter the root directory for "${packageName}":`,
-      placeholder: `packages/${packageName}`,
-      defaultValue: `packages/${packageName}`,
-      validate: (value) => {
-        if (!value)
-          return "Package root is required";
-        if (!fs2.existsSync(value))
-          return "Package root directory does not exist";
-        if (!fs2.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 confirm2({
-      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 text2({
-      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 = path6.join(packageRoot, value);
-        if (!fs2.existsSync(fullPath))
-          return `Entry file does not exist at ${fullPath}`;
-        if (!fs2.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 confirm2({
-      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 text2({
-      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 (!fs2.existsSync(value))
-          return "Entry file does not exist";
-        if (!fs2.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 confirm2({
-      message: "Do you want to add another entry file?",
-      initialValue: false
-    });
-    if (!shouldAddMore)
-      break;
-  }
-  return entryFiles;
-}
-async function selectOutputFormats() {
-  return await 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 confirm2({
-    message: "Generate TypeScript declarations?",
-    initialValue: true
-  });
-}
-async function selectWorkspaceConfigurationMethod() {
-  return await select2({
-    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 select2({
-    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") {
-    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 confirm2({
-      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) {
-      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 confirm2({
-      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) {
-      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` : "";
-  outro2(`
-  ${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 exec("bun add -d bunup", [], {
-    nodeOptions: { shell: true, stdio: "pipe" }
-  });
-}
-var import_picocolors9;
-var init_init = __esm(() => {
-  import_picocolors9 = __toESM(require_picocolors(), 1);
-  init_loaders();
-  init_utils();
-  init_utils2();
-});
-
-// src/cli/index.ts
-import { exec as exec2 } from "tinyexec";
-// package.json
-var version = "0.8.28";
-
-// src/cli/index.ts
-init_errors();
-init_logger();
-
-// src/cli/options.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
-
-// src/constants/index.ts
-var BUNUP_CLI_OPTIONS_URL = "https://bunup.dev/docs/guide/cli-options";
-
-// src/cli/options.ts
-init_errors();
-init_logger();
-init_utils();
-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") },
-  dtsOnly: { flags: ["dts-only"], handler: booleanHandler("dtsOnly") },
-  entry: {
-    flags: ["entry"],
-    handler: (value, options, subPath) => {
-      if (typeof value !== "string") {
-        throw new BunupCLIError(`Entry${subPath ? ` --entry.${subPath}` : ""} requires a string value`);
-      }
-      const entries = options.entry || {};
-      if (subPath) {
-        if (entries[subPath]) {
-          logger.warn(`Duplicate entry name '${subPath}' provided via --entry.${subPath}. Overwriting previous entry.`);
-        }
-        entries[subPath] = value;
-      } else {
-        const name = getBaseFileName(value);
-        if (entries[name]) {
-          logger.warn(`Duplicate entry name '${name}' derived from '${value}'. Overwriting previous entry.`);
-        }
-        entries[name] = 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_picocolors10 = __toESM(require_picocolors(), 1);
-import { loadConfig as loadConfig2 } from "coffi";
-
-// src/build.ts
-init_errors();
-import path3 from "path";
-import {
-  generateDts,
-  logIsolatedDeclarationErrors
-} from "bun-dts";
-
-// src/helpers/entry.ts
-init_utils();
-function getProcessableEntries(entry) {
-  if (typeof entry === "string") {
-    return [
-      {
-        entry,
-        outputBasePath: getEntryOutputBasePath(entry)
-      }
-    ];
-  }
-  if (typeof entry === "object" && !Array.isArray(entry)) {
-    return Object.entries(entry).map(([name, path2]) => ({
-      entry: path2,
-      outputBasePath: name
-    }));
-  }
-  return entry.map((_entry) => ({
-    entry: _entry,
-    outputBasePath: getEntryOutputBasePath(_entry)
-  }));
-}
-function getEntryOutputBasePath(entry) {
-  const pathSegments = cleanPath(removeExtension(entry)).split("/");
-  return pathSegments.length > 1 ? pathSegments.slice(1).join("/") : pathSegments.join("/");
-}
-function getResolvedNaming(outputBasePath, extension) {
-  return {
-    entry: `[dir]/${outputBasePath}${extension}`,
-    chunk: `${outputBasePath}-[hash].[ext]`,
-    asset: `${outputBasePath}-[name]-[hash].[ext]`
-  };
-}
-
-// src/build.ts
-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}`);
-// src/plugins/built-in/productivity/exports.ts
-init_logger();
-init_utils();
-// src/plugins/built-in/css/inject-styles.ts
-init_logger();
-
-// src/plugins/utils.ts
-var import_picocolors4 = __toESM(require_picocolors(), 1);
-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 });
-    }
-  }
-}
-// src/plugins/built-in/productivity/copy.ts
-init_utils();
-// src/plugins/internal/report.ts
-var import_picocolors5 = __toESM(require_picocolors(), 1);
-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
-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;
-}
-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(path3, pattern) {
-  return typeof pattern === "string" ? pattern === path3 : pattern.test(path3);
-}
-function isExternal(path3, options, packageJson) {
-  const packageDepsPatterns = getPackageDepsPatterns(packageJson);
-  const matchesExternalPattern = packageDepsPatterns.some((pattern) => pattern.test(path3)) || options.external?.some((pattern) => matchesPattern(path3, pattern));
-  const isExcludedFromExternal = options.noExternal?.some((pattern) => matchesPattern(path3, 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 processableEntries = getProcessableEntries(options.entry);
-  const packageType = packageJson.data?.type;
-  const plugins = [
-    externalOptionPlugin(options, packageJson.data),
-    ...filterBunupBunPlugins(options.plugins).map((p) => p.plugin)
-  ];
-  if (!options.dtsOnly) {
-    const buildPromises = options.format.flatMap((fmt) => processableEntries.map(async ({ entry, outputBasePath }) => {
-      const extension = options.outputExtension?.({
-        format: fmt,
-        packageType,
-        options,
-        entry
-      }).js ?? getDefaultJsOutputExtension(fmt, packageType);
-      const result = await Bun.build({
-        entrypoints: [`${rootDir}/${entry}`],
-        format: fmt,
-        naming: getResolvedNaming(outputBasePath, extension),
-        splitting: getResolvedSplitting(options.splitting, fmt),
-        bytecode: getResolvedBytecode(options.bytecode, fmt),
-        define: getResolvedDefine(options.define, options.env),
-        minify: getResolvedMinify(options),
-        outdir: `${rootDir}/${options.outDir}`,
-        target: options.target,
-        sourcemap: getResolvedSourcemap(options.sourcemap),
-        loader: options.loader,
-        drop: options.drop,
-        banner: options.banner,
-        footer: options.footer,
-        publicPath: options.publicPath,
-        env: getResolvedEnv(options.env),
-        plugins,
-        throw: false
-      });
-      for (const log of result.logs) {
-        if (log.level === "error") {
-          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,
-          dts: false,
-          entry,
-          outputBasePath,
-          format: fmt
-        });
-      }
-    }));
-    await Promise.all(buildPromises);
-  }
-  if (options.dts === true || typeof options.dts === "object" || options.dtsOnly) {
-    const dtsResolve = typeof options.dts === "object" && "resolve" in options.dts ? options.dts.resolve : undefined;
-    const dtsEntry = typeof options.dts === "object" && "entry" in options.dts ? options.dts.entry : undefined;
-    const processableDtsEntries = dtsEntry ? getProcessableEntries(dtsEntry) : processableEntries;
-    const dtsPromises = processableDtsEntries.map(async ({ entry, outputBasePath }) => {
-      let result;
-      try {
-        result = await generateDts(entry, {
-          cwd: rootDir,
-          preferredTsConfigPath: options.preferredTsconfigPath,
-          resolve: dtsResolve
-        });
-      } catch (error) {
-        throw new BunupDTSBuildError(parseErrorMessage(error));
-      }
-      for (const fmt of options.format) {
-        const extension = options.outputExtension?.({
-          format: fmt,
-          packageType,
-          options,
-          entry
-        }).dts ?? getDefaultDtsOutputExtension(fmt, packageType);
-        const filePath = path3.join(rootDir, options.outDir, `${outputBasePath}${extension}`);
-        const relativePathToRootDir = getRelativePathToRootDir(filePath, rootDir);
-        buildOutput.files.push({
-          fullPath: filePath,
-          relativePathToRootDir,
-          dts: true,
-          entry,
-          outputBasePath,
-          format: fmt
-        });
-        if (result.errors.length > 0) {
-          logIsolatedDeclarationErrors(result.errors, {
-            shouldExit: true
-          });
-        }
-        await Bun.write(filePath, result.dts);
-        logger.progress("DTS", relativePathToRootDir, {
-          identifier: options.name
-        });
-      }
-    });
-    await Promise.all(dtsPromises);
-  }
-  await runPluginBuildDoneHooks(bunupPlugins, options, buildOutput, {
-    packageJson,
-    rootDir
-  });
-  if (options.onSuccess) {
-    await options.onSuccess(options);
-  }
-}
-function getRelativePathToRootDir(filePath, rootDir) {
-  return filePath.replace(`${rootDir}/`, "");
-}
-
-// src/cli/index.ts
-init_loaders();
-init_utils();
-
-// src/watch.ts
-var import_picocolors6 = __toESM(require_picocolors(), 1);
-import path4 from "path";
-init_errors();
-init_logger();
-init_utils();
-async function watch(partialOptions, rootDir) {
-  const watchPaths = new Set;
-  const options = createBuildOptions(partialOptions);
-  const dtsEntry = typeof options.dts === "object" && "entry" in options.dts ? options.dts.entry : undefined;
-  const processableDtsEntries = dtsEntry ? getProcessableEntries(dtsEntry) : [];
-  const processableEntries = getProcessableEntries(options.entry);
-  const uniqueEntries = new Set([
-    ...processableDtsEntries.map(({ entry }) => entry),
-    ...processableEntries.map(({ entry }) => entry)
-  ]);
-  for (const entry of uniqueEntries) {
-    const entryPath = path4.resolve(rootDir, entry);
-    const parentDir = path4.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[\\/]/,
-      path4.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 = path4.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 loadConfig2({
-    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 exec2(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));