1604 lines
35 KiB
JavaScript
1604 lines
35 KiB
JavaScript
arrow_function_parens: {
|
|
input: {
|
|
something && (() => {});
|
|
}
|
|
expect_exact: "something&&(()=>{});"
|
|
}
|
|
arrow_function_parens_2: {
|
|
input: {
|
|
(() => null)();
|
|
}
|
|
expect_exact: "(()=>null)();"
|
|
}
|
|
|
|
typeof_arrow_functions: {
|
|
options = {
|
|
evaluate: true,
|
|
typeofs: true,
|
|
}
|
|
input: {
|
|
var foo = typeof (x => null);
|
|
console.log(foo);
|
|
}
|
|
expect_exact: "var foo=\"function\";console.log(foo);"
|
|
expect_stdout: "function"
|
|
node_version: ">=4"
|
|
}
|
|
|
|
classes: {
|
|
input: {
|
|
class SomeClass {
|
|
constructor() {
|
|
};
|
|
foo() {};
|
|
};
|
|
class NoSemi {
|
|
constructor(...args) {
|
|
}
|
|
foo() {}
|
|
};
|
|
class ChildClass extends SomeClass {};
|
|
var asExpression = class AsExpression {};
|
|
var nameless = class {};
|
|
}
|
|
expect_exact: "class SomeClass{constructor(){}foo(){}}class NoSemi{constructor(...args){}foo(){}}class ChildClass extends SomeClass{}var asExpression=class AsExpression{};var nameless=class{};"
|
|
}
|
|
|
|
class_statics: {
|
|
input: {
|
|
x = class {
|
|
static staticMethod() {}
|
|
static get foo() {}
|
|
static set bar() {}
|
|
static() { /* "static" can be a method name! */ }
|
|
get() { /* "get" can be a method name! */ }
|
|
set() { /* "set" can be a method name! */ }
|
|
}
|
|
}
|
|
expect_exact: "x=class{static staticMethod(){}static get foo(){}static set bar(){}static(){}get(){}set(){}};"
|
|
}
|
|
|
|
class_name_can_be_mangled: {
|
|
mangle = { };
|
|
input: {
|
|
function x() {
|
|
class Foo {
|
|
}
|
|
var class1 = Foo;
|
|
var class2 = class Bar {};
|
|
}
|
|
}
|
|
expect: {
|
|
function x() {
|
|
class a { }
|
|
var s = a;
|
|
var c = class a {};
|
|
}
|
|
}
|
|
}
|
|
|
|
class_name_can_be_preserved: {
|
|
mangle = {
|
|
keep_classnames: true
|
|
}
|
|
input: {
|
|
function x() {
|
|
(class Baz { });
|
|
class Foo {};
|
|
}
|
|
}
|
|
expect: {
|
|
function x() {
|
|
(class Baz { });
|
|
class Foo {};
|
|
}
|
|
}
|
|
}
|
|
|
|
classes_can_have_generators: {
|
|
input: {
|
|
class Foo {
|
|
*bar() {}
|
|
static *baz() {}
|
|
}
|
|
}
|
|
expect: {
|
|
class Foo {
|
|
*bar() {}
|
|
static *baz() {}
|
|
}
|
|
}
|
|
}
|
|
|
|
classes_can_have_computed_generators: {
|
|
input: {
|
|
class C4 {
|
|
*['constructor']() {}
|
|
}
|
|
}
|
|
expect: {
|
|
class C4 {
|
|
*['constructor']() {}
|
|
}
|
|
}
|
|
}
|
|
|
|
classes_can_have_computed_static: {
|
|
input: {
|
|
class C4 {
|
|
static ['constructor']() {}
|
|
}
|
|
}
|
|
expect: {
|
|
class C4 {
|
|
static ['constructor']() {}
|
|
}
|
|
}
|
|
}
|
|
|
|
class_methods_and_getters_with_keep_quoted_props_enabled: {
|
|
beautify = {
|
|
quote_style: 3,
|
|
keep_quoted_props: true,
|
|
}
|
|
input: {
|
|
class clss {
|
|
a() {}
|
|
"b"() {}
|
|
get c() { return "c"}
|
|
get "d"() { return "d"}
|
|
set e(a) { doSomething(a); }
|
|
set 'f'(a) { doSomething(b); }
|
|
static g() {}
|
|
static "h"() {}
|
|
}
|
|
}
|
|
expect_exact: 'class clss{a(){}"b"(){}get c(){return"c"}get"d"(){return"d"}set e(a){doSomething(a)}set\'f\'(a){doSomething(b)}static g(){}static"h"(){}}'
|
|
}
|
|
|
|
classes_with_expression_as_expand: {
|
|
input: {
|
|
class D extends (calls++, C) {}
|
|
}
|
|
expect_exact: "class D extends(calls++,C){}"
|
|
}
|
|
|
|
new_target: {
|
|
input: {
|
|
new.target;
|
|
new.target.name;
|
|
}
|
|
expect_exact: "new.target;new.target.name;"
|
|
}
|
|
|
|
number_literals: {
|
|
input: {
|
|
0b1001;
|
|
0B1001;
|
|
0o11;
|
|
0O11;
|
|
}
|
|
|
|
expect: {
|
|
9;
|
|
9;
|
|
9;
|
|
9;
|
|
}
|
|
}
|
|
|
|
import_statement: {
|
|
input: {
|
|
import "mod-name";
|
|
import Foo from "bar";
|
|
import { Bar, Baz } from 'lel';
|
|
import Bar, { Foo } from 'lel';
|
|
import { Bar as kex, Baz as food } from 'lel';
|
|
}
|
|
expect_exact: 'import"mod-name";import Foo from"bar";import{Bar,Baz}from"lel";import Bar,{Foo}from"lel";import{Bar as kex,Baz as food}from"lel";'
|
|
}
|
|
|
|
import_all_statement: {
|
|
input: {
|
|
import * from 'lel';
|
|
import * as Lel from 'lel';
|
|
}
|
|
expect_exact: 'import*from"lel";import*as Lel from"lel";'
|
|
}
|
|
|
|
export_statement: {
|
|
options = {
|
|
evaluate: true,
|
|
}
|
|
input: {
|
|
export default 1 + 2;
|
|
export var a = 4;
|
|
export let b = 6;
|
|
export const c = 6;
|
|
export function d() {};
|
|
export class e {};
|
|
}
|
|
expect_exact: "export default 3;export var a=4;export let b=6;export const c=6;export function d(){};export class e{};"
|
|
}
|
|
|
|
export_default_object_expression: {
|
|
options = {
|
|
evaluate: true,
|
|
}
|
|
input: {
|
|
export default {
|
|
foo: 1 + 2,
|
|
bar() { return 4; },
|
|
get baz() { return this.foo; },
|
|
};
|
|
}
|
|
expect_exact: "export default{foo:3,bar(){return 4},get baz(){return this.foo}};"
|
|
}
|
|
|
|
export_default_array: {
|
|
options = {
|
|
evaluate: true,
|
|
}
|
|
input: {
|
|
export default [ 1 + 2, foo ];
|
|
}
|
|
expect_exact: "export default[3,foo];"
|
|
}
|
|
|
|
export_default_anon_function: {
|
|
options = {
|
|
evaluate: true,
|
|
}
|
|
input: {
|
|
export default function(){
|
|
console.log(1 + 2);
|
|
}
|
|
}
|
|
expect_exact: "export default function(){console.log(3)};"
|
|
}
|
|
|
|
export_default_anon_class: {
|
|
options = {
|
|
evaluate: true,
|
|
}
|
|
input: {
|
|
export default class {
|
|
foo() { console.log(1 + 2); }
|
|
}
|
|
}
|
|
expect_exact: "export default class{foo(){console.log(3)}};"
|
|
}
|
|
|
|
export_module_statement: {
|
|
input: {
|
|
export * from "a.js";
|
|
export {A} from "a.js";
|
|
export {A, B} from "a.js";
|
|
export {C};
|
|
}
|
|
expect_exact: 'export*from"a.js";export{A}from"a.js";export{A,B}from"a.js";export{C};'
|
|
}
|
|
|
|
import_statement_mangling: {
|
|
mangle = { toplevel: true };
|
|
input: {
|
|
import Foo from "foo";
|
|
import Bar, {Food} from "lel";
|
|
import {What as Whatever} from "lel";
|
|
Foo();
|
|
Bar();
|
|
Food();
|
|
Whatever();
|
|
}
|
|
expect: {
|
|
import o from "foo";
|
|
import m, {Food as r} from "lel";
|
|
import {What as f} from "lel";
|
|
o();
|
|
m();
|
|
r();
|
|
f();
|
|
}
|
|
}
|
|
|
|
export_statement_mangling: {
|
|
mangle = { };
|
|
input: {
|
|
export var foo = 6;
|
|
export function bar() { }
|
|
export class Baz { }
|
|
bar(foo, Baz)
|
|
}
|
|
expect: {
|
|
export var foo = 6;
|
|
export function bar() { }
|
|
export class Baz { }
|
|
bar(foo, Baz)
|
|
}
|
|
}
|
|
|
|
// https://github.com/mishoo/UglifyJS2/issues/1021
|
|
regression_for_of_const: {
|
|
input: {
|
|
for (const x of y) {}
|
|
for (const x in y) {}
|
|
}
|
|
expect: {
|
|
for (const x of y);for (const x in y);
|
|
}
|
|
}
|
|
|
|
// Fabio: My patches accidentally caused a crash whenever
|
|
// there's an extraneous set of parens around an object.
|
|
regression_cannot_destructure: {
|
|
input: {
|
|
var x = ({ x : 3 });
|
|
x(({ x: 3 }));
|
|
}
|
|
expect_exact: "var x={x:3};x({x:3});";
|
|
}
|
|
|
|
regression_cannot_use_of: {
|
|
input: {
|
|
function of() {
|
|
}
|
|
var of = "is a valid variable name";
|
|
of = { of: "is ok" };
|
|
x.of;
|
|
of: foo()
|
|
}
|
|
expect: {
|
|
function of(){}
|
|
var of="is a valid variable name";
|
|
of={of:"is ok"};
|
|
x.of;
|
|
foo(); /* Label statement missing? No prob. */
|
|
}
|
|
}
|
|
|
|
fat_arrow_as_param: {
|
|
input: {
|
|
foo(x => x);
|
|
foo(x => x, y => y);
|
|
|
|
foo(x => (x, x));
|
|
foo(x => (x, x), y => (y, y));
|
|
}
|
|
expect_exact: "foo(x=>x);foo(x=>x,y=>y);foo(x=>(x,x));foo(x=>(x,x),y=>(y,y));"
|
|
}
|
|
|
|
default_assign: {
|
|
options = {
|
|
keep_fargs: false,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
function f(a, b = 3) {
|
|
console.log(a);
|
|
}
|
|
|
|
g = ([[] = 123]) => {};
|
|
h = ([[x, y, z] = [4, 5, 6]] = []) => {};
|
|
|
|
function i([[x, y, z] = [4, 5, 6]] = []) {
|
|
console.log(b);
|
|
};
|
|
}
|
|
expect: {
|
|
function f(a) {
|
|
console.log(a);
|
|
}
|
|
|
|
g = ([[] = 123]) => {};
|
|
h = ([[x, y, z] = [4, 5, 6]] = []) => {};
|
|
|
|
function i([[x, y, z] = [4, 5, 6]] = []) {
|
|
console.log(b);
|
|
};
|
|
}
|
|
}
|
|
|
|
expansion: {
|
|
options = {
|
|
keep_fargs: false,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
function f(a, ...b) {
|
|
console.log(a);
|
|
}
|
|
}
|
|
expect: {
|
|
function f(a) {
|
|
console.log(a);
|
|
}
|
|
}
|
|
}
|
|
|
|
issue_1613: {
|
|
mangle = { toplevel: true };
|
|
input: {
|
|
const name = 1;
|
|
const foo = {
|
|
name
|
|
};
|
|
}
|
|
expect_exact: "const n=1;const c={name:n};"
|
|
}
|
|
|
|
format_methods: {
|
|
beautify = {
|
|
beautify: true,
|
|
}
|
|
input: {
|
|
class A extends B {constructor(a){x()} static s(b,c){y()} run(d,e,f){z()}}
|
|
}
|
|
expect_exact: [
|
|
"class A extends B {",
|
|
" constructor(a) {",
|
|
" x();",
|
|
" }",
|
|
" static s(b, c) {",
|
|
" y();",
|
|
" }",
|
|
" run(d, e, f) {",
|
|
" z();",
|
|
" }",
|
|
"}",
|
|
]
|
|
}
|
|
|
|
issue_1898: {
|
|
options = {
|
|
}
|
|
mangle = {
|
|
}
|
|
input: {
|
|
class Foo {
|
|
bar() {
|
|
for (const x of [ 6, 5 ]) {
|
|
for (let y of [ 4, 3 ]) {
|
|
for (var z of [ 2, 1 ]) {
|
|
console.log(x, y, z);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
new Foo().bar();
|
|
}
|
|
expect: {
|
|
class Foo {
|
|
bar() {
|
|
for (const f of [ 6, 5 ])
|
|
for (let r of [ 4, 3 ])
|
|
for (var o of [ 2, 1 ])
|
|
console.log(f, r, o);
|
|
}
|
|
}
|
|
new Foo().bar();
|
|
}
|
|
}
|
|
|
|
issue_1753: {
|
|
mangle = { safari10: true };
|
|
input: {
|
|
class SomeClass {
|
|
constructor(props) {
|
|
let pickedSets = [];
|
|
for (let i = 0; i < 6; i++) {
|
|
pickedSets.push({
|
|
mainDrawNumbers: [],
|
|
extraDrawNumbers: []
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
expect: {
|
|
class SomeClass {
|
|
constructor(r) {
|
|
let s = [];
|
|
for (let a = 0; a < 6; a++)
|
|
s.push({
|
|
mainDrawNumbers: [],
|
|
extraDrawNumbers: []
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
issue_1753_disable: {
|
|
mangle = { safari10: false }
|
|
input: {
|
|
class SomeClass {
|
|
constructor(props) {
|
|
let pickedSets = [];
|
|
for (let i = 0; i < 6; i++) {
|
|
pickedSets.push({
|
|
mainDrawNumbers: [],
|
|
extraDrawNumbers: []
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
expect: {
|
|
class SomeClass {
|
|
constructor(r) {
|
|
let s = [];
|
|
for (let r = 0; r < 6; r++)
|
|
s.push({
|
|
mainDrawNumbers: [],
|
|
extraDrawNumbers: []
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class_extends: {
|
|
options = {
|
|
evaluate: true,
|
|
}
|
|
input: {
|
|
function f() {
|
|
class foo extends bar {}
|
|
class pro extends some.prop {}
|
|
class arr extends stuff[1 - 1] {}
|
|
class bin extends (a || b) {}
|
|
class seq extends (a, b) {}
|
|
class ter extends (a ? b : c) {}
|
|
class uni extends (!0) {}
|
|
}
|
|
}
|
|
expect_exact: "function f(){class foo extends bar{}class pro extends some.prop{}class arr extends stuff[0]{}class bin extends(a||b){}class seq extends(a,b){}class ter extends(a?b:c){}class uni extends(!0){}}"
|
|
}
|
|
|
|
class_extends_class: {
|
|
options = {
|
|
}
|
|
input: {
|
|
class anon extends class {} {}
|
|
class named extends class base {} {}
|
|
}
|
|
expect_exact: "class anon extends class{}{}class named extends class base{}{}"
|
|
}
|
|
|
|
class_extends_function: {
|
|
options = {
|
|
}
|
|
input: {
|
|
class anon extends function(){} {}
|
|
class named extends function base(){} {}
|
|
}
|
|
expect_exact: "class anon extends function(){}{}class named extends function base(){}{}"
|
|
}
|
|
|
|
class_extends_regex: {
|
|
options = {
|
|
}
|
|
input: {
|
|
function f() {
|
|
class rx1 extends (/rx/) {}
|
|
// class rx2 extends /rx/ {} // FIXME - parse error
|
|
}
|
|
}
|
|
expect_exact: "function f(){class rx1 extends(/rx/){}}"
|
|
}
|
|
|
|
issue_2028: {
|
|
options = {
|
|
side_effects: true,
|
|
}
|
|
input: {
|
|
var a = {};
|
|
(function(x) {
|
|
x.X = function() {
|
|
return X;
|
|
};
|
|
class X {
|
|
static hello() {
|
|
console.log("hello");
|
|
}
|
|
}
|
|
}(a));
|
|
a.X().hello();
|
|
}
|
|
expect: {
|
|
var a = {};
|
|
(function(x) {
|
|
x.X = function() {
|
|
return X;
|
|
};
|
|
class X {
|
|
static hello() {
|
|
console.log("hello");
|
|
}
|
|
}
|
|
}(a));
|
|
a.X().hello();
|
|
}
|
|
expect_stdout: "hello"
|
|
node_version: ">=6"
|
|
}
|
|
|
|
class_expression_statement: {
|
|
options = {
|
|
toplevel: false,
|
|
side_effects: false,
|
|
unused: false,
|
|
}
|
|
input: {
|
|
(class {});
|
|
(class NamedClassExpr {});
|
|
let expr = (class AnotherClassExpr {});
|
|
class C {}
|
|
}
|
|
expect_exact: "(class{});(class NamedClassExpr{});let expr=class AnotherClassExpr{};class C{}"
|
|
}
|
|
|
|
class_expression_statement_unused: {
|
|
options = {
|
|
toplevel: false,
|
|
side_effects: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
(class {});
|
|
(class NamedClassExpr {});
|
|
let expr = (class AnotherClassExpr {});
|
|
class C {}
|
|
}
|
|
expect_exact: "let expr=class{};class C{}"
|
|
}
|
|
|
|
class_expression_statement_unused_toplevel: {
|
|
options = {
|
|
toplevel: true,
|
|
side_effects: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
(class {});
|
|
(class NamedClassExpr {});
|
|
let expr = (class AnotherClassExpr {});
|
|
class C {}
|
|
}
|
|
expect_exact: ""
|
|
}
|
|
|
|
export_default_function_decl: {
|
|
options = {
|
|
toplevel: true,
|
|
passes: 3,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
// do not drop "unused" exports
|
|
export default function Foo() {};
|
|
export function Far() {};
|
|
}
|
|
expect_exact: "export default function Foo(){};export function Far(){};"
|
|
}
|
|
|
|
export_default_class_decl: {
|
|
options = {
|
|
toplevel: true,
|
|
passes: 3,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
// do not drop "unused" exports
|
|
export default class Car {};
|
|
export class Cab {};
|
|
}
|
|
expect_exact: "export default class Car{};export class Cab{};"
|
|
}
|
|
|
|
object_rest_spread: {
|
|
mangle = {
|
|
toplevel: true,
|
|
}
|
|
input: {
|
|
var { w: w1, ...V } = { w: 7, x: 1, y: 2 }; console.log(w1, V);
|
|
let { w: w2, ...L } = { w: 8, x: 3, y: 4 }; console.log(w2, L);
|
|
const { w: w3, ...C } = { w: 9, x: 5, y: 6 }; console.log(w3, C);
|
|
|
|
let b;
|
|
({ b, ...V } = { a: 1, b: 2, c: 3 }); console.log(V);
|
|
({ b, ...L } = { a: 4, b: 5, c: 6 }); console.log(L);
|
|
|
|
(function({ y, ...p }){ console.log(p); })({ x: 1, y: 2, z: 3 });
|
|
(({ y, ...p }) => { console.log(p); })({ x: 4, y: 5, z: 6 });
|
|
|
|
const T = { a: 1, b: 2 }; console.log({ ...T, w: 0, ...{}, ...L, ...{K: 9} });
|
|
}
|
|
expect: {
|
|
var { w: o, ...l } = { w: 7, x: 1, y: 2 }; console.log(o, l);
|
|
let { w: c, ...n } = { w: 8, x: 3, y: 4 }; console.log(c, n);
|
|
const { w: e, ...s } = { w: 9, x: 5, y: 6 }; console.log(e, s);
|
|
|
|
let g;
|
|
({ b: g, ...l } = { a: 1, b: 2, c: 3 }); console.log(l);
|
|
({ b: g, ...n } = { a: 4, b: 5, c: 6 }); console.log(n);
|
|
|
|
(function({ y: o, ...l }) { console.log(l); })({ x: 1, y: 2, z: 3 });
|
|
(({ y: o, ...l }) => { console.log(l); })({ x: 4, y: 5, z: 6 });
|
|
|
|
const w = { a: 1, b: 2 }; console.log({ ...w, w: 0, ...{}, ...n, ...{ K: 9 } });
|
|
}
|
|
}
|
|
|
|
object_spread_unsafe: {
|
|
options = {
|
|
collapse_vars: true,
|
|
evaluate: true,
|
|
join_vars: true,
|
|
passes: 3,
|
|
reduce_funcs: true,
|
|
reduce_vars: true,
|
|
side_effects: true,
|
|
toplevel: true,
|
|
unsafe: true,
|
|
unused: true,
|
|
}
|
|
mangle = {
|
|
toplevel: true,
|
|
}
|
|
input: {
|
|
var o1 = { x: 1, y: 2 };
|
|
var o2 = { x: 3, z: 4 };
|
|
var cloned = { ...o1 };
|
|
var merged = { ...o1, ...o2 };
|
|
console.log(cloned, merged);
|
|
}
|
|
expect: {
|
|
var o = { x: 1, y: 2 }, l = { ...o }, x = { ...o, ...{ x: 3, z: 4 } };
|
|
console.log(l, x);
|
|
}
|
|
}
|
|
|
|
array_spread_of_sequence: {
|
|
mangle = {
|
|
toplevel: true,
|
|
}
|
|
input: {
|
|
var a = [1];
|
|
console.log([...(a, a)]);
|
|
console.log([...a, a]);
|
|
console.log([...(a || a)]);
|
|
console.log([...a || a]);
|
|
}
|
|
expect: {
|
|
var o = [1];
|
|
console.log([...(o, o)]);
|
|
console.log([...o, o]);
|
|
console.log([...o || o]);
|
|
console.log([...o || o]);
|
|
}
|
|
expect_stdout: [
|
|
"[ 1 ]",
|
|
"[ 1, [ 1 ] ]",
|
|
"[ 1 ]",
|
|
"[ 1 ]",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
object_spread_of_sequence: {
|
|
mangle = {
|
|
toplevel: true,
|
|
}
|
|
input: {
|
|
var a = {x: 1};
|
|
console.log({ ...(a, a) });
|
|
console.log({ ...a, a });
|
|
console.log({ ...(a || a) });
|
|
console.log({ ...a || a });
|
|
}
|
|
expect: {
|
|
var o = { x: 1 };
|
|
console.log({ ...(o, o) });
|
|
console.log({ ...o, a: o });
|
|
console.log({ ...o || o });
|
|
console.log({ ...o || o });
|
|
}
|
|
}
|
|
|
|
// issue 2316
|
|
class_name_can_be_preserved_with_reserved: {
|
|
mangle = {
|
|
reserved: [ "Foo" ],
|
|
}
|
|
input: {
|
|
function x() {
|
|
class Foo {}
|
|
Foo.bar;
|
|
class Bar {}
|
|
Bar.foo;
|
|
}
|
|
function y() {
|
|
var Foo = class Foo {};
|
|
Foo.bar;
|
|
var Bar = class Bar {};
|
|
Bar.bar;
|
|
}
|
|
}
|
|
expect: {
|
|
function x() {
|
|
class Foo {}
|
|
Foo.bar;
|
|
class a {}
|
|
a.foo;
|
|
}
|
|
function y() {
|
|
var Foo = class Foo {};
|
|
Foo.bar;
|
|
var a = class a {};
|
|
a.bar;
|
|
}
|
|
}
|
|
}
|
|
|
|
issue_2345: {
|
|
options = {
|
|
evaluate: true,
|
|
side_effects: true,
|
|
unsafe: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
console.log([...[3, 2, 1]].join("-"));
|
|
var a = [3, 2, 1];
|
|
console.log([...a].join("-"));
|
|
}
|
|
expect: {
|
|
console.log([...[3, 2, 1]].join("-"));
|
|
var a = [3, 2, 1];
|
|
console.log([...a].join("-"));
|
|
}
|
|
expect_stdout: [
|
|
"3-2-1",
|
|
"3-2-1",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
issue_2349: {
|
|
mangle = {}
|
|
input: {
|
|
function foo(boo, key) {
|
|
const value = boo.get();
|
|
return value.map(({[key]: bar}) => bar);
|
|
}
|
|
console.log(foo({
|
|
get: () => [ {
|
|
blah: 42
|
|
} ]
|
|
}, "blah"));
|
|
}
|
|
expect: {
|
|
function foo(o, n) {
|
|
const t = o.get();
|
|
return t.map(({[n]: o}) => o);
|
|
}
|
|
console.log(foo({
|
|
get: () => [ {
|
|
blah: 42
|
|
} ]
|
|
}, "blah"));
|
|
}
|
|
expect_stdout: [
|
|
"[ 42 ]",
|
|
]
|
|
node_version: ">=7"
|
|
}
|
|
|
|
issue_2349b: {
|
|
options = {
|
|
arrows: true,
|
|
collapse_vars: true,
|
|
ecma: 6,
|
|
evaluate: true,
|
|
inline: true,
|
|
passes: 3,
|
|
properties: true,
|
|
reduce_funcs: true,
|
|
reduce_vars: true,
|
|
toplevel: true,
|
|
side_effects: true,
|
|
unsafe_arrows: true,
|
|
unused: true,
|
|
}
|
|
mangle = {
|
|
toplevel: true,
|
|
}
|
|
input: {
|
|
function foo(boo, key) {
|
|
const value = boo.get();
|
|
return value.map(function({[key]: bar}){ return bar; });
|
|
}
|
|
console.log(foo({
|
|
get: function() {
|
|
return [ {
|
|
blah: 42
|
|
} ];
|
|
}
|
|
}, "blah"));
|
|
}
|
|
expect: {
|
|
console.log([ {
|
|
blah: 42
|
|
} ].map(({["blah"]: l}) => l));
|
|
}
|
|
expect_stdout: [
|
|
"[ 42 ]",
|
|
]
|
|
node_version: ">=7"
|
|
}
|
|
|
|
shorthand_keywords: {
|
|
beautify = {
|
|
ecma: 6,
|
|
}
|
|
input: {
|
|
var foo = 0,
|
|
async = 1,
|
|
await = 2,
|
|
implements = 3,
|
|
package = 4,
|
|
private = 5,
|
|
protected = 6,
|
|
static = 7,
|
|
yield = 8;
|
|
console.log({
|
|
foo: foo,
|
|
0: 0,
|
|
NaN: NaN,
|
|
async: async,
|
|
await: await,
|
|
false: false,
|
|
implements: implements,
|
|
null: null,
|
|
package: package,
|
|
private: private,
|
|
protected: protected,
|
|
static: static,
|
|
this: this,
|
|
true: true,
|
|
undefined: undefined,
|
|
yield: yield,
|
|
});
|
|
}
|
|
expect_exact: "var foo=0,async=1,await=2,implements=3,package=4,private=5,protected=6,static=7,yield=8;console.log({foo,0:0,NaN:NaN,async,await,false:false,implements:implements,null:null,package:package,private:private,protected:protected,static:static,this:this,true:true,undefined:void 0,yield});"
|
|
expect_stdout: true
|
|
node_version: ">=4"
|
|
}
|
|
|
|
array_literal_with_spread_1: {
|
|
options = {
|
|
properties: true,
|
|
side_effects: true,
|
|
}
|
|
input: {
|
|
var f = (x) => [...x][0];
|
|
console.log(f(["PASS"]));
|
|
}
|
|
expect: {
|
|
var f = x => [ ...x ][0];
|
|
console.log(f([ "PASS" ]));
|
|
}
|
|
expect_stdout: "PASS"
|
|
node_version: ">=6"
|
|
}
|
|
|
|
array_literal_with_spread_2: {
|
|
options = {
|
|
properties: true,
|
|
side_effects: true,
|
|
}
|
|
input: {
|
|
console.log([10, ...[], 20, ...[30, 40], 50]["length"]);
|
|
console.log([10, ...[], 20, ...[30, 40], 50][0]);
|
|
console.log([10, ...[], 20, ...[30, 40], 50][1]);
|
|
console.log([10, ...[], 20, ...[30, 40], 50][2]);
|
|
console.log([10, ...[], 20, ...[30, 40], 50][3]);
|
|
console.log([10, ...[], 20, ...[30, 40], 50][4]);
|
|
console.log([10, ...[], 20, ...[30, 40], 50][5]);
|
|
}
|
|
expect: {
|
|
console.log([ 10, ...[], 20, ...[ 30, 40 ], 50 ]["length"]);
|
|
console.log(10);
|
|
console.log([ 10, ...[], 20, ...[ 30, 40 ], 50 ][1]);
|
|
console.log([ 10, ...[], 20, ...[ 30, 40 ], 50 ][2]);
|
|
console.log([ 10, ...[], 20, ...[ 30, 40 ], 50 ][3]);
|
|
console.log([ 10, ...[], 20, ...[ 30, 40 ], 50 ][4]);
|
|
console.log([ 10, ...[], 20, ...[ 30, 40 ], 50 ][5]);
|
|
}
|
|
expect_stdout: [
|
|
"5",
|
|
"10",
|
|
"20",
|
|
"30",
|
|
"40",
|
|
"50",
|
|
"undefined",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
array_literal_with_spread_3: {
|
|
options = {
|
|
properties: true,
|
|
side_effects: true,
|
|
}
|
|
input: {
|
|
console.log([10, 20][0]);
|
|
console.log([10, 20][1]);
|
|
console.log([10, 20][2]);
|
|
|
|
console.log([...[], 10, 20][0]);
|
|
console.log([...[], 10, 20][1]);
|
|
console.log([...[], 10, 20][2]);
|
|
|
|
console.log([10, ...[], 20][0]);
|
|
console.log([10, ...[], 20][1]);
|
|
console.log([10, ...[], 20][2]);
|
|
|
|
console.log([10, 20, ...[]][0]);
|
|
console.log([10, 20, ...[]][1]);
|
|
console.log([10, 20, ...[]][2]);
|
|
}
|
|
expect: {
|
|
console.log(10);
|
|
console.log(20);
|
|
console.log([ 10, 20 ][2]);
|
|
|
|
console.log([...[], 10, 20][0]);
|
|
console.log([...[], 10, 20][1]);
|
|
console.log([...[], 10, 20][2]);
|
|
|
|
console.log(10);
|
|
console.log([10, ...[], 20][1]);
|
|
console.log([10, ...[], 20][2]);
|
|
|
|
console.log(10);
|
|
console.log(20);
|
|
console.log([10, 20, ...[]][2]);
|
|
}
|
|
expect_stdout: [
|
|
"10",
|
|
"20",
|
|
"undefined",
|
|
"10",
|
|
"20",
|
|
"undefined",
|
|
"10",
|
|
"20",
|
|
"undefined",
|
|
"10",
|
|
"20",
|
|
"undefined",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
array_literal_with_spread_4: {
|
|
options = {
|
|
properties: true,
|
|
side_effects: true,
|
|
}
|
|
input: {
|
|
function t(x) {
|
|
console.log("(" + x + ")");
|
|
return 10 * x;
|
|
}
|
|
|
|
console.log([t(1), t(2)][0]);
|
|
console.log([t(1), t(2)][1]);
|
|
console.log([t(1), t(2)][2]);
|
|
|
|
console.log([...[], t(1), t(2)][0]);
|
|
console.log([...[], t(1), t(2)][1]);
|
|
console.log([...[], t(1), t(2)][2]);
|
|
|
|
console.log([t(1), ...[], t(2)][0]);
|
|
console.log([t(1), ...[], t(2)][1]);
|
|
console.log([t(1), ...[], t(2)][2]);
|
|
|
|
console.log([t(1), t(2), ...[]][0]);
|
|
console.log([t(1), t(2), ...[]][1]);
|
|
console.log([t(1), t(2), ...[]][2]);
|
|
}
|
|
expect: {
|
|
function t(x) {
|
|
console.log("(" + x + ")");
|
|
return 10 * x;
|
|
}
|
|
|
|
console.log([ t(1), t(2) ][0]);
|
|
console.log((t(1), t(2)));
|
|
console.log([ t(1), t(2) ][2]);
|
|
|
|
console.log([ ...[], t(1), t(2) ][0]);
|
|
console.log([ ...[], t(1), t(2) ][1]);
|
|
console.log([ ...[], t(1), t(2) ][2]);
|
|
|
|
console.log([ t(1), t(2) ][0]);
|
|
console.log([ t(1), ...[], t(2) ][1]);
|
|
console.log([ t(1), ...[], t(2) ][2]);
|
|
|
|
console.log([ t(1), t(2) ][0]);
|
|
console.log((t(1), t(2)));
|
|
console.log([ t(1), t(2), ...[] ][2]);
|
|
}
|
|
expect_stdout: [
|
|
"(1)", "(2)", "10",
|
|
"(1)", "(2)", "20",
|
|
"(1)", "(2)", "undefined",
|
|
|
|
"(1)", "(2)", "10",
|
|
"(1)", "(2)", "20",
|
|
"(1)", "(2)", "undefined",
|
|
|
|
"(1)", "(2)", "10",
|
|
"(1)", "(2)", "20",
|
|
"(1)", "(2)", "undefined",
|
|
|
|
"(1)", "(2)", "10",
|
|
"(1)", "(2)", "20",
|
|
"(1)", "(2)", "undefined",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
object_literal_method_using_arguments: {
|
|
options = {
|
|
arrows: true,
|
|
}
|
|
input: {
|
|
console.log(({
|
|
m() {
|
|
return arguments[0];
|
|
}
|
|
}).m("PASS"));
|
|
}
|
|
expect: {
|
|
console.log(({
|
|
m() {
|
|
return arguments[0];
|
|
}
|
|
}).m("PASS"));
|
|
}
|
|
expect_stdout: "PASS"
|
|
node_version: ">=6"
|
|
}
|
|
|
|
class_method_using_arguments: {
|
|
options = {
|
|
arrows: true,
|
|
}
|
|
input: {
|
|
console.log(new class {
|
|
m() {
|
|
return arguments[0];
|
|
}
|
|
}().m("PASS"));
|
|
}
|
|
expect: {
|
|
console.log(new class {
|
|
m() {
|
|
return arguments[0];
|
|
}
|
|
}().m("PASS"));
|
|
}
|
|
expect_stdout: "PASS"
|
|
node_version: ">=6"
|
|
}
|
|
|
|
issue_2676: {
|
|
options = {
|
|
reduce_vars: true,
|
|
toplevel: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
class A {}
|
|
A.a = 42;
|
|
}
|
|
expect: {
|
|
(class {}).a = 42;
|
|
}
|
|
}
|
|
|
|
issue_2762: {
|
|
mangle = {}
|
|
input: {
|
|
var bar = 1, T = true;
|
|
(function() {
|
|
if (T) {
|
|
const a = function() {
|
|
var foo = bar;
|
|
console.log(foo, a.prop, b.prop);
|
|
};
|
|
a.prop = 2;
|
|
const b = { prop: 3 };
|
|
a();
|
|
}
|
|
})();
|
|
}
|
|
expect: {
|
|
var bar = 1, T = true;
|
|
(function() {
|
|
if (T) {
|
|
const o = function() {
|
|
var p = bar;
|
|
console.log(p, o.prop, r.prop);
|
|
};
|
|
o.prop = 2;
|
|
const r = { prop: 3 };
|
|
o();
|
|
}
|
|
})();
|
|
}
|
|
expect_stdout: "1 2 3"
|
|
}
|
|
|
|
issue_2794_1: {
|
|
options = {
|
|
collapse_vars: true,
|
|
evaluate: true,
|
|
inline: true,
|
|
passes: 1,
|
|
properties: true,
|
|
reduce_funcs: true,
|
|
reduce_vars: true,
|
|
toplevel: false,
|
|
side_effects: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
function foo() {
|
|
for (const a of func(value)) {
|
|
console.log(a);
|
|
}
|
|
function func(va) {
|
|
return doSomething(va);
|
|
}
|
|
}
|
|
function doSomething(x) {
|
|
return [ x, 2 * x, 3 * x ];
|
|
}
|
|
const value = 10;
|
|
foo();
|
|
}
|
|
expect: {
|
|
function foo() {
|
|
for (const a of doSomething(value)) console.log(a);
|
|
}
|
|
function doSomething(x) {
|
|
return [ x, 2 * x, 3 * x ];
|
|
}
|
|
const value = 10;
|
|
foo();
|
|
}
|
|
expect_stdout: [
|
|
"10",
|
|
"20",
|
|
"30",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
issue_2794_2: {
|
|
mangle = {
|
|
toplevel: false,
|
|
}
|
|
options = {
|
|
collapse_vars: true,
|
|
evaluate: true,
|
|
inline: true,
|
|
passes: 1,
|
|
properties: true,
|
|
reduce_funcs: true,
|
|
reduce_vars: true,
|
|
toplevel: false,
|
|
side_effects: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
function foo() {
|
|
for (const a of func(value)) {
|
|
console.log(a);
|
|
}
|
|
function func(va) {
|
|
return doSomething(va);
|
|
}
|
|
}
|
|
function doSomething(x) {
|
|
return [ x, 2 * x, 3 * x ];
|
|
}
|
|
const value = 10;
|
|
foo();
|
|
}
|
|
expect: {
|
|
function foo() {
|
|
for (const o of doSomething(value)) console.log(o);
|
|
}
|
|
function doSomething(o) {
|
|
return [ o, 2 * o, 3 * o ];
|
|
}
|
|
const value = 10;
|
|
foo();
|
|
}
|
|
expect_stdout: [
|
|
"10",
|
|
"20",
|
|
"30",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
issue_2794_3: {
|
|
mangle = {
|
|
toplevel: true,
|
|
}
|
|
options = {
|
|
collapse_vars: true,
|
|
evaluate: true,
|
|
inline: 3,
|
|
passes: 3,
|
|
properties: true,
|
|
reduce_funcs: true,
|
|
reduce_vars: true,
|
|
toplevel: true,
|
|
side_effects: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
function foo() {
|
|
for (const a of func(value)) {
|
|
console.log(a);
|
|
}
|
|
function func(va) {
|
|
return doSomething(va);
|
|
}
|
|
}
|
|
function doSomething(x) {
|
|
return [ x, 2 * x, 3 * x ];
|
|
}
|
|
const value = 10;
|
|
foo();
|
|
}
|
|
expect: {
|
|
(function() {
|
|
for (const o of [ 10, 20, 30 ]) console.log(o);
|
|
})();
|
|
}
|
|
expect_stdout: [
|
|
"10",
|
|
"20",
|
|
"30",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
issue_2794_4: {
|
|
options = {}
|
|
input: {
|
|
for (var x of ([1, 2], [3, 4])) {
|
|
console.log(x);
|
|
}
|
|
}
|
|
expect_exact: "for(var x of([1,2],[3,4]))console.log(x);"
|
|
expect_stdout: [
|
|
"3",
|
|
"4",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
issue_2794_5: {
|
|
mangle = {}
|
|
options = {
|
|
evaluate: true,
|
|
passes: 1,
|
|
side_effects: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
for (var x of ([1, 2], [3, 4])) {
|
|
console.log(x);
|
|
}
|
|
}
|
|
expect_exact: "for(var x of[3,4])console.log(x);"
|
|
expect_stdout: [
|
|
"3",
|
|
"4",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
issue_2794_6: {
|
|
options = {
|
|
}
|
|
input: {
|
|
// TODO (or not): have parser flag invalid for-of expression.
|
|
// Consider it an uglify extension in the meantime.
|
|
for (let e of [1,2], [3,4,5]) {
|
|
console.log(e);
|
|
}
|
|
}
|
|
expect_exact: "for(let e of([1,2],[3,4,5]))console.log(e);"
|
|
expect_stdout: [
|
|
"3",
|
|
"4",
|
|
"5",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
inline_arrow_using_arguments: {
|
|
options = {
|
|
evaluate: true,
|
|
inline: 1,
|
|
reduce_funcs: true,
|
|
reduce_vars: true,
|
|
sequences: true,
|
|
side_effects: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
(function(){
|
|
((x) => {
|
|
console.log.apply(console, arguments),
|
|
console.log(x);
|
|
})(4);
|
|
})(3, 2, 1);
|
|
}
|
|
expect: {
|
|
(function(){
|
|
console.log.apply(console, arguments),
|
|
console.log(4);
|
|
})(3, 2, 1);
|
|
}
|
|
expect_stdout: [
|
|
"3 2 1",
|
|
"4",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
issue_2874_1: {
|
|
options = {
|
|
collapse_vars: true,
|
|
evaluate: true,
|
|
inline: 3,
|
|
reduce_funcs: true,
|
|
reduce_vars: true,
|
|
sequences: true,
|
|
side_effects: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
(function() {
|
|
function foo() {
|
|
let letters = ["A", "B", "C"];
|
|
let result = [2, 1, 0].map(key => bar(letters[key] + key));
|
|
return result;
|
|
}
|
|
function bar(value) {
|
|
return () => console.log(value);
|
|
}
|
|
foo().map(fn => fn());
|
|
})();
|
|
}
|
|
expect: {
|
|
(function() {
|
|
(function() {
|
|
let letters = [ "A", "B", "C" ];
|
|
return [ 2, 1, 0 ].map(key => (function(value) {
|
|
return () => console.log(value);
|
|
})(letters[key] + key));
|
|
})().map(fn => fn());
|
|
})();
|
|
}
|
|
expect_stdout: [
|
|
"C2",
|
|
"B1",
|
|
"A0",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
issue_2874_2: {
|
|
options = {
|
|
collapse_vars: true,
|
|
evaluate: true,
|
|
inline: 3,
|
|
reduce_funcs: true,
|
|
reduce_vars: true,
|
|
sequences: true,
|
|
side_effects: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
(function() {
|
|
let keys = [];
|
|
function foo() {
|
|
var result = [2, 1, 0].map(value => {
|
|
keys.push(value);
|
|
return bar();
|
|
});
|
|
return result;
|
|
}
|
|
function bar() {
|
|
var letters = ["A", "B", "C"], key = keys.shift();
|
|
return () => console.log(letters[key] + key);
|
|
}
|
|
foo().map(fn => fn());
|
|
})();
|
|
}
|
|
expect: {
|
|
(function() {
|
|
let keys = [];
|
|
[ 2, 1, 0 ].map(value => {
|
|
return keys.push(value), function() {
|
|
var letters = [ "A", "B", "C" ], key = keys.shift();
|
|
return () => console.log(letters[key] + key);
|
|
}();
|
|
}).map(fn => fn());
|
|
})();
|
|
}
|
|
expect_stdout: [
|
|
"C2",
|
|
"B1",
|
|
"A0",
|
|
]
|
|
node_version: ">=6"
|
|
}
|
|
|
|
issue_2874_3: {
|
|
options = {
|
|
collapse_vars: true,
|
|
evaluate: true,
|
|
inline: 3,
|
|
reduce_funcs: false,
|
|
reduce_vars: true,
|
|
sequences: true,
|
|
side_effects: true,
|
|
toplevel: true,
|
|
unused: true,
|
|
}
|
|
input: {
|
|
function f() {
|
|
return x + y;
|
|
}
|
|
let x, y;
|
|
let a = (z) => {
|
|
x = "A";
|
|
y = z;
|
|
console.log(f());
|
|
}
|
|
a(1);
|
|
a(2);
|
|
}
|
|
expect: {
|
|
let x, y;
|
|
let a = z => {
|
|
x = "A",
|
|
y = z,
|
|
console.log(x + y);
|
|
};
|
|
a(1),
|
|
a(2);
|
|
}
|
|
expect_stdout: [
|
|
"A1",
|
|
"A2",
|
|
]
|
|
node_version: ">=6"
|
|
}
|