arrow_1: {
    input: {
        console.log(((a = "PASS") => a)());
    }
    expect_exact: 'console.log(((a="PASS")=>a)());'
    expect_stdout: "PASS"
    node_version: ">=6"
}

arrow_2: {
    input: {
        console.log((([ a = "FAIL" ]) => a)([ "PASS" ]));
    }
    expect_exact: 'console.log((([a="FAIL"])=>a)(["PASS"]));'
    expect_stdout: "PASS"
    node_version: ">=6"
}

arrow_3: {
    input: {
        (([ a = console ] = null) => a.log("PASS"))("");
    }
    expect_exact: '(([a=console]=null)=>a.log("PASS"))("");'
    expect_stdout: "PASS"
    node_version: ">=6"
}

assign: {
    input: {
        [ a = "PASS" ] = [];
        console.log(a);
    }
    expect_exact: '[a="PASS"]=[];console.log(a);'
    expect_stdout: "PASS"
    node_version: ">=6"
}

declaration_var: {
    input: {
        var [ a = "PASS" ] = [ , ];
        console.log(a);
    }
    expect_exact: 'var[a="PASS"]=[,];console.log(a);'
    expect_stdout: "PASS"
    node_version: ">=6"
}

declaration_const: {
    input: {
        const [ a = "FAIL" ] = [ "PASS" ];
        console.log(a);
    }
    expect_exact: 'const[a="FAIL"]=["PASS"];console.log(a);'
    expect_stdout: "PASS"
    node_version: ">=6"
}

declaration_let: {
    input: {
        let [ a = "PASS" ] = [ void 42 ];
        console.log(a);
    }
    expect_exact: 'let[a="PASS"]=[void 42];console.log(a);'
    expect_stdout: "PASS"
    node_version: ">=6"
}

object_shorthand_assign: {
    input: {
        ({ a = "PASS" } = 42);
        console.log(a);
    }
    expect_exact: '({a="PASS"}=42);console.log(a);'
    expect_stdout: "PASS"
    node_version: ">=6"
}

object_shorthand_declaration: {
    input: {
        var { a = "PASS" } = 42;
        console.log(a);
    }
    expect_exact: 'var{a="PASS"}=42;console.log(a);'
    expect_stdout: "PASS"
    node_version: ">=6"
}

object_shorthand_function: {
    input: {
        (function({ a = "PASS" }) {
            console.log(a);
        })(42);
    }
    expect_exact: '(function({a="PASS"}){console.log(a)})(42);'
    expect_stdout: "PASS"
    node_version: ">=6"
}

retain_arguments_1: {
    options = {
        arguments: true,
    }
    input: {
        console.log(function(a = "FAIL") {
            return arguments[0];
        }() || "PASS");
    }
    expect: {
        console.log(function(a = "FAIL") {
            return arguments[0];
        }() || "PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

retain_arguments_2: {
    options = {
        arguments: true,
    }
    input: {
        console.log(function(a, b = null) {
            a = "FAIL";
            return arguments[0];
        }("PASS", 42));
    }
    expect: {
        console.log(function(a, b = null) {
            a = "FAIL";
            return arguments[0];
        }("PASS", 42));
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

process_boolean_returns: {
    options = {
        booleans: true,
        evaluate: true,
        reduce_vars: true,
    }
    input: {
        console.log(function(a = console.log("FAIL 1")) {
            return a() ? "PASS" : "FAIL 2";
        }(function() {
            return 42;
        }));
    }
    expect: {
        console.log(function(a = console.log("FAIL 1")) {
            return 42 ? "PASS" : "FAIL 2";
        }(function() {
            return 1;
        }));
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

collapse_arg_sequence: {
    options = {
        collapse_vars: true,
        unused: true,
    }
    input: {
        (function(a = (console.log("bar"), console.log)) {
            a("foo");
        })();
    }
    expect: {
        (function(a = console.log("bar")) {
            (0, console.log)("foo");
        })();
    }
    expect_stdout: [
        "bar",
        "foo",
    ]
    node_version: ">=6"
}

collapse_in_arg: {
    options = {
        collapse_vars: true,
        keep_fargs: false,
        unused: true,
    }
    input: {
        (function(a, b = a) {
            b("PASS");
        })(console.log);
    }
    expect: {
        (function(a) {
            a("PASS");
        })(console.log);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

collapse_value_1: {
    options = {
        collapse_vars: true,
        keep_fargs: false,
        unused: true,
    }
    input: {
        console.log(function(a = "PASS") {
            return a;
        }());
    }
    expect: {
        console.log(function() {
            return "PASS";
        }());
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

collapse_value_2: {
    options = {
        collapse_vars: true,
        keep_fargs: false,
        unused: true,
    }
    input: {
        (function(a = console) {
            return a;
        })().log("PASS");
    }
    expect: {
        (function() {
            return console;
        })().log("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

flatten_if: {
    options = {
        conditionals: true,
    }
    input: {
        if (console.log("PASS")) {
            var [
                a = function b() {
                    for (c in b);
                },
            ] = 0;
        }
    }
    expect: {
        var a;
        console.log("PASS") && ([
            a = function b() {
                for (c in b);
            },
        ] = 0);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

maintain_if: {
    options = {
        conditionals: true,
    }
    input: {
        if (a)
            for (;;);
        else
            var [ a = "PASS" ] = [];
        console.log(a);
    }
    expect: {
        if (a)
            for (;;);
        else
            var [ a = "PASS" ] = [];
        console.log(a);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

reduce_funarg: {
    options = {
        evaluate: true,
        keep_fargs: false,
        reduce_vars: true,
        unused: true,
    }
    input: {
        console.log(...function(a = "foo", b = "bar", c = "baz") {
            return [ a, b, c ];
        }(void 0, null));
    }
    expect: {
        console.log(...function() {
            return [ "foo", null, "baz" ];
        }());
    }
    expect_stdout: "foo null baz"
    node_version: ">=6"
}

reduce_array: {
    options = {
        evaluate: true,
        reduce_vars: true,
        toplevel: true,
        unsafe: true,
        unused: true,
    }
    input: {
        var [ a = "foo", b = "bar", c = "baz" ] = [ void 0, null ];
        console.log(a, b, c);
    }
    expect: {
        var [ c = "baz" ] = [];
        console.log("foo", null, c);
    }
    expect_stdout: "foo null baz"
    node_version: ">=6"
}

reduce_object: {
    options = {
        evaluate: true,
        reduce_vars: true,
        toplevel: true,
        unsafe: true,
        unused: true,
    }
    input: {
        var { a = "foo", b = "bar", c = "baz" } = { a: void 0, b: null };
        console.log(a, b, c);
    }
    expect: {
        var { c = "baz" } = {};
        console.log("foo", null, c);
    }
    expect_stdout: "foo null baz"
    node_version: ">=6"
}

evaluate_iife: {
    options = {
        evaluate: true,
    }
    input: {
        console.log(function(a = "PASS") {
            return a;
        }());
    }
    expect: {
        console.log("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

unsafe_evaluate_iife_1: {
    options = {
        evaluate: true,
        unsafe: true,
    }
    input: {
        console.log(function([ a ] = []) {
            return "PASS";
        }());
    }
    expect: {
        console.log(function([ a ] = []) {
            return "PASS";
        }());
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

unsafe_evaluate_iife_2: {
    options = {
        evaluate: true,
        reduce_vars: true,
        unsafe: true,
    }
    input: {
        console.log(function([ a ] = []) {
            return a[0];
        }([ [ "PASS" ] ]));
    }
    expect: {
        console.log(function([ a ] = []) {
            return a[0];
        }([ [ "PASS" ] ]));
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

inline_direct: {
    options = {
        default_values: true,
        inline: true,
        unused: true,
    }
    input: {
        console.log(function(a = "FAIL") {
            return a;
        }("PASS"));
    }
    expect: {
        console.log("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

inline_constant: {
    options = {
        inline: true,
    }
    input: {
        console.log(function(a = console.log("foo")) {
            return "bar";
        }(void console.log("baz")));
    }
    expect: {
        console.log((void console.log("baz"), console.log("foo"), "bar"));
    }
    expect_stdout: [
        "baz",
        "foo",
        "bar",
    ]
    node_version: ">=6"
}

inline_destructured: {
    options = {
        inline: true,
    }
    input: {
        console.log(function([ a ] = []) {
            return "PASS";
        }());
    }
    expect: {
        console.log(([ [] = [] ] = [], "PASS"));
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

inline_function: {
    options = {
        default_values: true,
        inline: true,
        sequences: true,
        side_effects: true,
        toplevel: true,
        unused: true,
    }
    input: {
        (function(a = console.log("foo"), b = console.log("bar")) {
            console.log("baz");
        }(void console.log("moo"), 42));
    }
    expect: {
        console.log("moo"),
        console.log("foo"),
        console.log("baz");
    }
    expect_stdout: [
        "moo",
        "foo",
        "baz",
    ]
    node_version: ">=6"
}

inline_loop_1: {
    options = {
        inline: true,
        reduce_vars: true,
        toplevel: true,
        unused: true,
    }
    input: {
        while (function f(a = "PASS") {
            console.log(a);
        }());
    }
    expect: {
        while (a = "PASS", void console.log(a));
        var a;
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

inline_loop_2: {
    options = {
        inline: true,
        sequences: true,
        toplevel: true,
        unused: true,
    }
    input: {
        while (function(a = [ "PASS" ]) {
            var a = function f(b) {
                console.log(a[b]);
            }(0);
        }());
    }
    expect: {
        while (a = [ "PASS" ],
            b = void 0,
            b = 0,
            void (a = void console.log(a[b])));
        var a, b;
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

inline_side_effects_1: {
    options = {
        inline: true,
        toplevel: true,
    }
    input: {
        var a = 42;
        (function(b = --a) {})(console);
        console.log(a);
    }
    expect: {
        var a = 42;
        [ b = --a ] = [ console ],
        void 0;
        var b;
        console.log(a);
    }
    expect_stdout: "42"
    node_version: ">=6"
}

inline_side_effects_2: {
    options = {
        side_effects: true,
    }
    input: {
        var a = 42;
        (function(b = --a) {})(console);
        console.log(a);
    }
    expect: {
        var a = 42;
        [ [][0] = --a ] = [ console ];
        console.log(a);
    }
    expect_stdout: "42"
    node_version: ">=6"
}

drop_empty_iife: {
    options = {
        side_effects: true,
    }
    input: {
        console.log(function(a = console.log("foo")) {}(void console.log("baz")));
    }
    expect: {
        console.log((console.log("baz"), void console.log("foo")));
    }
    expect_stdout: [
        "baz",
        "foo",
        "undefined",
    ]
    node_version: ">=6"
}

retain_empty_iife: {
    options = {
        side_effects: true,
    }
    input: {
        var a;
        try {
            (function(a = a) {})();
        } catch (e) {
            console.log("PASS");
        }
    }
    expect: {
        var a;
        try {
            (function(a = a) {})();
        } catch (e) {
            console.log("PASS");
        }
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

drop_new_function: {
    options = {
        side_effects: true,
    }
    input: {
        new function(a = console.log("PASS")) {}();
    }
    expect: {
        void console.log("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

retain_fargs: {
    options = {
        unused: true,
    }
    input: {
        (function([ a = console.log("PASS") ]) {})([]);
    }
    expect: {
        (function([ a = console.log("PASS") ]) {})([]);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

drop_fargs: {
    options = {
        keep_fargs: false,
        unused: true,
    }
    input: {
        console.log(function(a = 42, b = console.log("foo"), c = true) {
            return "bar";
        }(console.log("baz"), "moo", false));
    }
    expect: {
        console.log(function(b = console.log("foo")) {
            return "bar";
        }((console.log("baz"), "moo")));
    }
    expect_stdout: [
        "baz",
        "bar",
    ]
    expect_warnings: [
        "WARN: Dropping unused default argument c [test/compress/default-values.js:1,61]",
        "WARN: Side effects in default value of unused variable b [test/compress/default-values.js:1,37]",
        "WARN: Dropping unused default argument assignment a [test/compress/default-values.js:1,29]",
    ]
    node_version: ">=6"
}

hoist_vars: {
    options = {
        hoist_vars: true,
        join_vars: true,
        unused: true,
    }
    input: {
        var a = "PASS";
        var [ b = 42 ] = [];
        console.log(a, b);
    }
    expect: {
        var a = "PASS", [ b = 42 ] = [];
        console.log(a, b);
    }
    expect_stdout: "PASS 42"
    node_version: ">=6"
}

unused_var_1: {
    options = {
        toplevel: true,
        unused: true,
    }
    input: {
        var [ a = 42 ] = [ console.log("PASS") ];
    }
    expect: {
        console.log("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

unused_var_2: {
    options = {
        pure_getters: "strict",
        toplevel: true,
        unused: true,
    }
    input: {
        var {
            p: [ a ] = "" + console.log("FAIL"),
        } = {
            p: [ console.log("PASS") ],
        };
    }
    expect: {
        console.log("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

unused_value_assign_1: {
    options = {
        default_values: true,
        unused: true,
    }
    input: {
        [] = [ console.log("PASS") ];
    }
    expect: {
        [ console.log("PASS") ];
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

unused_value_assign_2: {
    options = {
        default_values: true,
        unused: true,
    }
    input: {
        [ a = console.log("FAIL") ] = [ "PASS" ];
        console.log(a);
    }
    expect: {
        [ a ] = [ "PASS" ];
        console.log(a);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

unused_value_var_1: {
    options = {
        default_values: true,
        unused: true,
    }
    input: {
        var [] = [ console.log("PASS") ];
    }
    expect: {
        console.log("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

unused_value_var_2: {
    options = {
        default_values: true,
        unused: true,
    }
    input: {
        var [ a = console.log("FAIL") ] = [ "PASS" ];
        console.log(a);
    }
    expect: {
        var a = [ "PASS" ][0];
        console.log(a);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

mangle_var_1: {
    mangle = {
        toplevel: false,
    }
    input: {
        var N = 1, [ {
            pname: p = "x",
            i: n = N,
        }, {
            [p + n]: v,
        } ] = [ {}, {
            x1: "PASS",
        } ];
        console.log(v);
    }
    expect: {
        var N = 1, [ {
            pname: p = "x",
            i: n = N,
        }, {
            [p + n]: v,
        } ] = [ {}, {
            x1: "PASS",
        } ];
        console.log(v);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

mangle_var_1_toplevel: {
    mangle = {
        toplevel: true,
    }
    input: {
        var N = 1, [ {
            pname: p = "x",
            i: n = N,
        }, {
            [p + n]: v,
        } ] = [ {}, {
            x1: "PASS",
        } ];
        console.log(v);
    }
    expect: {
        var o = 1, [ {
            pname: a = "x",
            i: e = o,
        }, {
            [a + e]: l,
        } ] = [ {}, {
            x1: "PASS",
        } ];
        console.log(l);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

mangle_var_2: {
    mangle = {
        toplevel: false,
    }
    input: {
        var N = 1, [ {
            pname: p = "x",
            i: n = N,
        } = {}, {
            [p + n]: v,
        } ] = [ , {
            x1: "PASS",
        } ];
        console.log(v);
    }
    expect: {
        var N = 1, [ {
            pname: p = "x",
            i: n = N,
        } = {}, {
            [p + n]: v,
        } ] = [ , {
            x1: "PASS",
        } ];
        console.log(v);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

mangle_var_2_toplevel: {
    mangle = {
        toplevel: true,
    }
    input: {
        var N = 1, [ {
            pname: p = "x",
            i: n = N,
        } = {}, {
            [p + n]: v,
        } ] = [ , {
            x1: "PASS",
        } ];
        console.log(v);
    }
    expect: {
        var o = 1, [ {
            pname: a = "x",
            i: e = o,
        } = {}, {
            [a + e]: l,
        } ] = [ , {
            x1: "PASS",
        } ];
        console.log(l);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

mangle_function_1: {
    mangle = {
        toplevel: false,
    }
    input: {
        var N = 1;
        (function(o, {
            pname: p,
        } = o, {
            [p + N]: v,
        } = o) {
            let N;
            console.log(v);
        })({
            pname: "x",
            x1: "PASS",
        });
    }
    expect: {
        var N = 1;
        (function(n, {
            pname: e,
        } = n, {
            [e + N]: o,
        } = n) {
            let a;
            console.log(o);
        })({
            pname: "x",
            x1: "PASS",
        });
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

mangle_function_1_toplevel: {
    mangle = {
        toplevel: true,
    }
    input: {
        var N = 1;
        (function(o, {
            pname: p,
        } = o, {
            [p + N]: v,
        } = o) {
            let N;
            console.log(v);
        })({
            pname: "x",
            x1: "PASS",
        });
    }
    expect: {
        var l = 1;
        (function(n, {
            pname: e,
        } = n, {
            [e + l]: o,
        } = n) {
            let a;
            console.log(o);
        })({
            pname: "x",
            x1: "PASS",
        });
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

mangle_function_2: {
    mangle = {
        toplevel: false,
    }
    input: {
        var N = 1;
        (function({
            pname: p = "x",
            i: n = N,
        }, {
            [p + n]: v,
        }) {
            let N;
            console.log(v);
        })({}, {
            x1: "PASS",
        });
    }
    expect: {
        var N = 1;
        (function({
            pname: n = "x",
            i: o = N,
        }, {
            [n + o]: e,
        }) {
            let l;
            console.log(e);
        })({}, {
            x1: "PASS",
        });
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

mangle_function_2_toplevel: {
    mangle = {
        toplevel: true,
    }
    input: {
        var N = 1;
        (function({
            pname: p = "x",
            i: n = N,
        }, {
            [p + n]: v,
        }) {
            let N;
            console.log(v);
        })({}, {
            x1: "PASS",
        });
    }
    expect: {
        var a = 1;
        (function({
            pname: n = "x",
            i: o = a,
        }, {
            [n + o]: e,
        }) {
            let l;
            console.log(e);
        })({}, {
            x1: "PASS",
        });
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

mangle_arrow_1: {
    mangle = {
        toplevel: false,
    }
    input: {
        var N = 1;
        ((o, {
            pname: p,
        } = o, {
            [p + N]: v,
        } = o) => {
            let N;
            console.log(v);
        })({
            pname: "x",
            x1: "PASS",
        });
    }
    expect: {
        var N = 1;
        ((e, {
            pname: a,
        } = e, {
            [a + N]: l,
        } = e) => {
            let n;
            console.log(l);
        })({
            pname: "x",
            x1: "PASS",
        });
    }
    expect_stdout: "PASS"
    node_version: ">=6.9.3"
}

mangle_arrow_1_toplevel: {
    mangle = {
        toplevel: true,
    }
    input: {
        var N = 1;
        ((o, {
            pname: p,
        } = o, {
            [p + N]: v,
        } = o) => {
            let N;
            console.log(v);
        })({
            pname: "x",
            x1: "PASS",
        });
    }
    expect: {
        var o = 1;
        ((e, {
            pname: a,
        } = e, {
            [a + o]: l,
        } = e) => {
            let n;
            console.log(l);
        })({
            pname: "x",
            x1: "PASS",
        });
    }
    expect_stdout: "PASS"
    node_version: ">=6.9.3"
}

mangle_arrow_2: {
    mangle = {
        toplevel: false,
    }
    input: {
        var N = 1;
        (({
            pname: p = "x",
            i: n = N,
        }, {
            [p + n]: v,
        }) => {
            let N;
            console.log(v);
        })({}, {
            x1: "PASS",
        });
    }
    expect: {
        var N = 1;
        (({
            pname: e = "x",
            i: l = N,
        }, {
            [e + l]: o,
        }) => {
            let a;
            console.log(o);
        })({}, {
            x1: "PASS",
        });
    }
    expect_stdout: "PASS"
    node_version: ">=6.9.3"
}

mangle_arrow_2_toplevel: {
    mangle = {
        toplevel: true,
    }
    input: {
        var N = 1;
        (({
            pname: p = "x",
            i: n = N,
        }, {
            [p + n]: v,
        }) => {
            let N;
            console.log(v);
        })({}, {
            x1: "PASS",
        });
    }
    expect: {
        var n = 1;
        (({
            pname: e = "x",
            i: l = n,
        }, {
            [e + l]: o,
        }) => {
            let a;
            console.log(o);
        })({}, {
            x1: "PASS",
        });
    }
    expect_stdout: "PASS"
    node_version: ">=6.9.3"
}

collapse_preceding_simple_arg: {
    options = {
        collapse_vars: true,
        unused: true,
    }
    input: {
        var a = "foo";
        console.log(function(b, c = "bar") {
            return b + c;
        }(a, a));
    }
    expect: {
        var a = "foo";
        console.log(function(b, c = "bar") {
            return a + c;
        }(0, a));
    }
    expect_stdout: "foofoo"
    node_version: ">=6"
}

drop_preceding_simple_arg: {
    options = {
        collapse_vars: true,
        keep_fargs: false,
        unused: true,
    }
    input: {
        var a = "foo";
        console.log(function(b, c = "bar") {
            return b + c;
        }(a, a));
    }
    expect: {
        var a = "foo";
        console.log(function(c = "bar") {
            return a + c;
        }(a));
    }
    expect_stdout: "foofoo"
    node_version: ">=6"
}

issue_4444: {
    options = {
        collapse_vars: true,
    }
    input: {
        var a = "PASS";
        console.log(function(b) {
            b = a;
            (function(c = b.p) {})();
            return a;
        }());
    }
    expect: {
        var a = "PASS";
        console.log(function(b) {
            b = a;
            (function(c = b.p) {})();
            return a;
        }());
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_4446_1: {
    options = {
        collapse_vars: true,
    }
    input: {
        a = 42;
        [ b = 42 ] = [ "PASS" ];
        c = 42;
        console.log(b, a);
    }
    expect: {
        [ b = 42 ] = [ "PASS" ];
        c = a = 42;
        console.log(b, a);
    }
    expect_stdout: "PASS 42"
    node_version: ">=6"
}

issue_4446_2: {
    options = {
        collapse_vars: true,
    }
    input: {
        a = 42;
        var [ b = 42 ] = [ "PASS" ];
        c = 42;
        console.log(b, a);
    }
    expect: {
        var [ b = 42 ] = [ "PASS" ];
        c = a = 42;
        console.log(b, a);
    }
    expect_stdout: "PASS 42"
    node_version: ">=6"
}

issue_4458: {
    options = {
        evaluate: true,
        reduce_vars: true,
        toplevel: true,
        unused: true,
    }
    input: {
        var a = "PASS";
        function f(b = a = "FAIL") {
            console.log(a, b);
        }
        f(42);
    }
    expect: {
        var a = "PASS";
        (function(b = a = "FAIL") {
            console.log(a, b);
        })(42);
    }
    expect_stdout: "PASS 42"
    node_version: ">=6"
}

issue_4460: {
    options = {
        collapse_vars: true,
    }
    input: {
        var log = console.log, a = "FAIL";
        var [ b = a ] = (a = "PASS", []);
        log(a, b);
    }
    expect: {
        var log = console.log, a = "FAIL";
        var [ b = a ] = (a = "PASS", []);
        log(a, b);
    }
    expect_stdout: "PASS PASS"
    node_version: ">=6"
}

issue_4461_1: {
    options = {
        collapse_vars: true,
        unused: true,
    }
    input: {
        var a = 0;
        (function(b = a && console.log("PASS"), c) {
            return c;
        })(void 0, a++);
    }
    expect: {
        var a = 0;
        (function(b = a && console.log("PASS"), c) {
            return c;
        })(void 0, a++);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_4461_2: {
    options = {
        collapse_vars: true,
        unused: true,
    }
    input: {
        var a = 0;
        (function([ b = a && console.log("PASS") ], c) {
            return c;
        })([], a++);
    }
    expect: {
        var a = 0;
        (function([ b = a && console.log("PASS") ], c) {
            return c;
        })([], a++);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_4468: {
    options = {
        evaluate: true,
        keep_fargs: false,
        pure_getters: "strict",
        reduce_vars: true,
        side_effects: true,
        unused: true,
    }
    input: {
        (function(a) {
            var {
                [console.log("PASS")]: b = a && (a.p = 0),
            } = 0;
            a;
        })(1234);
    }
    expect: {
        (function() {
            var {
                [console.log("PASS")]: b,
            } = 0;
        })();
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_4483: {
    options = {
        conditionals: true,
        evaluate: true,
        reduce_vars: true,
        toplevel: true,
    }
    input: {
        if (console)
            var [ a = "FAIL" ] = [], b = a = "PASS";
        console.log(b);
    }
    expect: {
        var a, b;
        console && ([ a = "FAIL" ] = [], b = "PASS");
        console.log(b);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_4485_1: {
    options = {
        pure_getters: "strict",
        side_effects: true,
    }
    input: {
        (function(a = null) {
            var arguments;
            try {
                arguments.length;
            } catch (e) {
                console.log("PASS");
            }
        })();
    }
    expect: {
        (function(a = null) {
            var arguments;
            try {
                arguments.length;
            } catch (e) {
                console.log("PASS");
            }
        })();
    }
    expect_stdout: true
    node_version: ">=6"
}

issue_4485_2: {
    options = {
        pure_getters: "strict",
        side_effects: true,
    }
    input: {
        (function(a = null) {
            var arguments = null;
            try {
                arguments.length;
            } catch (e) {
                console.log("PASS");
            }
        })();
    }
    expect: {
        (function(a = null) {
            var arguments = null;
            try {
                arguments.length;
            } catch (e) {
                console.log("PASS");
            }
        })();
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_4485_3: {
    options = {
        unused: true,
    }
    input: {
        (function(a = null) {
            var arguments;
            try {
                arguments.length;
            } catch (e) {
                console.log("PASS");
            }
        })();
    }
    expect: {
        (function(a = null) {
            var arguments;
            try {
                arguments.length;
            } catch (e) {
                console.log("PASS");
            }
        })();
    }
    expect_stdout: true
    node_version: ">=6"
}

issue_4496: {
    options = {
        default_values: true,
        unused: true,
    }
    input: {
        (function f(a = 0) {
            console.log(function(b) {
                a && b();
                return a;
            }(f));
        })(42);
    }
    expect: {
        (function f(a = 0) {
            console.log(function(b) {
                a && b();
                return a;
            }(f));
        })(42);
    }
    expect_stdout: [
        "0",
        "42",
    ]
    node_version: ">=6"
}

issue_4502_1: {
    options = {
        inline: true,
        unused: true,
    }
    input: {
        (function() {
            var a = "PASS";
            (function(b = a++) {
                var a;
            })(void 0, console.log(a));
        })();
    }
    expect: {
        (function() {
            var a = "PASS";
            void 0,
            console.log(a),
            a++,
            void 0;
        })();
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_4502_2: {
    options = {
        inline: true,
        unused: true,
    }
    input: {
        (function() {
            var a = "PASS";
            (function(b = a++) {})(void 0, console.log(a));
        })();
    }
    expect: {
        (function() {
            var a = "PASS";
            void 0,
            console.log(a),
            a++,
            void 0;
        })();
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_4502_3: {
    options = {
        side_effects: true,
    }
    input: {
        (function() {
            var a = "PASS";
            (function(b = a++) {})(void 0, console.log(a));
        })();
    }
    expect: {
        (function() {
            var a = "PASS";
            console.log(a),
            a++;
        })();
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_4502_4: {
    options = {
        side_effects: true,
    }
    input: {
        (function(a, b = console.log("FAIL")) {})(..."" + console.log(42));
    }
    expect: {
        [ , [][0] = console.log("FAIL") ] = [ ..."" + console.log(42) ];
    }
    expect_stdout: "42"
    node_version: ">=6"
}

issue_4510_1: {
    options = {
        default_values: true,
        unused: true,
    }
    input: {
        var a = [];
        var [ , b = console.log("PASS") ] = [ ...a, null ];
    }
    expect: {
        var a = [];
        var [ , b = console.log("PASS") ] = [ ...a, null ];
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_4510_2: {
    options = {
        default_values: true,
        unused: true,
    }
    input: {
        var o = {
            p: void 0,
        };
        var {
            p: a = console.log("PASS"),
        } = {
            p: null,
            ...o,
        };
    }
    expect: {
        var o = {
            p: void 0,
        };
        var {
            p: a = console.log("PASS"),
        } = {
            p: null,
            ...o,
        };
    }
    expect_stdout: "PASS"
    node_version: ">=8.3.0"
}

issue_4523: {
    options = {
        merge_vars: true,
    }
    input: {
        console.log(function() {
            var a, b;
            [ a = b = false ] = [ "FAIL" ];
            return b || "PASS";
        }());
    }
    expect: {
        console.log(function() {
            var a, b;
            [ a = b = false ] = [ "FAIL" ];
            return b || "PASS";
        }());
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_4540: {
    options = {
        reduce_vars: true,
        side_effects: true,
    }
    input: {
        console.log(function() {
            function f([ a = 0 ]) {}
            f([]);
        }());
    }
    expect: {
        console.log(function() {
            function f([ a = 0 ]) {}
            f([]);
        }());
    }
    expect_stdout: "undefined"
    node_version: ">=6"
}

issue_4548_1: {
    options = {
        merge_vars: true,
        toplevel: true,
    }
    input: {
        A = "foo";
        var a = A;
        [ b = c = "bar" ] = [ console, console.log(a) ];
        console.log(c);
        var c;
    }
    expect: {
        A = "foo";
        var a = A;
        [ b = c = "bar" ] = [ console, console.log(a) ];
        console.log(c);
        var c;
    }
    expect_stdout: [
        "foo",
        "undefined",
    ]
    node_version: ">=6"
}

issue_4548_2: {
    options = {
        merge_vars: true,
        toplevel: true,
    }
    input: {
        A = "foo";
        var a = A;
        var [ b = c = "bar" ] = [ console, console.log(a) ];
        console.log(c);
        var c;
    }
    expect: {
        A = "foo";
        var a = A;
        var [ b = c = "bar" ] = [ console, console.log(a) ];
        console.log(c);
        var c;
    }
    expect_stdout: [
        "foo",
        "undefined",
    ]
    node_version: ">=6"
}

issue_4588_1_unused: {
    options = {
        unused: true,
    }
    input: {
        console.log(function(a = 42) {}.length);
    }
    expect: {
        console.log(function(a = 0) {}.length);
    }
    expect_stdout: "0"
    node_version: ">=6"
}

issue_4588_2_unused: {
    options = {
        unused: true,
    }
    input: {
        console.log(function(a, b = void 0, c, d = "foo") {}.length);
    }
    expect: {
        console.log(function(a, b = 0, c, d) {}.length);
    }
    expect_stdout: "1"
    expect_warnings: [
        "WARN: Dropping unused default argument assignment d [test/compress/default-values.js:1,47]",
        "WARN: Dropping unused default argument value b [test/compress/default-values.js:1,32]",
    ]
    node_version: ">=6"
}

issue_4588_1_evaluate: {
    options = {
        evaluate: true,
        unsafe: true,
    }
    input: {
        console.log(function(a = 42) {}.length);
    }
    expect: {
        console.log(0);
    }
    expect_stdout: "0"
    node_version: ">=6"
}

issue_4588_2_evaluate: {
    options = {
        evaluate: true,
        unsafe: true,
    }
    input: {
        console.log(function(a, b = void 0, c, d = "foo") {}.length);
    }
    expect: {
        console.log(1);
    }
    expect_stdout: "1"
    node_version: ">=6"
}

issue_4817: {
    options = {
        ie: true,
        inline: true,
        unused: true,
    }
    input: {
        (function f(a = console.log(typeof f)) {
            return 42;
        })();
    }
    expect: {
        (function f(a = console.log(typeof f)) {
            return 42;
        })();
    }
    expect_stdout: "function"
    node_version: ">=6"
}

issue_4854: {
    options = {
        collapse_vars: true,
        inline: true,
        side_effects: true,
        unused: true,
    }
    input: {
        console.log(function(a) {
            (function(b = a = "foo") {
                [] = "foo";
            })();
            a;
        }());
    }
    expect: {
        console.log(void 0);
    }
    expect_stdout: "undefined"
    node_version: ">=6"
}

issue_4916: {
    options = {
        collapse_vars: true,
        pure_getters: "strict",
        reduce_vars: true,
    }
    input: {
        var log = console.log;
        (function(b = "foo") {
            b.value = "FAIL";
            b;
            log(b.value);
        })();
    }
    expect: {
        var log = console.log;
        (function(b = "foo") {
            b.value = "FAIL";
            b;
            log(b.value);
        })();
    }
    expect_stdout: "undefined"
    node_version: ">=6"
}

issue_4994: {
    options = {
        loops: true,
        unused: true,
    }
    input: {
        var a = "FAIL";
        (function(b = function() {
            for (a in { PASS: 42 });
        }()) {
            var a;
        })();
        console.log(a);
    }
    expect: {
        var a = "FAIL";
        (function(b = function() {
            for (a in { PASS: 42 });
        }()) {})();
        console.log(a);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5057_1: {
    options = {
        collapse_vars: true,
        inline: true,
        sequences: true,
        unused: true,
    }
    input: {
        var a = 42;
        (function() {
            var b = function(c = (console.log("foo"), b = a)) {
                a && console.log("bar");
            }();
        })();
    }
    expect: {
        var a = 42;
        console.log("foo"),
        void (a && console.log("bar"));
    }
    expect_stdout: [
        "foo",
        "bar",
    ]
    node_version: ">=6"
}

issue_5057_2: {
    options = {
        inline: true,
        unused: true,
    }
    input: {
        (function f(a) {
            (function(b = console.log("FAIL")) {})(a);
        })(42);
        console.log(typeof b);
    }
    expect: {
        (function(a) {
            [ b = console.log("FAIL") ] = [ a ],
            void 0;
            var b;
        })(42);
        console.log(typeof b);
    }
    expect_stdout: "undefined"
    node_version: ">=6"
}

issue_5057_3: {
    options = {
        inline: 3,
        unused: true,
    }
    input: {
        (function(a) {
            (function f(b) {
                (function(a = console.log("FAIL 1")) {})(b);
                console.log(a);
            })("FAIL 2");
        })("PASS");
    }
    expect: {
        (function(a) {
            (function(b) {
                (function(a = console.log("FAIL 1")) {})(b);
                console.log(a);
            })("FAIL 2");
        })("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5057_4: {
    options = {
        if_return: true,
        inline: true,
        unused: true,
    }
    input: {
        (function(a) {
            (function f(b) {
                (function(a = console.log("FAIL 1")) {})(b);
                console.log(a);
            })("FAIL 2");
        })("PASS");
    }
    expect: {
        (function(a) {
            var b = "FAIL 2";
            (function(a = console.log("FAIL 1")) {})(b);
            console.log(a);
        })("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5065: {
    options = {
        pure_getters: "strict",
        toplevel: true,
        unused: true,
    }
    input: {
        var [ a = console.log("PASS") ] = [ (A = 42).p ];
    }
    expect: {
        var [ a = console.log("PASS") ] = [ (A = 42).p ];
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5138_1: {
    options = {
        evaluate: true,
    }
    input: {
        console.log(function(a, b = a = "FAIL") {
            return a;
        }() && "PASS");
    }
    expect: {
        console.log(function(a, b = a = "FAIL") {
            return a;
        }() && "PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5138_2: {
    options = {
        evaluate: true,
    }
    input: {
        console.log(function(a, b = a = "FAIL 1") {
            return a;
        }(null, "FAIL 2") || "PASS");
    }
    expect: {
        console.log((null, "PASS"));
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5192: {
    options = {
        dead_code: true,
        ie: true,
    }
    input: {
        (function a(a,  [] = a = "PASS") {
            console.log(a);
        })("FAIL");
    }
    expect: {
        (function a(a,  [] = a = "PASS") {
            console.log(a);
        })("FAIL");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5246_1: {
    options = {
        keep_fargs: false,
        pure_getters: true,
        unused: true,
    }
    input: {
        console.log(function({} = 42) {
            return "PASS";
        }("foo"));
    }
    expect: {
        console.log(function() {
            return "PASS";
        }());
    }
    expect_stdout: "PASS"
    expect_warnings: [
        "INFO: Dropping unused default argument {} [test/compress/default-values.js:1,29]",
    ]
    node_version: ">=6"
}

issue_5246_2: {
    options = {
        keep_fargs: false,
        unused: true,
    }
    input: {
        (function f(a = "FAIL", [] = 42) {
            console.log(a);
        })("PASS", []);
    }
    expect: {
        (function(a = "FAIL") {
            console.log(a);
        })("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5246_3: {
    options = {
        default_values: true,
        keep_fargs: false,
        unused: true,
    }
    input: {
        console.log(function f([ , {} ] = null){}([ , {} ]));
    }
    expect: {
        console.log(function([ {} ]){}([ {} ]));
    }
    expect_stdout: "undefined"
    node_version: ">=6"
}

issue_5256: {
    options = {
        inline: true,
    }
    input: {
        (function(arguments = console.log) {
            console;
        })();
        console.log(typeof arguments);
    }
    expect: {
        // Syntax error on Node.js v6
        (function(arguments = console.log) {
            console;
        })();
        console.log(typeof arguments);
    }
    expect_stdout: "undefined"
    node_version: ">=8"
}

issue_5314_1: {
    options = {
        side_effects: true,
    }
    input: {
        A = this;
        new function() {
            (function(a = console.log(this === A ? "PASS" : "FAIL")) {})();
        }();
    }
    expect: {
        A = this;
        (function() {
            (function(a = console.log(this === A ? "PASS" : "FAIL")) {})();
        })();
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5314_2: {
    options = {
        side_effects: true,
    }
    input: {
        A = this;
        new function() {
            ((a = console.log(this === A ? "FAIL" : "PASS")) => {})();
        }();
    }
    expect: {
        A = this;
        new function() {
            console.log(this === A ? "FAIL" : "PASS");
        }();
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5336: {
    options = {
        default_values: true,
        unused: true,
    }
    input: {
        var a;
        do {
            (function f(b = console.log("PASS")) {
                a = f;
            })(42);
        } while (a());
    }
    expect: {
        var a;
        do {
            (function f(b = console.log("PASS")) {
                a = f;
            })(42);
        } while (a());
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5340_1: {
    options = {
        keep_fargs: true,
        pure_getters: "strict",
        unused: true,
    }
    input: {
        var a;
        (function(b = 42) {})(({ p: a } = true).q);
        console.log(a);
    }
    expect: {
        var a;
        (function(b = 0) {})(({ p: a } = true).q);
        console.log(a);
    }
    expect_stdout: "undefined"
    node_version: ">=6"
}

issue_5340_2: {
    options = {
        keep_fargs: true,
        pure_getters: "strict",
        side_effects: true,
        unused: true,
    }
    input: {
        var a;
        (function(b = 42) {})(({ p: a } = true).q);
        console.log(a);
    }
    expect: {
        var a;
        [ [][0] = 0 ] = [ ({ p: a } = true).q ];
        console.log(a);
    }
    expect_stdout: "undefined"
    node_version: ">=6"
}

issue_5340_3: {
    options = {
        keep_fargs: false,
        pure_getters: "strict",
        unused: true,
    }
    input: {
        var a;
        (function(b = 42) {})(({ p: a } = true).q);
        console.log(a);
    }
    expect: {
        var a;
        (function() {})(a = true.p);
        console.log(a);
    }
    expect_stdout: "undefined"
    node_version: ">=6"
}

issue_5407: {
    options = {
        evaluate: true,
        reduce_vars: true,
    }
    input: {
        (function(a) {
            for (var i = 0; i < 2; i++)
                (function(b = 4) {
                    console.log(b);
                    a = 2;
                })(a);
        })();
    }
    expect: {
        (function(a) {
            for (var i = 0; i < 2; i++)
                (function(b = 4) {
                    console.log(b);
                    a = 2;
                })(a);
        })();
    }
    expect_stdout: [
        "4",
        "2",
    ]
    node_version: ">=6"
}

issue_5444_1: {
    options = {
        merge_vars: true,
        toplevel: true,
    }
    input: {
        var a = 42;
        var b = function({} = setImmediate(function() {
            console.log(a++);
        })) {
            return this;
        }();
        console.log(typeof b);
    }
    expect: {
        var a = 42;
        var b = function({} = setImmediate(function() {
            console.log(a++);
        })) {
            return this;
        }();
        console.log(typeof b);
    }
    expect_stdout: [
        "object",
        "42",
    ]
    node_version: ">=6"
}

issue_5444_2: {
    options = {
        merge_vars: true,
    }
    input: {
        function f(a, b = a++) {
            return b;
        }
        console.log(f("FAIL") || "PASS");
    }
    expect: {
        function f(a, b = a++) {
            return b;
        }
        console.log(f("FAIL") || "PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5444_3: {
    options = {
        merge_vars: true,
    }
    input: {
        function f(a, b = function(c = a *= this) {
            return c;
        }()) {
            return b;
        }
        console.log(f("FAIL") || "PASS");
    }
    expect: {
        function f(a, b = function(c = a *= this) {
            return c;
        }()) {
            return b;
        }
        console.log(f("FAIL") || "PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5448_1: {
    options = {
        reduce_vars: true,
        unused: true,
    }
    input: {
        (function(a = typeof console.log) {
            do {
                var b = [ ...a ];
            } while (console.log("PASS"));
        })();
    }
    expect: {
        (function(a = console.log) {
            do {} while (console.log("PASS"));
        })();
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5448_2: {
    options = {
        keep_fargs: true,
        reduce_vars: true,
        unused: true,
    }
    input: {
        (function(a = typeof console) {
            do {
                var b = [ ...a ];
            } while (console.log("PASS"));
        })();
    }
    expect: {
        (function(a = 0) {
            do {} while (console.log("PASS"));
        })();
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5448_3: {
    options = {
        evaluate: true,
        reduce_vars: true,
        toplevel: true,
        unsafe: true,
        unused: true,
    }
    input: {
        var [ a = typeof console ] = [ void console.log("PASS") ];
        var b = [ ...a ];
    }
    expect: {
        console.log("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5448_4: {
    options = {
        evaluate: true,
        pure_getters: "strict",
        reduce_vars: true,
        toplevel: true,
        unsafe: true,
        unused: true,
    }
    input: {
        var { p: a = typeof console } = { p: void console.log("PASS") };
        var b = [ ...a ];
    }
    expect: {
        console.log("PASS");
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5463: {
    options = {
        collapse_vars: true,
        conditionals: true,
        evaluate: true,
        reduce_vars: true,
        toplevel: true,
        unsafe: true,
    }
    input: {
        if (console.log("PASS"))
            var a = void 0,
                b = void 0,
                b = ([ a = FAIL ] = b && b);
    }
    expect: {
        var a, b, b;
        console.log("PASS") && (
            b = a = void 0,
            b = [a = FAIL] = a
        );
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5465: {
    options = {
        inline: true,
        merge_vars: true,
        reduce_vars: true,
        toplevel: true,
        unused: true,
    }
    input: {
        function f(a, b) {
            (function(c = b = "FAIL 2") {
                this && console.log(b || "PASS");
            })(42 - a && a);
        }
        f("FAIL 1");
    }
    expect: {
        a = "FAIL 1",
        void function(c = b = "FAIL 2") {
            this && console.log(b || "PASS");
        }(42 - a && a);
        var a, b;
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5485: {
    options = {
        comparisons: true,
    }
    input: {
        (function f(f, a = console.log(void 0 === f ? "PASS" : "FAIL")) {})();
    }
    expect: {
        (function f(f, a = console.log(void 0 === f ? "PASS" : "FAIL")) {})();
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5533_1_keep_fargs: {
    options = {
        evaluate: true,
        inline: true,
        join_vars: true,
        keep_fargs: true,
        loops: true,
        side_effects: true,
        unused: true,
    }
    input: {
        "use strict";
        try {
            (function() {
                var a;
                for (; 1;)
                    a = function() {
                        (function f(b = 42) {
                            b;
                            throw "PASS";
                        })();
                    }();
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect: {
        "use strict";
        try {
            (function() {
                for (;;)
                    throw "PASS";
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5533_1_drop_fargs: {
    options = {
        evaluate: true,
        inline: true,
        join_vars: true,
        keep_fargs: false,
        loops: true,
        side_effects: true,
        unused: true,
    }
    input: {
        "use strict";
        try {
            (function() {
                var a;
                for (; 1;)
                    a = function() {
                        (function f(b = 42) {
                            b;
                            throw "PASS";
                        })();
                    }();
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect: {
        "use strict";
        try {
            (function() {
                for (;;)
                    throw "PASS";
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5533_2_keep_fargs: {
    options = {
        evaluate: true,
        inline: true,
        join_vars: true,
        keep_fargs: true,
        loops: true,
        side_effects: true,
        unused: true,
    }
    input: {
        "use strict";
        try {
            (function() {
                var a;
                for (; 1;)
                    a = function() {
                        (function f([ b ] = []) {
                            b;
                            throw "PASS";
                        })();
                    }();
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect: {
        "use strict";
        try {
            (function() {
                for (;;) {
                    var [ [] = [] ] = [];
                    throw "PASS";
                }
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5533_2_drop_fargs: {
    options = {
        evaluate: true,
        inline: true,
        join_vars: true,
        keep_fargs: false,
        loops: true,
        side_effects: true,
        unused: true,
    }
    input: {
        "use strict";
        try {
            (function() {
                var a;
                for (; 1;)
                    a = function() {
                        (function f([ b ] = []) {
                            b;
                            throw "PASS";
                        })();
                    }();
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect: {
        "use strict";
        try {
            (function() {
                for (;;) {
                    var [ [ , ] = [] ] = [];
                    throw "PASS";
                }
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5533_3_keep_fargs: {
    options = {
        evaluate: true,
        inline: true,
        join_vars: true,
        keep_fargs: true,
        loops: true,
        side_effects: true,
        unused: true,
    }
    input: {
        "use strict";
        try {
            (function() {
                var a;
                for (; 1;)
                    a = function() {
                        (function f(b = 42, c = null) {
                            c;
                            throw "PASS";
                        })();
                    }();
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect: {
        "use strict";
        try {
            (function() {
                for (;;)
                    throw "PASS";
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5533_3_drop_fargs: {
    options = {
        evaluate: true,
        inline: true,
        join_vars: true,
        keep_fargs: false,
        loops: true,
        side_effects: true,
        unused: true,
    }
    input: {
        "use strict";
        try {
            (function() {
                var a;
                for (; 1;)
                    a = function() {
                        (function f(b = 42, c = null) {
                            c;
                            throw "PASS";
                        })();
                    }();
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect: {
        "use strict";
        try {
            (function() {
                for (;;)
                    throw "PASS";
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5533_4_keep_fargs: {
    options = {
        evaluate: true,
        inline: true,
        join_vars: true,
        keep_fargs: true,
        loops: true,
        side_effects: true,
        unused: true,
    }
    input: {
        "use strict";
        try {
            (function() {
                var a;
                for (; 1;)
                    a = function() {
                        (function f(b = 42, [ c ] = []) {
                            c;
                            throw "PASS";
                        })();
                    }();
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect: {
        "use strict";
        try {
            (function() {
                for (;;) {
                    var [ [] = [] ] = [];
                    throw "PASS";
                }
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5533_4_drop_fargs: {
    options = {
        evaluate: true,
        inline: true,
        join_vars: true,
        keep_fargs: false,
        loops: true,
        side_effects: true,
        unused: true,
    }
    input: {
        "use strict";
        try {
            (function() {
                var a;
                for (; 1;)
                    a = function() {
                        (function f(b = 42, [ c ] = []) {
                            c;
                            throw "PASS";
                        })();
                    }();
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect: {
        "use strict";
        try {
            (function() {
                for (;;) {
                    var [ [] = [] ] = [];
                    throw "PASS";
                }
            })();
        } catch (e) {
            console.log(e);
        }
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5536: {
    options = {
        inline: true,
        keep_fargs: true,
        unused: true,
    }
    input: {
        (function*() {
            (([], a = 42) => {})([]);
            console.log(typeof a);
        })().next();
    }
    expect: {
        (function*() {
            [ , [][0] = 0 ] = [ [] ],
            void 0;
            console.log(typeof a);
        })().next();
    }
    expect_stdout: "undefined"
    node_version: ">=6"
}

issue_5566_1: {
    options = {
        unused: true,
    }
    input: {
        (function(a, f = function() {
            return a;
        }) {
            var a = "foo";
            console.log(a, f());
        })("bar");
    }
    expect: {
        (function(a, f = function() {
            return a;
        }) {
            var a = "foo";
            console.log(a, f());
        })("bar");
    }
    expect_stdout: "foo bar"
    node_version: ">=6"
}

issue_5566_2: {
    options = {
        inline: true,
        reduce_vars: true,
    }
    input: {
        (function(a, f = function() {
            return a;
        }) {
            function a() {}
            console.log(typeof a, typeof f());
        })(42);
    }
    expect: {
        (function(a, f = function() {
            return a;
        }) {
            function a() {}
            console.log(typeof a, typeof f());
        })(42);
    }
    expect_stdout: "function number"
    node_version: ">=6"
}

issue_5566_3: {
    options = {
        reduce_vars: true,
        unused: true,
    }
    input: {
        (function(a, f = function() {
            return a;
        }) {
            function a() {}
            console.log(typeof a, typeof f());
        })(42);
    }
    expect: {
        (function(a, f = function() {
            return a;
        }) {
            function a() {}
            console.log(typeof a, typeof f());
        })(42);
    }
    expect_stdout: "function number"
    node_version: ">=6"
}

issue_5566_4: {
    options = {
        collapse_vars: true,
        unused: true,
    }
    input: {
        (function(a, b = function() {
            return a;
        }) {
            var a = 0;
            b()("PASS");
        })(console.log);
    }
    expect: {
        (function(a, b = function() {
            return a;
        }) {
            var a = 0;
            b()("PASS");
        })(console.log);
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5566_5: {
    options = {
        hoist_vars: true,
    }
    input: {
        (function(a, f = function() {
            return a;
        }) {
            var a = "foo";
            var b;
            console.log(a, f());
        })("bar");
    }
    expect: {
        (function(a, f = function() {
            return a;
        }) {
            var a, b;
            a = "foo";
            console.log(a, f());
        })("bar");
    }
    expect_stdout: "foo bar"
    node_version: ">=6"
}

issue_5651: {
    options = {
        ie: true,
        unused: true,
    }
    input: {
        console.log(function arguments(a = "FAIL") {
            try {} catch (arguments) {
                var arguments;
            }
            return arguments[0];
        }());
    }
    expect: {
        console.log(function arguments(a = "FAIL") {
            try {} catch (arguments) {
                var arguments;
            }
            return arguments[0];
        }());
    }
    expect_stdout: true
    node_version: ">=6"
}

issue_5774: {
    options = {
        collapse_vars: true,
        conditionals: true,
        evaluate: true,
        join_vars: true,
        reduce_vars: true,
        sequences: true,
        unsafe: true,
    }
    input: {
        (function() {
            while (console.log("PASS")) {
                if (console) {
                    a = void 0;
                    var b = void 0;
                    var c = void 0;
                    ([ a = 0 ] = [ b, b ]);
                    var a;
                }
            }
        })();
    }
    expect: {
        (function() {
            while (console.log("PASS")) {
                var a, b, c, a;
                console && (
                    c = b = a = void 0,
                    [ a = 0 ] = [ a, a ]
                );
            }
        })();
    }
    expect_stdout: "PASS"
    node_version: ">=6"
}

issue_5863: {
    options = {
        collapse_vars: true,
        hoist_vars: true,
    }
    input: {
        console.log(typeof function f(a = function() {
            f = 42;
            return f;
        }()) {
            var f;
            var f;
            return a;
        }());
    }
    expect: {
        console.log(typeof function f(a = function() {
            f = 42;
            return f;
        }()) {
            var f;
            return a;
        }());
    }
    expect_stdout: "function"
    node_version: ">=6"
}
