Minifier

true false 

!0 !1 

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

x x x x !1 !0 

undefined let x = undefined; 

void 0 let x=void 0; 

x == undefined x != undefined 

x == null x != null 

Infinity -Infinity 

1/0 -1/0 

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" 

10000 100000 1000000 1.0 -42.0 

1e4 1e5 1e6 1 -42 

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

3 5 12 5 1 8 

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

1 7 6 32 8 -6 

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

"ab" "x123" "foobarbaz" 

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

"o" "h" 

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

"a123b" "result: 15" 

`Hello World` `Line 1 Line 2` 

"Hello World" "Line 1\nLine 2" 

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

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

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

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

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

x 'b' void 0 

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

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

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

!0 !0 !0 !1 !0 

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

x !1 !0 x 

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

x x 42 

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

x x 

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

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

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

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

!!x !!!x 

x !x 

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

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

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

function foo(){return x} 

while (false) {  neverRuns(); } 

// removed entirely 

{ } if (x) { } 

; // removed 

if (condition) {  doSomething(); } 

if(condition)doSomething(); 

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

const x=0; 

const x = /*@__PURE__*/ expensive(); // If x is unused... 

// removed entirely 

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

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

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

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

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

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

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

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

// This comment is removed /* So is this */ /*! But this license comment is kept */ function test() { /* inline comment */ } 

/*! But this license comment is kept */ function test(){} 

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

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

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

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; 

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

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

obj.longPropertyName 

obj.a 

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

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

"hello world".length "test".length 

11 4 

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

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

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

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

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

101 65 

x == void 0 x != void 0 

x == null x != null 

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

a,-b x,y,-z 

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" 

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

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

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

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

console.log(x); return y; 

return console.log(x),y; 

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

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

// lib.ts export enum Color { Red, Green, Blue }  // Input (main.ts) import { Color } from './lib'; const x = Color.Red; 

const x=0; 

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

const obj={foo:value} 

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

obj[0] arr[5] 

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

() => x a => a + 1 

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

{ x, y } { name, age } 

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

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

function test() {  debugger;  return x; } 

function test(){return x} 

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

void 0; void 0; x=void 0; 

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

void 0; void 0; 

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

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