elit 2.0.1 → 3.0.0

package/dist/build.js

@@ -1 +1,670 @@
-"use strict";var e=require("esbuild"),t=require("fs"),o=require("path"),n={outDir:"dist",minify:!0,sourcemap:!1,target:"es2020",format:"esm",treeshake:!0,logging:!0,external:[]};function i(e){if(0===e)return"0 B";let t=Math.floor(Math.log(e)/Math.log(1024));return parseFloat((e/Math.pow(1024,t)).toFixed(2))+" "+["B","KB","MB","GB"][t]}exports.build=async function(r){let l={...n,...r},s=Date.now();if(!l.entry)throw new Error("Entry file is required");let a=o.resolve(l.entry),c=o.resolve(l.outDir),g=l.outFile;if(!g){g=o.basename(l.entry,o.extname(l.entry))+("cjs"===l.format?".cjs":".js")}let f=o.join(c,g);try{t.mkdirSync(c,{recursive:!0})}catch{}l.logging&&(console.log("\n🔨 Building..."),console.log(`  Entry:  ${l.entry}`),console.log(`  Output: ${f}`),console.log(`  Format: ${l.format}`),console.log(`  Target: ${l.target}`));let u={name:"browser-only",setup(e){e.onResolve({filter:/^(node:.*|fs|path|http|https|url|os|child_process|net|tls|crypto|stream|util|events|buffer|zlib|readline|process|assert|constants|dns|domain|punycode|querystring|repl|string_decoder|sys|timers|tty|v8|vm)$/},()=>({path:"node-builtin",external:!0,sideEffects:!1})),e.onResolve({filter:/^(chokidar|esbuild|mime-types|open|ws|fs\/promises)$/},()=>({path:"server-dep",external:!0,sideEffects:!1})),e.onLoad({filter:/[\\/](server|config|cli)\.ts$/},()=>({contents:"export {}",loader:"js"}))}};try{let n=l.platform||("cjs"===l.format?"node":"browser"),r="browser"===n?[u]:[],g={};l.env&&(Object.entries(l.env).forEach(([e,t])=>{e.startsWith("VITE_")&&(g[`import.meta.env.${e}`]=JSON.stringify(t))}),l.env.MODE&&(g["import.meta.env.MODE"]=JSON.stringify(l.env.MODE)),g["import.meta.env.DEV"]=JSON.stringify("production"!==l.env.MODE),g["import.meta.env.PROD"]=JSON.stringify("production"===l.env.MODE));let m=await e.build({entryPoints:[a],bundle:!0,outfile:f,format:l.format,target:l.target,minify:l.minify,sourcemap:l.sourcemap,external:l.external,treeShaking:l.treeshake,globalName:l.globalName,platform:n,plugins:r,define:g,logLevel:l.logging?"info":"silent",metafile:!0,...l.minify&&{minifyWhitespace:!0,minifyIdentifiers:!0,minifySyntax:!0,legalComments:"none",mangleProps:/^_/,keepNames:!1}}),p=Date.now()-s,y=t.statSync(f).size;if(l.logging&&(console.log("\n✅ Build successful!"),console.log(`  Time: ${p}ms`),console.log(`  Size: ${i(y)}`),m.metafile)){let e=Object.keys(m.metafile.inputs).length;console.log(`  Files: ${e} input(s)`);let t=Object.keys(m.metafile.outputs);if(t.length>0){let e=m.metafile.outputs[t[0]];if(e&&e.inputs){let t=Object.entries(e.inputs).sort(([,e],[,t])=>t.bytesInOutput-e.bytesInOutput).slice(0,5);t.length>0&&(console.log("\n  📊 Top 5 largest modules:"),t.forEach(([e,t])=>{let o=e.split(/[/\\]/).pop()||e;console.log(`     ${o.padEnd(30)} ${i(t.bytesInOutput)}`)}))}}}let d={outputPath:f,buildTime:p,size:y};if(l.copy&&l.copy.length>0){l.logging&&console.log("\n📦 Copying files...");for(let e of l.copy){let n=o.resolve(e.from),i=o.resolve(c,e.to),r=o.dirname(i);if(t.existsSync(r)||t.mkdirSync(r,{recursive:!0}),t.existsSync(n)){if(e.transform){let o=t.readFileSync(n,"utf-8"),r=e.transform(o,l);t.writeFileSync(i,r)}else t.copyFileSync(n,i);l.logging&&console.log(`  ✓ ${e.from} → ${e.to}`)}else l.logging&&console.warn(`  ⚠ File not found: ${e.from}`)}}return l.onBuildEnd&&await l.onBuildEnd(d),l.logging&&console.log(""),d}catch(e){throw l.logging&&(console.error("\n❌ Build failed:"),console.error(e)),e}};
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/build.ts
+var build_exports = {};
+__export(build_exports, {
+  build: () => build
+});
+module.exports = __toCommonJS(build_exports);
+
+// src/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+var isNode = runtime === "node";
+var isBun = runtime === "bun";
+var isDeno = runtime === "deno";
+
+// src/fs.ts
+function parseOptions(options, defaultValue) {
+  return typeof options === "string" ? { encoding: options } : options || defaultValue;
+}
+function decodeContent(content, encoding) {
+  if (encoding) {
+    return new TextDecoder(encoding).decode(content);
+  }
+  return Buffer.from(content instanceof ArrayBuffer ? new Uint8Array(content) : content);
+}
+function dataToUint8Array(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Buffer) {
+    return new Uint8Array(data);
+  }
+  return data;
+}
+var fs;
+var fsPromises;
+if (isNode) {
+  fs = require("fs");
+  fsPromises = require("fs/promises");
+}
+function readFileSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fs.readFileSync(path, opts);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const content = file.arrayBuffer();
+    return decodeContent(content, opts.encoding);
+  } else if (isDeno) {
+    const content = Deno.readFileSync(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+function writeFileSync(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    fs.writeFileSync(path, data, opts);
+  } else if (isBun) {
+    Bun.write(path, data);
+  } else if (isDeno) {
+    Deno.writeFileSync(path, dataToUint8Array(data));
+  }
+}
+function existsSync(path) {
+  try {
+    statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function statSync(path) {
+  if (isNode) {
+    return fs.statSync(path);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const size = file.size;
+    try {
+      file.arrayBuffer();
+    } catch {
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+    }
+    return createStatsObject(path, size, false);
+  } else if (isDeno) {
+    const info = Deno.statSync(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+function mkdirSync(path, options) {
+  const opts = typeof options === "number" ? { mode: options } : options || {};
+  if (isNode) {
+    fs.mkdirSync(path, opts);
+  } else if (isBun) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  } else if (isDeno) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  }
+}
+function copyFileSync(src, dest, flags) {
+  if (isNode) {
+    fs.copyFileSync(src, dest, flags);
+  } else if (isBun) {
+    Deno.copyFileSync(src, dest);
+  } else if (isDeno) {
+    Deno.copyFileSync(src, dest);
+  }
+}
+function createStatsObject(_path, size, isDir) {
+  const now = Date.now();
+  return {
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: 0,
+    ino: 0,
+    mode: isDir ? 16877 : 33188,
+    nlink: 1,
+    uid: 0,
+    gid: 0,
+    rdev: 0,
+    size,
+    blksize: 4096,
+    blocks: Math.ceil(size / 512),
+    atimeMs: now,
+    mtimeMs: now,
+    ctimeMs: now,
+    birthtimeMs: now,
+    atime: new Date(now),
+    mtime: new Date(now),
+    ctime: new Date(now),
+    birthtime: new Date(now)
+  };
+}
+function createStatsFromDenoFileInfo(info) {
+  return {
+    isFile: () => info.isFile,
+    isDirectory: () => info.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => info.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: info.dev || 0,
+    ino: info.ino || 0,
+    mode: info.mode || 0,
+    nlink: info.nlink || 1,
+    uid: info.uid || 0,
+    gid: info.gid || 0,
+    rdev: 0,
+    size: info.size,
+    blksize: info.blksize || 4096,
+    blocks: info.blocks || Math.ceil(info.size / 512),
+    atimeMs: info.atime?.getTime() || Date.now(),
+    mtimeMs: info.mtime?.getTime() || Date.now(),
+    ctimeMs: info.birthtime?.getTime() || Date.now(),
+    birthtimeMs: info.birthtime?.getTime() || Date.now(),
+    atime: info.atime || /* @__PURE__ */ new Date(),
+    mtime: info.mtime || /* @__PURE__ */ new Date(),
+    ctime: info.birthtime || /* @__PURE__ */ new Date(),
+    birthtime: info.birthtime || /* @__PURE__ */ new Date()
+  };
+}
+
+// src/path.ts
+function getSeparator(isWin) {
+  return isWin ? "\\" : "/";
+}
+function getCwd() {
+  if (isNode || isBun) {
+    return process.cwd();
+  } else if (isDeno) {
+    return Deno.cwd();
+  }
+  return "/";
+}
+function findLastSeparator(path) {
+  return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+}
+function createPathOps(isWin) {
+  return {
+    sep: getSeparator(isWin),
+    delimiter: isWin ? ";" : ":",
+    normalize: (path) => normalizePath(path, isWin),
+    join: (...paths) => joinPaths(paths, isWin),
+    resolve: (...paths) => resolvePaths(paths, isWin),
+    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+    relative: (from, to) => relativePath(from, to, isWin),
+    dirname: (path) => getDirname(path, isWin),
+    basename: (path, ext) => getBasename(path, ext, isWin),
+    extname: (path) => getExtname(path),
+    parse: (path) => parsePath(path, isWin),
+    format: (pathObject) => formatPath(pathObject, isWin)
+  };
+}
+function isAbsolutePosix(path) {
+  return path.length > 0 && path[0] === "/";
+}
+function isAbsoluteWin(path) {
+  const len = path.length;
+  if (len === 0) return false;
+  const code = path.charCodeAt(0);
+  if (code === 47 || code === 92) {
+    return true;
+  }
+  if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+    if (len > 2 && path.charCodeAt(1) === 58) {
+      const code2 = path.charCodeAt(2);
+      if (code2 === 47 || code2 === 92) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var isWindows = (() => {
+  if (isNode) {
+    return process.platform === "win32";
+  } else if (isDeno) {
+    return Deno.build.os === "windows";
+  }
+  return typeof process !== "undefined" && process.platform === "win32";
+})();
+var posix = createPathOps(false);
+var win32 = createPathOps(true);
+function normalizePath(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
+  const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
+  let normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const parts = normalized.split(separator);
+  const result = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "" || part === ".") {
+      if (i === 0 && isAbsolute) result.push("");
+      continue;
+    }
+    if (part === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        if (!(result.length === 1 && result[0] === "")) {
+          result.pop();
+        }
+      } else if (!isAbsolute) {
+        result.push("..");
+      }
+    } else {
+      result.push(part);
+    }
+  }
+  let final = result.join(separator);
+  if (final.length === 0) {
+    return isAbsolute ? separator : ".";
+  }
+  if (trailingSeparator && final[final.length - 1] !== separator) {
+    final += separator;
+  }
+  return final;
+}
+function joinPaths(paths, isWin) {
+  if (paths.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  let joined = "";
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    if (path && path.length > 0) {
+      if (joined.length === 0) {
+        joined = path;
+      } else {
+        joined += separator + path;
+      }
+    }
+  }
+  if (joined.length === 0) return ".";
+  return normalizePath(joined, isWin);
+}
+function resolvePaths(paths, isWin) {
+  const separator = getSeparator(isWin);
+  let resolved = "";
+  let isAbsolute = false;
+  for (let i = paths.length - 1; i >= 0 && !isAbsolute; i--) {
+    const path = paths[i];
+    if (path && path.length > 0) {
+      resolved = path + (resolved.length > 0 ? separator + resolved : "");
+      isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+    }
+  }
+  if (!isAbsolute) {
+    const cwd = getCwd();
+    resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
+  }
+  return normalizePath(resolved, isWin);
+}
+function relativePath(from, to, isWin) {
+  from = resolvePaths([from], isWin);
+  to = resolvePaths([to], isWin);
+  if (from === to) return "";
+  const separator = getSeparator(isWin);
+  const fromParts = from.split(separator).filter((p) => p.length > 0);
+  const toParts = to.split(separator).filter((p) => p.length > 0);
+  let commonLength = 0;
+  const minLength = Math.min(fromParts.length, toParts.length);
+  for (let i = 0; i < minLength; i++) {
+    if (fromParts[i] === toParts[i]) {
+      commonLength++;
+    } else {
+      break;
+    }
+  }
+  const upCount = fromParts.length - commonLength;
+  const result = [];
+  for (let i = 0; i < upCount; i++) {
+    result.push("..");
+  }
+  for (let i = commonLength; i < toParts.length; i++) {
+    result.push(toParts[i]);
+  }
+  return result.join(separator) || ".";
+}
+function getDirname(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const normalized = normalizePath(path, isWin);
+  const lastSepIndex = normalized.lastIndexOf(separator);
+  if (lastSepIndex === -1) return ".";
+  if (lastSepIndex === 0) return separator;
+  return normalized.slice(0, lastSepIndex);
+}
+function getBasename(path, ext, isWin) {
+  if (path.length === 0) return "";
+  const lastSepIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+  let base = lastSepIndex === -1 ? path : path.slice(lastSepIndex + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, base.length - ext.length);
+  }
+  return base;
+}
+function getExtname(path) {
+  const lastDotIndex = path.lastIndexOf(".");
+  const lastSepIndex = findLastSeparator(path);
+  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+    return "";
+  }
+  return path.slice(lastDotIndex);
+}
+function parsePath(path, isWin) {
+  let root = "";
+  if (isWin) {
+    if (path.length >= 2 && path[1] === ":") {
+      root = path.slice(0, 2);
+      if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
+        root += "\\";
+      }
+    } else if (path[0] === "\\" || path[0] === "/") {
+      root = "\\";
+    }
+  } else {
+    if (path[0] === "/") {
+      root = "/";
+    }
+  }
+  const dir = getDirname(path, isWin);
+  const base = getBasename(path, void 0, isWin);
+  const ext = getExtname(path);
+  const name = ext ? base.slice(0, base.length - ext.length) : base;
+  return { root, dir, base, ext, name };
+}
+function formatPath(pathObject, isWin) {
+  const separator = getSeparator(isWin);
+  const dir = pathObject.dir || pathObject.root || "";
+  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) return base;
+  if (dir === pathObject.root) return dir + base;
+  return dir + separator + base;
+}
+function join(...paths) {
+  return joinPaths(paths, isWindows);
+}
+function resolve(...paths) {
+  return resolvePaths(paths, isWindows);
+}
+function dirname(path) {
+  return getDirname(path, isWindows);
+}
+function basename(path, ext) {
+  return getBasename(path, ext, isWindows);
+}
+function extname(path) {
+  return getExtname(path);
+}
+
+// src/build.ts
+function ensureDir(dirPath) {
+  try {
+    mkdirSync(dirPath, { recursive: true });
+  } catch (error) {
+  }
+}
+function calculateBuildMetrics(startTime, outputPath) {
+  const buildTime = Date.now() - startTime;
+  const stats = statSync(outputPath);
+  return { buildTime, size: stats.size };
+}
+function readFileAsString(filePath) {
+  const contentBuffer = readFileSync(filePath, "utf-8");
+  return typeof contentBuffer === "string" ? contentBuffer : contentBuffer.toString("utf-8");
+}
+function getMinifyOptions(minify) {
+  return minify ? {
+    minifyWhitespace: true,
+    minifyIdentifiers: true,
+    minifySyntax: true,
+    legalComments: "none",
+    mangleProps: /^_/,
+    keepNames: false
+  } : {};
+}
+function logBuildInfo(config, outputPath) {
+  console.log("\n\u{1F528} Building...");
+  console.log(`  Entry:  ${config.entry}`);
+  console.log(`  Output: ${outputPath}`);
+  console.log(`  Format: ${config.format}`);
+  console.log(`  Target: ${config.target}`);
+}
+function logBuildSuccess(buildTime, size) {
+  console.log(`
+\u2705 Build successful!`);
+  console.log(`  Time: ${buildTime}ms`);
+  console.log(`  Size: ${formatBytes(size)}`);
+}
+var defaultOptions = {
+  outDir: "dist",
+  minify: true,
+  sourcemap: false,
+  target: "es2020",
+  format: "esm",
+  treeshake: true,
+  logging: true,
+  external: []
+};
+async function build(options) {
+  const config = { ...defaultOptions, ...options };
+  const startTime = Date.now();
+  if (!config.entry) {
+    throw new Error("Entry file is required");
+  }
+  const entryPath = resolve(config.entry);
+  const outDir = resolve(config.outDir);
+  let outFile = config.outFile;
+  if (!outFile) {
+    const baseName = basename(config.entry, extname(config.entry));
+    const ext = config.format === "cjs" ? ".cjs" : ".js";
+    outFile = baseName + ext;
+  }
+  const outputPath = join(outDir, outFile);
+  ensureDir(outDir);
+  if (config.logging) {
+    logBuildInfo(config, outputPath);
+  }
+  const browserOnlyPlugin = {
+    name: "browser-only",
+    setup(build2) {
+      build2.onResolve({ filter: /^(node:.*|fs|path|http|https|url|os|child_process|net|tls|crypto|stream|util|events|buffer|zlib|readline|process|assert|constants|dns|domain|punycode|querystring|repl|string_decoder|sys|timers|tty|v8|vm)$/ }, () => {
+        return { path: "node-builtin", external: true, sideEffects: false };
+      });
+      build2.onResolve({ filter: /^(chokidar|esbuild|mime-types|open|ws|fs\/promises)$/ }, () => {
+        return { path: "server-dep", external: true, sideEffects: false };
+      });
+      build2.onLoad({ filter: /[\\/](server|config|cli)\.ts$/ }, () => {
+        return {
+          contents: "export {}",
+          loader: "js"
+        };
+      });
+    }
+  };
+  try {
+    const platform = config.platform || (config.format === "cjs" ? "node" : "browser");
+    const plugins = platform === "browser" ? [browserOnlyPlugin] : [];
+    const define = {};
+    if (config.env) {
+      Object.entries(config.env).forEach(([key, value]) => {
+        if (key.startsWith("VITE_")) {
+          define[`import.meta.env.${key}`] = JSON.stringify(value);
+        }
+      });
+      if (config.env.MODE) {
+        define["import.meta.env.MODE"] = JSON.stringify(config.env.MODE);
+      }
+      define["import.meta.env.DEV"] = JSON.stringify(config.env.MODE !== "production");
+      define["import.meta.env.PROD"] = JSON.stringify(config.env.MODE === "production");
+    }
+    let result;
+    let buildTime;
+    let size;
+    if (runtime === "node") {
+      const { build: esbuild } = await import("esbuild");
+      result = await esbuild({
+        entryPoints: [entryPath],
+        bundle: true,
+        outfile: outputPath,
+        format: config.format,
+        target: config.target,
+        minify: config.minify,
+        sourcemap: config.sourcemap,
+        external: config.external,
+        treeShaking: config.treeshake,
+        globalName: config.globalName,
+        platform,
+        plugins,
+        define,
+        logLevel: config.logging ? "info" : "silent",
+        metafile: true,
+        // Additional optimizations
+        ...getMinifyOptions(config.minify)
+      });
+      ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
+    } else if (runtime === "bun") {
+      result = await Bun.build({
+        entrypoints: [entryPath],
+        outdir: outDir,
+        target: "bun",
+        format: config.format === "cjs" ? "cjs" : "esm",
+        minify: config.minify,
+        sourcemap: config.sourcemap ? "external" : "none",
+        external: config.external,
+        naming: outFile,
+        define
+      });
+      if (!result.success) {
+        throw new Error("Bun build failed: " + JSON.stringify(result.logs));
+      }
+      ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
+    } else {
+      result = await Deno.emit(entryPath, {
+        bundle: "module",
+        check: false,
+        compilerOptions: {
+          target: config.target,
+          module: config.format === "cjs" ? "commonjs" : "esnext",
+          sourceMap: config.sourcemap
+        }
+      });
+      const bundledCode = result.files["deno:///bundle.js"];
+      if (bundledCode) {
+        await Deno.writeTextFile(outputPath, bundledCode);
+      }
+      ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
+    }
+    if (config.logging) {
+      logBuildSuccess(buildTime, size);
+      if (runtime === "node" && result.metafile) {
+        const inputs = Object.keys(result.metafile.inputs).length;
+        console.log(`  Files: ${inputs} input(s)`);
+        const outputKeys = Object.keys(result.metafile.outputs);
+        if (outputKeys.length > 0) {
+          const mainOutput = result.metafile.outputs[outputKeys[0]];
+          if (mainOutput && mainOutput.inputs) {
+            const sortedInputs = Object.entries(mainOutput.inputs).sort(([, a], [, b]) => {
+              const aBytes = a.bytesInOutput || 0;
+              const bBytes = b.bytesInOutput || 0;
+              return bBytes - aBytes;
+            }).slice(0, 5);
+            if (sortedInputs.length > 0) {
+              console.log("\n  \u{1F4CA} Top 5 largest modules:");
+              sortedInputs.forEach(([file, info]) => {
+                const fileName = file.split(/[/\\]/).pop() || file;
+                const infoBytes = info.bytesInOutput || 0;
+                console.log(`     ${fileName.padEnd(30)} ${formatBytes(infoBytes)}`);
+              });
+            }
+          }
+        }
+      }
+    }
+    const buildResult = {
+      outputPath,
+      buildTime,
+      size
+    };
+    if (config.copy && config.copy.length > 0) {
+      if (config.logging) {
+        console.log("\n\u{1F4E6} Copying files...");
+      }
+      for (const copyItem of config.copy) {
+        const fromPath = resolve(copyItem.from);
+        const toPath = resolve(outDir, copyItem.to);
+        const targetDir = dirname(toPath);
+        if (!existsSync(targetDir)) {
+          ensureDir(targetDir);
+        }
+        if (existsSync(fromPath)) {
+          if (copyItem.transform) {
+            const content = readFileAsString(fromPath);
+            const transformed = copyItem.transform(content, config);
+            writeFileSync(toPath, transformed);
+          } else {
+            copyFileSync(fromPath, toPath);
+          }
+          if (config.logging) {
+            console.log(`  \u2713 ${copyItem.from} \u2192 ${copyItem.to}`);
+          }
+        } else if (config.logging) {
+          console.warn(`  \u26A0 File not found: ${copyItem.from}`);
+        }
+      }
+    }
+    if (config.onBuildEnd) {
+      await config.onBuildEnd(buildResult);
+    }
+    if (config.logging) {
+      console.log("");
+    }
+    return buildResult;
+  } catch (error) {
+    if (config.logging) {
+      console.error("\n\u274C Build failed:");
+      console.error(error);
+    }
+    throw error;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build
+});