v2.8.16

Turns out the only place in `Compressor` which can generate invalid `AST_For.init` is within `drop_unused()`, so focus the fix-up efforts.

supercedes #1652
fixes #1656

.github/ISSUE_TEMPLATE.md

@@ -1,7 +1,9 @@
-- Bug report or feature request?
+- Bug report or feature request? <!-- Note: sub-optimal but correct code is not a bug -->
 - `uglify-js` version (`uglifyjs -V`)
 - JavaScript input - ideally as small as possible.
 - The `uglifyjs` CLI command executed or `minify()` options used.
 - An example of JavaScript output produced and/or the error or warning.
-
+<!--
-Note: the release version of `uglify-js` only supports ES5. Those wishing to minify ES6 should use the experimental [`harmony`](https://github.com/mishoo/UglifyJS2#harmony) branch.
+    Note: the release version of uglify-js only supports ES5. Those wishing
+    to minify ES6 should use the experimental harmony branch.
+-->

.travis.yml

@@ -5,7 +5,6 @@ node_js:
     - "0.12"
     - "4"
     - "6"
-    - "7"
 env:
     - UGLIFYJS_TEST_ALL=1
 matrix:

README.md

@@ -10,8 +10,10 @@ There's also an
 [in-browser online demo](http://lisperator.net/uglifyjs/#demo) (for Firefox,
 Chrome and probably Safari).
 
-Note: release versions of `uglify-js` only support ECMAScript 5 (ES5). If you wish to minify
+#### Note:
+- release versions of `uglify-js` only support ECMAScript 5 (ES5). If you wish to minify
 ES2015+ (ES6+) code then please use the [harmony](#harmony) development branch.
+- Node 7 has a known performance regression and runs `uglify-js` twice as slow.
 
 Install
 -------
@@ -68,7 +70,8 @@ The available options are:
   --source-map-inline           Write base64-encoded source map to the end of js output.
   --in-source-map               Input source map, useful if you're compressing
                                 JS that was generated from some other original
-                                code.
+                                code. Specify "inline" if the source map is included
+                                inline with the sources.
   --screw-ie8                   Use this flag if you don't wish to support
                                 Internet Explorer 6/7/8.
                                 By default UglifyJS will not try to be IE-proof.
@@ -200,9 +203,10 @@ compressed JS by mapping every token in the compiled JS to its original
 location.
 
 To use this feature you need to pass `--in-source-map
-/path/to/input/source.map`.  Normally the input source map should also point
+/path/to/input/source.map` or `--in-source-map inline` if the source map is
-to the file containing the generated JS, so if that's correct you can omit
+included inline with the sources. Normally the input source map should also
-input files from the command line.
+point to the file containing the generated JS, so if that's correct you can
+omit input files from the command line.
 
 ## Mangler options
 

bin/uglifyjs

@@ -561,7 +561,7 @@ function getOptions(flag, constants) {
 
         var ast;
         try {
-            ast = UglifyJS.parse(x, { expression: true });
+            ast = UglifyJS.parse(x, { cli: true, expression: true });
         } catch(ex) {
             if (ex instanceof UglifyJS.JS_Parse_Error) {
                 print_error("Error parsing arguments for flag `" + flag + "': " + x);

lib/ast.js

@@ -984,8 +984,8 @@ TreeWalker.prototype = {
     push: function (node) {
         if (node instanceof AST_Lambda) {
             this.directives = Object.create(this.directives);
-        } else if (node instanceof AST_Directive) {
+        } else if (node instanceof AST_Directive && !this.directives[node.value]) {
-            this.directives[node.value] = this.directives[node.value] ? "up" : true;
+            this.directives[node.value] = node;
         }
         this.stack.push(node);
     },
@@ -1013,7 +1013,7 @@ TreeWalker.prototype = {
             for (var i = 0; i < node.body.length; ++i) {
                 var st = node.body[i];
                 if (!(st instanceof AST_Directive)) break;
-                if (st.value == type) return true;
+                if (st.value == type) return st;
             }
         }
     },

lib/output.js

@@ -799,7 +799,7 @@ function OutputStream(options) {
         output.print("for");
         output.space();
         output.with_parens(function(){
-            if (self.init && !(self.init instanceof AST_EmptyStatement)) {
+            if (self.init) {
                 if (self.init instanceof AST_Definitions) {
                     self.init.print(output);
                 } else {

lib/parse.js

@@ -695,6 +695,7 @@ function parse($TEXT, options) {
         html5_comments : true,
         bare_returns   : false,
         shebang        : true,
+        cli            : false,
     });
 
     var S = {
@@ -1456,7 +1457,7 @@ function parse($TEXT, options) {
 
     function make_unary(ctor, op, expr) {
         if ((op == "++" || op == "--") && !is_assignable(expr))
-            croak("Invalid use of " + op + " operator");
+            croak("Invalid use of " + op + " operator", null, ctor === AST_UnaryPrefix ? expr.start.col - 1 : null);
         return new ctor({ operator: op, expression: expr });
     };
 
@@ -1501,9 +1502,8 @@ function parse($TEXT, options) {
     };
 
     function is_assignable(expr) {
-        if (!options.strict) return true;
+        if (options.cli) return true;
-        if (expr instanceof AST_This) return false;
+        return expr instanceof AST_PropAccess || expr instanceof AST_SymbolRef;
-        return (expr instanceof AST_PropAccess || expr instanceof AST_Symbol);
     };
 
     var maybe_assign = function(no_in) {

lib/utils.js

@@ -126,9 +126,11 @@ function merge(obj, ext) {
     return count;
 };
 
-function noop() {};
+function noop() {}
 function return_false() { return false; }
 function return_true() { return true; }
+function return_this() { return this; }
+function return_null() { return null; }
 
 var MAP = (function(){
     function MAP(a, f, backwards) {

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.11",
+  "version": "2.8.16",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -30,7 +30,6 @@
   ],
   "dependencies": {
     "source-map": "~0.5.1",
-    "uglify-to-browserify": "~1.0.0",
     "yargs": "~3.10.0"
   },
   "devDependencies": {
@@ -40,13 +39,15 @@
     "estraverse": "~1.5.1",
     "mocha": "~2.3.4"
   },
+  "optionalDependencies": {
+    "uglify-to-browserify": "~1.0.0"
+  },
   "browserify": {
     "transform": [
       "uglify-to-browserify"
     ]
   },
   "scripts": {
-    "shrinkwrap": "rm ./npm-shrinkwrap.json; rm -rf ./node_modules; npm i && npm shrinkwrap && npm outdated",
     "test": "node test/run-tests.js"
   },
   "keywords": ["uglify", "uglify-js", "minify", "minifier"]

test/compress/collapse_vars.js

@@ -43,6 +43,7 @@ collapse_vars_side_effects_1: {
                 z = i += 4;
             log(x, z, y, i);
         }
+        f1(), f2(), f3(), f4();
     }
     expect: {
         function f1() {
@@ -73,7 +74,9 @@ collapse_vars_side_effects_1: {
                 y = i += 3;
             log(x, i += 4, y, i);
         }
+        f1(), f2(), f3(), f4();
     }
+    expect_stdout: true
 }
 
 collapse_vars_side_effects_2: {
@@ -823,6 +826,7 @@ collapse_vars_repeated: {
             console.log(e + "!");
         })("!");
     }
+    expect_stdout: true
 }
 
 collapse_vars_closures: {
@@ -1109,6 +1113,7 @@ collapse_vars_eval_and_with: {
             return function() { with (o) console.log(a) };
         })()();
     }
+    expect_stdout: true
 }
 
 collapse_vars_constants: {
@@ -1152,7 +1157,8 @@ collapse_vars_arguments: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true,
+        toplevel:true
     }
     input: {
         var outer = function() {
@@ -1167,6 +1173,7 @@ collapse_vars_arguments: {
             (function(){console.log(arguments);})(7, 1);
         })();
     }
+    expect_stdout: true
 }
 
 collapse_vars_short_circuit: {
@@ -1316,6 +1323,7 @@ collapse_vars_regexp: {
                 console.log(result[0]);
         })();
     }
+    expect_stdout: true
 }
 
 issue_1537: {
@@ -1335,6 +1343,7 @@ issue_1537: {
 issue_1562: {
     options = {
         collapse_vars: true,
+        toplevel: true,
     }
     input: {
         var v = 1, B = 2;
@@ -1363,3 +1372,221 @@ issue_1562: {
         for (; f(z + 2) ;) bar(30);
     }
 }
+
+issue_1605_1: {
+    options = {
+        collapse_vars: true,
+        toplevel: false,
+    }
+    input: {
+        function foo(x) {
+            var y = x;
+            return y;
+        }
+        var o = new Object;
+        o.p = 1;
+    }
+    expect: {
+        function foo(x) {
+            return x;
+        }
+        var o = new Object;
+        o.p = 1;
+    }
+}
+
+issue_1605_2: {
+    options = {
+        collapse_vars: true,
+        toplevel: "vars",
+    }
+    input: {
+        function foo(x) {
+            var y = x;
+            return y;
+        }
+        var o = new Object;
+        o.p = 1;
+    }
+    expect: {
+        function foo(x) {
+            return x;
+        }
+        (new Object).p = 1;
+    }
+}
+
+issue_1631_1: {
+    options = {
+        cascade: true,
+        collapse_vars: true,
+        hoist_funs: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var pc = 0;
+        function f(x) {
+            pc = 200;
+            return 100;
+        }
+        function x() {
+            var t = f();
+            pc += t;
+            return pc;
+        }
+        console.log(x());
+    }
+    expect: {
+        function f(x) {
+            return pc = 200, 100;
+        }
+        function x() {
+            var t = f();
+            return pc += t;
+        }
+        var pc = 0;
+        console.log(x());
+    }
+    expect_stdout: "300"
+}
+
+issue_1631_2: {
+    options = {
+        cascade: true,
+        collapse_vars: true,
+        hoist_funs: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 0, b = 1;
+        function f() {
+            a = 2;
+            return 4;
+        }
+        function g() {
+            var t = f();
+            b = a + t;
+            return b;
+        }
+        console.log(g());
+    }
+    expect: {
+        function f() {
+            return a = 2, 4;
+        }
+        function g() {
+            var t = f();
+            return b = a + t;
+        }
+        var a = 0, b = 1;
+        console.log(g());
+    }
+    expect_stdout: "6"
+}
+
+issue_1631_3: {
+    options = {
+        cascade: true,
+        collapse_vars: true,
+        hoist_funs: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function g() {
+            var a = 0, b = 1;
+            function f() {
+                a = 2;
+                return 4;
+            }
+            var t = f();
+            b = a + t;
+            return b;
+        }
+        console.log(g());
+    }
+    expect: {
+        function g() {
+            function f() {
+                return a = 2, 4;
+            }
+            var a = 0, b = 1, t = f();
+            return b = a + t;
+        }
+        console.log(g());
+    }
+    expect_stdout: "6"
+}
+
+var_side_effects_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var print = console.log.bind(console);
+        function foo(x) {
+            var twice = x * 2;
+            print('Foo:', twice);
+        }
+        foo(10);
+    }
+    expect: {
+        var print = console.log.bind(console);
+        function foo(x) {
+            print('Foo:', 2 * x);
+        }
+        foo(10);
+    }
+    expect_stdout: true
+}
+
+var_side_effects_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var print = console.log.bind(console);
+        function foo(x) {
+            var twice = x.y * 2;
+            print('Foo:', twice);
+        }
+        foo({ y: 10 });
+    }
+    expect: {
+        var print = console.log.bind(console);
+        function foo(x) {
+            var twice = 2 * x.y;
+            print('Foo:', twice);
+        }
+        foo({ y: 10 });
+    }
+    expect_stdout: true
+}
+
+var_side_effects_3: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+    }
+    input: {
+        var print = console.log.bind(console);
+        function foo(x) {
+            var twice = x.y * 2;
+            print('Foo:', twice);
+        }
+        foo({ y: 10 });
+    }
+    expect: {
+        var print = console.log.bind(console);
+        function foo(x) {
+            print('Foo:', 2 * x.y);
+        }
+        foo({ y: 10 });
+    }
+    expect_stdout: true
+}

test/compress/concat-strings.js

@@ -51,6 +51,7 @@ concat_2: {
             "1" + "2" + "3"
         );
     }
+    expect_stdout: true
 }
 
 concat_3: {
@@ -79,6 +80,7 @@ concat_3: {
             1 + 2 + "3" + "4" + "5"
         );
     }
+    expect_stdout: true
 }
 
 concat_4: {
@@ -107,6 +109,7 @@ concat_4: {
             1 + "2" + "3" + "4" + "5"
         );
     }
+    expect_stdout: true
 }
 
 concat_5: {
@@ -135,6 +138,7 @@ concat_5: {
             "1" + 2 + "3" + "4" + "5"
         );
     }
+    expect_stdout: true
 }
 
 concat_6: {
@@ -163,6 +167,7 @@ concat_6: {
             "1" + "2" + "3" + "4" + "5"
         );
     }
+    expect_stdout: true
 }
 
 concat_7: {
@@ -188,6 +193,7 @@ concat_7: {
             x += "foo"
         );
     }
+    expect_stdout: true
 }
 
 concat_8: {
@@ -213,4 +219,5 @@ concat_8: {
             x += "foo"
         );
     }
+    expect_stdout: true
 }

test/compress/conditionals.js

@@ -797,3 +797,139 @@ no_evaluate: {
         }
     }
 }
+
+equality_conditionals_false: {
+    options = {
+        conditionals: false,
+        sequences: true,
+    }
+    input: {
+        function f(a, b, c) {
+            console.log(
+                a == (b ? a : a),
+                a == (b ? a : c),
+                a != (b ? a : a),
+                a != (b ? a : c),
+                a === (b ? a : a),
+                a === (b ? a : c),
+                a !== (b ? a : a),
+                a !== (b ? a : c)
+            );
+        }
+        f(0, 0, 0);
+        f(0, true, 0);
+        f(1, 2, 3);
+        f(1, null, 3);
+        f(NaN);
+        f(NaN, "foo");
+    }
+    expect: {
+        function f(a, b, c) {
+            console.log(
+                a == (b ? a : a),
+                a == (b ? a : c),
+                a != (b ? a : a),
+                a != (b ? a : c),
+                a === (b ? a : a),
+                a === (b ? a : c),
+                a !== (b ? a : a),
+                a !== (b ? a : c)
+            );
+        }
+        f(0, 0, 0),
+        f(0, true, 0),
+        f(1, 2, 3),
+        f(1, null, 3),
+        f(NaN),
+        f(NaN, "foo");
+    }
+    expect_stdout: true
+}
+
+equality_conditionals_true: {
+    options = {
+        conditionals: true,
+        sequences: true,
+    }
+    input: {
+        function f(a, b, c) {
+            console.log(
+                a == (b ? a : a),
+                a == (b ? a : c),
+                a != (b ? a : a),
+                a != (b ? a : c),
+                a === (b ? a : a),
+                a === (b ? a : c),
+                a !== (b ? a : a),
+                a !== (b ? a : c)
+            );
+        }
+        f(0, 0, 0);
+        f(0, true, 0);
+        f(1, 2, 3);
+        f(1, null, 3);
+        f(NaN);
+        f(NaN, "foo");
+    }
+    expect: {
+        function f(a, b, c) {
+            console.log(
+                (b, a == a),
+                a == (b ? a : c),
+                (b, a != a),
+                a != (b ? a : c),
+                (b, a === a),
+                a === (b ? a : c),
+                (b, a !== a),
+                a !== (b ? a : c)
+            );
+        }
+        f(0, 0, 0),
+        f(0, true, 0),
+        f(1, 2, 3),
+        f(1, null, 3),
+        f(NaN),
+        f(NaN, "foo");
+    }
+    expect_stdout: true
+}
+
+issue_1645_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a = 100, b = 10;
+        (b = a) ? a++ + (b += a) ? b += a : b += a : b ^= a;
+        console.log(a, b);
+    }
+    expect: {
+        var a = 100, b = 10;
+        (b = a) ? (a++ + (b += a), b += a) : b ^= a;
+        console.log(a,b);
+    }
+    expect_stdout: true
+}
+
+issue_1645_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a = 0;
+        function f() {
+            return a++;
+        }
+        f() ? a += 2 : a += 4;
+        console.log(a);
+    }
+    expect: {
+        var a = 0;
+        function f(){
+            return a++;
+        }
+        f() ? a += 2 : a += 4;
+        console.log(a);
+    }
+    expect_stdout: true
+}

test/compress/const.js

@@ -162,4 +162,5 @@ regexp_literal_not_const: {
             while (result = REGEXP_LITERAL.exec("acdabcdeabbb")) console.log(result[0]);
         })();
     }
+    expect_stdout: true
 }

test/compress/dead-code.js

@@ -87,6 +87,7 @@ dead_code_constant_boolean_should_warn_more: {
         var x = 10, y;
         var moo;
     }
+    expect_stdout: true
 }
 
 dead_code_const_declaration: {
@@ -113,6 +114,7 @@ dead_code_const_declaration: {
         var moo;
         function bar() {}
     }
+    expect_stdout: true
 }
 
 dead_code_const_annotation: {
@@ -140,6 +142,7 @@ dead_code_const_annotation: {
         var moo;
         function bar() {}
     }
+    expect_stdout: true
 }
 
 dead_code_const_annotation_regex: {
@@ -163,6 +166,7 @@ dead_code_const_annotation_regex: {
         var CONST_FOO_ANN = !1;
         CONST_FOO_ANN && console.log('reachable');
     }
+    expect_stdout: true
 }
 
 dead_code_const_annotation_complex_scope: {
@@ -208,4 +212,5 @@ dead_code_const_annotation_complex_scope: {
         var meat = 'beef';
         var pork = 'bad';
     }
+    expect_stdout: true
 }

test/compress/drop-unused.js

@@ -791,3 +791,17 @@ issue_1583: {
         }
     }
 }
+
+issue_1656: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        for(var a=0;;);
+    }
+    expect_exact: "for (;;) ;"
+}

test/compress/evaluate.js

@@ -200,6 +200,7 @@ negative_zero: {
             1 / (-0)
         );
     }
+    expect_stdout: true
 }
 
 positive_zero: {
@@ -220,6 +221,7 @@ positive_zero: {
             1 / (0)
         );
     }
+    expect_stdout: true
 }
 
 unsafe_constant: {
@@ -243,6 +245,7 @@ unsafe_constant: {
             (void 0).a
         );
     }
+    expect_stdout: true
 }
 
 unsafe_object: {
@@ -266,6 +269,7 @@ unsafe_object: {
             1..b + 1
         );
     }
+    expect_stdout: true
 }
 
 unsafe_object_nested: {
@@ -289,6 +293,7 @@ unsafe_object_nested: {
             2
         );
     }
+    expect_stdout: true
 }
 
 unsafe_object_complex: {
@@ -312,6 +317,7 @@ unsafe_object_complex: {
             2
         );
     }
+    expect_stdout: true
 }
 
 unsafe_object_repeated: {
@@ -335,6 +341,7 @@ unsafe_object_repeated: {
             1..b + 1
         );
     }
+    expect_stdout: true
 }
 
 unsafe_object_accessor: {
@@ -384,6 +391,7 @@ unsafe_function: {
             ({a:{b:1},b:function(){}}).a.b + 1
         );
     }
+    expect_stdout: true
 }
 
 unsafe_integer_key: {
@@ -411,6 +419,7 @@ unsafe_integer_key: {
             1["1"] + 1
         );
     }
+    expect_stdout: true
 }
 
 unsafe_integer_key_complex: {
@@ -438,6 +447,7 @@ unsafe_integer_key_complex: {
             2
         );
     }
+    expect_stdout: true
 }
 
 unsafe_float_key: {
@@ -465,6 +475,7 @@ unsafe_float_key: {
             1["3.14"] + 1
         );
     }
+    expect_stdout: true
 }
 
 unsafe_float_key_complex: {
@@ -492,6 +503,7 @@ unsafe_float_key_complex: {
             2
         );
     }
+    expect_stdout: true
 }
 
 unsafe_array: {
@@ -527,6 +539,7 @@ unsafe_array: {
             (void 0)[1] + 1
         );
     }
+    expect_stdout: true
 }
 
 unsafe_string: {
@@ -554,6 +567,7 @@ unsafe_string: {
             "11"
         );
     }
+    expect_stdout: true
 }
 
 unsafe_array_bad_index: {
@@ -575,6 +589,7 @@ unsafe_array_bad_index: {
             [1, 2, 3, 4][3.14] + 1
         );
     }
+    expect_stdout: true
 }
 
 unsafe_string_bad_index: {
@@ -596,6 +611,7 @@ unsafe_string_bad_index: {
             "1234"[3.14] + 1
         );
     }
+    expect_stdout: true
 }
 
 unsafe_prototype_function: {
@@ -642,6 +658,7 @@ call_args: {
         console.log(1);
         +(1, 1);
     }
+    expect_stdout: true
 }
 
 call_args_drop_param: {
@@ -663,6 +680,7 @@ call_args_drop_param: {
         console.log(1);
         +(b, 1);
     }
+    expect_stdout: true
 }
 
 in_boolean_context: {
@@ -700,4 +718,87 @@ in_boolean_context: {
             (foo(), !1)
         );
     }
+    expect_stdout: true
+}
+
+unsafe_charAt: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            "1234" + 1,
+            "1234".charAt(0) + 1,
+            "1234".charAt(6 - 5) + 1,
+            ("12" + "34").charAt(0) + 1,
+            ("12" + "34").charAt(6 - 5) + 1,
+            [1, 2, 3, 4].join("").charAt(0) + 1
+        );
+    }
+    expect: {
+        console.log(
+            "12341",
+            "11",
+            "21",
+            "11",
+            "21",
+            "11"
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_charAt_bad_index: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            "1234".charAt() + 1,
+            "1234".charAt("a") + 1,
+            "1234".charAt(3.14) + 1
+        );
+    }
+    expect: {
+        console.log(
+            "11",
+            "11",
+            "41"
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_charAt_noop: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            s.charAt(0),
+            "string".charAt(x)
+        );
+    }
+    expect: {
+        console.log(
+            s.charAt(0),
+            "string".charAt(x)
+        );
+    }
+}
+
+issue_1649: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log(-1 + -1);
+    }
+    expect: {
+        console.log(-2);
+    }
+    expect_stdout: "-2";
 }

test/compress/functions.js

@@ -39,6 +39,7 @@ iifes_returning_constants_keep_fargs_true: {
         console.log(6);
         console.log((a(), b(), 6));
     }
+    expect_stdout: true
 }
 
 iifes_returning_constants_keep_fargs_false: {
@@ -73,6 +74,7 @@ iifes_returning_constants_keep_fargs_false: {
         console.log(6);
         console.log((a(), b(), 6));
     }
+    expect_stdout: true
 }
 
 issue_485_crashing_1530: {

test/compress/html_comments.js

@@ -47,22 +47,6 @@ html_comment_in_greater_than_or_equal: {
     expect_exact: "function f(a,b){return a-- >=b}";
 }
 
-html_comment_in_right_shift_assign: {
-    input: {
-        // Note: illegal javascript
-        function f(a, b) { return a-- >>= b; }
-    }
-    expect_exact: "function f(a,b){return a-- >>=b}";
-}
-
-html_comment_in_zero_fill_right_shift_assign: {
-    input: {
-        // Note: illegal javascript
-        function f(a, b) { return a-- >>>= b; }
-    }
-    expect_exact: "function f(a,b){return a-- >>>=b}";
-}
-
 html_comment_in_string_literal: {
     input: {
         function f() { return "<!--HTML-->comment in<!--string literal-->"; }

test/compress/issue-1034.js

@@ -39,7 +39,7 @@ non_hoisted_function_after_return_2a: {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
         if_return: true, join_vars: true, cascade: true, side_effects: true,
-        collapse_vars: false, passes: 2
+        collapse_vars: false, passes: 2, warnings: "verbose"
     }
     input: {
         function foo(x) {
@@ -75,7 +75,7 @@ non_hoisted_function_after_return_2a: {
         "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:53,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:56,12]",
         "WARN: Dropping unused variable b [test/compress/issue-1034.js:51,20]",
-        "WARN: Dropping unused variable c [test/compress/issue-1034.js:53,16]"
+        "WARN: Dropping unused variable c [test/compress/issue-1034.js:53,16]",
     ]
 }
 
@@ -114,8 +114,5 @@ non_hoisted_function_after_return_2b: {
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:97,12]",
         "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:97,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:101,12]",
-        "WARN: Dropping unused variable b [test/compress/issue-1034.js:95,20]",
-        "WARN: Dropping unused variable c [test/compress/issue-1034.js:97,16]"
     ]
 }
-

test/compress/issue-1202.js

@@ -49,4 +49,3 @@ mangle_keep_fnames_true: {
         }
     }
 }
-

test/compress/issue-1275.js

@@ -46,4 +46,5 @@ string_plus_optimization: {
         }
         foo();
     }
+    expect_stdout: true
 }

test/compress/issue-1321.js

@@ -14,6 +14,7 @@ issue_1321_no_debug: {
         x["a"] = 2 * x.b;
         console.log(x.b, x["a"]);
     }
+    expect_stdout: true
 }
 
 issue_1321_debug: {
@@ -33,6 +34,7 @@ issue_1321_debug: {
         x["_$foo$_"] = 2 * x.a;
         console.log(x.a, x["_$foo$_"]);
     }
+    expect_stdout: true
 }
 
 issue_1321_with_quoted: {
@@ -51,4 +53,5 @@ issue_1321_with_quoted: {
         x["b"] = 2 * x.a;
         console.log(x.a, x["b"]);
     }
+    expect_stdout: true
 }

test/compress/issue-1447.js

@@ -42,4 +42,5 @@ conditional_false_stray_else_in_loop: {
         }
     }
     expect_exact: "for(var i=1;i<=4;++i)if(!(i<=2))console.log(i);"
+    expect_stdout: true
 }

test/compress/issue-1588.js

@@ -0,0 +1,99 @@
+screw_ie8: {
+    options = {
+        screw_ie8: true,
+    }
+    mangle = {
+        screw_ie8: true,
+    }
+    input: {
+        try { throw "foo"; } catch (x) { console.log(x); }
+    }
+    expect_exact: 'try{throw"foo"}catch(o){console.log(o)}'
+    expect_stdout: [
+        "foo"
+    ]
+}
+
+support_ie8: {
+    options = {
+        screw_ie8: false,
+    }
+    mangle = {
+        screw_ie8: false,
+    }
+    input: {
+        try { throw "foo"; } catch (x) { console.log(x); }
+    }
+    expect_exact: 'try{throw"foo"}catch(x){console.log(x)}'
+    expect_stdout: "foo"
+}
+
+safe_undefined: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        unsafe: false,
+    }
+    mangle = {}
+    input: {
+        var a, c;
+        console.log(function(undefined) {
+            return function() {
+                if (a)
+                    return b;
+                if (c)
+                    return d;
+            };
+        }(1)());
+    }
+    expect: {
+        var a, c;
+        console.log(function(n) {
+            return function() {
+                return a ? b : c ? d : void 0;
+            };
+        }(1)());
+    }
+    expect_stdout: true
+}
+
+unsafe_undefined: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        unsafe: true,
+    }
+    mangle = {}
+    input: {
+        var a, c;
+        console.log(function(undefined) {
+            return function() {
+                if (a)
+                    return b;
+                if (c)
+                    return d;
+            };
+        }()());
+    }
+    expect: {
+        var a, c;
+        console.log(function(n) {
+            return function() {
+                return a ? b : c ? d : n;
+            };
+        }()());
+    }
+    expect_stdout: true
+}
+
+runtime_error: {
+    input: {
+        const a = 1;
+        console.log(a++);
+    }
+    expect: {
+        const a = 1;
+        console.log(a++);
+    }
+    expect_stdout: true
+}

test/compress/issue-1609.js

@@ -0,0 +1,56 @@
+chained_evaluation_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a = 1;
+            (function() {
+                var b = a, c;
+                c = f(b);
+                c.bar = b;
+            })();
+        })();
+    }
+    expect: {
+        (function() {
+            (function() {
+                var c;
+                c = f(1);
+                c.bar = 1;
+            })();
+        })();
+    }
+}
+
+chained_evaluation_2: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a = "long piece of string";
+            (function() {
+                var b = a, c;
+                c = f(b);
+                c.bar = b;
+            })();
+        })();
+    }
+    expect: {
+        (function() {
+            var a = "long piece of string";
+            (function() {
+                var c;
+                c = f(a);
+                c.bar = a;
+            })();
+        })();
+    }
+}

test/compress/issue-1639.js

@@ -0,0 +1,88 @@
+
+issue_1639_1: {
+    options = {
+        booleans: true,
+        cascade: true,
+        conditionals: true,
+        evaluate: true,
+        join_vars: true,
+        loops: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 100, b = 10;
+
+        var L1 = 5;
+        while (--L1 > 0) {
+            if ((--b), false) {
+                if (b) {
+                    var ignore = 0;
+                }
+            }
+        }
+
+        console.log(a, b);
+    }
+    expect: {
+        for (var a = 100, b = 10, L1 = 5; --L1 > 0;)
+            if (--b, !1) var ignore = 0;
+        console.log(a, b);
+    }
+    expect_stdout: true
+}
+
+issue_1639_2: {
+    options = {
+        booleans: true,
+        cascade: true,
+        conditionals: true,
+        evaluate: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 100, b = 10;
+
+        function f19() {
+            if (++a, false)
+                if (a)
+                    if (++a);
+        }
+        f19();
+
+        console.log(a, b);
+    }
+    expect: {
+        var a = 100, b = 10;
+        function f19() {
+            ++a, 1;
+        }
+        f19(),
+        console.log(a, b);
+    }
+    expect_stdout: true
+}
+
+issue_1639_3: {
+    options = {
+        booleans: true,
+        cascade: true,
+        conditionals: true,
+        evaluate: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 100, b = 10;
+        a++ && false && a ? 0 : 0;
+        console.log(a, b);
+    }
+    expect: {
+        var a = 100, b = 10;
+        a++,
+        console.log(a, b);
+    }
+    expect_stdout: true
+}

test/compress/issue-1656.js

@@ -0,0 +1,45 @@
+f7: {
+    options = {
+        booleans: true,
+        cascade: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        drop_debugger: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        loops: true,
+        negate_iife: true,
+        passes: 3,
+        properties: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        var a = 100, b = 10;
+        function f22464() {
+            var brake146670 = 5;
+            while (((b = a) ? !a : ~a ? null : b += a) && --brake146670 > 0) {
+            }
+        }
+        f22464();
+        console.log(a, b);
+    }
+    expect_exact: [
+        "var a = 100, b = 10;",
+        "",
+        "!function() {",
+        "    for (;b = a, !1; ) ;",
+        "}(), console.log(a, b);",
+    ]
+    expect_stdout: true
+}

test/compress/issue-640.js

@@ -48,6 +48,7 @@ dead_code_const_annotation_regex: {
         var CONST_FOO_ANN = !1;
         if (CONST_FOO_ANN) console.log('reachable');
     }
+    expect_stdout: true
 }
 
 drop_console_2: {
@@ -225,6 +226,7 @@ issue_1254_negate_iife_true: {
         })()();
     }
     expect_exact: '(function(){return function(){console.log("test")}})()();'
+    expect_stdout: true
 }
 
 issue_1254_negate_iife_nested: {
@@ -240,6 +242,7 @@ issue_1254_negate_iife_nested: {
         })()()()()();
     }
     expect_exact: '(function(){return function(){console.log("test")}})()()()()();'
+    expect_stdout: true
 }
 
 conditional: {

test/compress/issue-892.js

@@ -29,4 +29,5 @@ dont_mangle_arguments: {
         })(5,6,7);
     }
     expect_exact: "(function(){var arguments=arguments,o=9;console.log(o,arguments)})(5,6,7);"
+    expect_stdout: true
 }

test/compress/issue-973.js

@@ -50,6 +50,7 @@ this_binding_conditionals: {
 this_binding_collapse_vars: {
     options = {
         collapse_vars: true,
+        toplevel: true,
     };
     input: {
         var c = a; c();

test/compress/issue-976.js

@@ -42,6 +42,7 @@ eval_collapse_vars: {
             eval("console.log(a);");
         })(eval);
     }
+    expect_stdout: true
 }
 
 eval_unused: {

test/compress/labels.js

@@ -9,6 +9,7 @@ labels_1: {
     expect: {
         foo || console.log("bar");
     }
+    expect_stdout: true
 }
 
 labels_2: {
@@ -40,6 +41,7 @@ labels_3: {
         for (var i = 0; i < 5; ++i)
             i < 3 || console.log(i);
     }
+    expect_stdout: true
 }
 
 labels_4: {
@@ -54,6 +56,7 @@ labels_4: {
         for (var i = 0; i < 5; ++i)
             i < 3 || console.log(i);
     }
+    expect_stdout: true
 }
 
 labels_5: {

test/compress/loops.js

@@ -166,6 +166,7 @@ keep_collapse_const_in_own_block_scope: {
             console.log(i);
         console.log(c);
     }
+    expect_stdout: true
 }
 
 keep_collapse_const_in_own_block_scope_2: {
@@ -186,6 +187,7 @@ keep_collapse_const_in_own_block_scope_2: {
             console.log(i);
         console.log(c);
     }
+    expect_stdout: true
 }
 
 evaluate: {
@@ -295,7 +297,15 @@ issue_186_beautify: {
         else
             bar();
     }
-    expect_exact: 'var x = 3;\n\nif (foo()) do {\n    do {\n        alert(x);\n    } while (--x);\n} while (x); else bar();'
+    expect_exact: [
+        'var x = 3;',
+        '',
+        'if (foo()) do {',
+        '    do {',
+        '        alert(x);',
+        '    } while (--x);',
+        '} while (x); else bar();',
+    ]
 }
 
 issue_186_beautify_ie8: {
@@ -314,7 +324,17 @@ issue_186_beautify_ie8: {
         else
             bar();
     }
-    expect_exact: 'var x = 3;\n\nif (foo()) {\n    do {\n        do {\n            alert(x);\n        } while (--x);\n    } while (x);\n} else bar();'
+    expect_exact: [
+        'var x = 3;',
+        '',
+        'if (foo()) {',
+        '    do {',
+        '        do {',
+        '            alert(x);',
+        '        } while (--x);',
+        '    } while (x);',
+        '} else bar();',
+    ]
 }
 
 issue_186_bracketize: {
@@ -374,7 +394,19 @@ issue_186_beautify_bracketize: {
         else
             bar();
     }
-    expect_exact: 'var x = 3;\n\nif (foo()) {\n    do {\n        do {\n            alert(x);\n        } while (--x);\n    } while (x);\n} else {\n    bar();\n}'
+    expect_exact: [
+        'var x = 3;',
+        '',
+        'if (foo()) {',
+        '    do {',
+        '        do {',
+        '            alert(x);',
+        '        } while (--x);',
+        '    } while (x);',
+        '} else {',
+        '    bar();',
+        '}',
+    ]
 }
 
 issue_186_beautify_bracketize_ie8: {
@@ -394,5 +426,35 @@ issue_186_beautify_bracketize_ie8: {
         else
             bar();
     }
-    expect_exact: 'var x = 3;\n\nif (foo()) {\n    do {\n        do {\n            alert(x);\n        } while (--x);\n    } while (x);\n} else {\n    bar();\n}'
+    expect_exact: [
+        'var x = 3;',
+        '',
+        'if (foo()) {',
+        '    do {',
+        '        do {',
+        '            alert(x);',
+        '        } while (--x);',
+        '    } while (x);',
+        '} else {',
+        '    bar();',
+        '}',
+    ]
+}
+
+issue_1648: {
+    options = {
+        join_vars: true,
+        loops: true,
+        passes: 2,
+        sequences: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            x();
+            var b = 1;
+            while (1);
+        }
+    }
+    expect_exact: "function f(){for(x();1;);}"
 }

test/compress/max_line_len.js

@@ -7,7 +7,13 @@ too_short: {
             return { c: 42, d: a(), e: "foo"};
         }
     }
-    expect_exact: 'function f(a){\nreturn{\nc:42,\nd:a(),\ne:"foo"}}'
+    expect_exact: [
+        'function f(a){',
+        'return{',
+        'c:42,',
+        'd:a(),',
+        'e:"foo"}}',
+    ]
     expect_warnings: [
         "WARN: Output exceeds 10 characters"
     ]
@@ -22,7 +28,12 @@ just_enough: {
             return { c: 42, d: a(), e: "foo"};
         }
     }
-    expect_exact: 'function f(a){\nreturn{c:42,\nd:a(),e:"foo"}\n}'
+    expect_exact: [
+        'function f(a){',
+        'return{c:42,',
+        'd:a(),e:"foo"}',
+        '}',
+    ]
     expect_warnings: [
     ]
 }

test/compress/negate-iife.js

@@ -70,6 +70,7 @@ negate_iife_3_evaluate: {
     expect: {
         console.log(true);
     }
+    expect_stdout: true
 }
 
 negate_iife_3_side_effects: {
@@ -111,6 +112,7 @@ negate_iife_3_off_evaluate: {
     expect: {
         console.log(true);
     }
+    expect_stdout: true
 }
 
 negate_iife_4: {
@@ -243,6 +245,7 @@ negate_iife_nested: {
             }(7);
         }).f();
     }
+    expect_stdout: true
 }
 
 negate_iife_nested_off: {
@@ -275,6 +278,7 @@ negate_iife_nested_off: {
             })(7);
         }).f();
     }
+    expect_stdout: true
 }
 
 negate_iife_issue_1073: {
@@ -299,6 +303,7 @@ negate_iife_issue_1073: {
             };
         }(7))();
     }
+    expect_stdout: true
 }
 
 issue_1254_negate_iife_false: {
@@ -313,6 +318,7 @@ issue_1254_negate_iife_false: {
         })()();
     }
     expect_exact: '(function(){return function(){console.log("test")}})()();'
+    expect_stdout: true
 }
 
 issue_1254_negate_iife_true: {
@@ -327,6 +333,7 @@ issue_1254_negate_iife_true: {
         })()();
     }
     expect_exact: '!function(){return function(){console.log("test")}}()();'
+    expect_stdout: true
 }
 
 issue_1254_negate_iife_nested: {
@@ -341,6 +348,7 @@ issue_1254_negate_iife_nested: {
         })()()()()();
     }
     expect_exact: '!function(){return function(){console.log("test")}}()()()()();'
+    expect_stdout: true
 }
 
 issue_1288: {

test/compress/reduce_vars.js

@@ -58,6 +58,7 @@ reduce_vars: {
         })();
         console.log(2);
     }
+    expect_stdout: true
 }
 
 modified: {
@@ -401,6 +402,7 @@ iife: {
             console.log(0, 1 * b, 5);
         }(1, 2, 3);
     }
+    expect_stdout: true
 }
 
 iife_new: {
@@ -420,6 +422,7 @@ iife_new: {
             console.log(0, 1 * b, 5);
         }(1, 2, 3);
     }
+    expect_stdout: true
 }
 
 multi_def: {
@@ -707,6 +710,7 @@ toplevel_on: {
     expect: {
         console.log(3);
     }
+    expect_stdout: true
 }
 
 toplevel_off: {
@@ -724,6 +728,7 @@ toplevel_off: {
         var x = 3;
         console.log(x);
     }
+    expect_stdout: true
 }
 
 toplevel_on_loops_1: {
@@ -751,6 +756,7 @@ toplevel_on_loops_1: {
             })();
         while (x);
     }
+    expect_stdout: true
 }
 
 toplevel_off_loops_1: {
@@ -779,6 +785,7 @@ toplevel_off_loops_1: {
             bar();
         while (x);
     }
+    expect_stdout: true
 }
 
 toplevel_on_loops_2: {
@@ -1121,6 +1128,7 @@ defun_label: {
             }(2));
         }();
     }
+    expect_stdout: true
 }
 
 double_reference: {
@@ -1164,6 +1172,7 @@ iife_arguments_1: {
             return f;
         });
     }
+    expect_stdout: true
 }
 
 iife_arguments_2: {
@@ -1186,6 +1195,7 @@ iife_arguments_2: {
             }() === arguments[0]);
         })();
     }
+    expect_stdout: true
 }
 
 iife_eval_1: {
@@ -1207,6 +1217,7 @@ iife_eval_1: {
             return f;
         });
     }
+    expect_stdout: true
 }
 
 iife_eval_2: {
@@ -1230,6 +1241,7 @@ iife_eval_2: {
             console.log(x() === eval("x"));
         })();
     }
+    expect_stdout: true
 }
 
 iife_func_side_effects: {
@@ -1252,3 +1264,103 @@ iife_func_side_effects: {
         })(x(), 0, z());
     }
 }
+
+issue_1595_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function f(a) {
+            return f(a + 1);
+        })(2);
+    }
+    expect: {
+        (function f(a) {
+            return f(a + 1);
+        })(2);
+    }
+}
+
+issue_1595_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function f(a) {
+            return g(a + 1);
+        })(2);
+    }
+    expect: {
+        (function(a) {
+            return g(a + 1);
+        })(2);
+    }
+}
+
+issue_1595_3: {
+    options = {
+        evaluate: true,
+        passes: 2,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function f(a) {
+            return g(a + 1);
+        })(2);
+    }
+    expect: {
+        (function(a) {
+            return g(3);
+        })();
+    }
+}
+
+issue_1595_4: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function iife(a, b, c) {
+            console.log(a, b, c);
+            if (a) iife(a - 1, b, c);
+        })(3, 4, 5);
+    }
+    expect: {
+        (function iife(a, b, c) {
+            console.log(a, b, c);
+            if (a) iife(a - 1, b, c);
+        })(3, 4, 5);
+    }
+    expect_stdout: true
+}
+
+issue_1606: {
+    options = {
+        evaluate: true,
+        hoist_vars: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f() {
+            var a;
+            function g(){};
+            var b = 2;
+            x(b);
+        }
+    }
+    expect: {
+        function f() {
+            var a, b;
+            function g(){};
+            b = 2;
+            x(b);
+        }
+    }
+}

test/compress/screw-ie8.js

@@ -1,20 +1,29 @@
 do_screw: {
-    options = { screw_ie8: true };
+    options = {
+        screw_ie8: true,
+    }
     beautify = {
         screw_ie8: true,
-        ascii_only: true
+        ascii_only: true,
-    };
+    }
-
+    input: {
-    input: f("\v");
+        f("\v");
-    expect_exact: 'f("\\v");';
+    }
+    expect_exact: 'f("\\v");'
 }
 
 dont_screw: {
-    options = { screw_ie8: false };
+    options = {
-    beautify = { screw_ie8: false, ascii_only: true };
+        screw_ie8: false,
-
+    }
-    input: f("\v");
+    beautify = {
-    expect_exact: 'f("\\x0B");';
+        screw_ie8: false,
+        ascii_only: true,
+    }
+    input: {
+        f("\v");
+    }
+    expect_exact: 'f("\\x0B");'
 }
 
 do_screw_constants: {
@@ -119,6 +128,7 @@ do_screw_try_catch_undefined: {
             return void 0===o
         }
     }
+    expect_stdout: true
 }
 
 dont_screw_try_catch_undefined: {
@@ -147,6 +157,7 @@ dont_screw_try_catch_undefined: {
             return n === undefined
         }
     }
+    expect_stdout: true
 }
 
 reduce_vars: {
@@ -199,6 +210,7 @@ issue_1586_1: {
         }
     }
     expect_exact: "function f(){try{}catch(c){console.log(c.message)}}"
+    expect_stdout: true
 }
 
 issue_1586_2: {
@@ -217,4 +229,5 @@ issue_1586_2: {
         }
     }
     expect_exact: "function f(){try{}catch(c){console.log(c.message)}}"
+    expect_stdout: true
 }

test/compress/sequences.js

@@ -86,6 +86,7 @@ make_sequences_4: {
         switch (x = 5, y) {}
         with (x = 5, obj);
     }
+    expect_stdout: true
 }
 
 lift_sequences_1: {
@@ -103,15 +104,18 @@ lift_sequences_1: {
 lift_sequences_2: {
     options = { sequences: true, evaluate: true };
     input: {
-        var foo, bar;
+        var foo = 1, bar;
         foo.x = (foo = {}, 10);
         bar = (bar = {}, 10);
+        console.log(foo, bar);
     }
     expect: {
-        var foo, bar;
+        var foo = 1, bar;
         foo.x = (foo = {}, 10),
-        bar = {}, bar = 10;
+        bar = {}, bar = 10,
+        console.log(foo, bar);
     }
+    expect_stdout: true
 }
 
 lift_sequences_3: {
@@ -138,6 +142,23 @@ lift_sequences_4: {
     }
 }
 
+lift_sequences_5: {
+    options = {
+        sequences: true,
+    }
+    input: {
+        var a = 2, b;
+        a *= (b, a = 4, 3);
+        console.log(a);
+    }
+    expect: {
+        var a = 2, b;
+        b, a *= (a = 4, 3),
+        console.log(a);
+    }
+    expect_stdout: "6"
+}
+
 for_sequences: {
     options = { sequences: true };
     input: {
@@ -230,6 +251,7 @@ negate_iife_for: {
         for (!function() {}(), i = 0; i < 5; i++) console.log(i);
         for (function() {}(); i < 5; i++) console.log(i);
     }
+    expect_stdout: true
 }
 
 iife: {

test/compress/transform.js

@@ -0,0 +1,130 @@
+booleans_evaluate: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        console.log(typeof void 0 != "undefined");
+        console.log(1 == 1, 1 === 1)
+        console.log(1 != 1, 1 !== 1)
+    }
+    expect: {
+        console.log(!1);
+        console.log(!0, !0);
+        console.log(!1, !1);
+    }
+    expect_stdout: true
+}
+
+booleans_global_defs: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        global_defs: {
+            A: true,
+        },
+    }
+    input: {
+        console.log(A == 1);
+    }
+    expect: {
+        console.log(!0);
+    }
+}
+
+condition_evaluate: {
+    options = {
+        booleans: true,
+        dead_code: false,
+        evaluate: true,
+        loops: false,
+    }
+    input: {
+        while (1 === 2);
+        for (; 1 == true;);
+        if (void 0 == null);
+    }
+    expect: {
+        while (!1);
+        for (; !0;);
+        if (!0);
+    }
+}
+
+if_else_empty: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        if ({} ? a : b); else {}
+    }
+    expect: {
+        !{} ? b : a;
+    }
+}
+
+label_if_break: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+    }
+    input: {
+        L: if (true) {
+            a;
+            break L;
+        }
+    }
+    expect: {
+        a;
+    }
+}
+
+while_if_break: {
+    options = {
+        conditionals: true,
+        loops: true,
+        sequences: true,
+    }
+    input: {
+        while (a) {
+            if (b) if(c) d;
+            if (e) break;
+        }
+    }
+    expect: {
+        for(; a && (b && c && d, !e););
+    }
+}
+
+if_return: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+    }
+    input: {
+        function f(w, x, y, z) {
+            if (x) return;
+            if (w) {
+                if (y) return;
+            } else if (z) return;
+            if (x == y) return true;
+
+            if (x) w();
+            if (y) z();
+            return true;
+        }
+    }
+    expect: {
+        function f(w, x, y, z) {
+            if (!x) {
+                if (w) {
+                    if (y) return;
+                } else if (z) return;
+                return x == y || (x && w(), y && z(), !0);
+            }
+        }
+    }
+}

test/input/invalid/assign_1.js

@@ -0,0 +1 @@
+console.log(1 || 5--);

test/input/invalid/assign_2.js

@@ -0,0 +1 @@
+console.log(2 || (Math.random() /= 2));

test/input/invalid/assign_3.js

@@ -0,0 +1 @@
+console.log(3 || ++this);

test/input/issue-1632/^{foo}[bar](baz)+$.js

@@ -0,0 +1 @@
+console.log(x);

test/mocha/cli.js

@@ -152,7 +152,7 @@ describe("bin/uglifyjs", function () {
        });
     });
     it("Should process inline source map", function(done) {
-        var command = uglifyjscmd + ' test/input/issue-520/input.js -cm toplevel --in-source-map inline --source-map-inline';
+        var command = uglifyjscmd + ' test/input/issue-520/input.js -mc toplevel --in-source-map inline --source-map-inline';
 
         exec(command, function (err, stdout) {
             if (err) throw err;
@@ -251,4 +251,59 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("Should support hyphen as shorthand", function(done) {
+       var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep-fnames=true';
+
+       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();
+       });
+    });
+    it("Should throw syntax error (5--)", function(done) {
+       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();
+       });
+    });
+    it("Should throw syntax error (Math.random() /= 2)", function(done) {
+       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();
+       });
+    });
+    it("Should throw syntax error (++this)", function(done) {
+       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,18",
+               "console.log(3 || ++this);",
+               "                  ^",
+               "SyntaxError: Invalid use of ++ operator"
+           ].join("\n"));
+           done();
+       });
+    });
 });

test/mocha/glob.js

@@ -1,5 +1,6 @@
 var Uglify = require('../../');
 var assert = require("assert");
+var path = require("path");
 
 describe("minify() with input file globs", function() {
     it("minify() with one input file glob string.", function() {
@@ -19,6 +20,39 @@ describe("minify() with input file globs", function() {
         ], {
             compress: { toplevel: true }
         });
-        assert.strictEqual(result.code, 'var print=console.log.bind(console);print("qux",function(n){return 3*n}(3),function(n){return n/2}(12)),function(n){print("Foo:",2*n)}(11);');
+        assert.strictEqual(result.code, 'var print=console.log.bind(console),a=function(n){return 3*n}(3),b=function(n){return n/2}(12);print("qux",a,b),function(n){print("Foo:",2*n)}(11);');
+    });
+    it("should throw with non-matching glob string", function() {
+        var glob = "test/input/issue-1242/blah.*";
+        assert.strictEqual(Uglify.simple_glob(glob).length, 1);
+        assert.strictEqual(Uglify.simple_glob(glob)[0], glob);
+        assert.throws(function() {
+            Uglify.minify(glob);
+        }, "should throw file not found");
+    });
+    it('"?" in glob string should not match "/"', function() {
+        var glob = "test/input?issue-1242/foo.*";
+        assert.strictEqual(Uglify.simple_glob(glob).length, 1);
+        assert.strictEqual(Uglify.simple_glob(glob)[0], glob);
+        assert.throws(function() {
+            Uglify.minify(glob);
+        }, "should throw file not found");
+    });
+    it("should handle special characters in glob string", function() {
+        var result = Uglify.minify("test/input/issue-1632/^{*}[???](*)+$.??");
+        assert.strictEqual(result.code, "console.log(x);");
+    });
+    it("should handle array of glob strings - matching and otherwise", function() {
+        var dir = "test/input/issue-1242";
+        var matches = Uglify.simple_glob([
+            path.join(dir, "b*.es5"),
+            path.join(dir, "z*.es5"),
+            path.join(dir, "*.js"),
+        ]);
+        assert.strictEqual(matches.length, 4);
+        assert.strictEqual(matches[0], path.join(dir, "bar.es5"));
+        assert.strictEqual(matches[1], path.join(dir, "baz.es5"));
+        assert.strictEqual(matches[2], path.join(dir, "z*.es5"));
+        assert.strictEqual(matches[3], path.join(dir, "qux.js"));
     });
 });

test/mocha/minify.js

@@ -78,6 +78,7 @@ describe("minify", function() {
         });
         it("Should process inline source map", function() {
             var code = Uglify.minify("./test/input/issue-520/input.js", {
+                compress: { toplevel: true },
                 inSourceMap: "inline",
                 sourceMapInline: true
             }).code + "\n";

test/mozilla-ast.js

@@ -5,7 +5,7 @@ var UglifyJS = require(".."),
     escodegen = require("escodegen"),
     esfuzz = require("esfuzz"),
     estraverse = require("estraverse"),
-    prefix = Array(20).join("\b") + "    ";
+    prefix = "\r    ";
 
 // Normalizes input AST for UglifyJS in order to get correct comparison.
 

test/run-tests.js

@@ -6,10 +6,22 @@ var U = require("../tools/node");
 var path = require("path");
 var fs = require("fs");
 var assert = require("assert");
+var vm = require("vm");
 
 var tests_dir = path.dirname(module.filename);
 var failures = 0;
 var failed_files = {};
+var same_stdout = ~process.version.lastIndexOf("v0.12.", 0) ? function(expected, actual) {
+    if (typeof expected != typeof actual) return false;
+    if (typeof expected != "string") {
+        if (expected.name != actual.name) return false;
+        expected = expected.message.slice(expected.message.lastIndexOf("\n") + 1);
+        actual = actual.message.slice(actual.message.lastIndexOf("\n") + 1);
+    }
+    return expected == actual;
+} : function(expected, actual) {
+    return typeof expected == typeof actual && expected.toString() == actual.toString();
+};
 
 run_compress_tests();
 if (failures) {
@@ -71,10 +83,15 @@ function test_directory(dir) {
 }
 
 function as_toplevel(input, mangle_options) {
-    if (input instanceof U.AST_BlockStatement) input = input.body;
+    if (!(input instanceof U.AST_BlockStatement))
-    else if (input instanceof U.AST_Statement) input = [ input ];
+        throw new Error("Unsupported input syntax");
-    else throw new Error("Unsupported input syntax");
+    for (var i = 0; i < input.body.length; i++) {
-    var toplevel = new U.AST_Toplevel({ body: input });
+        var stat = input.body[i];
+        if (stat instanceof U.AST_SimpleStatement && stat.body instanceof U.AST_String)
+            input.body[i] = new U.AST_Directive(stat.body);
+        else break;
+    }
+    var toplevel = new U.AST_Toplevel(input);
     toplevel.figure_out_scope(mangle_options);
     return toplevel;
 }
@@ -88,6 +105,23 @@ function run_compress_tests() {
         function test_case(test) {
             log_test(test.name);
             U.base54.reset();
+            var output_options = test.beautify || {};
+            var expect;
+            if (test.expect) {
+                expect = make_code(as_toplevel(test.expect, test.mangle), output_options);
+            } else {
+                expect = test.expect_exact;
+            }
+            var input = as_toplevel(test.input, test.mangle);
+            var input_code = make_code(input, output_options);
+            var input_formatted = make_code(test.input, {
+                beautify: true,
+                quote_style: 3,
+                keep_quoted_props: true
+            });
+            if (test.mangle_props) {
+                input = U.mangle_properties(input, test.mangle_props);
+            }
             var options = U.defaults(test.options, {
                 warnings: false
             });
@@ -97,25 +131,9 @@ function run_compress_tests() {
                 U.AST_Node.warn_function = function(text) {
                     warnings_emitted.push("WARN: " + text);
                 };
-                options.warnings = true;
+                if (!options.warnings) options.warnings = true;
             }
             var cmp = new U.Compressor(options, true);
-            var output_options = test.beautify || {};
-            var expect;
-            if (test.expect) {
-                expect = make_code(as_toplevel(test.expect, test.mangle), output_options);
-            } else {
-                expect = test.expect_exact;
-            }
-            var input = as_toplevel(test.input, test.mangle);
-            var input_code = make_code(test.input, {
-                beautify: true,
-                quote_style: 3,
-                keep_quoted_props: true
-            });
-            if (test.mangle_props) {
-                input = U.mangle_properties(input, test.mangle_props);
-            }
             var output = cmp.compress(input);
             output.figure_out_scope(test.mangle);
             if (test.mangle) {
@@ -125,7 +143,7 @@ function run_compress_tests() {
             output = make_code(output, output_options);
             if (expect != output) {
                 log("!!! failed\n---INPUT---\n{input}\n---OUTPUT---\n{output}\n---EXPECTED---\n{expected}\n\n", {
-                    input: input_code,
+                    input: input_formatted,
                     output: output,
                     expected: expect
                 });
@@ -138,7 +156,7 @@ function run_compress_tests() {
                     var reparsed_ast = U.parse(output);
                 } catch (ex) {
                     log("!!! Test matched expected result but cannot parse output\n---INPUT---\n{input}\n---OUTPUT---\n{output}\n--REPARSE ERROR--\n{error}\n\n", {
-                        input: input_code,
+                        input: input_formatted,
                         output: output,
                         error: ex.toString(),
                     });
@@ -157,7 +175,7 @@ function run_compress_tests() {
                     var actual_warnings = JSON.stringify(warnings_emitted);
                     if (expected_warnings != actual_warnings) {
                         log("!!! failed\n---INPUT---\n{input}\n---EXPECTED WARNINGS---\n{expected_warnings}\n---ACTUAL WARNINGS---\n{actual_warnings}\n\n", {
-                            input: input_code,
+                            input: input_formatted,
                             expected_warnings: expected_warnings,
                             actual_warnings: actual_warnings,
                         });
@@ -165,6 +183,36 @@ function run_compress_tests() {
                         failed_files[file] = 1;
                     }
                 }
+                if (test.expect_stdout) {
+                    var stdout = run_code(input_code);
+                    if (test.expect_stdout === true) {
+                        test.expect_stdout = stdout;
+                    }
+                    if (!same_stdout(test.expect_stdout, stdout)) {
+                        log("!!! Invalid input or expected stdout\n---INPUT---\n{input}\n---EXPECTED {expected_type}---\n{expected}\n---ACTUAL {actual_type}---\n{actual}\n\n", {
+                            input: input_formatted,
+                            expected_type: typeof test.expect_stdout == "string" ? "STDOUT" : "ERROR",
+                            expected: test.expect_stdout,
+                            actual_type: typeof stdout == "string" ? "STDOUT" : "ERROR",
+                            actual: stdout,
+                        });
+                        failures++;
+                        failed_files[file] = 1;
+                    } else {
+                        stdout = run_code(output);
+                        if (!same_stdout(test.expect_stdout, stdout)) {
+                            log("!!! failed\n---INPUT---\n{input}\n---EXPECTED {expected_type}---\n{expected}\n---ACTUAL {actual_type}---\n{actual}\n\n", {
+                                input: input_formatted,
+                                expected_type: typeof test.expect_stdout == "string" ? "STDOUT" : "ERROR",
+                                expected: test.expect_stdout,
+                                actual_type: typeof stdout == "string" ? "STDOUT" : "ERROR",
+                                actual: stdout,
+                            });
+                            failures++;
+                            failed_files[file] = 1;
+                        }
+                    }
+                }
             }
         }
         var tests = parse_test(path.resolve(dir, file));
@@ -214,6 +262,23 @@ function parse_test(file) {
         }));
     }
 
+    function read_string(stat) {
+        if (stat.TYPE == "SimpleStatement") {
+            var body = stat.body;
+            switch(body.TYPE) {
+              case "String":
+                return body.value;
+              case "Array":
+                return body.elements.map(function(element) {
+                    if (element.TYPE !== "String")
+                        throw new Error("Should be array of strings");
+                    return element.value;
+                }).join("\n");
+            }
+        }
+        throw new Error("Should be string or array of strings");
+    }
+
     function get_one_test(name, block) {
         var test = { name: name, options: {} };
         var tw = new U.TreeWalker(function(node, descend){
@@ -226,28 +291,26 @@ function parse_test(file) {
                 return true;
             }
             if (node instanceof U.AST_LabeledStatement) {
+                var label = node.label;
                 assert.ok(
-                    ["input", "expect", "expect_exact", "expect_warnings"].indexOf(node.label.name) >= 0,
+                    ["input", "expect", "expect_exact", "expect_warnings", "expect_stdout"].indexOf(label.name) >= 0,
                     tmpl("Unsupported label {name} [{line},{col}]", {
-                        name: node.label.name,
+                        name: label.name,
-                        line: node.label.start.line,
+                        line: label.start.line,
-                        col: node.label.start.col
+                        col: label.start.col
                     })
                 );
                 var stat = node.body;
-                if (stat instanceof U.AST_BlockStatement) {
+                if (label.name == "expect_exact") {
-                    if (stat.body.length == 1) stat = stat.body[0];
+                    test[label.name] = read_string(stat);
-                    else if (stat.body.length == 0) stat = new U.AST_EmptyStatement();
+                } else if (label.name == "expect_stdout") {
-                }
+                    if (stat.TYPE == "SimpleStatement" && stat.body instanceof U.AST_Boolean) {
-                if (node.label.name === "expect_exact") {
+                        test[label.name] = stat.body.value;
-                    if (!(stat.TYPE === "SimpleStatement" && stat.body.TYPE === "String")) {
-                        throw new Error(
-                            "The value of the expect_exact clause should be a string, " +
-                            "like `expect_exact: \"some.exact.javascript;\"`");
-                    }
-                    test[node.label.name] = stat.body.start.value
                     } else {
-                    test[node.label.name] = stat;
+                        test[label.name] = read_string(stat) + "\n";
+                    }
+                } else {
+                    test[label.name] = stat;
                 }
                 return true;
             }
@@ -269,3 +332,19 @@ function evaluate(code) {
         code = make_code(code, { beautify: true });
     return new Function("return(" + code + ")")();
 }
+
+function run_code(code) {
+    var stdout = "";
+    var original_write = process.stdout.write;
+    process.stdout.write = function(chunk) {
+        stdout += chunk;
+    };
+    try {
+        new vm.Script(code).runInNewContext({ console: console }, { timeout: 5000 });
+        return stdout;
+    } catch (ex) {
+        return ex;
+    } finally {
+        process.stdout.write = original_write;
+    }
+}

test/ufuzz.js

@@ -0,0 +1,225 @@
+// ufuzz.js
+// derived from https://github.com/qfox/uglyfuzzer by Peter van der Zee
+"use strict";
+
+// workaround for tty output truncation upon process.exit()
+[process.stdout, process.stderr].forEach(function(stream){
+    if (stream._handle && stream._handle.setBlocking)
+        stream._handle.setBlocking(true);
+});
+
+var vm = require("vm");
+var minify = require("..").minify;
+
+function run_code(code) {
+    var stdout = "";
+    var original_write = process.stdout.write;
+    process.stdout.write = function(chunk) {
+        stdout += chunk;
+    };
+    try {
+        new vm.Script(code).runInNewContext({ console: console }, { timeout: 5000 });
+        return stdout;
+    } catch (ex) {
+        return ex;
+    } finally {
+        process.stdout.write = original_write;
+    }
+}
+
+function rng(max) {
+  return Math.floor(max * Math.random());
+}
+
+function createFunctionDecls(n, recurmax) {
+  if (--recurmax < 0) { return ';'; }
+  var s = '';
+  while (--n > 0) {
+    s += createFunctionDecl(recurmax) + '\n';
+  }
+  return s;
+}
+
+var funcs = 0;
+function createFunctionDecl(recurmax) {
+  if (--recurmax < 0) { return ';'; }
+  var func = funcs++;
+  return 'function f' + func + '(){' + createStatements(3, recurmax) + '}\nf' + func + '();';
+}
+
+function createStatements(n, recurmax) {
+  if (--recurmax < 0) { return ';'; }
+  var s = '';
+  while (--n > 0) {
+    s += createStatement(recurmax);
+  }
+  return s;
+}
+
+var loops = 0;
+function createStatement(recurmax) {
+  var loop = ++loops;
+  if (--recurmax < 0) { return ';'; }
+  switch (rng(7)) {
+    case 0:
+      return '{' + createStatement(recurmax) + '}';
+    case 1:
+      return 'if (' + createExpression(recurmax) + ')' + createStatement(recurmax);
+    case 2:
+      return '{var brake' + loop + ' = 5; do {' + createStatement(recurmax) + '} while ((' + createExpression(recurmax) + ') && --brake' + loop + ' > 0);}';
+    case 3:
+      return '{var brake' + loop + ' = 5; while ((' + createExpression(recurmax) + ') && --brake' + loop + ' > 0)' + createStatement(recurmax) + '}';
+    case 4:
+      return 'for (var brake' + loop + ' = 5; (' + createExpression(recurmax) + ') && brake' + loop + ' > 0; --brake' + loop + ')' + createStatement(recurmax);
+    case 5:
+      return ';';
+    case 6:
+      return createExpression() + ';';
+  }
+}
+
+function createExpression(recurmax) {
+  if (--recurmax < 0) { return '0'; }
+  switch (rng(8)) {
+    case 0:
+      return '(' + createUnaryOp() + 'a)';
+    case 1:
+      return '(a' + (Math.random() > 0.5 ? '++' : '--') + ')';
+    case 2:
+      return '(b ' + createAssignment() + ' a)';
+    case 3:
+      return '(' + Math.random() + ' > 0.5 ? a : b)';
+    case 4:
+      return createExpression(recurmax) + createBinaryOp() + createExpression(recurmax);
+    case 5:
+      return createValue();
+    case 6:
+      return '(' + createExpression(recurmax) + ')';
+    case 7:
+      return createExpression(recurmax) + '?(' + createExpression(recurmax) + '):(' + createExpression(recurmax) + ')';
+  }
+}
+
+function createValue() {
+  var values = [
+    'true',
+    'false',
+    '22',
+    '0',
+    '(-1)',
+    'NaN',
+    'undefined',
+    'null',
+    '"foo"',
+    '"bar"' ];
+  return values[rng(values.length)];
+}
+
+function createBinaryOp() {
+  switch (rng(6)) {
+    case 0:
+      return '+';
+    case 1:
+      return '-';
+    case 2:
+      return ',';
+    case 3:
+      return '&&';
+    case 4:
+      return '||';
+    case 5:
+      return '^';
+  }
+}
+
+function createAssignment() {
+  switch (rng(4)) {
+    case 0:
+      return '=';
+    case 1:
+      return '-=';
+    case 2:
+      return '^=';
+    case 3:
+      return '+=';
+  }
+}
+
+function createUnaryOp() {
+  switch (rng(4)) {
+    case 0:
+      return '--';
+    case 1:
+      return '++';
+    case 2:
+      return '~';
+    case 3:
+      return '!';
+  }
+}
+
+function log() {
+    console.log("//=============================================================");
+    console.log("// original code");
+    console.log("//");
+    console.log(original_code);
+    console.log();
+    console.log();
+    console.log("//-------------------------------------------------------------");
+    console.log("// original code (beautify'd)");
+    console.log("//");
+    console.log(beautify_code);
+    console.log();
+    console.log();
+    console.log("//-------------------------------------------------------------");
+    console.log("// uglified code");
+    console.log("//");
+    console.log(uglify_code);
+    console.log();
+    console.log();
+    console.log("original result:");
+    console.log(original_result);
+    console.log("beautified result:");
+    console.log(beautify_result);
+    console.log("uglified result:");
+    console.log(uglify_result);
+}
+
+var num_iterations = +process.argv[2] || 1/0;
+var verbose = !!process.argv[3];
+for (var round = 0; round < num_iterations; round++) {
+    process.stdout.write(round + " of " + num_iterations + "\r");
+    var original_code = [
+        "var a = 100, b = 10;",
+        createFunctionDecls(rng(3) + 1, 10),
+        "console.log(a, b);"
+    ].join("\n");
+    var beautify_code = minify(original_code, {
+        fromString: true,
+        mangle: false,
+        compress: false,
+        output: {
+            beautify: true,
+            bracketize: true,
+        },
+    }).code;
+
+    var uglify_code = minify(beautify_code, {
+        fromString: true,
+        mangle: false,
+        compress: {
+            passes: 3,
+        },
+        output: {
+            beautify: true,
+            bracketize: true,
+        },
+    }).code;
+
+    var original_result = run_code(original_code);
+    var beautify_result = run_code(beautify_code);
+    var uglify_result = run_code(uglify_code);
+    var ok = original_result == beautify_result && original_result == uglify_result;
+    if (verbose || !ok) log();
+    if (!ok) process.exit(1);
+}

tools/exports.js

@@ -18,6 +18,6 @@ exports["tokenizer"] = tokenizer;
 exports["is_identifier"] = is_identifier;
 exports["SymbolDef"] = SymbolDef;
 
-if (typeof DEBUG !== "undefined" && DEBUG) {
+if (global.UGLIFY_DEBUG) {
     exports["EXPECT_DIRECTIVE"] = EXPECT_DIRECTIVE;
 }

tools/node.js

@@ -7,7 +7,8 @@
 var path = require("path");
 var fs = require("fs");
 
-var FILES = exports.FILES = [
+var UglifyJS = exports;
+var FILES = UglifyJS.FILES = [
     "../lib/utils.js",
     "../lib/ast.js",
     "../lib/parse.js",
@@ -20,17 +21,14 @@ var FILES = exports.FILES = [
     "../lib/propmangle.js",
     "./exports.js",
 ].map(function(file){
-    return fs.realpathSync(path.join(path.dirname(__filename), file));
+    return require.resolve(file);
 });
 
-var UglifyJS = exports;
+new Function("MOZ_SourceMap", "exports", FILES.map(function(file){
-
-new Function("MOZ_SourceMap", "exports", "DEBUG", FILES.map(function(file){
     return fs.readFileSync(file, "utf8");
 }).join("\n\n"))(
     require("source-map"),
-    UglifyJS,
+    UglifyJS
-    !!global.UGLIFY_DEBUG
 );
 
 UglifyJS.AST_Node.warn_function = function(txt) {
@@ -46,7 +44,7 @@ function read_source_map(code) {
     return JSON.parse(new Buffer(match[2], "base64"));
 }
 
-exports.minify = function(files, options) {
+UglifyJS.minify = function(files, options) {
     options = UglifyJS.defaults(options, {
         spidermonkey     : false,
         outSourceMap     : null,
@@ -181,7 +179,7 @@ exports.minify = function(files, options) {
     };
 };
 
-// exports.describe_ast = function() {
+// UglifyJS.describe_ast = function() {
 //     function doitem(ctor) {
 //         var sub = {};
 //         ctor.SUBCLASSES.forEach(function(ctor){
@@ -195,7 +193,7 @@ exports.minify = function(files, options) {
 //     return doitem(UglifyJS.AST_Node).sub;
 // }
 
-exports.describe_ast = function() {
+UglifyJS.describe_ast = function() {
     var out = UglifyJS.OutputStream({ beautify: true });
     function doitem(ctor) {
         out.print("AST_" + ctor.TYPE);
@@ -249,13 +247,13 @@ function readReservedFile(filename, reserved) {
     return reserved;
 }
 
-exports.readReservedFile = readReservedFile;
+UglifyJS.readReservedFile = readReservedFile;
 
-exports.readDefaultReservedFile = function(reserved) {
+UglifyJS.readDefaultReservedFile = function(reserved) {
-    return readReservedFile(path.join(__dirname, "domprops.json"), reserved);
+    return readReservedFile(require.resolve("./domprops.json"), reserved);
 };
 
-exports.readNameCache = function(filename, key) {
+UglifyJS.readNameCache = function(filename, key) {
     var cache = null;
     if (filename) {
         try {
@@ -273,7 +271,7 @@ exports.readNameCache = function(filename, key) {
     return cache;
 };
 
-exports.writeNameCache = function(filename, key, cache) {
+UglifyJS.writeNameCache = function(filename, key, cache) {
     if (filename) {
         var data;
         try {
@@ -294,13 +292,9 @@ exports.writeNameCache = function(filename, key, cache) {
 // Example: "foo/bar/*baz??.*.js"
 // Argument `glob` may be a string or an array of strings.
 // Returns an array of strings. Garbage in, garbage out.
-exports.simple_glob = function simple_glob(glob) {
+UglifyJS.simple_glob = function simple_glob(glob) {
-    var results = [];
     if (Array.isArray(glob)) {
-        glob.forEach(function(elem) {
+        return [].concat.apply([], glob.map(simple_glob));
-            results = results.concat(simple_glob(elem));
-        });
-        return results;
     }
     if (glob.match(/\*|\?/)) {
         var dir = path.dirname(glob);
@@ -308,28 +302,19 @@ exports.simple_glob = function simple_glob(glob) {
             var entries = fs.readdirSync(dir);
         } catch (ex) {}
         if (entries) {
-            var pattern = "^" + (path.basename(glob)
+            var pattern = "^" + path.basename(glob)
-                .replace(/\(/g, "\\(")
+                .replace(/[.+^$[\]\\(){}]/g, "\\$&")
-                .replace(/\)/g, "\\)")
-                .replace(/\{/g, "\\{")
-                .replace(/\}/g, "\\}")
-                .replace(/\[/g, "\\[")
-                .replace(/\]/g, "\\]")
-                .replace(/\+/g, "\\+")
-                .replace(/\^/g, "\\^")
-                .replace(/\$/g, "\\$")
                 .replace(/\*/g, "[^/\\\\]*")
-                .replace(/\./g, "\\.")
+                .replace(/\?/g, "[^/\\\\]") + "$";
-                .replace(/\?/g, ".")) + "$";
             var mod = process.platform === "win32" ? "i" : "";
             var rx = new RegExp(pattern, mod);
-            for (var i in entries) {
+            var results = entries.filter(function(name) {
-                if (rx.test(entries[i]))
+                return rx.test(name);
-                    results.push(dir + "/" + entries[i]);
+            }).map(function(name) {
+                return path.join(dir, name);
+            });
+            if (results.length) return results;
         }
     }
-    }
+    return [ glob ];
-    if (results.length === 0)
-        results = [ glob ];
-    return results;
 };