bunup 0.14.7 → 0.14.9

package/dist/cli/index.js

@@ -5,7 +5,7 @@ import {
   printBuildReport,
   processLoadedConfigs,
   resolveBuildOptions
-} from "../shared/bunup-q245t34y.js";
+} from "../shared/bunup-g3r7h8pa.js";
 import {
   BunupCLIError,
   BunupWatchError,
@@ -18,13 +18,13 @@ import {
   logTime,
   logger,
   parseErrorMessage
-} from "../shared/bunup-r5agr54b.js";
+} from "../shared/bunup-rh8gn8xh.js";
 
 // packages/bunup/src/cli/index.ts
 import { loadConfig } from "coffi";
 import pc3 from "picocolors";
 // packages/bunup/package.json
-var version = "0.14.7";
+var version = "0.14.9";
 
 // packages/bunup/src/watch.ts
 import path from "path";
@@ -97,14 +97,15 @@ import { cli, z } from "zlye";
 var program = cli().name("bunup").version(version).description("A blazing-fast build tool for your TypeScript/React libraries \u2014 built on Bun").with({
   ignoreOptionDefaultValue: true
 }).example([
-  pc2.gray(`${pc2.blue("bunup src/index.ts")}                            # Basic build`),
+  pc2.gray(`${pc2.blue("bunup")}                            # Basic build`),
+  pc2.gray(`${pc2.blue("bunup src/index.ts")}               # Single entry file`),
   pc2.gray(`${pc2.blue("bunup src/**/*.ts")}                             # Glob pattern for multiple files`),
-  pc2.gray(`${pc2.blue("bunup src/index.ts --watch")}                    # Watch mode`),
-  pc2.gray(`${pc2.blue("bunup src/index.ts --format cjs,esm")}           # Multiple formats`),
-  pc2.gray(`${pc2.blue("bunup src/index.ts --target bun")}               # Bun target`),
-  pc2.gray(`${pc2.blue("bunup src/index.ts src/cli.ts")}                 # Multiple entries`),
-  pc2.gray(`${pc2.blue("bunup src/index.ts --dts.splitting")}            # Declaration splitting`),
-  pc2.gray(`${pc2.blue("bunup src/index.ts --no-clean")}                 # Disable cleaning output directory before build`)
+  pc2.gray(`${pc2.blue("bunup --watch")}                    # Watch mode`),
+  pc2.gray(`${pc2.blue("bunup --format cjs,esm")}           # Multiple formats`),
+  pc2.gray(`${pc2.blue("bunup --target bun")}               # Bun target`),
+  pc2.gray(`${pc2.blue("bunup src/cli.ts")}                 # Multiple entries`),
+  pc2.gray(`${pc2.blue("bunup --dts.splitting")}            # Declaration splitting`),
+  pc2.gray(`${pc2.blue("bunup --no-clean")}                 # Disable cleaning output directory before build`)
 ]).option("entry", z.union(z.string().describe("Entry file or glob pattern"), z.array(z.string()).describe("Multiple entry files or globs")).alias("e").optional()).option("config", z.string().describe("Path to configuration file").alias("c").example("./configs/custom.bunup.config.js").optional()).option("filter", z.array(z.string()).describe("Filter workspace packages by name").optional()).option("name", z.string().describe("Name of the build configuration (for logging and identification)").example("my-library").optional()).option("out-dir", z.string().describe("Output directory for bundled files").alias("o").default("dist")).option("format", z.union(z.string().choices(["esm", "cjs", "iife"]).describe("Single output format"), z.array(z.string().choices(["esm", "cjs", "iife"])).describe("Multiple output formats")).alias("f").default("esm")).option("minify", z.boolean().describe("Enable all minification options (whitespace, identifiers, syntax)").optional()).option("minify-whitespace", z.boolean().describe("Minify whitespace in the output to reduce file size").optional()).option("minify-identifiers", z.boolean().describe("Minify identifiers by renaming variables to shorter names").optional()).option("minify-syntax", z.boolean().describe("Minify syntax by optimizing code structure").optional()).option("watch", z.boolean().describe("Watch for file changes and rebuild automatically").optional()).option("clean", z.boolean().describe("Clean the output directory before building").default(true)).option("silent", z.boolean().describe("Disable logging during the build process").alias("q").optional()).option("splitting", z.boolean().describe("Enable code splitting").default(true, "enabled by default for ESM format")).option("conditions", z.array(z.string()).describe("Package.json export conditions for import resolution").optional()).option("target", z.string().choices(["bun", "node", "browser"]).describe("Target environment for the bundle").alias("t").default("node")).option("external", z.array(z.string()).describe("External packages that should not be bundled").optional()).option("no-external", z.array(z.string()).describe("Packages that should be bundled even if listed in external").optional()).option("shims", z.boolean().describe("Enable shims for Node.js globals and ESM/CJS interoperability").optional()).option("report", z.object({
   gzip: z.boolean().describe("Enable gzip compression size calculation").default(true),
   brotli: z.boolean().describe("Enable brotli compression size calculation").optional(),
@@ -127,8 +128,19 @@ var program = cli().name("bunup").version(version).description("A blazing-fast b
   "text",
   "css",
   "html"
-])).describe("File extension to loader mapping").example("--loader.'.css'=text --loader.'.txt'=file").optional()).option("public-path", z.string().describe("Public path prefix for assets and chunk files").example("https://cdn.example.com/").optional()).option("ignore-dce-annotations", z.boolean().describe("Ignore dead code elimination annotations (@__PURE__, sideEffects)")).option("emit-dce-annotations", z.boolean().describe("Force emit @__PURE__ annotations even with minification")).option("on-success", z.string().describe("Command to run after successful build").optional()).option("css", z.object({
-  "typed-modules": z.boolean().describe("Generate TypeScript definitions for CSS modules").default(true)
+])).describe("File extension to loader mapping").example("--loader.'.css'=text --loader.'.txt'=file").optional()).option("public-path", z.string().describe("Public path prefix for assets and chunk files").example("https://cdn.example.com/").optional()).option("ignore-dce-annotations", z.boolean().describe("Ignore dead code elimination annotations (@__PURE__, sideEffects)")).option("emit-dce-annotations", z.boolean().describe("Force emit @__PURE__ annotations even with minification")).option("on-success", z.string().describe("Command to run after successful build").optional()).option("exports", z.union(z.boolean(), z.object({
+  exclude: z.array(z.string()).describe("Entry points to exclude from exports field").optional(),
+  "exclude-css": z.boolean().describe("Whether to exclude CSS files from exports field").optional(),
+  "include-package-json": z.boolean().describe('Whether to include "./package.json" in exports field').default(true),
+  all: z.boolean().describe("Whether to add wildcard export for deep imports").optional()
+})).describe("Configure automatic package.json exports generation").optional()).option("unused", z.union(z.boolean(), z.object({
+  level: z.string().choices(["warn", "error"]).describe("The level of reporting for unused dependencies").default("warn"),
+  ignore: z.array(z.string()).describe("Dependencies to ignore when checking for unused dependencies").optional()
+})).describe("Detect and report unused dependencies").optional()).option("css", z.object({
+  "typed-modules": z.boolean().describe("Generate TypeScript definitions for CSS modules").default(true),
+  inject: z.union(z.boolean(), z.object({
+    minify: z.boolean().describe("Whether to minify the styles being injected").optional()
+  })).describe("Inject CSS styles into document head at runtime").optional()
 }).optional()).rest("entries", z.string().describe("Entry point files to bundle"));
 var parseCliOptions = (argv) => {
   const result = program.parse(argv);

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Arrayable, BuildContext, BuildMeta, BuildOptions, BuildOutput, BuildOutputFile, BunupPlugin, DefineConfigItem, DefineWorkspaceItem, WithOptional } from "./shared/bunup-s6gfzz2v";
+import { Arrayable, BuildContext, BuildMeta, BuildOptions, BuildOutput, BuildOutputFile, BunupPlugin, DefineConfigItem, DefineWorkspaceItem, WithOptional } from "./shared/bunup-zenttvjh";
 declare function build(userOptions: Partial<BuildOptions>, rootDir?: string): Promise<BuildOutput>;
 declare function defineConfig(options: Arrayable<DefineConfigItem>): Arrayable<DefineConfigItem>;
 declare function defineWorkspace(options: WithOptional<DefineWorkspaceItem, "config">[], sharedOptions?: Partial<DefineConfigItem>): DefineWorkspaceItem[];

package/dist/index.js

@@ -1,8 +1,8 @@
 // @bun
 import {
   build
-} from "./shared/bunup-q245t34y.js";
-import"./shared/bunup-r5agr54b.js";
+} from "./shared/bunup-g3r7h8pa.js";
+import"./shared/bunup-rh8gn8xh.js";
 // packages/bunup/src/define.ts
 function defineConfig(options) {
   return options;

package/dist/plugins.d.ts

@@ -1,4 +1,4 @@
-import { BuildContext, BunupPlugin, BunupPluginHooks, MaybePromise } from "./shared/bunup-s6gfzz2v";
+import { BunupPlugin, BunupPluginHooks, exports, injectStyles, unused } from "./shared/bunup-zenttvjh";
 type CopyOptions = {
 	/** Whether to follow symbolic links when copying files. */
 	followSymlinks?: boolean
@@ -28,115 +28,9 @@ declare class CopyBuilder {
 	get name(): string;
 	get hooks(): BunupPluginHooks;
 }
-type CustomExports = Record<string, string | Record<string, string | Record<string, string>>>;
-type Exclude = ((ctx: BuildContext) => string[] | undefined) | string[];
-interface ExportsPluginOptions {
-	/**
-	* Additional export fields to preserve alongside automatically generated exports
-	*
-	* @see https://bunup.dev/docs/builtin-plugins/exports#customexports
-	*/
-	customExports?: (ctx: BuildContext) => CustomExports | undefined;
-	/**
-	* Entry points to exclude from the exports field
-	*
-	* @see https://bunup.dev/docs/builtin-plugins/exports#exclude
-	*/
-	exclude?: Exclude;
-	/**
-	* Whether to exclude CSS files from being added to the exports field
-	*
-	* @default false
-	*/
-	excludeCss?: boolean;
-	/**
-	* Whether to include "./package.json": "./package.json" in the exports field
-	*
-	* @default true
-	* @see https://bunup.dev/docs/builtin-plugins/exports#includepackagejson
-	*/
-	includePackageJson?: boolean;
-	/**
-	* Whether to add a wildcard export that allows deep imports
-	*
-	* When true, adds "./*": "./*" to exports, making all files accessible
-	* When false (default), only explicit exports are accessible
-	*
-	* @default false
-	* @see https://bunup.dev/docs/builtin-plugins/exports#all
-	*/
-	all?: boolean;
-}
-/**
-* A plugin that generates the exports field in the package.json file automatically.
-*
-* @see https://bunup.dev/docs/builtin-plugins/exports
-*/
-declare function exports(options?: ExportsPluginOptions): BunupPlugin;
 import { BunPlugin } from "bun";
-type InjectStylesPluginOptions = {
-	/**
-	* Custom function to inject CSS into the document head.
-	*
-	* By default, bunup uses its own `injectStyle` function that creates a `<style>`
-	* tag and appends it to the document head. You can provide your own injection
-	* logic to customize how styles are applied to the document.
-	*
-	* @param css - The processed CSS string (already JSON stringified)
-	* @param filePath - The original file path of the CSS file being processed
-	* @returns JavaScript code that will inject the styles when executed
-	*
-	* @example
-	* ```ts
-	* injectStyles({
-	*   inject: (css, filePath) => {
-	*     return `
-	*       const style = document.createElement('style');
-	*       style.setAttribute('data-source', '${filePath}');
-	*       style.textContent = ${css};
-	*       document.head.appendChild(style);
-	*     `;
-	*   }
-	* })
-	* ```
-	*
-	* The default injection handles cases like when `document` is undefined (e.g., server-side rendering) and compatibility with older browsers. Consider these when implementing custom injection logic.
-	*/
-	inject?: (css: string, filePath: string) => MaybePromise<string>
-	/**
-	* Whether to minify the styles being injected.
-	*
-	* @default true
-	*/
-	minify?: boolean
-};
-/**
-* A plugin that injects styles into the document head at runtime instead of bundling them to the build output.
-*
-* @see https://bunup.dev/docs/builtin-plugins/inject-styles
-*/
-declare function injectStyles(options?: InjectStylesPluginOptions): BunPlugin;
-import { BunPlugin as BunPlugin2 } from "bun";
 /**
 * A plugin that provides shims for Node.js globals and ESM/CJS interoperability.
 */
-declare function shims(): BunPlugin2;
-interface UnusedOptions {
-	/**
-	* The level of reporting for unused dependencies
-	* @default 'warn'
-	*/
-	level?: "warn" | "error";
-	/**
-	* Dependencies to ignore when checking for unused dependencies
-	* @default []
-	*/
-	ignore?: string[];
-}
-/**
-* A plugin that detects and reports unused dependencies.
-*
-* @see https://bunup.dev/docs/builtin-plugins/unused
-*/
-declare function unused(options?: UnusedOptions): BunupPlugin;
+declare function shims(): BunPlugin;
 export { unused, shims, injectStyles, exports, copy };

package/dist/plugins.js

@@ -1,17 +1,15 @@
 // @bun
 import {
-  CSS_RE,
-  JS_DTS_RE,
-  cleanPath,
-  detectFileFormatting,
   ensureArray,
-  formatListWithAnd,
+  exports,
+  injectStyles,
   isGlobPattern,
   logger,
-  shims
-} from "./shared/bunup-r5agr54b.js";
+  shims,
+  unused
+} from "./shared/bunup-rh8gn8xh.js";
 
-// packages/bunup/src/plugins/built-in/copy.ts
+// packages/bunup/src/plugins/copy.ts
 import { basename, extname, join } from "path";
 function copy(pattern) {
   return new CopyBuilder(pattern);
@@ -91,401 +89,6 @@ async function copyFile(sourcePath, finalDestinationPath) {
   const sourceFile = Bun.file(sourcePath);
   await Bun.write(finalDestinationPath, sourceFile);
 }
-// packages/bunup/src/plugins/built-in/exports.ts
-import path from "path";
-function exports(options = {}) {
-  return {
-    name: "exports",
-    hooks: {
-      onBuildDone: async (ctx) => {
-        await processPackageJsonExports(ctx, options);
-      }
-    }
-  };
-}
-async function processPackageJsonExports(ctx, options) {
-  const { output, options: buildOptions, meta } = ctx;
-  if (!meta.packageJson.path || !meta.packageJson.data) {
-    return;
-  }
-  try {
-    const { exportsField, entryPoints } = generateExportsFields(output.files, options.exclude, options.excludeCss, ctx);
-    const updatedFiles = createUpdatedFilesArray(meta.packageJson.data, buildOptions.outDir);
-    const mergedExports = mergeCustomExportsWithGenerated(exportsField, options.customExports, ctx);
-    const finalExports = addPackageJsonOrWildcardExport(mergedExports, options.includePackageJson, options.all);
-    const newPackageJson = createUpdatedPackageJson(meta.packageJson.data, entryPoints, finalExports, updatedFiles);
-    if (Bun.deepEquals(newPackageJson, meta.packageJson.data)) {
-      return;
-    }
-    const formatting = await detectFileFormatting(meta.packageJson.path);
-    let jsonContent = JSON.stringify(newPackageJson, null, formatting.indentation);
-    if (formatting.hasTrailingNewline) {
-      jsonContent += `
-`;
-    }
-    await Bun.write(meta.packageJson.path, jsonContent);
-  } catch {
-    logger.error("Failed to update package.json");
-  }
-}
-function generateExportsFields(files, exclude, excludeCss, ctx) {
-  const filteredFiles = filterFiles(files, exclude, ctx);
-  const { filesByExportKey, allDtsFiles, cssFiles } = groupFilesByExportKey(filteredFiles);
-  const exportsField = createExportEntries(filesByExportKey);
-  if (!excludeCss) {
-    addCssToExports(exportsField, cssFiles);
-  }
-  const entryPoints = extractEntryPoints(exportsField, allDtsFiles);
-  return { exportsField, entryPoints };
-}
-function groupFilesByExportKey(files) {
-  const filesByExportKey = new Map;
-  const allDtsFiles = new Map;
-  const cssFiles = [];
-  for (const file of files) {
-    const exportKey = getExportKey(cleanPath(file.pathRelativeToOutdir));
-    if (CSS_RE.test(file.fullPath)) {
-      cssFiles.push(file);
-      continue;
-    }
-    const format = file.format === "esm" ? "import" : "require";
-    if (!filesByExportKey.has(exportKey)) {
-      filesByExportKey.set(exportKey, new Map);
-      allDtsFiles.set(exportKey, []);
-    }
-    const formatMap = filesByExportKey.get(exportKey);
-    const dtsFiles = allDtsFiles.get(exportKey);
-    if (formatMap && dtsFiles) {
-      if (!formatMap.has(format)) {
-        formatMap.set(format, { dts: undefined, source: undefined });
-      }
-      const fileEntry = formatMap.get(format);
-      if (fileEntry) {
-        if (file.dts) {
-          fileEntry.dts = file;
-          dtsFiles.push(file);
-        } else {
-          fileEntry.source = file;
-        }
-      }
-    }
-  }
-  return { filesByExportKey, allDtsFiles, cssFiles };
-}
-function createExportEntries(filesByExportKey) {
-  const exportsField = {};
-  for (const [exportKey, formatMap] of filesByExportKey.entries()) {
-    exportsField[exportKey] = {};
-    let hasFormatSpecificTypes = false;
-    let primaryTypesPath;
-    for (const [format, files] of formatMap.entries()) {
-      const formatKey = format;
-      if (files.dts && files.source) {
-        exportsField[exportKey][formatKey] = {
-          types: `./${cleanPath(files.dts.pathRelativeToRootDir)}`,
-          default: `./${cleanPath(files.source.pathRelativeToRootDir)}`
-        };
-        hasFormatSpecificTypes = true;
-        if (!primaryTypesPath) {
-          primaryTypesPath = `./${cleanPath(files.dts.pathRelativeToRootDir)}`;
-        }
-      } else if (files.source) {
-        exportsField[exportKey][formatKey] = `./${cleanPath(files.source.pathRelativeToRootDir)}`;
-        if (files.dts) {
-          primaryTypesPath = `./${cleanPath(files.dts.pathRelativeToRootDir)}`;
-        }
-      } else if (files.dts) {
-        primaryTypesPath = `./${cleanPath(files.dts.pathRelativeToRootDir)}`;
-      }
-    }
-    if (!hasFormatSpecificTypes && primaryTypesPath) {
-      exportsField[exportKey].types = primaryTypesPath;
-    }
-  }
-  return exportsField;
-}
-function extractEntryPoints(exportsField, allDtsFiles) {
-  const entryPoints = {};
-  const dotExport = exportsField["."];
-  if (!dotExport || typeof dotExport === "string") {
-    return entryPoints;
-  }
-  for (const [field, value] of Object.entries(dotExport)) {
-    if (field === "types")
-      continue;
-    const entryPoint = exportFieldToEntryPoint(field);
-    if (typeof value === "string") {
-      entryPoints[entryPoint] = value;
-    } else if (value && typeof value === "object" && "default" in value) {
-      entryPoints[entryPoint] = value.default;
-    }
-  }
-  const dotEntryDtsFiles = allDtsFiles.get(".");
-  if (dotEntryDtsFiles?.length) {
-    const standardDts = findStandardDtsFile(dotEntryDtsFiles);
-    if (standardDts) {
-      entryPoints.types = `./${cleanPath(standardDts.pathRelativeToRootDir)}`;
-    } else {
-      entryPoints.types = extractTypesFromExport(dotExport);
-    }
-  }
-  return entryPoints;
-}
-function findStandardDtsFile(dtsFiles) {
-  return dtsFiles.find((file) => file.pathRelativeToRootDir.endsWith(".d.ts") && !file.pathRelativeToRootDir.endsWith(".d.mts") && !file.pathRelativeToRootDir.endsWith(".d.cts"));
-}
-function extractTypesFromExport(dotExport) {
-  const typesValue = dotExport.types;
-  if (typeof typesValue === "string") {
-    return typesValue;
-  }
-  if (typesValue && typeof typesValue === "object" && "types" in typesValue) {
-    return typesValue.types;
-  }
-  const importValue = dotExport.import;
-  if (importValue && typeof importValue === "object" && "types" in importValue) {
-    return importValue.types;
-  }
-  return;
-}
-function createUpdatedFilesArray(packageJsonData, outDir) {
-  const existingFiles = Array.isArray(packageJsonData.files) ? packageJsonData.files : [];
-  return [...new Set([...existingFiles, outDir])];
-}
-function mergeCustomExportsWithGenerated(baseExports, customExportsProvider, ctx) {
-  const mergedExports = { ...baseExports };
-  if (!customExportsProvider) {
-    return mergedExports;
-  }
-  const customExports = customExportsProvider(ctx);
-  if (!customExports) {
-    return mergedExports;
-  }
-  for (const [key, value] of Object.entries(customExports)) {
-    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;
-      }
-    }
-  }
-  return mergedExports;
-}
-function createUpdatedPackageJson(originalData, entryPoints, exports2, files) {
-  const { main, module, types, ...restPackageJson } = originalData;
-  const newPackageJson = {
-    ...Object.fromEntries(Object.entries({
-      name: originalData.name,
-      description: originalData.description,
-      version: originalData.version,
-      type: originalData.type,
-      private: originalData.private
-    }).filter(([_, value]) => value !== undefined)),
-    files,
-    ...entryPoints,
-    exports: exports2
-  };
-  for (const key in restPackageJson) {
-    if (Object.hasOwn(restPackageJson, key) && !Object.hasOwn(newPackageJson, key)) {
-      newPackageJson[key] = restPackageJson[key];
-    }
-  }
-  return newPackageJson;
-}
-function filterFiles(files, exclude, ctx) {
-  return files.filter((file) => (JS_DTS_RE.test(file.fullPath) || CSS_RE.test(file.fullPath)) && (file.kind === "entry-point" || file.kind === "asset") && (file.format === "esm" || file.format === "cjs" || CSS_RE.test(file.fullPath)) && (!file.entrypoint || !isExcluded(file.entrypoint, exclude, ctx)));
-}
-var DEFAULT_CLI_EXCLUSIONS = [
-  "cli.ts",
-  "cli/index.ts",
-  "src/cli.ts",
-  "src/cli/index.ts"
-];
-function isExcluded(entrypoint, exclude, ctx) {
-  const userPatterns = typeof exclude === "function" ? exclude(ctx) : exclude;
-  const allPatterns = [...DEFAULT_CLI_EXCLUSIONS, ...userPatterns ?? []];
-  return allPatterns.some((pattern) => new Bun.Glob(pattern).match(entrypoint));
-}
-function getExportKey(pathRelativeToOutdir) {
-  const pathSegments = cleanPath(removeExtension(pathRelativeToOutdir)).split("/");
-  if (pathSegments.length === 1 && pathSegments[0].startsWith("index")) {
-    return ".";
-  }
-  return `./${pathSegments.filter((segment) => !segment.startsWith("index")).join("/")}`;
-}
-function removeExtension(filePath) {
-  const basename2 = path.basename(filePath);
-  const firstDotIndex = basename2.indexOf(".");
-  if (firstDotIndex === -1) {
-    return filePath;
-  }
-  const nameWithoutExtensions = basename2.slice(0, firstDotIndex);
-  const directory = path.dirname(filePath);
-  return directory === "." ? nameWithoutExtensions : path.join(directory, nameWithoutExtensions);
-}
-function addCssToExports(exportsField, cssFiles) {
-  if (cssFiles.length === 0)
-    return;
-  for (const cssFile of cssFiles) {
-    const exportKey = getCssExportKey(cleanPath(cssFile.pathRelativeToOutdir));
-    exportsField[exportKey] = `./${cleanPath(cssFile.pathRelativeToRootDir)}`;
-  }
-}
-function getCssExportKey(pathRelativeToOutdir) {
-  const pathSegments = cleanPath(removeExtension(pathRelativeToOutdir)).split("/");
-  const fileName = pathSegments[pathSegments.length - 1];
-  if (fileName === "index") {
-    if (pathSegments.length === 1) {
-      return "./styles.css";
-    } else {
-      return `./${pathSegments.slice(0, -1).join("/")}.css`;
-    }
-  } else {
-    return `./${pathSegments.join("/")}.css`;
-  }
-}
-function addPackageJsonOrWildcardExport(exports2, includePackageJson, all) {
-  const finalExports = { ...exports2 };
-  if (all) {
-    finalExports["./*"] = "./*";
-  } else if (includePackageJson !== false) {
-    if (!finalExports["./package.json"]) {
-      finalExports["./package.json"] = "./package.json";
-    }
-  }
-  return finalExports;
-}
-function exportFieldToEntryPoint(exportField) {
-  switch (exportField) {
-    case "types":
-      return "types";
-    case "require":
-      return "main";
-    default:
-      return "module";
-  }
-}
-// packages/bunup/src/plugins/built-in/inject-styles.ts
-import path2 from "path";
-import { getDefaultCssBrowserTargets } from "@bunup/shared";
-import { transform } from "lightningcss";
-function injectStyles(options) {
-  const { inject, minify = true } = options ?? {};
-  return {
-    name: "bunup:inject-styles",
-    async setup(build) {
-      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 } = transform({
-          filename: path2.basename(args.path),
-          code: Buffer.from(source),
-          minify,
-          targets: getDefaultCssBrowserTargets()
-        });
-        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"
-        };
-      });
-    }
-  };
-}
-// packages/bunup/src/plugins/built-in/unused.ts
-import pc from "picocolors";
-function unused(options = {}) {
-  const { level = "warn", ignore = [] } = options;
-  return {
-    name: "unused",
-    hooks: {
-      onBuildDone: async (ctx) => {
-        const { options: buildOptions, output, meta } = ctx;
-        if (buildOptions.watch) {
-          return;
-        }
-        const transpiler = new Bun.Transpiler({
-          loader: "js"
-        });
-        const jsFiles = output.files.filter((file) => file.fullPath.endsWith(".js"));
-        const packageDependencies = typeof meta.packageJson.data?.dependencies === "object" ? meta.packageJson.data.dependencies : {};
-        const externals = [
-          ...buildOptions.external ?? [],
-          ...buildOptions.noExternal ?? []
-        ];
-        const allImportPaths = new Set;
-        for (const file of jsFiles) {
-          const code = await Bun.file(file.fullPath).text();
-          const codeWithoutShebang = code.replace(/^#!.*$/m, "");
-          const importPaths = transpiler.scanImports(codeWithoutShebang).map((imp) => imp.path);
-          for (const importPath of importPaths) {
-            if (externals.some((ex) => typeof ex === "string" ? importPath.startsWith(ex) : ex.test(importPath)))
-              continue;
-            if (importPath.startsWith("node:") || importPath.startsWith("bun:"))
-              continue;
-            allImportPaths.add(importPath);
-          }
-        }
-        const allDependencies = Object.keys(packageDependencies);
-        const unusedDependencies = allDependencies.filter((dependency) => {
-          if (ignore.includes(dependency))
-            return false;
-          return !Array.from(allImportPaths).some((importPath) => importPath === dependency || importPath.startsWith(`${dependency}/`));
-        });
-        if (unusedDependencies.length > 0) {
-          const count = unusedDependencies.length;
-          const depText = count === 1 ? "dependency" : "dependencies";
-          const coloredDeps = formatListWithAnd(unusedDependencies.map((dep) => pc.yellow(dep)));
-          const removeCommand = pc.cyan(`bun remove ${unusedDependencies.join(" ")}`);
-          const message = [
-            `
-Your project${buildOptions.name ? ` ${buildOptions.name}` : ""} has ${count} unused ${depText}: ${coloredDeps}.`,
-            `You can remove ${count === 1 ? "it" : "them"} with ${removeCommand}`
-          ].join(" ");
-          if (level === "error") {
-            logger.log(pc.red(message));
-            process.exit(1);
-          } else {
-            logger.log(message);
-          }
-        }
-      }
-    }
-  };
-}
 export {
   unused,
   shims,