Bun incluye un minificador rápido de JavaScript y TypeScript que puede reducir el tamaño de los bundles en un 80% o más (dependiendo del código base) y hacer que el código de salida se ejecute más rápido. El minificador realiza docenas de optimizaciones incluyendo plegado de constantes, eliminación de código muerto y transformaciones de sintaxis. A diferencia de otros minificadores, el minificador de Bun hace que bun build se ejecute más rápido ya que hay menos código que imprimir.

Uso de CLI

Habilitar toda la minificación

Usa la bandera --minify para habilitar todos los modos de minificación:

bun build ./index.ts --minify --outfile=out.js

La bandera --minify habilita automáticamente:

• Minificación de espacios en blanco
• Minificación de sintaxis
• Minificación de identificadores

Modo de producción

La bandera --production habilita automáticamente la minificación:

bun build ./index.ts --production --outfile=out.js

La bandera --production también:

• Establece process.env.NODE_ENV a production
• Habilita el import y transform JSX en modo producción

Control granular

Puedes habilitar modos específicos de minificación individualmente:

# Solo eliminar espacios en blanco
bun build ./index.ts --minify-whitespace --outfile=out.js

# Solo minificar sintaxis
bun build ./index.ts --minify-syntax --outfile=out.js

# Solo minificar identificadores
bun build ./index.ts --minify-identifiers --outfile=out.js

# Combinar modos específicos
bun build ./index.ts --minify-whitespace --minify-syntax --outfile=out.js

API de JavaScript

Al usar el empaquetador de Bun programáticamente, configura la minificación a través de la opción minify:

await Bun.build({
  entrypoints: ["./index.ts"],
  outdir: "./out",
  minify: true, // Habilitar todos los modos de minificación
});

Para control granular, pasa un objeto:

await Bun.build({
  entrypoints: ["./index.ts"],
  outdir: "./out",
  minify: {
    whitespace: true,
    syntax: true,
    identifiers: true,
  },
});

Modos de Minificación

El minificador de Bun tiene tres modos independientes que pueden habilitarse por separado o combinados.

Minificación de espacios en blanco (--minify-whitespace)

Elimina todos los espacios en blanco, saltos de línea y formato innecesarios de la salida.

Minificación de sintaxis (--minify-syntax)

Reescribe la sintaxis de JavaScript a formas equivalentes más cortas y realiza plegado de constantes, eliminación de código muerto y otras optimizaciones.

Minificación de identificadores (--minify-identifiers)

Renombra variables locales y nombres de funciones a identificadores más cortos usando optimización basada en frecuencia.

Todas las Transformaciones

Acortamiento de literales booleanos

Modo: --minify-syntax

Convierte literales booleanos a expresiones más cortas.

true
false

!0
!1

Optimizaciones de álgebra booleana

Modo: --minify-syntax

Simplifica expresiones booleanas usando reglas lógicas.

!!x
x === true
x && true
x || false
!true
!false

x
x
x
x
!1
!0

Acortamiento de undefined

Modo: --minify-syntax

Reemplaza undefined con un equivalente más corto.

undefined
let x = undefined;

void 0
let x=void 0;

Optimización de igualdad con undefined

Modo: --minify-syntax

Optimiza comparaciones de igualdad laxa con undefined.

x == undefined
x != undefined

x == null
x != null

Acortamiento de Infinity

Modo: --minify-syntax

Convierte Infinity a expresiones matemáticas.

Infinity
-Infinity

1/0
-1/0

Optimizaciones de typeof

Modo: --minify-syntax

Optimiza comparaciones de typeof y evalúa expresiones typeof constantes.

typeof x === 'undefined'
typeof x !== 'undefined'
typeof require
typeof null
typeof true
typeof 123
typeof "str"
typeof 123n

typeof x>'u'
typeof x<'u'
"function"
"object"
"boolean"
"number"
"string"
"bigint"

Formato de números

Modo: --minify-syntax

Formatea números en la representación más compacta.

10000
100000
1000000
1.0
-42.0

1e4
1e5
1e6
1
-42

Plegado de constantes aritméticas

Modo: --minify-syntax

Evalúa operaciones aritméticas en tiempo de compilación.

1 + 2
10 - 5
3 * 4
10 / 2
10 % 3
2 ** 3

3
5
12
5
1
8

Plegado de constantes bitwise

Modo: --minify-syntax

Evalúa operaciones bitwise en tiempo de compilación.

5 & 3
5 | 3
5 ^ 3
8 << 2
32 >> 2
~5

1
7
6
32
8
-6

Concatenación de cadenas

Modo: --minify-syntax

Combina literales de cadena en tiempo de compilación.

"a" + "b"
"x" + 123
"foo" + "bar" + "baz"

"ab"
"x123"
"foobarbaz"

Indexación de cadenas

Modo: --minify-syntax

Evalúa acceso a caracteres de cadenas en tiempo de compilación.

"foo"[2]
"hello"[0]

"o"
"h"

Plegado de literales de plantilla

Modo: --minify-syntax

Evalúa literales de plantilla con expresiones constantes.

`a${123}b`
`result: ${5 + 10}`

"a123b"
"result: 15"

Conversión de literales de plantilla a cadena

Modo: --minify-syntax

Convierte literales de plantilla simples a cadenas regulares.

`Hello World`
`Line 1
Line 2`

"Hello World"
"Line 1\nLine 2"

Optimización de comillas de cadena

Modo: --minify-syntax

Elige el carácter de comillas óptimo para minimizar escapes.

"It's a string"
'He said "hello"'
`Simple string`

"It's a string"
'He said "hello"'
"Simple string"

Inline de spread de arrays

Modo: --minify-syntax

Incluye en línea operaciones de spread de arrays con arrays constantes.

[1, ...[2, 3], 4]
[...[a, b]]

[1,2,3,4]
[a,b]

Indexación de arrays

Modo: --minify-syntax

Evalúa acceso a arrays constantes en tiempo de compilación.

[x][0]
['a', 'b', 'c'][1]
['a', , 'c'][1]

x
'b'
void 0

Optimización de acceso a propiedades

Modo: --minify-syntax

Convierte notación de corchetes a notación de punto cuando es posible.

obj["property"]
obj["validName"]
obj["123"]
obj["invalid-name"]

obj.property
obj.validName
obj["123"]
obj["invalid-name"]

Plegado de comparaciones

Modo: --minify-syntax

Evalúa comparaciones constantes en tiempo de compilación.

3 < 5
5 > 3
3 <= 3
5 >= 6
"a" < "b"

!0
!0
!0
!1
!0

Plegado de operaciones lógicas

Modo: --minify-syntax

Simplifica operaciones lógicas con valores constantes.

true && x
false && x
true || x
false || x

x
!1
!0
x

Plegado de coalescencia nula

Modo: --minify-syntax

Evalúa coalescencia nula con valores conocidos.

null ?? x
undefined ?? x
42 ?? x

x
x
42

Simplificación de expresiones coma

Modo: --minify-syntax

Elimina expresiones sin efectos secundarios de secuencias coma.

(0, x)
(123, "str", x)

x
x

Plegado de condicionales ternarios

Modo: --minify-syntax

Evalúa expresiones condicionales con condiciones constantes.

true ? a : b
false ? a : b
x ? true : false
x ? false : true

a
b
x ? !0 : !1
x ? !1 : !0

Plegado de expresiones unarias

Modo: --minify-syntax

Simplifica operaciones unarias.

+123
+"123"
-(-x)
~~x
!!x

123
123
123
123
x
~~x
!!x
x

Eliminación de doble negación

Modo: --minify-syntax

Elimina dobles negaciones innecesarias.

!!x
!!!x

x
!x

Optimización de declaraciones if

Modo: --minify-syntax

Optimiza declaraciones if con condiciones constantes.

if (true) x;
if (false) x;
if (x) { a; }
if (x) {} else y;

x;
// eliminado
if(x)a;
if(!x)y;

Eliminación de código muerto

Modo: --minify-syntax

Elimina código inalcanzable y código sin efectos secundarios.

if (false) {
  unreachable();
}
function foo() {
  return x;
  deadCode();
}

function foo(){return x}

Eliminación de ramas inalcanzables

Modo: --minify-syntax

Elimina ramas que nunca pueden ejecutarse.

while (false) {
  neverRuns();
}

// eliminado por completo

Eliminación de bloques vacíos

Modo: --minify-syntax

Elimina bloques vacíos y llaves innecesarias.

{ }
if (x) { }

;
// eliminado

Desenrollado de bloques de una sola declaración

Modo: --minify-syntax

Elimina llaves innecesarias alrededor de declaraciones únicas.

if (condition) {
  doSomething();
}

if(condition)doSomething();

Inline de enums de TypeScript

Modo: --minify-syntax

Incluye en línea valores de enum de TypeScript en tiempo de compilación.

enum Color { Red, Green, Blue }
const x = Color.Red;

const x=0;

Soporte de anotaciones pure

Modo: Siempre activo

Respeta las anotaciones /*@__PURE__*/ para tree shaking.

const x = /*@__PURE__*/ expensive();
// Si x no se usa...

// eliminado por completo

Renombrado de identificadores

Modo: --minify-identifiers

Renombra variables locales a nombres más cortos basados en la frecuencia de uso.

function calculateSum(firstNumber, secondNumber) {
  const result = firstNumber + secondNumber;
  return result;
}

function a(b,c){const d=b+c;return d}

Estrategia de nomenclatura:

• Los identificadores más frecuentemente usados obtienen los nombres más cortos (a, b, c...)
• Letras simples: a-z (26 nombres)
• Letras dobles: aa-zz (676 nombres)
• Letras triples y más según sea necesario

Identificadores preservados:

• Palabras clave y reservadas de JavaScript
• Identificadores globales
• Exportaciones nombradas (para mantener la API)
• Nombres de CommonJS: exports, module

Eliminación de espacios en blanco

Modo: --minify-whitespace

Elimina todos los espacios en blanco innecesarios.

function add(a, b) {
    return a + b;
}
let x = 10;

function add(a,b){return a+b;}let x=10;

Optimización de punto y coma

Modo: --minify-whitespace

Inserta punto y coma solo cuando es necesario.

let a = 1;
let b = 2;
return a + b;

let a=1;let b=2;return a+b

Eliminación de espacios en operadores

Modo: --minify-whitespace

Elimina espacios alrededor de operadores.

a + b
x = y * z
foo && bar || baz

a+b
x=y*z
foo&&bar||baz

Eliminación de comentarios

Modo: --minify-whitespace

Elimina comentarios excepto comentarios importantes de licencia.

// Este comentario se elimina
/* También este */
/*! Pero este comentario de licencia se mantiene */
function test() { /* comentario en línea */ }

/*! Pero este comentario de licencia se mantiene */
function test(){}

Formato de objetos y arrays

Modo: --minify-whitespace

Elimina espacios en blanco en literales de objetos y arrays.

const obj = {
    name: "John",
    age: 30
};
const arr = [1, 2, 3];

const obj={name:"John",age:30};const arr=[1,2,3];

Formato de flujo de control

Modo: --minify-whitespace

Elimina espacios en blanco en estructuras de control.

if (condition) {
    doSomething();
}
for (let i = 0; i < 10; i++) {
    console.log(i);
}

if(condition)doSomething();for(let i=0;i<10;i++)console.log(i);

Formato de funciones

Modo: --minify-whitespace

Elimina espacios en blanco en declaraciones de funciones.

function myFunction(param1, param2) {
    return param1 + param2;
}
const arrow = (a, b) => a + b;

function myFunction(a,b){return a+b}const arrow=(a,b)=>a+b;

Minimización de paréntesis

Modo: Siempre activo

Solo agrega paréntesis cuando es necesario para la precedencia de operadores.

(a + b) * c
a + (b * c)
((x))

(a+b)*c
a+b*c
x

Mangle de propiedades

Modo: --minify-identifiers (con configuración)

Renombra propiedades de objetos a nombres más cortos cuando se configura.

obj.longPropertyName

obj.a

Plegado de valores de literales de plantilla

Modo: --minify-syntax

Convierte valores interpolados que no son cadenas a cadenas y los pliega en la plantilla.

`hello ${123}`
`value: ${true}`
`result: ${null}`
`status: ${undefined}`
`big: ${10n}`

"hello 123"
"value: true"
"result: null"
"status: undefined"
"big: 10"

Plegado de constantes de longitud de cadena

Modo: --minify-syntax

Evalúa la propiedad .length en literales de cadena en tiempo de compilación.

"hello world".length
"test".length

11
4

Simplificación de llamadas a constructores

Modo: --minify-syntax

Simplifica llamadas a constructores para tipos integrados.

new Object()
new Object(null)
new Object({a: 1})
new Array()
new Array(x, y)

{}
{}
{a:1}
[]
[x,y]

Inline de objetos de una sola propiedad

Modo: --minify-syntax

Incluye en línea acceso a propiedades para objetos con una sola propiedad.

({fn: () => console.log('hi')}).fn()

(() => console.log('hi'))()

Plegado de constantes String charCodeAt

Modo: Siempre activo

Evalúa charCodeAt() en literales de cadena para caracteres ASCII.

"hello".charCodeAt(1)
"A".charCodeAt(0)

101
65

Igualdad Void 0 a igualdad null

Modo: --minify-syntax

Convierte comparaciones de igualdad laxa con void 0 a null ya que son equivalentes.

x == void 0
x != void 0

x == null
x != null

Optimización de operador de negación

Modo: --minify-syntax

Mueve el operador de negación a través de expresiones coma.

-(a, b)
-(x, y, z)

a,-b
x,y,-z

Inline de propiedades Import.meta

Modo: Modo bundle

Incluye en línea propiedades import.meta en tiempo de construcción cuando los valores son conocidos.

import.meta.dir
import.meta.file
import.meta.path
import.meta.url

"/path/to/directory"
"filename.js"
"/full/path/to/file.js"
"file:///full/path/to/file.js"

Fusión de declaraciones de variables

Modo: --minify-syntax

Fusiona declaraciones de variables adyacentes del mismo tipo.

let a = 1;
let b = 2;
const c = 3;
const d = 4;

let a=1,b=2;
const c=3,d=4;

Fusión de declaraciones de expresiones

Modo: --minify-syntax

Fusiona declaraciones de expresiones adyacentes usando el operador coma.

console.log(1);
console.log(2);
console.log(3);

console.log(1),console.log(2),console.log(3);

Fusión de declaraciones return

Modo: --minify-syntax

Fusiona expresiones antes de return con el operador coma.

console.log(x);
return y;

return console.log(x),y;

Fusión de declaraciones throw

Modo: --minify-syntax

Fusiona expresiones antes de throw con el operador coma.

console.log(x);
throw new Error();

throw(console.log(x),new Error());

Inline de enums de TypeScript entre módulos

Modo: --minify-syntax (modo bundle)

Incluye en línea valores de enum a través de límites de módulos.

// lib.ts
export enum Color { Red, Green, Blue }

// Input (main.ts)
import { Color } from './lib';
const x = Color.Red;

const x=0;

Inline de enums de propiedades computadas

Modo: --minify-syntax

Incluye en línea valores de enum usados como propiedades de objetos computados.

enum Keys { FOO = 'foo' }
const obj = { [Keys.FOO]: value }

const obj={foo:value}

Número de cadena a índice numérico

Modo: --minify-syntax

Convierte acceso a propiedades numéricas de cadena a índice numérico.

obj["0"]
arr["5"]

obj[0]
arr[5]

Acortamiento de cuerpo de función flecha

Modo: Siempre activo

Usa sintaxis de cuerpo de expresión cuando una función flecha solo devuelve un valor.

() => { return x; }
(a) => { return a + 1; }

() => x
a => a + 1

Atajo de propiedades de objeto

Modo: Siempre activo

Usa sintaxis abreviada cuando el nombre de la propiedad y el identificador del valor coinciden.

{ x: x, y: y }
{ name: name, age: age }

{ x, y }
{ name, age }

Atajo de método

Modo: Siempre activo

Usa sintaxis abreviada de método en literales de objetos.

{
  foo: function() {},
  bar: async function() {}
}

{
  foo() {},
  async bar() {}
}

Eliminar declaraciones debugger

Modo: --drop=debugger

Elimina declaraciones debugger del código.

function test() {
  debugger;
  return x;
}

function test(){return x}

Eliminar llamadas a console

Modo: --drop=console

Elimina todas las llamadas a métodos console.* del código.

console.log("debug");
console.warn("warning");
x = console.error("error");

void 0;
void 0;
x=void 0;

Eliminar llamadas a funciones personalizadas

Modo: --drop=<name>

Elimina llamadas a funciones o métodos globales especificados.

assert(condition);
obj.assert(test);

void 0;
void 0;

Keep Names

Al minificar identificadores, es posible que desees preservar los nombres originales de funciones y clases para propósitos de depuración. Usa la bandera --keep-names:

bun build ./index.ts --minify --keep-names --outfile=out.js

O en la API de JavaScript:

await Bun.build({
  entrypoints: ["./index.ts"],
  outdir: "./out",
  minify: {
    identifiers: true,
    keepNames: true,
  },
});

Esto preserva la propiedad .name en funciones y clases mientras aún minifica los nombres de identificadores reales en el código.

Ejemplo Combinado

Usando los tres modos de minificación juntos:

const myVariable = 42;

const myFunction = () => {
  const isValid = true;
  const result = undefined;
  return isValid ? myVariable : result;
};

const output = myFunction();

// Salida con --minify (49 bytes, 69% de reducción)
const a=42,b=()=>{const c=!0,d=void 0;return c?a:d},e=b();

Cuándo Usar Minificación

Usa --minify para:

• Bundles de producción
• Reducir costos de ancho de banda de CDN
• Mejorar tiempos de carga de páginas

Usa modos individuales para:

• --minify-whitespace: Reducción rápida de tamaño sin cambios semánticos
• --minify-syntax: Salida más pequeña manteniendo identificadores legibles para depuración
• --minify-identifiers: Máxima reducción de tamaño (combina con --keep-names para mejores stack traces)

Evita la minificación para:

• Builds de desarrollo (más difícil de depurar)
• Cuando necesitas mensajes de error legibles
• Librerías donde los consumidores pueden leer el código fuente