Bun include un veloce minifier JavaScript e TypeScript che può ridurre le dimensioni dei bundle dell'80% o più (dipendendo dal codebase) e far eseguire il codice di output più velocemente. Il minifier esegue dozzine di ottimizzazioni inclusi constant folding, dead code elimination, e trasformazioni di sintassi. A differenza di altri minifier, il minifier di Bun fa eseguire bun build più velocemente poiché c'è meno codice da stampare.

Uso CLI

Abilita tutta la minificazione

Usa il flag --minify per abilitare tutte le modalità di minificazione:

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

Il flag --minify abilita automaticamente:

• Minificazione whitespace
• Minificazione sintassi
• Minificazione identificatori

Modalità production

Il flag --production abilita automaticamente la minificazione:

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

Il flag --production anche:

• Imposta process.env.NODE_ENV a production
• Abilita l'import & transform JSX production-mode

Controllo granulare

Puoi abilitare modalità di minificazione specifiche individualmente:

# Rimuovi solo whitespace
bun build ./index.ts --minify-whitespace --outfile=out.js

# Minifica solo la sintassi
bun build ./index.ts --minify-syntax --outfile=out.js

# Minifica solo gli identificatori
bun build ./index.ts --minify-identifiers --outfile=out.js

# Combina modalità specifiche
bun build ./index.ts --minify-whitespace --minify-syntax --outfile=out.js

API JavaScript

Quando usi il bundler di Bun programmaticamente, configura la minificazione attraverso l'opzione minify:

await Bun.build({
  entrypoints: ["./index.ts"],
  outdir: "./out",
  minify: true, // Abilita tutte le modalità di minificazione
});

Per controllo granulare, passa un oggetto:

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

Modalità di Minificazione

Il minifier di Bun ha tre modalità indipendenti che possono essere abilitate separatamente o combinate.

Minificazione whitespace (--minify-whitespace)

Rimuove tutti i whitespace, newline, e formattazione non necessari dall'output.

Minificazione sintassi (--minify-syntax)

Riscrive la sintassi JavaScript in forme equivalenti più corte ed esegue constant folding, dead code elimination, e altre ottimizzazioni.

Minificazione identificatori (--minify-identifiers)

Rinomina variabili locali e nomi di funzione a identificatori più corti usando ottimizzazione basata sulla frequenza.

Tutte le Trasformazioni

Accorciamento letterali booleani

Modalità: --minify-syntax

Converte i letterali booleani in espressioni più corte.

true
false

!0
!1

Ottimizzazioni algebra booleana

Modalità: --minify-syntax

Semplifica le espressioni booleane usando regole logiche.

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

x
x
x
x
!1
!0

Accorciamento undefined

Modalità: --minify-syntax

Rimpiazza undefined con equivalente più corto.

undefined
let x = undefined;

void 0
let x=void 0;

Ottimizzazione uguaglianza undefined

Modalità: --minify-syntax

Ottimizza i controlli di uguaglianza loose con undefined.

x == undefined
x != undefined

x == null
x != null

Accorciamento Infinity

Modalità: --minify-syntax

Converte Infinity in espressioni matematiche.

Infinity
-Infinity

1/0
-1/0

Ottimizzazioni typeof

Modalità: --minify-syntax

Ottimizza i confronti typeof e valuta le espressioni typeof costanti.

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"

Formattazione numeri

Modalità: --minify-syntax

Formatta i numeri nella rappresentazione più compatta.

10000
100000
1000000
1.0
-42.0

1e4
1e5
1e6
1
-42

Constant folding aritmetico

Modalità: --minify-syntax

Valuta le operazioni aritmetiche a compile time.

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

3
5
12
5
1
8

Constant folding bitwise

Modalità: --minify-syntax

Valuta le operazioni bitwise a compile time.

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

1
7
6
32
8
-6

Concatenazione stringhe

Modalità: --minify-syntax

Combina i letterali di stringa a compile time.

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

"ab"
"x123"
"foobarbaz"

Indicizzazione stringhe

Modalità: --minify-syntax

Valuta l'accesso ai caratteri delle stringhe a compile time.

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

"o"
"h"

Constant folding template literal

Modalità: --minify-syntax

Valuta i template literal con espressioni costanti.

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

"a123b"
"result: 15"

Conversione template literal a stringa

Modalità: --minify-syntax

Converte i template literal semplici in stringhe regolari.

`Hello World`
`Line 1
Line 2`

"Hello World"
"Line 1\nLine 2"

Ottimizzazione quote stringhe

Modalità: --minify-syntax

Sceglie il carattere quote ottimale per minimizzare gli escape.

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

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

Inlining array spread

Modalità: --minify-syntax

Inlines le operazioni array spread con array costanti.

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

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

Indicizzazione array

Modalità: --minify-syntax

Valuta l'accesso agli array costanti a compile time.

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

x
'b'
void 0

Ottimizzazione accesso proprietà

Modalità: --minify-syntax

Converte la notazione bracket in dot notation quando possibile.

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

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

Constant folding confronti

Modalità: --minify-syntax

Valuta i confronti costanti a compile time.

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

!0
!0
!0
!1
!0

Constant folding operazioni logiche

Modalità: --minify-syntax

Semplifica le operazioni logiche con valori costanti.

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

x
!1
!0
x

Constant folding nullish coalescing

Modalità: --minify-syntax

Valuta il nullish coalescing con valori conosciuti.

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

x
x
42

Semplificazione espressioni comma

Modalità: --minify-syntax

Rimuove le espressioni senza side-effect dalle sequenze comma.

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

x
x

Constant folding condizionale ternario

Modalità: --minify-syntax

Valuta le espressioni condizionali con condizioni costanti.

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

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

Constant folding espressioni unarie

Modalità: --minify-syntax

Semplifica le operazioni unarie.

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

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

Rimozione doppia negazione

Modalità: --minify-syntax

Rimuove le doppie negazioni non necessarie.

!!x
!!!x

x
!x

Ottimizzazione statement if

Modalità: --minify-syntax

Ottimizza gli statement if con condizioni costanti.

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

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

Dead code elimination

Modalità: --minify-syntax

Rimuove il codice irraggiungibile e il codice senza side effects.

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

function foo(){return x}

Rimozione branch irraggiungibili

Modalità: --minify-syntax

Rimuove i branch che non possono mai essere eseguiti.

while (false) {
  neverRuns();
}

// rimosso interamente

Rimozione blocchi vuoti

Modalità: --minify-syntax

Rimuove i blocchi vuoti e le parentesi non necessarie.

{ }
if (x) { }

;
// rimosso

Unwrapping blocchi singolo statement

Modalità: --minify-syntax

Rimuove le parentesi non necessarie attorno a singoli statement.

if (condition) {
  doSomething();
}

if(condition)doSomething();

Inlining enum TypeScript

Modalità: --minify-syntax

Inlines i valori enum TypeScript a compile time.

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

const x=0;

Supporto annotazioni pure

Modalità: Sempre attivo

Rispetta le annotazioni /*@__PURE__*/ per il tree shaking.

const x = /*@__PURE__*/ expensive();
// Se x è inutilizzato...

// rimosso interamente

Rinomina identificatori

Modalità: --minify-identifiers

Rinomina le variabili locali a nomi più corti basati sulla frequenza d'uso.

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

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

Strategia di naming:

• Gli identificatori più frequentemente usati ottengono i nomi più corti (a, b, c...)
• Lettere singole: a-z (26 nomi)
• Lettere doppie: aa-zz (676 nomi)
• Lettere triple e oltre secondo necessità

Identificatori preservati:

• Parole chiave e riservate JavaScript
• Identificatori globali
• Export nominati (per mantenere l'API)
• Nomi CommonJS: exports, module

Rimozione whitespace

Modalità: --minify-whitespace

Rimuove tutti i whitespace non necessari.

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

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

Ottimizzazione punto e virgola

Modalità: --minify-whitespace

Inserisce punti e virgola solo quando necessario.

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

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

Rimozione spazi operatori

Modalità: --minify-whitespace

Rimuove gli spazi attorno agli operatori.

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

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

Rimozione commenti

Modalità: --minify-whitespace

Rimuove i commenti eccetto importanti commenti di license.

// Questo commento è rimosso
/* Anche questo */
/*! Ma questo commento di license è mantenuto */
function test() { /* commento inline */ }

/*! Ma questo commento di license è mantenuto */
function test(){}

Formattazione oggetti e array

Modalità: --minify-whitespace

Rimuove il whitespace in oggetti e array literal.

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

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

Formattazione control flow

Modalità: --minify-whitespace

Rimuove il whitespace nelle strutture di controllo.

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

Formattazione funzioni

Modalità: --minify-whitespace

Rimuove il whitespace nelle dichiarazioni di funzione.

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;

Minimizzazione parentesi

Modalità: Sempre attivo

Aggiunge parentesi solo quando necessario per la precedenza degli operatori.

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

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

Property mangling

Modalità: --minify-identifiers (con configurazione)

Rinomina le proprietà degli oggetti a nomi più corti quando configurato.

obj.longPropertyName

obj.a

Constant folding valori template literal

Modalità: --minify-syntax

Converte i valori interpolati non-stringa in stringhe e li folda nel template.

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

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

Constant folding lunghezza stringa

Modalità: --minify-syntax

Valuta la proprietà .length sui letterali di stringa a compile time.

"hello world".length
"test".length

11
4

Semplificazione chiamate costruttore

Modalità: --minify-syntax

Semplifica le chiamate costruttore per i tipi built-in.

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

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

Inlining oggetti singola proprietà

Modalità: --minify-syntax

Inlines l'accesso alle proprietà per oggetti con una singola proprietà.

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

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

Constant folding string charCodeAt

Modalità: Sempre attivo

Valuta charCodeAt() sui letterali di stringa per caratteri ASCII.

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

101
65

Uguaglianza Void 0 a uguaglianza null

Modalità: --minify-syntax

Converte i controlli di uguaglianza loose con void 0 a null poiché sono equivalenti.

x == void 0
x != void 0

x == null
x != null

Ottimizzazione operatore negazione

Modalità: --minify-syntax

Sposta l'operatore di negazione attraverso le espressioni comma.

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

a,-b
x,y,-z

Inlining proprietà Import.meta

Modalità: Modalità bundle

Inlines le proprietà import.meta a build time quando i valori sono conosciuti.

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

"/percorso/alla/directory"
"filename.js"
"/percorso/completo/al/file.js"
"file:///percorso/completo/al/file.js"

Unione dichiarazioni variabili

Modalità: --minify-syntax

Unisce dichiarazioni di variabili adiacenti dello stesso tipo.

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

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

Unione statement espressione

Modalità: --minify-syntax

Unisce statement di espressione adiacenti usando l'operatore comma.

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

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

Unione statement return

Modalità: --minify-syntax

Unisce espressioni prima del return con l'operatore comma.

console.log(x);
return y;

return console.log(x),y;

Unione statement throw

Modalità: --minify-syntax

Unisce espressioni prima del throw con l'operatore comma.

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

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

Inlining enum cross-module TypeScript

Modalità: --minify-syntax (modalità bundle)

Inlines i valori enum attraverso i confini dei moduli.

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

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

const x=0;

Inlining enum proprietà computata

Modalità: --minify-syntax

Inlines i valori enum usati come proprietà di oggetti computate.

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

const obj={foo:value}

Numero stringa a indice numerico

Modalità: --minify-syntax

Converte l'accesso alle proprietà numeriche stringa in indice numerico.

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

obj[0]
arr[5]

Accorciamento corpo arrow function

Modalità: Sempre attivo

Usa la sintassi expression body quando una arrow function restituisce solo un valore.

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

() => x
a => a + 1

Shorthand proprietà oggetto

Modalità: Sempre attivo

Usa la sintassi shorthand quando il nome della proprietà e l'identificatore del valore corrispondono.

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

{ x, y }
{ name, age }

Shorthand metodo

Modalità: Sempre attivo

Usa la sintassi shorthand del metodo negli oggetti literal.

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

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

Drop statement debugger

Modalità: --drop=debugger

Rimuove gli statement debugger dal codice.

function test() {
  debugger;
  return x;
}

function test(){return x}

Drop chiamate console

Modalità: --drop=console

Rimuove tutte le chiamate ai metodi console.* dal codice.

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

void 0;
void 0;
x=void 0;

Drop chiamate funzione custom

Modalità: --drop=<name>

Rimuove le chiamate a funzioni o metodi globali specificati.

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

void 0;
void 0;

Keep Names

Quando minifichi gli identificatori, potresti voler preservare i nomi originali di funzioni e classi per scopi di debugging. Usa il flag --keep-names:

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

O nell'API JavaScript:

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

Questo preserva la proprietà .name su funzioni e classi mentre minifica ancora i nomi effettivi degli identificatori nel codice.

Esempio Combinato

Usando tutte e tre le modalità di minificazione insieme:

const myVariable = 42;

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

const output = myFunction();

// Output con --minify (49 byte, 69% riduzione)
const a=42,b=()=>{const c=!0,d=void 0;return c?a:d},e=b();

Quando Usare la Minificazione

Usa --minify per:

• Bundle production
• Ridurre i costi di banda CDN
• Migliorare i tempi di caricamento pagina

Usa modalità individuali per:

• --minify-whitespace: Riduzione rapida delle dimensioni senza cambiamenti semantici
• --minify-syntax: Output più piccolo mantenendo identificatori leggibili per il debugging
• --minify-identifiers: Massima riduzione delle dimensioni (combina con --keep-names per migliori stack trace)

Evita la minificazione per:

• Build di sviluppo (più difficile da debuggare)
• Quando hai bisogno di messaggi di errore leggibili
• Librerie dove i consumatori potrebbero leggere il sorgente