v2.8.6

- consolidate `cascade` optimisations
- support ++/-- postfixes
- remove redundant optimisation identified in #1460

fixes #368

README.md

@@ -75,8 +75,6 @@ The available options are:
   --support-ie8                 Use this flag to support Internet Explorer 6/7/8.
                                 Equivalent to setting `screw_ie8: false` in `minify()`
                                 for `compress`, `mangle` and `output` options.
-                                Note: `--support-ie8` may generate incorrect code
-                                for `try`/`catch` in ES5 compliant browsers.
   --expr                        Parse a single expression, rather than a
                                 program (for parsing JSON)
   -p, --prefix                  Skip prefix for original filenames that appear
@@ -350,6 +348,9 @@ to set `true`; it's effectively a shortcut for `foo=true`).
   comparison are switching. Compression only works if both `comparisons` and
   `unsafe_comps` are both set to true.
 
+- `unsafe_math` (default: false) -- optimize numerical expressions like
+  `2 * x * 3` into `6 * x`, which may give imprecise floating point results.
+
 - `unsafe_proto` (default: false) -- optimize expressions like
   `Array.prototype.slice.call(a)` into `[].slice.call(a)`
 
@@ -423,6 +424,9 @@ to set `true`; it's effectively a shortcut for `foo=true`).
   such as `console.info` and/or retain side effects from function arguments
   after dropping the function call then use `pure_funcs` instead.
 
+- `expression` -- default `false`.  Pass `true` to preserve completion values
+  from terminal statements without `return`, e.g. in bookmarklets.
+
 - `keep_fargs` -- default `true`.  Prevents the
   compressor from discarding unused function arguments.  You need this
   for code which relies on `Function.length`.
@@ -621,7 +625,7 @@ function uglify(ast, options, mangle) {
 
   // Compression
   uAST.figure_out_scope();
-  uAST = uAST.transform(UglifyJS.Compressor(options));
+  uAST = UglifyJS.Compressor(options).compress(uAST);
 
   // Mangling (optional)
   if (mangle) {
@@ -865,7 +869,7 @@ toplevel.figure_out_scope()
 Like this:
 ```javascript
 var compressor = UglifyJS.Compressor(options);
-var compressed_ast = toplevel.transform(compressor);
+var compressed_ast = compressor.compress(toplevel);
 ```
 
 The `options` can be missing.  Available options are discussed above in

bin/uglifyjs

@@ -8,7 +8,6 @@ var sys = require("util");
 var yargs = require("yargs");
 var fs = require("fs");
 var path = require("path");
-var async = require("async");
 var acorn;
 var screw_ie8 = true;
 var ARGS = yargs
@@ -27,7 +26,7 @@ mangling you need to use `-c` and `-m`.\
     .describe("source-map-include-sources", "Pass this flag if you want to include the content of source files in the source map as sourcesContent property.")
     .describe("in-source-map", "Input source map, useful if you're compressing JS that was generated from some other original code.")
     .describe("screw-ie8", "Do not support Internet Explorer 6/7/8. This flag is enabled by default.")
-    .describe("support-ie8", "Support non-standard Internet Explorer 6/7/8 javascript. Note: may generate incorrect code for try/catch in ES5 compliant browsers.")
+    .describe("support-ie8", "Support non-standard Internet Explorer 6/7/8 javascript.")
     .describe("expr", "Parse a single expression, rather than a program (for parsing JSON)")
     .describe("p", "Skip prefix for original filenames that appear in source maps. \
 For example -p 3 will drop 3 directories from file names and ensure they are relative paths. \
@@ -319,8 +318,11 @@ var STATS = {};
 var TOPLEVEL = null;
 var P_RELATIVE = ARGS.p && ARGS.p == "relative";
 var SOURCES_CONTENT = {};
+var index = 0;
 
-async.eachLimit(files, 1, function (file, cb) {
+!function cb() {
+    if (index == files.length) return done();
+    var file = files[index++];
     read_whole_file(file, function (err, code) {
         if (err) {
             print_error("ERROR: can't read file: " + file);
@@ -388,7 +390,9 @@ async.eachLimit(files, 1, function (file, cb) {
         });
         cb();
     });
-}, function () {
+}();
+
+function done() {
     var OUTPUT_FILE = ARGS.o;
 
     var SOURCE_MAP = (ARGS.source_map || ARGS.source_map_inline) ? UglifyJS.SourceMap({
@@ -537,7 +541,7 @@ async.eachLimit(files, 1, function (file, cb) {
             }));
         }
     }
-});
+}
 
 /* -----[ functions ]----- */
 

lib/ast.js

@@ -812,9 +812,6 @@ var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
 
 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
     $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
-    $propdoc: {
-        init: "[AST_Node*/S] array of initializers for this declaration."
-    }
 }, AST_Symbol);
 
 var AST_SymbolVar = DEFNODE("SymbolVar", null, {

lib/output.js

@@ -46,17 +46,8 @@
 var EXPECT_DIRECTIVE = /^$|[;{][\s\n]*$/;
 
 function is_some_comments(comment) {
-    var text = comment.value;
+    // multiline comment
-    var type = comment.type;
+    return comment.type == "comment2" && /@preserve|@license|@cc_on/i.test(comment.value);
-    if (type == "comment2") {
-        // multiline comment
-        return /@preserve|@license|@cc_on/i.test(text);
-    }
-    return type == "comment5";
-}
-
-function is_comment5(comment) {
-    return comment.type == "comment5";
 }
 
 function OutputStream(options) {
@@ -86,7 +77,7 @@ function OutputStream(options) {
     }, true);
 
     // Convert comment option to RegExp if neccessary and set up comments filter
-    var comment_filter = options.shebang ? is_comment5 : return_false; // Default case, throw all comments away except shebangs
+    var comment_filter = return_false; // Default case, throw all comments away
     if (options.comments) {
         var comments = options.comments;
         if (typeof options.comments === "string" && /^\/.*\/[a-zA-Z]*$/.test(options.comments)) {
@@ -98,12 +89,12 @@ function OutputStream(options) {
         }
         if (comments instanceof RegExp) {
             comment_filter = function(comment) {
-                return comment.type == "comment5" || comments.test(comment.value);
+                return comment.type != "comment5" && comments.test(comment.value);
             };
         }
         else if (typeof comments === "function") {
             comment_filter = function(comment) {
-                return comment.type == "comment5" || comments(this, comment);
+                return comment.type != "comment5" && comments(this, comment);
             };
         }
         else if (comments === "some") {
@@ -400,10 +391,6 @@ function OutputStream(options) {
         return OUTPUT;
     };
 
-    if (options.preamble) {
-        print(options.preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
-    }
-
     var stack = [];
     return {
         get             : get,
@@ -523,6 +510,17 @@ function OutputStream(options) {
                 }));
             }
 
+            if (comments.length > 0 && output.pos() == 0) {
+                if (output.option("shebang") && comments[0].type == "comment5") {
+                    output.print("#!" + comments.shift().value + "\n");
+                    output.indent();
+                }
+                var preamble = output.option("preamble");
+                if (preamble) {
+                    output.print(preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
+                }
+            }
+
             comments = comments.filter(output.comment_filter, self);
 
             // Keep single line comments after nlb, after nlb
@@ -547,10 +545,6 @@ function OutputStream(options) {
                         output.space();
                     }
                 }
-                else if (output.pos() === 0 && c.type == "comment5" && output.option("shebang")) {
-                    output.print("#!" + c.value + "\n");
-                    output.indent();
-                }
             });
         }
     });

lib/parse.js

@@ -558,6 +558,11 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     function next_token(force_regexp) {
         if (force_regexp != null)
             return read_regexp(force_regexp);
+        if (shebang && S.pos == 0 && looking_at("#!")) {
+            start_token();
+            forward(2);
+            skip_line_comment("comment5");
+        }
         for (;;) {
             skip_whitespace();
             start_token();
@@ -589,13 +594,6 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             if (PUNC_CHARS(ch)) return token("punc", next());
             if (OPERATOR_CHARS(ch)) return read_operator();
             if (code == 92 || is_identifier_start(code)) return read_word();
-            if (shebang) {
-                if (S.pos == 0 && looking_at("#!")) {
-                    forward(2);
-                    skip_line_comment("comment5");
-                    continue;
-                }
-            }
             break;
         }
         parse_error("Unexpected character '" + ch + "'");

lib/scope.js

@@ -97,7 +97,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     var labels = new Dictionary();
     var defun = null;
     var tw = new TreeWalker(function(node, descend){
-        if (options.screw_ie8 && node instanceof AST_Catch) {
+        if (node instanceof AST_Catch) {
             var save_scope = scope;
             scope = new AST_Scope(node);
             scope.init_scope_vars();
@@ -154,12 +154,10 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
         }
         else if (node instanceof AST_SymbolVar
                  || node instanceof AST_SymbolConst) {
-            var def = defun.def_variable(node);
+            defun.def_variable(node);
-            def.init = tw.parent().value;
         }
         else if (node instanceof AST_SymbolCatch) {
-            (options.screw_ie8 ? scope : defun)
+            scope.def_variable(node);
-                .def_variable(node);
         }
         else if (node instanceof AST_LabelRef) {
             var sym = labels.get(node.name);
@@ -209,6 +207,23 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     });
     self.walk(tw);
 
+    // pass 3: fix up any scoping issue with IE8
+    if (!options.screw_ie8) {
+        self.walk(new TreeWalker(function(node, descend) {
+            if (node instanceof AST_SymbolCatch) {
+                var name = node.name;
+                var scope = node.thedef.scope.parent_scope;
+                var def = scope.find_variable(name) || self.globals.get(name) || scope.def_variable(node);
+                node.thedef.references.forEach(function(ref) {
+                    ref.thedef = def;
+                    ref.reference(options);
+                });
+                node.thedef = def;
+                return true;
+            }
+        }));
+    }
+
     if (options.cache) {
         this.cname = options.cache.cname;
     }

lib/utils.js

@@ -185,7 +185,7 @@ function push_uniq(array, el) {
 
 function string_template(text, props) {
     return text.replace(/\{(.+?)\}/g, function(str, p){
-        return props[p];
+        return props && props[p];
     });
 };
 

package.json

@@ -4,7 +4,7 @@
   "homepage": "http://lisperator.net/uglifyjs",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "2.8.0",
+  "version": "2.8.6",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -29,7 +29,6 @@
     "LICENSE"
   ],
   "dependencies": {
-    "async": "~0.2.6",
     "source-map": "~0.5.1",
     "uglify-to-browserify": "~1.0.0",
     "yargs": "~3.10.0"

test/compress/collapse_vars.js

@@ -1141,7 +1141,7 @@ collapse_vars_constants: {
         function f3(x) {
             var b = x.prop;
             sideeffect1();
-            return b + (function() { return -9; })();
+            return b + -9;
         }
     }
 }
@@ -1315,3 +1315,17 @@ collapse_vars_regexp: {
         })();
     }
 }
+
+issue_1537: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var k = '';
+        for (k in {prop: 'val'}){}
+    }
+    expect: {
+        var k = '';
+        for (k in {prop: 'val'});
+    }
+}

test/compress/concat-strings.js

@@ -164,3 +164,53 @@ concat_6: {
         );
     }
 }
+
+concat_7: {
+    input: {
+        console.log(
+            "" + 1,
+            "" + "1",
+            "" + 1 + 2,
+            "" + 1 + "2",
+            "" + "1" + 2,
+            "" + "1" + "2",
+            "" + (x += "foo")
+        );
+    }
+    expect: {
+        console.log(
+            "" + 1,
+            "1",
+            "" + 1 + 2,
+            1 + "2",
+            "1" + 2,
+            "1" + "2",
+            x += "foo"
+        );
+    }
+}
+
+concat_8: {
+    input: {
+        console.log(
+            1 + "",
+            "1" + "",
+            1 + 2 + "",
+            1 + "2" + "",
+            "1" + 2 + "",
+            "1" + "2" + "",
+            (x += "foo") + ""
+        );
+    }
+    expect: {
+        console.log(
+            1 + "",
+            "1",
+            1 + 2 + "",
+            1 + "2",
+            "1" + 2,
+            "1" + "2",
+            x += "foo"
+        );
+    }
+}

test/compress/conditionals.js

@@ -50,7 +50,8 @@ ifs_3_should_warn: {
         conditionals : true,
         dead_code    : true,
         evaluate     : true,
-        booleans     : true
+        booleans     : true,
+        side_effects : true,
     };
     input: {
         var x, y;
@@ -135,16 +136,28 @@ ifs_6: {
         comparisons: true
     };
     input: {
-        var x;
+        var x, y;
         if (!foo && !bar && !baz && !boo) {
             x = 10;
         } else {
             x = 20;
         }
+        if (y) {
+            x[foo] = 10;
+        } else {
+            x[foo] = 20;
+        }
+        if (foo) {
+            x[bar] = 10;
+        } else {
+            x[bar] = 20;
+        }
     }
     expect: {
-        var x;
+        var x, y;
         x = foo || bar || baz || boo ? 20 : 10;
+        x[foo] = y ? 10 : 20;
+        foo ? x[bar] = 10 : x[bar] = 20;
     }
 }
 
@@ -159,10 +172,16 @@ cond_1: {
         } else {
             do_something(y);
         }
+        if (some_condition()) {
+            side_effects(x);
+        } else {
+            side_effects(y);
+        }
     }
     expect: {
         var do_something;
         do_something(some_condition() ? x : y);
+        some_condition() ? side_effects(x) : side_effects(y);
     }
 }
 
@@ -213,10 +232,16 @@ cond_4: {
         } else {
             do_something();
         }
+        if (some_condition()) {
+            side_effects();
+        } else {
+            side_effects();
+        }
     }
     expect: {
         var do_something;
         some_condition(), do_something();
+        some_condition(), side_effects();
     }
 }
 
@@ -250,7 +275,8 @@ cond_5: {
 cond_7: {
     options = {
         conditionals: true,
-        evaluate    : true
+        evaluate    : true,
+        side_effects: true,
     };
     input: {
         var x, y, z, a, b;
@@ -714,6 +740,7 @@ issue_1154: {
         conditionals: true,
         evaluate    : true,
         booleans    : true,
+        side_effects: true,
     };
     input: {
         function f1(x) { return x ? -1 : -1; }
@@ -742,7 +769,7 @@ issue_1154: {
         function g2() { return g(), 2; }
         function g3() { return g(), -4; }
         function g4() { return g(), !1; }
-        function g5() { return g(), void 0; }
+        function g5() { return void g(); }
         function g6() { return g(), "number"; }
     }
 }
@@ -750,7 +777,8 @@ issue_1154: {
 no_evaluate: {
     options = {
         conditionals: true,
-        evaluate    : false
+        evaluate    : false,
+        side_effects: true,
     }
     input: {
         function f(b) {

test/compress/dead-code.js

@@ -64,7 +64,8 @@ dead_code_constant_boolean_should_warn_more: {
         loops        : true,
         booleans     : true,
         conditionals : true,
-        evaluate     : true
+        evaluate     : true,
+        side_effects : true,
     };
     input: {
         while (!((foo && bar) || (x + "0"))) {

test/compress/drop-unused.js

@@ -632,7 +632,7 @@ iife: {
     }
     expect: {
         function f() {
-            ~function() {}(b);
+            b;
         }
     }
 }
@@ -679,3 +679,24 @@ const_assign: {
         }
     }
 }
+
+issue_1539: {
+    options = {
+        cascade: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var a, b;
+            a = b = 42;
+            return a;
+        }
+    }
+    expect: {
+        function f() {
+            return 42;
+        }
+    }
+}

test/compress/evaluate.js

@@ -337,6 +337,32 @@ unsafe_object_repeated: {
     }
 }
 
+unsafe_object_accessor: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        function f() {
+            var a = {
+                get b() {},
+                set b() {}
+            };
+            return {a:a};
+        }
+    }
+    expect: {
+        function f() {
+            var a = {
+                get b() {},
+                set b() {}
+            };
+            return {a:a};
+        }
+    }
+}
+
 unsafe_function: {
     options = {
         evaluate  : true,
@@ -614,9 +640,28 @@ call_args: {
     expect: {
         const a = 1;
         console.log(1);
+        +(1, 1);
+    }
+}
+
+call_args_drop_param: {
+    options = {
+        evaluate: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        const a = 1;
+        console.log(a);
         +function(a) {
-            return 1;
+            return a;
-        }(1);
+        }(a, b);
+    }
+    expect: {
+        const a = 1;
+        console.log(1);
+        +(b, 1);
     }
 }
 
@@ -624,25 +669,35 @@ in_boolean_context: {
     options = {
         booleans: true,
         evaluate: true,
+        sequences: true,
+        side_effects: true,
     }
     input: {
-        !42;
+        console.log(
-        !"foo";
+            !42,
-        ![1, 2];
+            !"foo",
-        !/foo/;
+            ![1, 2],
-        !b(42);
+            !/foo/,
-        !b("foo");
+            !b(42),
-        !b([1, 2]);
+            !b("foo"),
-        !b(/foo/);
+            !b([1, 2]),
+            !b(/foo/),
+            ![1, foo()],
+            ![1, foo(), 2]
+        );
     }
     expect: {
-        !1;
+        console.log(
-        !1;
+            !1,
-        !1;
+            !1,
-        !1;
+            !1,
-        !b(42);
+            !1,
-        !b("foo");
+            !b(42),
-        !b([1, 2]);
+            !b("foo"),
-        !b(/foo/);
+            !b([1, 2]),
+            !b(/foo/),
+            ![1, foo()],
+            (foo(), !1)
+        );
     }
 }

test/compress/functions.js

@@ -6,3 +6,88 @@ non_ascii_function_identifier_name: {
     }
     expect_exact: "function fooλ(δλ){}function λ(δλ){}(function λ(δλ){})();"
 }
+
+iifes_returning_constants_keep_fargs_true: {
+    options = {
+        keep_fargs    : true,
+        side_effects  : true,
+        evaluate      : true,
+        unused        : true,
+        dead_code     : true,
+        conditionals  : true,
+        comparisons   : true,
+        booleans      : true,
+        if_return     : true,
+        join_vars     : true,
+        reduce_vars   : true,
+        cascade       : true,
+    }
+    input: {
+        (function(){ return -1.23; }());
+        console.log( function foo(){ return "okay"; }() );
+        console.log( function foo(x, y, z){ return 123; }() );
+        console.log( function(x, y, z){ return z; }() );
+        console.log( function(x, y, z){ if (x) return y; return z; }(1, 2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3, a(), b()) );
+    }
+    expect: {
+        console.log("okay");
+        console.log(123);
+        console.log(void 0);
+        console.log(2);
+        console.log(6);
+        console.log((a(), b(), 6));
+    }
+}
+
+iifes_returning_constants_keep_fargs_false: {
+    options = {
+        keep_fargs    : false,
+        side_effects  : true,
+        evaluate      : true,
+        unused        : true,
+        dead_code     : true,
+        conditionals  : true,
+        comparisons   : true,
+        booleans      : true,
+        if_return     : true,
+        join_vars     : true,
+        reduce_vars   : true,
+        cascade       : true,
+    }
+    input: {
+        (function(){ return -1.23; }());
+        console.log( function foo(){ return "okay"; }() );
+        console.log( function foo(x, y, z){ return 123; }() );
+        console.log( function(x, y, z){ return z; }() );
+        console.log( function(x, y, z){ if (x) return y; return z; }(1, 2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3, a(), b()) );
+    }
+    expect: {
+        console.log("okay");
+        console.log(123);
+        console.log(void 0);
+        console.log(2);
+        console.log(6);
+        console.log((a(), b(), 6));
+    }
+}
+
+issue_485_crashing_1530: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+    }
+    input: {
+        (function(a) {
+            if (true) return;
+            var b = 42;
+        })(this);
+    }
+    expect: {
+        this, void 0;
+    }
+}

test/compress/issue-1261.js

@@ -116,3 +116,61 @@ pure_function_calls_toplevel: {
         "WARN: Dropping unused variable iife1 [test/compress/issue-1261.js:84,12]",
     ]
 }
+
+should_warn: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        /* @__PURE__ */(function(){x})(), void/* @__PURE__ */(function(){y})();
+        /* @__PURE__ */(function(){x})() || true ? foo() : bar();
+        true || /* @__PURE__ */(function(){y})() ? foo() : bar();
+        /* @__PURE__ */(function(){x})() && false ? foo() : bar();
+        false && /* @__PURE__ */(function(){y})() ? foo() : bar();
+        /* @__PURE__ */(function(){x})() + "foo" ? bar() : baz();
+        "foo" + /* @__PURE__ */(function(){y})() ? bar() : baz();
+        /* @__PURE__ */(function(){x})() ? foo() : foo();
+        [/* @__PURE__ */(function(){x})()] ? foo() : bar();
+        !{ foo: /* @__PURE__ */(function(){x})() } ? bar() : baz();
+    }
+    expect: {
+        foo();
+        foo();
+        bar();
+        bar();
+        bar();
+        bar();
+        foo();
+        foo();
+        baz();
+    }
+    expect_warnings: [
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:128,61]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:128,23]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:128,23]",
+        "WARN: Boolean || always true [test/compress/issue-1261.js:129,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:129,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:129,23]",
+        "WARN: Boolean || always true [test/compress/issue-1261.js:130,8]",
+        "WARN: Condition always true [test/compress/issue-1261.js:130,8]",
+        "WARN: Boolean && always false [test/compress/issue-1261.js:131,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:131,23]",
+        "WARN: Condition always false [test/compress/issue-1261.js:131,23]",
+        "WARN: Boolean && always false [test/compress/issue-1261.js:132,8]",
+        "WARN: Condition always false [test/compress/issue-1261.js:132,8]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:133,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:133,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:133,23]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:134,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:134,31]",
+        "WARN: Condition always true [test/compress/issue-1261.js:134,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:135,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:136,24]",
+        "WARN: Condition always true [test/compress/issue-1261.js:136,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:137,31]",
+        "WARN: Condition always false [test/compress/issue-1261.js:137,8]",
+    ]
+}

test/compress/issue-1275.js

@@ -35,7 +35,7 @@ string_plus_optimization: {
                 throw "nope";
             }
             try {
-                console.log('0' + throwing_function() ? "yes" : "no");
+                console.log((throwing_function(), "yes"));
             } catch (ex) {
                 console.log(ex);
             }

test/compress/issue-1443.js

@@ -2,6 +2,7 @@
 
 unsafe_undefined: {
     options = {
+        conditionals: true,
         if_return: true,
         unsafe: true
     }
@@ -19,12 +20,7 @@ unsafe_undefined: {
     expect: {
         function f(n) {
             return function() {
-                if (a)
+                return a ? b : c ? d : n;
-                    return b;
-                if (c)
-                    return d;
-                else
-                    return n;
             };
         }
     }
@@ -32,6 +28,7 @@ unsafe_undefined: {
 
 keep_fnames: {
     options = {
+        conditionals: true,
         if_return: true,
         unsafe: true
     }
@@ -57,12 +54,7 @@ keep_fnames: {
                 function n(n) {
                     return n * n;
                 }
-                if (a)
+                return a ? b : c ? d : r;
-                    return b;
-                if (c)
-                    return d;
-                else
-                    return r;
             };
         }
     }

test/compress/issue-368.js

@@ -0,0 +1,41 @@
+collapse: {
+    options = {
+        cascade: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f1() {
+            var a;
+            a = typeof b === 'function' ? b() : b;
+            return a !== undefined && c();
+        }
+        function f2(b) {
+            var a;
+            b = c();
+            a = typeof b === 'function' ? b() : b;
+            return 'stirng' == typeof a && d();
+        }
+        function f3(c) {
+            var a;
+            a = b(a / 2);
+            if (a < 0) {
+                c++;
+                return c / 2;
+            }
+        }
+    }
+    expect: {
+        function f1() {
+            return void 0 !== ('function' === typeof b ? b() : b) && c();
+        }
+        function f2(b) {
+            return b = c(), 'stirng' == typeof ('function' === typeof b ? b() : b) && d();
+        }
+        function f3(c) {
+            var a;
+            if ((a = b(a / 2)) < 0) return c++ / 2;
+        }
+    }
+}

test/compress/issue-640.js

@@ -0,0 +1,317 @@
+cond_5: {
+    options = {
+        conditionals: true,
+        expression: true,
+    }
+    input: {
+        if (some_condition()) {
+            if (some_other_condition()) {
+                do_something();
+            } else {
+                alternate();
+            }
+        } else {
+            alternate();
+        }
+
+        if (some_condition()) {
+            if (some_other_condition()) {
+                do_something();
+            }
+        }
+    }
+    expect: {
+        some_condition() && some_other_condition() ? do_something() : alternate();
+        if (some_condition() && some_other_condition()) do_something();
+    }
+}
+
+dead_code_const_annotation_regex: {
+    options = {
+        booleans     : true,
+        conditionals : true,
+        dead_code    : true,
+        evaluate     : true,
+        expression   : true,
+        loops        : true,
+    }
+    input: {
+        var unused;
+        // @constraint this shouldn't be a constant
+        var CONST_FOO_ANN = false;
+        if (CONST_FOO_ANN) {
+            console.log("reachable");
+        }
+    }
+    expect: {
+        var unused;
+        var CONST_FOO_ANN = !1;
+        if (CONST_FOO_ANN) console.log('reachable');
+    }
+}
+
+drop_console_2: {
+    options = {
+        drop_console: true,
+        expression: true,
+    }
+    input: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+    expect: {
+        // with regular compression these will be stripped out as well
+        void 0;
+        void 0;
+    }
+}
+
+drop_value: {
+    options = {
+        expression: true,
+        side_effects: true,
+    }
+    input: {
+        (1, [2, foo()], 3, {a:1, b:bar()});
+    }
+    expect: {
+        foo(), {a:1, b:bar()};
+    }
+}
+
+wrongly_optimized: {
+    options = {
+        conditionals: true,
+        booleans: true,
+        evaluate: true,
+        expression: true,
+    }
+    input: {
+        function func() {
+            foo();
+        }
+        if (func() || true) {
+            bar();
+        }
+    }
+    expect: {
+        function func() {
+            foo();
+        }
+        // TODO: optimize to `func(), bar()`
+        if (func(), !0) bar();
+    }
+}
+
+negate_iife_1: {
+    options = {
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function(){ stuff() })();
+    }
+    expect: {
+        (function(){ stuff() })();
+    }
+}
+
+negate_iife_3: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_3_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: false,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_4: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        (function(){ return t })() ? console.log(true) : console.log(false), function(){
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_5: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        (function(){ return t })() ? foo(true) : bar(false), function(){
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_5_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: false,
+        sequences: true,
+    };
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        (function(){ return t })() ? foo(true) : bar(false), function(){
+            console.log("something");
+        }();
+    }
+}
+
+issue_1254_negate_iife_true: {
+    options = {
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: '(function(){return function(){console.log("test")}})()();'
+}
+
+issue_1254_negate_iife_nested: {
+    options = {
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()()()()();
+    }
+    expect_exact: '(function(){return function(){console.log("test")}})()()()()();'
+}
+
+conditional: {
+    options = {
+        expression: true,
+        pure_funcs: [ "pure" ],
+        side_effects: true,
+    }
+    input: {
+        pure(1 | a() ? 2 & b() : 7 ^ c());
+        pure(1 | a() ? 2 & b() : 5);
+        pure(1 | a() ? 4 : 7 ^ c());
+        pure(1 | a() ? 4 : 5);
+        pure(3 ? 2 & b() : 7 ^ c());
+        pure(3 ? 2 & b() : 5);
+        pure(3 ? 4 : 7 ^ c());
+        pure(3 ? 4 : 5);
+    }
+    expect: {
+        1 | a() ? b() : c();
+        1 | a() && b();
+        1 | a() || c();
+        a();
+        3 ? b() : c();
+        3 && b();
+        3 || c();
+        pure(3 ? 4 : 5);
+    }
+}
+
+limit_1: {
+    options = {
+        expression: true,
+        sequences: 3,
+    }
+    input: {
+        a;
+        b;
+        c;
+        d;
+        e;
+        f;
+        g;
+        h;
+        i;
+        j;
+        k;
+    }
+    expect: {
+        // Turned into a single return statement
+        // so it can no longer be split into lines
+        a,b,c,d,e,f,g,h,i,j,k;
+    }
+}
+
+iife: {
+    options = {
+        expression: true,
+        sequences: true,
+    }
+    input: {
+        x = 42;
+        (function a() {})();
+        !function b() {}();
+        ~function c() {}();
+        +function d() {}();
+        -function e() {}();
+        void function f() {}();
+        typeof function g() {}();
+    }
+    expect: {
+        x = 42, function a() {}(), function b() {}(), function c() {}(),
+        function d() {}(), function e() {}(), function f() {}(), typeof function g() {}();
+    }
+}

test/compress/loops.js

@@ -213,6 +213,30 @@ evaluate: {
             a();
         for(;;)
             c();
-        d();
+        // rule disabled due to issue_1532
+        do d(); while (false);
+    }
+}
+
+issue_1532: {
+    options = {
+        evaluate: true,
+        loops: true,
+    }
+    input: {
+        function f(x, y) {
+            do {
+                if (x) break;
+                foo();
+            } while (false);
+        }
+    }
+    expect: {
+        function f(x, y) {
+            do {
+                if (x) break;
+                foo();
+            } while (false);
+        }
     }
 }

test/compress/negate-iife.js

@@ -32,16 +32,57 @@ negate_iife_2: {
     }
 }
 
+negate_iife_2_side_effects: {
+    options = {
+        negate_iife: true,
+        side_effects: true,
+    }
+    input: {
+        (function(){ return {} })().x = 10; // should not transform this one
+    }
+    expect: {
+        (function(){ return {} })().x = 10;
+    }
+}
+
 negate_iife_3: {
     options = {
         negate_iife: true,
         conditionals: true
     };
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        !function(){ return t }() ? console.log(false) : console.log(true);
+    }
+}
+
+negate_iife_3_evaluate: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        negate_iife: true,
+    }
     input: {
         (function(){ return true })() ? console.log(true) : console.log(false);
     }
     expect: {
-        !function(){ return true }() ? console.log(false) : console.log(true);
+        console.log(true);
+    }
+}
+
+negate_iife_3_side_effects: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        side_effects: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        !function(){ return t }() ? console.log(false) : console.log(true);
     }
 }
 
@@ -50,11 +91,25 @@ negate_iife_3_off: {
         negate_iife: false,
         conditionals: true,
     };
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        !function(){ return t }() ? console.log(false) : console.log(true);
+    }
+}
+
+negate_iife_3_off_evaluate: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        negate_iife: false,
+    }
     input: {
         (function(){ return true })() ? console.log(true) : console.log(false);
     }
     expect: {
-        !function(){ return true }() ? console.log(false) : console.log(true);
+        console.log(true);
     }
 }
 
@@ -65,13 +120,13 @@ negate_iife_4: {
         sequences: true
     };
     input: {
-        (function(){ return true })() ? console.log(true) : console.log(false);
+        (function(){ return t })() ? console.log(true) : console.log(false);
         (function(){
             console.log("something");
         })();
     }
     expect: {
-        !function(){ return true }() ? console.log(false) : console.log(true), function(){
+        !function(){ return t }() ? console.log(false) : console.log(true), function(){
             console.log("something");
         }();
     }
@@ -86,7 +141,7 @@ sequence_off: {
     };
     input: {
         function f() {
-            (function(){ return true })() ? console.log(true) : console.log(false);
+            (function(){ return t })() ? console.log(true) : console.log(false);
             (function(){
                 console.log("something");
             })();
@@ -95,19 +150,19 @@ sequence_off: {
             (function(){
                 console.log("something");
             })();
-            (function(){ return true })() ? console.log(true) : console.log(false);
+            (function(){ return t })() ? console.log(true) : console.log(false);
         }
     }
     expect: {
         function f() {
-            !function(){ return true }() ? console.log(false) : console.log(true), function(){
+            !function(){ return t }() ? console.log(false) : console.log(true), function(){
                 console.log("something");
             }();
         }
         function g() {
             (function(){
                 console.log("something");
-            })(), function(){ return true }() ? console.log(true) : console.log(false);
+            })(), function(){ return t }() ? console.log(true) : console.log(false);
         }
     }
 }
@@ -119,7 +174,7 @@ negate_iife_5: {
         conditionals: true,
     };
     input: {
-        if ((function(){ return true })()) {
+        if ((function(){ return t })()) {
             foo(true);
         } else {
             bar(false);
@@ -129,7 +184,7 @@ negate_iife_5: {
         })();
     }
     expect: {
-        !function(){ return true }() ? bar(false) : foo(true), function(){
+        !function(){ return t }() ? bar(false) : foo(true), function(){
             console.log("something");
         }();
     }
@@ -142,7 +197,7 @@ negate_iife_5_off: {
         conditionals: true,
     };
     input: {
-        if ((function(){ return true })()) {
+        if ((function(){ return t })()) {
             foo(true);
         } else {
             bar(false);
@@ -152,7 +207,7 @@ negate_iife_5_off: {
         })();
     }
     expect: {
-        !function(){ return true }() ? bar(false) : foo(true), function(){
+        !function(){ return t }() ? bar(false) : foo(true), function(){
             console.log("something");
         }();
     }
@@ -320,3 +375,35 @@ issue_1288: {
         }(0);
     }
 }
+
+issue_1288_side_effects: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        side_effects: true,
+    }
+    input: {
+        if (w) ;
+        else {
+            (function f() {})();
+        }
+        if (!x) {
+            (function() {
+                x = {};
+            })();
+        }
+        if (y)
+            (function() {})();
+        else
+            (function(z) {
+                return z;
+            })(0);
+    }
+    expect: {
+        w;
+        x || function() {
+            x = {};
+        }();
+        y;
+    }
+}

test/compress/numbers.js

@@ -17,3 +17,139 @@ hex_numbers_in_parentheses_for_prototype_functions: {
     }
     expect_exact: "-2;(-2).toFixed(0);2;2..toFixed(0);.2;.2.toFixed(0);2e-8;2e-8.toFixed(0);0xde0b6b3a7640080;(0xde0b6b3a7640080).toFixed(0);"
 }
+
+comparisons: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        console.log(
+            ~x === 42,
+            x % n === 42
+        );
+    }
+    expect: {
+        console.log(
+            42 == ~x,
+            x % n == 42
+        );
+    }
+}
+
+evaluate_1: {
+    options = {
+        evaluate: true,
+        unsafe_math: false,
+    }
+    input: {
+        console.log(
+            x + 1 + 2,
+            x * 1 * 2,
+            +x + 1 + 2,
+            1 + x + 2 + 3,
+            1 | x | 2 | 3,
+            1 + x-- + 2 + 3,
+            1 + (x*y + 2) + 3,
+            1 + (2 + x + 3),
+            1 + (2 + ~x + 3),
+            -y + (2 + ~x + 3),
+            1 & (2 & x & 3),
+            1 + (2 + (x |= 0) + 3)
+        );
+    }
+    expect: {
+        console.log(
+            x + 1 + 2,
+            1 * x * 2,
+            +x + 1 + 2,
+            1 + x + 2 + 3,
+            3 | x,
+            1 + x-- + 2 + 3,
+            x*y + 2 + 1 + 3,
+            1 + (2 + x + 3),
+            2 + ~x + 3 + 1,
+            -y + (2 + ~x + 3),
+            0 & x,
+            2 + (x |= 0) + 3 + 1
+        );
+    }
+}
+
+evaluate_2: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(
+            x + 1 + 2,
+            x * 1 * 2,
+            +x + 1 + 2,
+            1 + x + 2 + 3,
+            1 | x | 2 | 3,
+            1 + x-- + 2 + 3,
+            1 + (x*y + 2) + 3,
+            1 + (2 + x + 3),
+            1 & (2 & x & 3),
+            1 + (2 + (x |= 0) + 3)
+        );
+    }
+    expect: {
+        console.log(
+            x + 1 + 2,
+            2 * x,
+            3 + +x,
+            1 + x + 2 + 3,
+            3 | x,
+            6 + x--,
+            6 + x*y,
+            1 + (2 + x + 3),
+            0 & x,
+            6 + (x |= 0)
+        );
+    }
+}
+
+evaluate_3: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(1 + Number(x) + 2);
+    }
+    expect: {
+        console.log(3 + +x);
+    }
+}
+
+evaluate_4: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log(
+            1+ +a,
+            +a+1,
+            1+-a,
+            -a+1,
+            +a+ +b,
+            +a+-b,
+            -a+ +b,
+            -a+-b
+        );
+    }
+    expect: {
+        console.log(
+            +a+1,
+            +a+1,
+            1-a,
+            1-a,
+            +a+ +b,
+            +a-b,
+            -a+ +b,
+            -a-b
+        );
+    }
+}

test/compress/reduce_vars.js

@@ -470,3 +470,196 @@ multi_def_2: {
         var repeatLength = this.getBits(bitsLength) + bitsOffset;
     }
 }
+
+use_before_var: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(t);
+        var t = 1;
+    }
+    expect: {
+        console.log(t);
+        var t = 1;
+    }
+}
+
+inner_var_if: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f(){
+            return 0;
+        }
+        if (f())
+            var t = 1;
+        if (!t)
+            console.log(t);
+    }
+    expect: {
+        function f(){
+            return 0;
+        }
+        if (f())
+            var t = 1;
+        if (!t)
+            console.log(t);
+    }
+}
+
+inner_var_label: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f(){
+            return 1;
+        }
+        l: {
+            if (f()) break l;
+            var t = 1;
+        }
+        console.log(t);
+    }
+    expect: {
+        function f(){
+            return 1;
+        }
+        l: {
+            if (f()) break l;
+            var t = 1;
+        }
+        console.log(t);
+    }
+}
+
+inner_var_for: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        var a = 1;
+        x(a, b, d);
+        for (var b = 2, c = 3; x(a, b, c, d); x(a, b, c, d)) {
+            var d = 4, e = 5;
+            x(a, b, c, d, e);
+        }
+        x(a, b, c, d, e)
+    }
+    expect: {
+        var a = 1;
+        x(1, b, d);
+        for (var b = 2, c = 3; x(1, b, 3, d); x(1, b, 3, d)) {
+            var d = 4, e = 5;
+            x(1, b, 3, d, e);
+        }
+        x(1, b, 3, d, e);
+    }
+}
+
+inner_var_for_in_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        var a = 1, b = 2;
+        for (b in (function() {
+            return x(a, b, c);
+        })()) {
+            var c = 3, d = 4;
+            x(a, b, c, d);
+        }
+        x(a, b, c, d);
+    }
+    expect: {
+        var a = 1, b = 2;
+        for (b in (function() {
+            return x(1, b, c);
+        })()) {
+            var c = 3, d = 4;
+            x(1, b, c, d);
+        }
+        x(1, b, c, d);
+    }
+}
+
+inner_var_for_in_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        for (var long_name in {})
+            console.log(long_name);
+    }
+    expect: {
+        for (var long_name in {})
+            console.log(long_name);
+    }
+}
+
+inner_var_catch: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        try {
+            a();
+        } catch (e) {
+            var b = 1;
+        }
+        console.log(b);
+    }
+    expect: {
+        try {
+            a();
+        } catch (e) {
+            var b = 1;
+        }
+        console.log(b);
+    }
+}
+
+issue_1533_1: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+    }
+    input: {
+        var id = "";
+        for (id in {break: "me"})
+            console.log(id);
+    }
+    expect: {
+        var id = "";
+        for (id in {break: "me"})
+            console.log(id);
+    }
+}
+
+issue_1533_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        var id = "";
+        for (var id in {break: "me"})
+            console.log(id);
+        console.log(id);
+    }
+    expect: {
+        var id = "";
+        for (var id in {break: "me"})
+            console.log(id);
+        console.log(id);
+    }
+}

test/compress/screw-ie8.js

@@ -17,6 +17,26 @@ dont_screw: {
     expect_exact: 'f("\\x0B");';
 }
 
+do_screw_constants: {
+    options = {
+        screw_ie8: true,
+    }
+    input: {
+        f(undefined, Infinity);
+    }
+    expect_exact: "f(void 0,1/0);"
+}
+
+dont_screw_constants: {
+    options = {
+        screw_ie8: false,
+    }
+    input: {
+        f(undefined, Infinity);
+    }
+    expect_exact: "f(undefined,Infinity);"
+}
+
 do_screw_try_catch: {
     options = { screw_ie8: true };
     mangle = { screw_ie8: true };
@@ -46,8 +66,6 @@ do_screw_try_catch: {
 }
 
 dont_screw_try_catch: {
-    // This test is known to generate incorrect code for screw_ie8=false.
-    // Update expected result in the event this bug is ever fixed.
     options = { screw_ie8: false };
     mangle = { screw_ie8: false };
     beautify = { screw_ie8: false };
@@ -64,11 +82,11 @@ dont_screw_try_catch: {
     }
     expect: {
         bad = function(n){
-            return function(n){
+            return function(t){
                 try{
-                    t()
+                    n()
-                } catch(t) {
+                } catch(n) {
-                    n(t)
+                    t(n)
                 }
             }
         };
@@ -104,8 +122,6 @@ do_screw_try_catch_undefined: {
 }
 
 dont_screw_try_catch_undefined: {
-    // This test is known to generate incorrect code for screw_ie8=false.
-    // Update expected result in the event this bug is ever fixed.
     options = { screw_ie8: false };
     mangle = { screw_ie8: false };
     beautify = { screw_ie8: false };
@@ -121,14 +137,48 @@ dont_screw_try_catch_undefined: {
         };
     }
     expect: {
-        function a(o){
+        function a(n){
             try{
                 throw "Stuff"
-            } catch (n) {
+            } catch (undefined) {
-                console.log("caught: "+n)
+                console.log("caught: " + undefined)
             }
-            console.log("undefined is " + n);
+            console.log("undefined is " + undefined);
-            return o === n
+            return n === undefined
+        }
+    }
+}
+
+reduce_vars: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        screw_ie8: false,
+        unused: true,
+    }
+    mangle = {
+        screw_ie8: false,
+    }
+    input: {
+        function f() {
+            var a;
+            try {
+                x();
+            } catch (a) {
+                y();
+            }
+            alert(a);
+        }
+    }
+    expect: {
+        function f() {
+            var t;
+            try {
+                x();
+            } catch (t) {
+                y();
+            }
+            alert(t);
         }
     }
 }

test/compress/sequences.js

@@ -248,6 +248,39 @@ iife: {
     }
     expect: {
         x = 42, function a() {}(), function b() {}(), function c() {}(),
-        function d() {}(), function e() {}(), function f() {}(), function g() {}()
+        function d() {}(), function e() {}(), function f() {}(), function g() {}();
+    }
+}
+
+unsafe_undefined: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        function f(undefined) {
+            if (a)
+                return b;
+            if (c)
+                return d;
+        }
+        function g(undefined) {
+            if (a)
+                return b;
+            if (c)
+                return d;
+            e();
+        }
+    }
+    expect: {
+        function f(undefined) {
+            return a ? b : c ? d : undefined;
+        }
+        function g(undefined) {
+            return a ? b : c ? d : void e();
+        }
     }
 }

test/compress/typeof.js

@@ -29,6 +29,7 @@ typeof_in_boolean_context: {
         booleans     : true,
         evaluate     : true,
         conditionals : true,
+        side_effects : true,
     };
     input: {
         function f1(x) { return typeof x ? "yes" : "no"; }
@@ -36,12 +37,14 @@ typeof_in_boolean_context: {
         typeof 0 ? foo() : bar();
         !typeof console.log(1);
         var a = !typeof console.log(2);
+        if (typeof (1 + foo()));
     }
     expect: {
         function f1(x) { return "yes"; }
         function f2() { return g(), "Yes"; }
         foo();
-        !(console.log(1), !0);
+        console.log(1);
         var a = !(console.log(2), !0);
+        foo();
     }
 }

test/mocha/comment-filter.js

@@ -72,4 +72,12 @@ describe("comment filters", function() {
         assert.strictEqual(UglifyJS.parse("/* ok */ function a(){}").print_to_string(options), "/* ok */function a(){}");
         assert.strictEqual(UglifyJS.parse("/* ok */ function a(){}").print_to_string(options), "/* ok */function a(){}");
     });
+
+    it("Should handle shebang and preamble correctly", function() {
+        var code = UglifyJS.minify("#!/usr/bin/node\nvar x = 10;", {
+            fromString: true,
+            output: { preamble: "/* Build */" }
+        }).code;
+        assert.strictEqual(code, "#!/usr/bin/node\n/* Build */\nvar x=10;");
+    })
 });

test/mocha/minify.js

@@ -154,6 +154,17 @@ describe("minify", function() {
             var code = result.code;
             assert.strictEqual(code, "//  comment1   comment2\nbar();");
         });
+        it("should not drop #__PURE__ hint if function is retained", function() {
+            var result = Uglify.minify("var a = /*#__PURE__*/(function(){ foo(); })();", {
+                fromString: true,
+                output: {
+                    comments: "all",
+                    beautify: false,
+                }
+            });
+            var code = result.code;
+            assert.strictEqual(code, "var a=/*#__PURE__*/function(){foo()}();");
+        })
     });
 
     describe("JS_Parse_Error", function() {
@@ -171,4 +182,13 @@ describe("minify", function() {
         });
     });
 
+    describe("Compressor", function() {
+        it("should be backward compatible with ast.transform(compressor)", function() {
+            var ast = Uglify.parse("function f(a){for(var i=0;i<a;i++)console.log(i)}");
+            ast.figure_out_scope();
+            ast = ast.transform(Uglify.Compressor());
+            assert.strictEqual(ast.print_to_string(), "function f(a){for(var i=0;i<a;i++)console.log(i)}");
+        });
+    })
+
 });