bunup 0.8.30 → 0.8.32

package/dist/index.cjs

@@ -1,1168 +0,0 @@
-// @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/index.ts
-var exports_src = {};
-__export(exports_src, {
-  defineWorkspace: () => defineWorkspace,
-  defineConfig: () => defineConfig,
-  build: () => build
-});
-module.exports = __toCommonJS(exports_src);
-
-// src/define.ts
-function defineConfig(options) {
-  return options;
-}
-function defineWorkspace(options) {
-  return options;
-}
-// 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_picocolors3 = __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_picocolors3.default.cyan(name)}] is required for the ${pluginName} plugin. Please install it with: ${import_picocolors3.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_picocolors4 = __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_picocolors4.default.blue },
-          { header: "Size", align: "right", color: import_picocolors4.default.green },
-          {
-            header: "Gzip",
-            align: "right",
-            color: import_picocolors4.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)}/`, "");
-}
-})