bunup 0.8.48 → 0.8.49

package/dist/chunk-b38k5sg1.js

@@ -0,0 +1,949 @@
+import {
+  filterBunupBunPlugins,
+  filterBunupPlugins,
+  runPluginBuildDoneHooks,
+  runPluginBuildStartHooks
+} from "./chunk-t9xma3m6.js";
+import {
+  loadPackageJson,
+  loadTsConfig
+} from "./chunk-5v78yfze.js";
+import {
+  BunupBuildError,
+  JS_RE,
+  cleanOutDir,
+  cleanPath,
+  deleteExtension,
+  ensureArray,
+  formatFileSize,
+  generateRandomString,
+  getDeclarationExtensionFromJsExtension,
+  getDefaultDtsExtention,
+  getDefaultOutputExtension,
+  getExtension,
+  getFilesFromGlobs,
+  getPackageDeps,
+  getShortFilePath,
+  isDev,
+  isNullOrUndefined,
+  isTypeScriptFile,
+  link,
+  logTable,
+  logger,
+  replaceExtension,
+  returnPathIfExists,
+  setSilent
+} from "./chunk-y0jgbvca.js";
+
+// src/build.ts
+import path2 from "path";
+import pc3 from "picocolors";
+
+// src/dts/generate.ts
+import fs from "fs/promises";
+import path from "path";
+import { isolatedDeclaration } from "oxc-transform";
+import { resolveTsImportPath } from "ts-import-resolver";
+
+// src/dts/fake-js.ts
+import { parse } from "@babel/parser";
+
+// src/dts/re.ts
+var IMPORT_TYPE_RE = /import\s+type\s+/g;
+var EXPORT_TYPE_RE = /export\s+type\s+/g;
+var IMPORT_EXPORT_NAMES_RE = /(import|export)\s*{([^}]*)}/g;
+var IMPORT_EXPORT_WITH_DEFAULT_RE = /(import|export)(\s+[^{,]+,)?\s*{([^}]*)}/g;
+var TYPE_WORD_RE = /\btype\s+/g;
+var EXPORT_DEFAULT_RE = /\bexport\s+default\s+/g;
+var EXPORT_RE = /\bexport\s+/g;
+var TOKENIZE_RE = /(\s+|\/\/.*?(?:\n|$)|\/\*[\s\S]*?\*\/|[a-zA-Z_$][a-zA-Z0-9_$]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?|[(){}[\],.;:]|=>|&&|\|\||[=!<>]=?|\+\+|--|[-+*/%&|^!~?]|\.{3}|::|\.)/g;
+var CAPITAL_LETTER_RE = /[A-Z]/;
+var NODE_MODULES_RE = /node_modules/;
+
+// src/dts/ast.ts
+function isLikelyVariableOrTypeName(token) {
+  return CAPITAL_LETTER_RE.test(token) && !token.startsWith("/*") && !token.startsWith("@") && !token.startsWith('"') && !token.startsWith("'") && !token.startsWith("`");
+}
+function isImportDeclaration(node) {
+  return node.type === "ImportDeclaration";
+}
+function isExportAllDeclaration(node) {
+  return node.type === "ExportAllDeclaration";
+}
+function isReExportStatement(node) {
+  return node.type === "ExportNamedDeclaration" && !node.declaration;
+}
+function hasExportModifier(node, text) {
+  return node.type.startsWith("Export") || text.trim().startsWith("export");
+}
+function hasDefaultExportModifier(node, text) {
+  return node.type === "ExportDefaultDeclaration" || text.trim().startsWith("export default");
+}
+function isDefaultReExport(node) {
+  return node.type === "ExportDefaultDeclaration" && node.declaration?.type === "Identifier";
+}
+function getName(node, source) {
+  if (!node)
+    return null;
+  if (node.type === "ExportNamedDeclaration" && node.declaration) {
+    return getName(node.declaration, source);
+  }
+  if (node.type === "ExportDefaultDeclaration" && node.declaration) {
+    if (node.declaration.type === "Identifier") {
+      return node.declaration.name;
+    }
+    return getName(node.declaration, source);
+  }
+  switch (node.type) {
+    case "TSInterfaceDeclaration":
+    case "TSTypeAliasDeclaration":
+    case "ClassDeclaration":
+    case "TSEnumDeclaration":
+    case "FunctionDeclaration":
+    case "TSDeclareFunction":
+      if (node.id && node.id.type === "Identifier") {
+        return node.id.name;
+      }
+      break;
+    case "TSModuleDeclaration":
+      if (node.id) {
+        if (node.id.type === "Identifier") {
+          return node.id.name;
+        }
+        if (node.id.type === "StringLiteral" && typeof node.id.value === "string") {
+          return node.id.value;
+        }
+      }
+      break;
+    case "VariableDeclaration": {
+      const declarations = node.declarations;
+      if (declarations?.length === 1 && declarations[0].id?.type === "Identifier") {
+        return declarations[0].id.name;
+      }
+      break;
+    }
+  }
+  return null;
+}
+function getCommentText(comments) {
+  if (!comments)
+    return null;
+  return comments.map((comment) => {
+    return comment.type === "CommentBlock" ? `/*${comment.value}*/` : comment.type === "CommentLine" ? `//${comment.value}` : null;
+  }).join(`
+`);
+}
+function getAllImportNames(body) {
+  const importNames = [];
+  for (const statement of body) {
+    if (isImportDeclaration(statement)) {
+      const importDecl = statement;
+      if (importDecl.specifiers) {
+        for (const specifier of importDecl.specifiers) {
+          if (specifier.type === "ImportDefaultSpecifier") {
+            importNames.push(specifier.local.name);
+          } else if (specifier.type === "ImportSpecifier") {
+            importNames.push(specifier.local.name);
+          } else if (specifier.type === "ImportNamespaceSpecifier") {
+            importNames.push(specifier.local.name);
+          }
+        }
+      }
+    }
+  }
+  return importNames;
+}
+
+// src/dts/fake-js.ts
+async function dtsToFakeJs(dtsContent) {
+  const parsed = parse(dtsContent, {
+    sourceType: "module",
+    plugins: ["typescript"],
+    allowImportExportEverywhere: true,
+    allowAwaitOutsideFunction: true
+  });
+  const referencedNames = new Set;
+  const exportedNames = new Set;
+  const result = [];
+  for (const name of getAllImportNames(parsed.program.body)) {
+    referencedNames.add(name);
+  }
+  for (const statement of parsed.program.body) {
+    if (isNullOrUndefined(statement.start) || isNullOrUndefined(statement.end)) {
+      continue;
+    }
+    let leadingComment = null;
+    leadingComment = getCommentText(statement.leadingComments);
+    const slicedContent = dtsContent.substring(statement.start, statement.end);
+    let statementText = `${leadingComment ? `${leadingComment}
+` : ""}${slicedContent}`;
+    const name = getName(statement, dtsContent);
+    if (name) {
+      referencedNames.add(name);
+    }
+    const isDefaultExport = hasDefaultExportModifier(statement, statementText);
+    const isExported = hasExportModifier(statement, statementText);
+    if (isDefaultExport) {
+      result.push(`export { ${name} as default };`);
+      if (isDefaultReExport(statement)) {
+        continue;
+      }
+    }
+    if (isImportDeclaration(statement) || isExportAllDeclaration(statement) || isReExportStatement(statement)) {
+      result.push(jsifyImportExport(statement, dtsContent));
+      continue;
+    }
+    if (isExported) {
+      statementText = statementText.replace(EXPORT_DEFAULT_RE, "").replace(EXPORT_RE, "");
+    }
+    const tokens = tokenizeText(statementText, referencedNames);
+    const varName = name || generateRandomString();
+    result.push(`var ${varName} = [${tokens.join(", ")}];`);
+    if (isExported && !isDefaultExport && !exportedNames.has(varName)) {
+      result.push(`export { ${varName} };`);
+      exportedNames.add(varName);
+    }
+  }
+  return result.join(`
+`);
+}
+async function fakeJsToDts(fakeJsContent) {
+  const parseResult = parse(fakeJsContent, {
+    sourceType: "module"
+  });
+  const program = parseResult.program;
+  const resultParts = [];
+  for (const node of program.body) {
+    if (isNullOrUndefined(node.start) || isNullOrUndefined(node.end)) {
+      continue;
+    }
+    if (isImportDeclaration(node) || isExportAllDeclaration(node) || isReExportStatement(node)) {
+      resultParts.push(fakeJsContent.substring(node.start, node.end).trim().replace(".mjs", "").replace(".cjs", "").replace(".js", ""));
+      continue;
+    }
+    if (node.type === "ExpressionStatement") {
+      const namespaceDecl = handleNamespace(node);
+      if (namespaceDecl) {
+        resultParts.push(namespaceDecl);
+        continue;
+      }
+    }
+    if (node.type === "VariableDeclaration") {
+      for (const declaration of node.declarations) {
+        if (declaration.init?.type === "ArrayExpression") {
+          const dtsContent = processTokenArray(declaration.init);
+          if (dtsContent) {
+            resultParts.push(dtsContent);
+          }
+        }
+      }
+    }
+  }
+  return resultParts.join(`
+`);
+}
+function jsifyImportExport(node, source) {
+  if (isNullOrUndefined(node.start) || isNullOrUndefined(node.end)) {
+    return "";
+  }
+  const text = source.substring(node.start, node.end);
+  let result = text.replace(IMPORT_TYPE_RE, "import ").replace(EXPORT_TYPE_RE, "export ").replace(IMPORT_EXPORT_NAMES_RE, (_, keyword, names) => `${keyword} {${names.replace(TYPE_WORD_RE, "")}}`);
+  result = result.replace(IMPORT_EXPORT_WITH_DEFAULT_RE, (_, keyword, defaultPart = "", names = "") => {
+    const cleanedNames = names.replace(TYPE_WORD_RE, "");
+    return `${keyword}${defaultPart}{${cleanedNames}}`;
+  });
+  return result;
+}
+function tokenizeText(text, referencedNames) {
+  const tokens = [];
+  let match;
+  while (true) {
+    match = TOKENIZE_RE.exec(text);
+    if (match === null)
+      break;
+    const token = match[0];
+    if (isLikelyVariableOrTypeName(token) || referencedNames.has(token)) {
+      tokens.push(token);
+    } else {
+      const processedToken = token.replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+      tokens.push(JSON.stringify(processedToken));
+    }
+  }
+  return tokens;
+}
+function processTokenArray(arrayLiteral) {
+  if (arrayLiteral.type !== "ArrayExpression") {
+    return null;
+  }
+  const tokens = [];
+  for (const element of arrayLiteral.elements) {
+    if (element?.type === "StringLiteral" && typeof element.value === "string") {
+      const processedValue = element.value.replace(/\\n/g, `
+`).replace(/\\t/g, "\t").replace(/\\r/g, "\r");
+      tokens.push(processedValue);
+    } else if (element?.type === "Identifier") {
+      tokens.push(element.name);
+    }
+  }
+  return tokens.join("");
+}
+function handleNamespace(stmt) {
+  const expr = stmt.expression;
+  if (!expr || expr.type !== "CallExpression" || expr.callee?.type !== "Identifier" || expr.arguments?.length !== 2 || expr.arguments[0].type !== "Identifier" || expr.arguments[1].type !== "ObjectExpression") {
+    return null;
+  }
+  const namespaceName = expr.arguments[0].name;
+  const properties = expr.arguments[1].properties.filter((prop) => prop.type === "ObjectProperty").map((prop) => {
+    if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.value.type === "ArrowFunctionExpression" && prop.value.body.type === "Identifier") {
+      const keyName = prop.key.name;
+      const returnName = prop.value.body.name;
+      return keyName === returnName ? keyName : `${returnName} as ${keyName}`;
+    }
+    return null;
+  }).filter(Boolean);
+  if (properties.length === 0) {
+    return null;
+  }
+  return `declare namespace ${namespaceName} {
+  export { ${properties.join(", ")} };
+}`;
+}
+
+// src/dts/logger.ts
+import pc from "picocolors";
+
+// src/constants/index.ts
+var BUNUP_DOCS_URL = "https://bunup.dev/docs";
+var UNDERSTANDING_ISOLATED_DECLARATIONS_URL = "https://github.com/arshad-yaseen/bunup/blob/main/docs/isolated-declarations.md";
+
+// src/dts/logger.ts
+function logIsolatedDeclarationErrors(errors) {
+  let hasSeverityError = false;
+  for (const error of errors) {
+    if (error.error.severity === "Error") {
+      hasSeverityError = true;
+    }
+    logSingle(error);
+  }
+  if (hasSeverityError) {
+    if (isDev()) {
+      console.log(`
+${pc.yellow("Please address the suggestions above before publishing your package.")}
+`);
+    }
+    console.log(`${pc.cyan("Why?")} ${pc.underline(UNDERSTANDING_ISOLATED_DECLARATIONS_URL)}
+`);
+    if (!isDev()) {
+      process.exit(1);
+    }
+  }
+}
+function logSingle(error) {
+  const label = error.error.labels[0];
+  const position = label ? calculateDtsErrorLineAndColumn(error.content, label.start) : "";
+  const shortPath = getShortFilePath(error.file);
+  const errorMessage = `${shortPath}${position}: ${formatDtsErrorMessage(error.error.message)}`;
+  const { color, prefix } = getSeverityFormatting(error.error.severity);
+  const formattedMessage = `${color(prefix)} ${errorMessage}`;
+  const codeFrame = label ? getCodeFrame(error.content, label.start, label.end) : error.error.codeframe ? error.error.codeframe : "";
+  const helpMessage = error.error.helpMessage ? `
+${pc.cyan("Help:")} ${error.error.helpMessage}` : "";
+  console.log(`
+${formattedMessage}${helpMessage}
+
+${pc.gray(codeFrame)}`);
+}
+function getSeverityFormatting(severity) {
+  if (isDev()) {
+    switch (severity) {
+      case "Error":
+        return {
+          color: pc.blue,
+          prefix: "Suggestion"
+        };
+      case "Warning":
+        return { color: pc.yellow, prefix: "Suggestion" };
+      case "Advice":
+        return { color: pc.blue, prefix: "Advice" };
+      default:
+        return {
+          color: pc.blue,
+          prefix: "Suggestion"
+        };
+    }
+  }
+  switch (severity) {
+    case "Error":
+      return {
+        color: pc.red,
+        prefix: "ERROR"
+      };
+    case "Warning":
+      return { color: pc.yellow, prefix: "WARNING" };
+    case "Advice":
+      return { color: pc.blue, prefix: "ADVICE" };
+    default:
+      return {
+        color: pc.red,
+        prefix: "ERROR"
+      };
+  }
+}
+function formatDtsErrorMessage(errorMessage) {
+  return errorMessage.replace(" with --isolatedDeclarations", "").replace(" with --isolatedDeclaration", "");
+}
+function calculateDtsErrorLineAndColumn(sourceText, labelStart) {
+  if (labelStart === undefined)
+    return "";
+  const lines = sourceText.slice(0, labelStart).split(`
+`);
+  const lineNumber = lines.length;
+  const columnStart = lines[lines.length - 1].length + 1;
+  return ` (${lineNumber}:${columnStart})`;
+}
+function getCodeFrame(sourceText, start, end) {
+  const lines = sourceText.split(`
+`);
+  const errorLine = sourceText.slice(0, start).split(`
+`).length;
+  const lineContent = lines[errorLine - 1];
+  const startCol = start - sourceText.slice(0, start).lastIndexOf(`
+`) - 1;
+  const endCol = end ? Math.min(end - sourceText.slice(0, start).lastIndexOf(`
+`) - 1, lineContent.length) : startCol + 1;
+  const arrowLine = " ".repeat(startCol) + pc[isDev() ? "blue" : "red"](pc.dim("\u23AF".repeat(Math.max(1, endCol - startCol))));
+  return `${lineContent}
+${arrowLine}`;
+}
+function handleBunBuildLogs(logs) {
+  for (const log of logs) {
+    if (log.level === "error") {
+      logger.error(`${log.message} in ${log.position?.file}`);
+      throw new Error("Failed to generate declaration file");
+    }
+    if (log.level === "warning") {
+      logger.warn(log.message);
+    }
+    if (log.level === "info") {
+      logger.info(log.message);
+    }
+  }
+}
+
+// src/dts/resolver.ts
+import { dirname } from "path";
+import process2 from "process";
+import { ResolverFactory } from "oxc-resolver";
+function createResolver({
+  tsconfig,
+  cwd = process2.cwd(),
+  resolveOption
+}) {
+  const resolver = new ResolverFactory({
+    mainFields: ["types", "typings", "module", "main"],
+    conditionNames: ["types", "typings", "import", "require"],
+    extensions: [".d.ts", ".d.mts", ".d.cts", ".ts", ".mts", ".cts"],
+    tsconfig: tsconfig ? { configFile: tsconfig, references: "auto" } : undefined
+  });
+  const resolutionCache = new Map;
+  return (importSource, importer) => {
+    if (importSource === "bun")
+      return null;
+    const cacheKey = `${importSource}:${importer || ""}`;
+    if (resolutionCache.has(cacheKey)) {
+      return resolutionCache.get(cacheKey) || null;
+    }
+    let shouldResolve = false;
+    if (resolveOption !== undefined) {
+      if (typeof resolveOption === "boolean") {
+        shouldResolve = resolveOption;
+      } else if (Array.isArray(resolveOption)) {
+        shouldResolve = resolveOption.some((resolver2) => {
+          if (typeof resolver2 === "string") {
+            return resolver2 === importSource;
+          }
+          return resolver2.test(importSource);
+        });
+      }
+    }
+    if (!shouldResolve) {
+      resolutionCache.set(cacheKey, null);
+      return null;
+    }
+    const directory = importer ? dirname(importer) : cwd;
+    const resolution = resolver.sync(directory, importSource);
+    if (!resolution.path) {
+      resolutionCache.set(cacheKey, null);
+      return null;
+    }
+    const resolved = resolution.path;
+    if (JS_RE.test(resolved)) {
+      const dts = returnPathIfExists(resolved.replace(JS_RE, ".d.ts")) || returnPathIfExists(resolved.replace(JS_RE, ".d.mts")) || returnPathIfExists(resolved.replace(JS_RE, ".d.cts"));
+      const result2 = isTypeScriptFile(dts) ? dts : null;
+      resolutionCache.set(cacheKey, result2);
+      return result2;
+    }
+    const result = isTypeScriptFile(resolved) ? resolved : null;
+    resolutionCache.set(cacheKey, result);
+    return result;
+  };
+}
+
+// src/dts/generate.ts
+async function generateDts(entrypoints, options) {
+  const { resolve, preferredTsConfigPath } = options;
+  const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+  const tsconfig = await loadTsConfig(cwd, preferredTsConfigPath);
+  const tempOutDir = path.resolve(path.join(cwd, `.bunup-dts-${generateRandomString()}`));
+  const nonAbsoluteEntrypoints = entrypoints.filter((entrypoint) => !path.isAbsolute(entrypoint));
+  const resolvedEntrypoints = await getFilesFromGlobs(nonAbsoluteEntrypoints, cwd);
+  const absoluteEntrypoints = entrypoints.filter((entrypoint) => path.isAbsolute(entrypoint));
+  if (![...resolvedEntrypoints, ...absoluteEntrypoints].length) {
+    throw new Error("The dts entrypoints you provided do not exist. Please make sure the entrypoints point to valid files.");
+  }
+  const collectedErrors = [];
+  const resolver = createResolver({
+    cwd,
+    resolveOption: resolve,
+    tsconfig: tsconfig.filepath
+  });
+  const fakeJsPlugin = {
+    name: "fake-js",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        if (!NODE_MODULES_RE.test(args.importer)) {
+          const resolved = resolveTsImportPath({
+            importer: args.importer,
+            path: args.path,
+            cwd,
+            tsconfig: tsconfig.config
+          });
+          if (resolved && isTypeScriptFile(resolved)) {
+            return { path: resolved };
+          }
+        }
+        const resolvedFromNodeModules = resolver(args.path, args.importer);
+        if (resolvedFromNodeModules) {
+          return { path: resolvedFromNodeModules };
+        }
+        return {
+          path: args.path,
+          external: true
+        };
+      });
+      build.onLoad({ filter: /\.(ts|tsx|d\.ts|d\.mts|d\.cts)$/ }, async (args) => {
+        const sourceText = await Bun.file(args.path).text();
+        const declarationResult = isolatedDeclaration(args.path, sourceText);
+        if (!collectedErrors.some((e) => e.file === args.path)) {
+          for (const error of declarationResult.errors) {
+            collectedErrors.push({
+              error,
+              file: args.path,
+              content: sourceText
+            });
+          }
+        }
+        const fakeJsContent = await dtsToFakeJs(declarationResult.code);
+        return {
+          loader: "js",
+          contents: fakeJsContent
+        };
+      });
+    }
+  };
+  const result = await Bun.build({
+    entrypoints: [
+      ...resolvedEntrypoints.map((entry) => path.resolve(path.join(cwd, entry))),
+      ...absoluteEntrypoints
+    ],
+    outdir: tempOutDir,
+    format: "esm",
+    target: "node",
+    splitting: options.splitting,
+    plugins: [fakeJsPlugin],
+    throw: false,
+    packages: "external",
+    minify: options.minify
+  });
+  handleBunBuildLogs(result.logs);
+  try {
+    const outputs = result.outputs.filter((output) => output.kind === "chunk" || output.kind === "entry-point");
+    const bundledFiles = [];
+    for (const output of outputs) {
+      const bundledFakeJsPath = output.path;
+      const bundledFakeJsContent = await Bun.file(bundledFakeJsPath).text();
+      const dtsContent = isolatedDeclaration("treeshake.d.ts", await fakeJsToDts(bundledFakeJsContent));
+      const entrypoint = output.kind === "entry-point" ? entrypoints[bundledFiles.length] : undefined;
+      const chunkFileName = output.kind === "chunk" ? replaceExtension(path.basename(output.path), getDeclarationExtensionFromJsExtension(getExtension(output.path))) : undefined;
+      const outputPath = cleanPath(replaceExtension(cleanPath(output.path).replace(`${cleanPath(tempOutDir)}/`, ""), getDeclarationExtensionFromJsExtension(getExtension(output.path))));
+      bundledFiles.push({
+        kind: output.kind === "entry-point" ? "entry-point" : "chunk",
+        entrypoint,
+        chunkFileName,
+        outputPath,
+        dts: dtsContent.code,
+        pathInfo: {
+          outputPathWithoutExtension: deleteExtension(outputPath),
+          ext: getExtension(outputPath)
+        }
+      });
+    }
+    return {
+      files: bundledFiles,
+      errors: collectedErrors
+    };
+  } catch (error) {
+    console.error(error);
+    return {
+      files: [],
+      errors: collectedErrors
+    };
+  } finally {
+    await fs.rm(tempOutDir, { recursive: true, force: true });
+  }
+}
+// src/plugins/internal/linter.ts
+var rules = [
+  {
+    check: (ctx) => {
+      const hasMinification = !!(ctx.options.minify || ctx.options.minifyWhitespace || ctx.options.minifyIdentifiers || ctx.options.minifySyntax);
+      return hasMinification && !ctx.options.sourcemap;
+    },
+    message: `You are using minification without source maps. Consider enabling source maps to help with debugging minified code. Learn more: ${link("https://bunup.dev/docs/guide/options#source-maps")}`,
+    logLevel: "recommended"
+  }
+];
+function linter() {
+  return {
+    type: "bunup",
+    name: "linter",
+    hooks: {
+      onBuildDone: (ctx) => {
+        let hasWarnings = false;
+        for (const rule of rules) {
+          if (rule.check(ctx)) {
+            if (!hasWarnings) {
+              logger.space();
+            }
+            logger[rule.logLevel ?? "warn"](rule.message);
+            hasWarnings = true;
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/plugins/internal/report.ts
+import pc2 from "picocolors";
+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: pc2.blue },
+          { header: "Size", align: "right", color: pc2.green },
+          {
+            header: "Gzip",
+            align: "right",
+            color: pc2.magenta
+          }
+        ];
+        const data = files.map((file) => {
+          return {
+            File: file.name,
+            Size: file.formattedSize,
+            Gzip: file.formattedGzipSize
+          };
+        });
+        const footer = {
+          File: "Total",
+          Size: formattedTotalSize,
+          Gzip: formattedTotalGzipSize
+        };
+        logger.space();
+        logTable(columns, data, footer);
+        logger.space();
+      }
+    }
+  };
+}
+
+// src/plugins/internal/use-client.ts
+function useClient() {
+  return {
+    type: "bunup",
+    name: "use-client",
+    hooks: {
+      onBuildDone: async ({ output }) => {
+        for (const file of output.files) {
+          let text = await Bun.file(file.fullPath).text();
+          const hasUseClient = text.split(`
+`).some((line) => line.trim().startsWith(`"use client";`));
+          if (hasUseClient) {
+            text = text.replaceAll(`"use client";`, "");
+            text = `"use client";
+${text}`;
+          }
+          await Bun.write(file.fullPath, text);
+        }
+      }
+    }
+  };
+}
+
+// src/options.ts
+var DEFAULT_OPTIONS = {
+  entry: ["src/index.ts"],
+  format: ["cjs"],
+  outDir: "dist",
+  target: "node",
+  clean: true
+};
+function createBuildOptions(partialOptions) {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...partialOptions
+  };
+  return {
+    ...options,
+    plugins: [...options.plugins ?? [], useClient(), linter(), report()]
+  };
+}
+function getResolvedMinify(options) {
+  const { minify, minifyWhitespace, minifyIdentifiers, minifySyntax } = options;
+  const defaultValue = minify === true;
+  return {
+    whitespace: minifyWhitespace ?? defaultValue,
+    identifiers: minifyIdentifiers ?? defaultValue,
+    syntax: minifySyntax ?? defaultValue
+  };
+}
+function getResolvedBytecode(bytecode, format) {
+  return format === "cjs" ? bytecode : undefined;
+}
+function getResolvedSourcemap(sourcemap) {
+  if (sourcemap === true) {
+    return "inline";
+  }
+  return typeof sourcemap === "string" ? sourcemap : undefined;
+}
+function getResolvedDefine(define, env) {
+  return {
+    ...typeof env === "object" && Object.keys(env).reduce((acc, key) => {
+      const value = JSON.stringify(env[key]);
+      acc[`process.env.${key}`] = value;
+      acc[`import.meta.env.${key}`] = value;
+      return acc;
+    }, {}),
+    ...define
+  };
+}
+function getResolvedSplitting(splitting, format) {
+  return splitting === undefined ? format === "esm" : splitting;
+}
+function getResolvedDtsSplitting(splitting) {
+  return splitting ?? true;
+}
+var DEFAULT_ENTRY_NAMING = "[dir]/[name].[ext]";
+function getResolvedNaming(fmt, packageType) {
+  const replaceExt = (pattern) => pattern.replace(".[ext]", getDefaultOutputExtension(fmt, packageType));
+  return replaceExt(DEFAULT_ENTRY_NAMING);
+}
+function getResolvedEnv(env) {
+  return typeof env === "string" ? env : undefined;
+}
+
+// src/helpers/external.ts
+function getPackageDepsPatterns(packageJson) {
+  return getPackageDeps(packageJson).map((dep) => new RegExp(`^${dep}($|\\/|\\\\)`));
+}
+function matchesPattern(path2, pattern) {
+  return typeof pattern === "string" ? pattern === path2 : pattern.test(path2);
+}
+function isExternal(path2, options, packageJson) {
+  const packageDepsPatterns = getPackageDepsPatterns(packageJson);
+  const matchesExternalPattern = packageDepsPatterns.some((pattern) => pattern.test(path2)) || options.external?.some((pattern) => matchesPattern(path2, pattern));
+  const isExcludedFromExternal = options.noExternal?.some((pattern) => matchesPattern(path2, 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
+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.info(`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)
+  ];
+  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(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),
+      ignoreDCEAnnotations: options.ignoreDCEAnnotations,
+      emitDCEAnnotations: options.emitDCEAnnotations,
+      throw: false,
+      plugins
+    });
+    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);
+    }
+    let entrypointIndex = 0;
+    for (const file of result.outputs) {
+      const relativePathToRootDir = getRelativePathToRootDir(file.path, rootDir);
+      const relativePathToOutputDir = getRelativePathToOutputDir(relativePathToRootDir, options.outDir);
+      if (file.kind === "entry-point") {
+        logger.success(`${pc3.dim(`${options.outDir}/`)}${relativePathToOutputDir}`, {
+          identifier: options.name
+        });
+      }
+      buildOutput.files.push({
+        fullPath: file.path,
+        relativePathToRootDir,
+        relativePathToOutputDir,
+        dts: false,
+        format: fmt,
+        kind: file.kind,
+        entrypoint: file.kind === "entry-point" ? cleanPath(entrypoints[entrypointIndex]) : undefined
+      });
+      if (file.kind === "entry-point") {
+        entrypointIndex++;
+      }
+    }
+  });
+  await Promise.all(buildPromises);
+  if (options.dts) {
+    const { entry, splitting, ...dtsOptions } = typeof options.dts === "object" ? options.dts : {};
+    const dtsResult = await generateDts(ensureArray(entry ?? entrypoints), {
+      cwd: rootDir,
+      preferredTsConfigPath: options.preferredTsconfigPath,
+      splitting: getResolvedDtsSplitting(splitting),
+      ...dtsOptions
+    });
+    if (dtsResult.errors.length) {
+      logIsolatedDeclarationErrors(dtsResult.errors);
+    }
+    for (const fmt of options.format) {
+      for (const file of dtsResult.files) {
+        const dtsExtension = getDefaultDtsExtention(fmt, packageType);
+        const relativePathToOutputDir = cleanPath(`${file.pathInfo.outputPathWithoutExtension}${dtsExtension}`);
+        const relativePathToRootDir = cleanPath(`${options.outDir}/${relativePathToOutputDir}`);
+        if (file.kind === "entry-point") {
+          logger.success(`${pc3.dim(`${options.outDir}/`)}${relativePathToOutputDir}`, {
+            identifier: options.name
+          });
+        }
+        const fullPath = path2.join(rootDir, relativePathToRootDir);
+        await Bun.write(fullPath, file.dts);
+        buildOutput.files.push({
+          fullPath,
+          relativePathToRootDir,
+          relativePathToOutputDir,
+          dts: true,
+          format: fmt,
+          kind: file.kind,
+          entrypoint: file.entrypoint ? cleanPath(file.entrypoint) : undefined
+        });
+      }
+    }
+  }
+  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)}/`, "");
+}
+
+export { BUNUP_DOCS_URL, createBuildOptions, build };