O Bun inclui um minificador rápido de JavaScript e TypeScript que pode reduzir tamanhos de bundle em 80% ou mais (dependendo do codebase) e fazer o código de output rodar mais rápido. O minificador realiza dezenas de otimizações incluindo constant folding, dead code elimination e transformações de sintaxe. Diferentemente de outros minificadores, o minificador do Bun faz o bun build rodar mais rápido já que há menos código para imprimir.

Uso na CLI

Habilitar toda minificação

Use a flag --minify para habilitar todos os modos de minificação:

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

A flag --minify automaticamente habilita:

• Minificação de whitespace
• Minificação de sintaxe
• Minificação de identificadores

Modo de produção

A flag --production automaticamente habilita minificação:

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

A flag --production também:

• Define process.env.NODE_ENV como production
• Habilita o import e transform JSX em modo de produção

Controle granular

Você pode habilitar modos específicos de minificação individualmente:

# Apenas remover whitespace
bun build ./index.ts --minify-whitespace --outfile=out.js

# Apenas minificar sintaxe
bun build ./index.ts --minify-syntax --outfile=out.js

# Apenas 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 JavaScript

Ao usar o bundler do Bun programaticamente, configure minificação através da opção minify:

await Bun.build({
  entrypoints: ["./index.ts"],
  outdir: "./out",
  minify: true, // Habilita todos os modos de minificação
});

Para controle granular, passe um objeto:

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

Modos de Minificação

O minificador do Bun tem três modos independentes que podem ser habilitados separadamente ou combinados.

Minificação de whitespace (--minify-whitespace)

Remove todos whitespaces, newlines e formatação desnecessários do output.

Minificação de sintaxe (--minify-syntax)

Reescreve sintaxe JavaScript para formas equivalentes mais curtas e realiza constant folding, dead code elimination e outras otimizações.

Minificação de identificadores (--minify-identifiers)

Renomeia variáveis locais e nomes de função para identificadores mais curtos usando otimização baseada em frequência.

Todas as Transformações

Encurtamento de literais booleanos

Modo: --minify-syntax

Converte literais booleanos para expressões mais curtas.

true
false

!0
!1

Otimizações de álgebra booleana

Modo: --minify-syntax

Simplifica expressões booleanas usando regras lógicas.

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

x
x
x
x
!1
!0

Encurtamento de undefined

Modo: --minify-syntax

Substitui undefined por equivalente mais curto.

undefined
let x = undefined;

void 0
let x=void 0;

Otimização de igualdade undefined

Modo: --minify-syntax

Otimiza verificações de igualdade loose com undefined.

x == undefined
x != undefined

x == null
x != null

Encurtamento de Infinity

Modo: --minify-syntax

Converte Infinity para expressões matemáticas.

Infinity
-Infinity

1/0
-1/0

Otimizações de typeof

Modo: --minify-syntax

Otimiza comparações de typeof e avalia expressões 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"

Formatação de números

Modo: --minify-syntax

Formata números na representação mais compacta.

10000
100000
1000000
1.0
-42.0

1e4
1e5
1e6
1
-42

Constant folding aritmético

Modo: --minify-syntax

Avalia operações aritméticas em tempo de compilação.

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

3
5
12
5
1
8

Constant folding bitwise

Modo: --minify-syntax

Avalia operações bitwise em tempo de compilação.

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

1
7
6
32
8
-6

Concatenação de strings

Modo: --minify-syntax

Combina literais de string em tempo de compilação.

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

"ab"
"x123"
"foobarbaz"

Indexação de strings

Modo: --minify-syntax

Avalia acesso a caracteres de string em tempo de compilação.

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

"o"
"h"

Constant folding de template literals

Modo: --minify-syntax

Avalia template literals com expressões constantes.

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

"a123b"
"result: 15"

Conversão de template literal para string

Modo: --minify-syntax

Converte template literals simples para strings regulares.

`Hello World`
`Line 1
Line 2`

"Hello World"
"Line 1\nLine 2"

Otimização de aspas de strings

Modo: --minify-syntax

Escolhe o caractere de aspa ótimo 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 array

Modo: --minify-syntax

Faz inline de operações de spread de array com arrays constantes.

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

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

Indexação de arrays

Modo: --minify-syntax

Avalia acesso a array constante em tempo de compilação.

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

x
'b'
void 0

Otimização de acesso a propriedades

Modo: --minify-syntax

Converte notação de colchetes para notação de ponto quando possível.

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

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

Constant folding de comparações

Modo: --minify-syntax

Avalia comparações constantes em tempo de compilação.

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

!0
!0
!0
!1
!0

Simplificação de operações lógicas

Modo: --minify-syntax

Simplifica operações lógicas com valores constantes.

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

x
!1
!0
x

Constant folding de nullish coalescing

Modo: --minify-syntax

Avalia nullish coalescing com valores conhecidos.

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

x
x
42

Simplificação de expressão vírgula

Modo: --minify-syntax

Remove expressões sem side effects de sequências de vírgula.

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

x
x

Constant folding de ternário

Modo: --minify-syntax

Avalia expressões condicionais com condições constantes.

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

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

Constant folding de expressão unária

Modo: --minify-syntax

Simplifica operações unárias.

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

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

Remoção de dupla negação

Modo: --minify-syntax

Remove duplas negações desnecessárias.

!!x
!!!x

x
!x

Otimização de declaração if

Modo: --minify-syntax

Otimiza declarações if com condições constantes.

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

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

Dead code elimination

Modo: --minify-syntax

Remove código inalcançável e código sem side effects.

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

function foo(){return x}

Remoção de branches inalcançáveis

Modo: --minify-syntax

Remove branches que nunca podem executar.

while (false) {
  neverRuns();
}

// removido inteiramente

Remoção de blocos vazios

Modo: --minify-syntax

Remove blocos vazios e braces desnecessários.

{ }
if (x) { }

;
// removido

Unwrap de blocos de declaração única

Modo: --minify-syntax

Remove braces desnecessários em torno de declarações únicas.

if (condition) {
  doSomething();
}

if(condition)doSomething();

Inline de enums TypeScript

Modo: --minify-syntax

Faz inline de valores de enum TypeScript em tempo de compilação.

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

const x=0;

Suporte a anotações pure

Modo: Sempre ativo

Respeita anotações /*@__PURE__*/ para tree shaking.

const x = /*@__PURE__*/ expensive();
// Se x não for usado...

// removido inteiramente

Renomeação de identificadores

Modo: --minify-identifiers

Renomeia variáveis locais para nomes mais curtos baseado na frequência de uso.

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

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

Estratégia de nomeação:

• Identificadores mais frequentemente usados recebem os nomes mais curtos (a, b, c...)
• Letras únicas: a-z (26 nomes)
• Letras duplas: aa-zz (676 nomes)
• Letras triplas e além conforme necessário

Identificadores preservados:

• Palavras-chave e reservadas JavaScript
• Identificadores globais
• Named exports (para manter API)
• Nomes CommonJS: exports, module

Remoção de whitespace

Modo: --minify-whitespace

Remove todos whitespaces desnecessários.

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

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

Otimização de ponto e vírgula

Modo: --minify-whitespace

Insere ponto e vírgula apenas quando necessário.

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

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

Remoção de espaçamento de operadores

Modo: --minify-whitespace

Remove espaços em torno de operadores.

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

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

Remoção de comentários

Modo: --minify-whitespace

Remove comentários exceto comentários de licença importantes.

// Este comentário é removido
/* Este também */
/*! Mas este comentário de licença é mantido */
function test() { /* comentário inline */ }

/*! Mas este comentário de licença é mantido */
function test(){}

Formatação de objetos e arrays

Modo: --minify-whitespace

Remove whitespace em literais de objeto e array.

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

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

Formatação de controle de fluxo

Modo: --minify-whitespace

Remove whitespace em estruturas de controle.

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);

Formatação de funções

Modo: --minify-whitespace

Remove whitespace em declarações de função.

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;

Minimização de parênteses

Modo: Sempre ativo

Adiciona parênteses apenas quando necessário para precedência de operadores.

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

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

Property mangling

Modo: --minify-identifiers (com configuração)

Renomeia propriedades de objeto para nomes mais curtos quando configurado.

obj.longPropertyName

obj.a

Constant folding de valores de template literal

Modo: --minify-syntax

Converte valores interpolados não-string para strings e os fold no template.

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

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

Constant folding de string length

Modo: --minify-syntax

Avalia propriedade .length em literais de string em tempo de compilação.

"hello world".length
"test".length

11
4

Simplificação de chamadas de construtor

Modo: --minify-syntax

Simplifica chamadas de construtor para tipos built-in.

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

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

Inline de objeto de propriedade única

Modo: --minify-syntax

Faz inline de acesso a propriedade para objetos com uma única propriedade.

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

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

Constant folding de string charCodeAt

Modo: Sempre ativo

Avalia charCodeAt() em literais de string para caracteres ASCII.

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

101
65

Igualdade void 0 para igualdade null

Modo: --minify-syntax

Converte verificações de igualdade loose com void 0 para null já que são equivalentes.

x == void 0
x != void 0

x == null
x != null

Otimização de operador de negação

Modo: --minify-syntax

Move operador de negação através de expressões de vírgula.

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

a,-b
x,y,-z

Inline de propriedades import.meta

Modo: Modo bundle

Faz inline de propriedades import.meta em tempo de build quando valores são conhecidos.

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"

Merge de declarações de variáveis

Modo: --minify-syntax

Funde declarações de variáveis adjacentes do mesmo tipo.

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

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

Merge de declarações de expressão

Modo: --minify-syntax

Funde declarações de expressão adjacentes usando operador vírgula.

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

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

Merge de declarações return

Modo: --minify-syntax

Funde expressões antes de return com operador vírgula.

console.log(x);
return y;

return console.log(x),y;

Merge de declarações throw

Modo: --minify-syntax

Funde expressões antes de throw com operador vírgula.

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

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

Inline de enum TypeScript cross-module

Modo: --minify-syntax (modo bundle)

Faz inline de valores de enum através de limites de módulo.

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

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

const x=0;

Inline de enum de propriedade computada

Modo: --minify-syntax

Faz inline de valores de enum usados como propriedades de objeto computadas.

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

const obj={foo:value}

String numérica para índice numérico

Modo: --minify-syntax

Converte acesso a propriedade numérica string para índice numérico.

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

obj[0]
arr[5]

Encurtamento de corpo de arrow function

Modo: Sempre ativo

Usa sintaxe de corpo de expressão quando uma arrow function apenas retorna um valor.

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

() => x
a => a + 1

Shorthand de propriedade de objeto

Modo: Sempre ativo

Usa sintaxe shorthand quando nome da propriedade e identificador de valor coincidem.

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

{ x, y }
{ name, age }

Shorthand de método

Modo: Sempre ativo

Usa sintaxe de shorthand de método em literais de objeto.

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

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

Drop de declarações debugger

Modo: --drop=debugger

Remove declarações debugger do código.

function test() {
  debugger;
  return x;
}

function test(){return x}

Drop de chamadas console

Modo: --drop=console

Remove todas as chamadas de método console.* do código.

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

void 0;
void 0;
x=void 0;

Drop de chamadas de função customizadas

Modo: --drop=<name>

Remove chamadas para funções globais ou métodos especificados.

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

void 0;
void 0;

Keep Names

Ao minificar identificadores, você pode querer preservar nomes originais de função e classe para propósitos de debug. Use a flag --keep-names:

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

Ou na API JavaScript:

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

Isso preserva a propriedade .name em funções e classes enquanto ainda minifica os nomes reais de identificador no código.

Exemplo Combinado

Usando todos os três modos de minificação juntos:

const myVariable = 42;

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

const output = myFunction();

// Output com --minify (49 bytes, 69% redução)
const a=42,b=()=>{const c=!0,d=void 0;return c?a:d},e=b();

Quando Usar Minificação

Use --minify para:

• Bundles de produção
• Reduzir custos de banda de CDN
• Melhorar tempos de carregamento de página

Use modos individuais para:

• --minify-whitespace: Redução rápida de tamanho sem mudanças semânticas
• --minify-syntax: Output menor enquanto mantém identificadores legíveis para debug
• --minify-identifiers: Máxima redução de tamanho (combine com --keep-names para melhores stack traces)

Evite minificação para:

• Builds de desenvolvimento (mais difícil de debug)
• Quando você precisa de mensagens de erro legíveis
• Bibliotecas onde consumidores podem ler o source