bunup 0.8.29 → 0.8.30

package/dist/plugins.cjs

@@ -0,0 +1,866 @@
+// @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/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_path.default.basename(filePath);
+  const firstDotIndex = basename.indexOf(".");
+  if (firstDotIndex === -1) {
+    return filePath;
+  }
+  const nameWithoutExtensions = basename.slice(0, firstDotIndex);
+  const directory = import_node_path.default.dirname(filePath);
+  return directory === "." ? nameWithoutExtensions : import_node_path.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_path.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(path2) {
+  let cleaned = import_node_path.normalize(path2).replace(/\\/g, "/");
+  cleaned = cleaned.replace(/^[a-zA-Z]:\//, "");
+  cleaned = cleaned.replace(/^\/+/, "");
+  cleaned = cleaned.replace(/\/+/g, "/");
+  return cleaned;
+}
+function isDirectoryPath(filePath) {
+  return import_node_path.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_path;
+var init_utils = __esm(() => {
+  import_node_fs = __toESM(require("fs"));
+  import_promises = __toESM(require("fs/promises"));
+  import_node_path = __toESM(require("path"));
+  init_errors();
+});
+
+// src/plugins.ts
+var exports_plugins = {};
+__export(exports_plugins, {
+  shims: () => shims,
+  report: () => report,
+  injectStyles: () => injectStyles,
+  exports: () => exports2,
+  copy: () => copy
+});
+module.exports = __toCommonJS(exports_plugins);
+
+// 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 }) => {
+          const content = await Bun.file(path).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_path2 = __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_path2.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_path3 = require("path");
+var import_node_path4 = 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_path3.join(meta.rootDir, filePath));
+            await Bun.write(outPath && isDirectoryPath(outPath) ? import_node_path3.join(destinationPath, import_node_path4.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();
+      }
+    }
+  };
+}
+})