v2.8.28

fixes #2040

.travis.yml

@@ -1,5 +1,4 @@
 language: node_js
-before_install: "npm install -g npm"
 node_js:
     - "0.10"
     - "0.12"

README.md

@@ -353,6 +353,9 @@ to set `true`; it's effectively a shortcut for `foo=true`).
 - `unsafe_proto` (default: false) -- optimize expressions like
   `Array.prototype.slice.call(a)` into `[].slice.call(a)`
 
+- `unsafe_regexp` (default: false) -- enable substitutions of variables with
+  `RegExp` values the same way as if they are constants.
+
 - `conditionals` -- apply optimizations for `if`-s and conditional
   expressions
 
@@ -443,10 +446,10 @@ to set `true`; it's effectively a shortcut for `foo=true`).
 - `keep_infinity` -- default `false`. Pass `true` to prevent `Infinity` from
   being compressed into `1/0`, which may cause performance issues on Chrome.
 
-- `side_effects` -- default `false`. Pass `true` to potentially drop functions
-marked as "pure".  A function call is marked as "pure" if a comment annotation
-`/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For example:
-`/*@__PURE__*/foo()`;
+- `side_effects` -- default `true`. Pass `false` to disable potentially dropping
+  functions marked as "pure".  A function call is marked as "pure" if a comment
+  annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
+  example: `/*@__PURE__*/foo();`
 
 
 ### The `unsafe` option

lib/compress.js

@@ -84,6 +84,7 @@ function Compressor(options, false_by_default) {
         unsafe_comps  : false,
         unsafe_math   : false,
         unsafe_proto  : false,
+        unsafe_regexp : false,
         unused        : !false_by_default,
         warnings      : true,
     }, true);
@@ -3680,7 +3681,7 @@ merge(Compressor.prototype, {
             if (fixed) {
                 if (d.should_replace === undefined) {
                     var init = fixed.evaluate(compressor);
-                    if (init !== fixed) {
+                    if (init !== fixed && (compressor.option("unsafe_regexp") || !(init instanceof RegExp))) {
                         init = make_node_from_constant(init, fixed);
                         var value = init.optimize(compressor).print_to_string().length;
                         var fn;

lib/output.js

@@ -1207,9 +1207,8 @@ function OutputStream(options) {
         });
         else output.print("{}");
     });
-    DEFPRINT(AST_ObjectKeyVal, function(self, output){
-        var key = self.key;
-        var quote = self.quote;
+
+    function print_property_name(key, quote, output) {
         if (output.option("quote_keys")) {
             output.print_string(key + "");
         } else if ((typeof key == "number"
@@ -1226,20 +1225,24 @@ function OutputStream(options) {
         } else {
             output.print_string(key, quote);
         }
+    }
+
+    DEFPRINT(AST_ObjectKeyVal, function(self, output){
+        print_property_name(self.key, self.quote, output);
         output.colon();
         self.value.print(output);
     });
-    DEFPRINT(AST_ObjectSetter, function(self, output){
-        output.print("set");
+    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, output) {
+        output.print(type);
         output.space();
-        self.key.print(output);
-        self.value._do_print(output, true);
+        print_property_name(this.key.name, this.quote, output);
+        this.value._do_print(output, true);
+    });
+    DEFPRINT(AST_ObjectSetter, function(self, output){
+        self._print_getter_setter("set", output);
     });
     DEFPRINT(AST_ObjectGetter, function(self, output){
-        output.print("get");
-        output.space();
-        self.key.print(output);
-        self.value._do_print(output, true);
+        self._print_getter_setter("get", output);
     });
     DEFPRINT(AST_Symbol, function(self, output){
         var def = self.definition();

lib/parse.js

@@ -285,7 +285,11 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         S.regex_allowed = ((type == "operator" && !UNARY_POSTFIX(value)) ||
                            (type == "keyword" && KEYWORDS_BEFORE_EXPRESSION(value)) ||
                            (type == "punc" && PUNC_BEFORE_EXPRESSION(value)));
-        prev_was_dot = (type == "punc" && value == ".");
+        if (type == "punc" && value == ".") {
+            prev_was_dot = true;
+        } else if (!is_comment) {
+            prev_was_dot = false;
+        }
         var ret = {
             type    : type,
             value   : value,
@@ -803,17 +807,16 @@ function parse($TEXT, options) {
     };
 
     var statement = embed_tokens(function() {
-        var tmp;
         handle_regexp();
         switch (S.token.type) {
           case "string":
             if (S.in_directives) {
-                tmp = peek();
+                var token = peek();
                 if (S.token.raw.indexOf("\\") == -1
-                    && (tmp.nlb
-                        || is_token(tmp, "eof")
-                        || is_token(tmp, "punc", ";")
-                        || is_token(tmp, "punc", "}"))) {
+                    && (token.nlb
+                        || is_token(token, "eof")
+                        || is_token(token, "punc", ";")
+                        || is_token(token, "punc", "}"))) {
                     S.input.add_directive(S.token.value);
                 } else {
                     S.in_directives = false;
@@ -852,75 +855,103 @@ function parse($TEXT, options) {
             }
 
           case "keyword":
-            switch (tmp = S.token.value, next(), tmp) {
+            switch (S.token.value) {
               case "break":
+                next();
                 return break_cont(AST_Break);
 
               case "continue":
+                next();
                 return break_cont(AST_Continue);
 
               case "debugger":
+                next();
                 semicolon();
                 return new AST_Debugger();
 
               case "do":
+                next();
+                var body = in_loop(statement);
+                expect_token("keyword", "while");
+                var condition = parenthesised();
+                semicolon(true);
                 return new AST_Do({
-                    body      : in_loop(statement),
-                    condition : (expect_token("keyword", "while"), tmp = parenthesised(), semicolon(true), tmp)
+                    body      : body,
+                    condition : condition
                 });
 
               case "while":
+                next();
                 return new AST_While({
                     condition : parenthesised(),
                     body      : in_loop(statement)
                 });
 
               case "for":
+                next();
                 return for_();
 
               case "function":
+                next();
                 return function_(AST_Defun);
 
               case "if":
+                next();
                 return if_();
 
               case "return":
                 if (S.in_function == 0 && !options.bare_returns)
                     croak("'return' outside of function");
+                next();
+                var value = null;
+                if (is("punc", ";")) {
+                    next();
+                } else if (!can_insert_semicolon()) {
+                    value = expression(true);
+                    semicolon();
+                }
                 return new AST_Return({
-                    value: ( is("punc", ";")
-                             ? (next(), null)
-                             : can_insert_semicolon()
-                             ? null
-                             : (tmp = expression(true), semicolon(), tmp) )
+                    value: value
                 });
 
               case "switch":
+                next();
                 return new AST_Switch({
                     expression : parenthesised(),
                     body       : in_loop(switch_body_)
                 });
 
               case "throw":
+                next();
                 if (S.token.nlb)
                     croak("Illegal newline after 'throw'");
+                var value = expression(true);
+                semicolon();
                 return new AST_Throw({
-                    value: (tmp = expression(true), semicolon(), tmp)
+                    value: value
                 });
 
               case "try":
+                next();
                 return try_();
 
               case "var":
-                return tmp = var_(), semicolon(), tmp;
+                next();
+                var node = var_();
+                semicolon();
+                return node;
 
               case "const":
-                return tmp = const_(), semicolon(), tmp;
+                next();
+                var node = const_();
+                semicolon();
+                return node;
 
               case "with":
                 if (S.input.has_directive("use strict")) {
                     croak("Strict mode may not include a with statement");
                 }
+                next();
                 return new AST_With({
                     expression : parenthesised(),
                     body       : statement()

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.25",
+  "version": "2.8.28",
   "engines": {
     "node": ">=0.8.0"
   },

test/compress/evaluate.js

@@ -989,3 +989,50 @@ Infinity_NaN_undefined_LHS: {
         "}",
     ]
 }
+
+issue_1964_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe_regexp: false,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect_stdout: "b"
+}
+
+issue_1964_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe_regexp: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            return "a b c".split(/\s/)[1];
+        }
+        console.log(f());
+    }
+    expect_stdout: "b"
+}

test/compress/issue-1943.js

@@ -0,0 +1,31 @@
+operator: {
+    input: {
+        a. //comment
+        typeof
+    }
+    expect_exact: "a.typeof;"
+}
+
+name: {
+    input: {
+        a. //comment
+        b
+    }
+    expect_exact: "a.b;"
+}
+
+keyword: {
+    input: {
+        a. //comment
+        default
+    }
+    expect_exact: "a.default;"
+}
+
+atom: {
+    input: {
+        a. //comment
+        true
+    }
+    expect_exact: "a.true;"
+}

test/compress/properties.js

@@ -555,3 +555,105 @@ native_prototype: {
         "".indexOf.call(e, "bar");
     }
 }
+
+accessor_boolean: {
+    input: {
+        var a = 1;
+        var b = {
+            get true() {
+                return a;
+            },
+            set false(c) {
+                a = c;
+            }
+        };
+        console.log(b.true, b.false = 2, b.true);
+    }
+    expect_exact: 'var a=1;var b={get true(){return a},set false(c){a=c}};console.log(b.true,b.false=2,b.true);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_get_set: {
+    input: {
+        var a = 1;
+        var b = {
+            get set() {
+                return a;
+            },
+            set get(c) {
+                a = c;
+            }
+        };
+        console.log(b.set, b.get = 2, b.set);
+    }
+    expect_exact: 'var a=1;var b={get set(){return a},set get(c){a=c}};console.log(b.set,b.get=2,b.set);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_null_undefined: {
+    input: {
+        var a = 1;
+        var b = {
+            get null() {
+                return a;
+            },
+            set undefined(c) {
+                a = c;
+            }
+        };
+        console.log(b.null, b.undefined = 2, b.null);
+    }
+    expect_exact: 'var a=1;var b={get null(){return a},set undefined(c){a=c}};console.log(b.null,b.undefined=2,b.null);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_number: {
+    input: {
+        var a = 1;
+        var b = {
+            get 42() {
+                return a;
+            },
+            set 42(c) {
+                a = c;
+            }
+        };
+        console.log(b[42], b[42] = 2, b[42]);
+    }
+    expect_exact: 'var a=1;var b={get 42(){return a},set 42(c){a=c}};console.log(b[42],b[42]=2,b[42]);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_string: {
+    input: {
+        var a = 1;
+        var b = {
+            get "a-b"() {
+                return a;
+            },
+            set "a-b"(c) {
+                a = c;
+            }
+        };
+        console.log(b["a-b"], b["a-b"] = 2, b["a-b"]);
+    }
+    expect_exact: 'var a=1;var b={get"a-b"(){return a},set"a-b"(c){a=c}};console.log(b["a-b"],b["a-b"]=2,b["a-b"]);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_this: {
+    input: {
+        var a = 1;
+        var b = {
+            get this() {
+                return a;
+            },
+            set this(c) {
+                a = c;
+            }
+        };
+        console.log(b.this, b.this = 2, b.this);
+    }
+    expect_exact: 'var a=1;var b={get this(){return a},set this(c){a=c}};console.log(b.this,b.this=2,b.this);'
+    expect_stdout: "1 2 2"
+}

test/input/invalid/else.js

@@ -0,0 +1 @@
+if (0) else 1;

test/input/invalid/return.js

@@ -0,0 +1 @@
+return 42;

test/mocha/cli.js

@@ -51,15 +51,15 @@ describe("bin/uglifyjs", function () {
         });
     });
     it("Should append source map to output when using --source-map-inline", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1323/sample.js --source-map-inline';
+        var command = uglifyjscmd + ' test/input/issue-1323/sample.js --source-map-inline';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n" +
-               "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=\n");
-           done();
-       });
+            assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n" +
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=\n");
+            done();
+        });
     });
     it("should not append source map to output when not using --source-map-inline", function (done) {
         var command = uglifyjscmd + ' test/input/issue-1323/sample.js';
@@ -72,84 +72,84 @@ describe("bin/uglifyjs", function () {
         });
     });
     it("Should work with --keep-fnames (mangle only)", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m';
+        var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
+            done();
+        });
     });
     it("Should work with --keep-fnames (mangle & compress)", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m -c unused=false';
+        var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m -c unused=false';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(5==f(g)());\n");
-           done();
-       });
+            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(5==f(g)());\n");
+            done();
+        });
     });
     it("Should work with keep_fnames under mangler options", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep_fnames=true';
+        var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep_fnames=true';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
+            done();
+        });
     });
     it("Should work with --define (simple)", function (done) {
-       var command = uglifyjscmd + ' test/input/global_defs/simple.js --define D=5 -c';
+        var command = uglifyjscmd + ' test/input/global_defs/simple.js --define D=5 -c';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "console.log(5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "console.log(5);\n");
+            done();
+        });
     });
     it("Should work with --define (nested)", function (done) {
-       var command = uglifyjscmd + ' test/input/global_defs/nested.js --define C.D=5,C.V=3 -c';
+        var command = uglifyjscmd + ' test/input/global_defs/nested.js --define C.D=5,C.V=3 -c';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "console.log(3,5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "console.log(3,5);\n");
+            done();
+        });
     });
     it("Should work with --define (AST_Node)", function (done) {
-       var command = uglifyjscmd + ' test/input/global_defs/simple.js --define console.log=stdout.println -c';
+        var command = uglifyjscmd + ' test/input/global_defs/simple.js --define console.log=stdout.println -c';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "stdout.println(D);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "stdout.println(D);\n");
+            done();
+        });
     });
     it("Should work with `--beautify`", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1482/input.js -b';
+        var command = uglifyjscmd + ' test/input/issue-1482/input.js -b';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, readFileSync("test/input/issue-1482/default.js", "utf8"));
-           done();
-       });
+            assert.strictEqual(stdout, readFileSync("test/input/issue-1482/default.js", "utf8"));
+            done();
+        });
     });
     it("Should work with `--beautify bracketize`", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1482/input.js -b bracketize';
+        var command = uglifyjscmd + ' test/input/issue-1482/input.js -b bracketize';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, readFileSync("test/input/issue-1482/bracketize.js", "utf8"));
-           done();
-       });
+            assert.strictEqual(stdout, readFileSync("test/input/issue-1482/bracketize.js", "utf8"));
+            done();
+        });
     });
     it("Should process inline source map", function(done) {
         var command = uglifyjscmd + ' test/input/issue-520/input.js -mc toplevel --in-source-map inline --source-map-inline';
@@ -252,133 +252,163 @@ describe("bin/uglifyjs", function () {
         });
     });
     it("Should support hyphen as shorthand", function(done) {
-       var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep-fnames=true';
+        var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep-fnames=true';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
+            done();
+        });
     });
     it("Should throw syntax error (5--)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_1.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_1.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_1.js:1,18",
-               "console.log(1 || 5--);",
-               "                  ^",
-               "SyntaxError: Invalid use of -- operator"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_1.js:1,18",
+                "console.log(1 || 5--);",
+                "                  ^",
+                "SyntaxError: Invalid use of -- operator"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (Math.random() /= 2)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_2.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_2.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_2.js:1,32",
-               "console.log(2 || (Math.random() /= 2));",
-               "                                ^",
-               "SyntaxError: Invalid assignment"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_2.js:1,32",
+                "console.log(2 || (Math.random() /= 2));",
+                "                                ^",
+                "SyntaxError: Invalid assignment"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (++this)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_3.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_3.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_3.js:1,17",
-               "console.log(3 || ++this);",
-               "                 ^",
-               "SyntaxError: Invalid use of ++ operator"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_3.js:1,17",
+                "console.log(3 || ++this);",
+                "                 ^",
+                "SyntaxError: Invalid use of ++ operator"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (++null)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_4.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_4.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_4.js:1,0",
-               "++null",
-               "^",
-               "SyntaxError: Invalid use of ++ operator"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_4.js:1,0",
+                "++null",
+                "^",
+                "SyntaxError: Invalid use of ++ operator"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (a.=)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/dot_1.js';
+        var command = uglifyjscmd + ' test/input/invalid/dot_1.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/dot_1.js:1,2",
-               "a.=",
-               "  ^",
-               "SyntaxError: Unexpected token: operator (=)"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/dot_1.js:1,2",
+                "a.=",
+                "  ^",
+                "SyntaxError: Unexpected token: operator (=)"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (%.a)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/dot_2.js';
+        var command = uglifyjscmd + ' test/input/invalid/dot_2.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/dot_2.js:1,0",
-               "%.a;",
-               "^",
-               "SyntaxError: Unexpected token: operator (%)"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/dot_2.js:1,0",
+                "%.a;",
+                "^",
+                "SyntaxError: Unexpected token: operator (%)"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (a./();)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/dot_3.js';
+        var command = uglifyjscmd + ' test/input/invalid/dot_3.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/dot_3.js:1,2",
-               "a./();",
-               "  ^",
-               "SyntaxError: Unexpected token: operator (/)"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/dot_3.js:1,2",
+                "a./();",
+                "  ^",
+                "SyntaxError: Unexpected token: operator (/)"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error ({%: 1})", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/object.js';
+        var command = uglifyjscmd + ' test/input/invalid/object.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/object.js:1,13",
-               "console.log({%: 1});",
-               "             ^",
-               "SyntaxError: Unexpected token: operator (%)"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/object.js:1,13",
+                "console.log({%: 1});",
+                "             ^",
+                "SyntaxError: Unexpected token: operator (%)"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (else)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/else.js';
+
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/else.js:1,7",
+                "if (0) else 1;",
+                "       ^",
+                "SyntaxError: Unexpected token: keyword (else)"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (return)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/return.js';
+
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/return.js:1,0",
+                "return 42;",
+                "^",
+                "SyntaxError: 'return' outside of function"
+            ].join("\n"));
+            done();
+        });
     });
 });