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
!x

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

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

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