v2.6.1

Close #866

.travis.yml

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

README.md

@@ -134,6 +134,8 @@ The available options are:
   --mangle-props                Mangle property names
   --mangle-regex                Only mangle property names matching the regex
   --name-cache                  File to hold mangled names mappings
+  --pure-funcs                  List of functions that can be safely removed if
+                                their return value is not used           [array]
 ```
 
 Specify `--output` (`-o`) to declare the output file.  Otherwise the output
@@ -346,7 +348,7 @@ to set `true`; it's effectively a shortcut for `foo=true`).
 - `drop_console` -- default `false`.  Pass `true` to discard calls to
   `console.*` functions.
 
-- `keep_fargs` -- default `false`.  Pass `true` to prevent the
+- `keep_fargs` -- default `true`.  Prevents the
   compressor from discarding unused function arguments.  You need this
   for code which relies on `Function.length`.
 
@@ -370,7 +372,6 @@ when this flag is on:
 - `void 0` → `undefined` (if there is a variable named "undefined" in
   scope; we do it because the variable name will be mangled, typically
   reduced to a single character)
-- discards unused function arguments (affects `function.length`)
 
 ### Conditional compilation
 

bin/uglifyjs

@@ -72,6 +72,8 @@ You need to pass an argument to this option to specify the name that your module
     .describe("mangle-props", "Mangle property names")
     .describe("mangle-regex", "Only mangle property names matching the regex")
     .describe("name-cache", "File to hold mangled names mappings")
+    .describe("pure-funcs", "List of functions that can be safely removed if their return value is not used")
+    .describe("dump-spidermonkey-ast", "Dump SpiderMonkey AST to stdout.")
 
     .alias("p", "prefix")
     .alias("o", "output")
@@ -104,6 +106,7 @@ You need to pass an argument to this option to specify the name that your module
     .string("prefix")
     .string("name-cache")
     .array("reserved-file")
+    .array("pure-funcs")
 
     .boolean("expr")
     .boolean("source-map-include-sources")
@@ -115,6 +118,7 @@ You need to pass an argument to this option to specify the name that your module
     .boolean("stats")
     .boolean("acorn")
     .boolean("spidermonkey")
+    .boolean("dump-spidermonkey-ast")
     .boolean("lint")
     .boolean("V")
     .boolean("version")
@@ -175,6 +179,10 @@ if (ARGS.d) {
     if (COMPRESS) COMPRESS.global_defs = getOptions("d");
 }
 
+if (ARGS.pure_funcs) {
+    if (COMPRESS) COMPRESS.pure_funcs = ARGS.pure_funcs;
+}
+
 if (ARGS.r) {
     if (MANGLE) MANGLE.except = ARGS.r.replace(/^\s+|\s+$/g).split(/\s*,+\s*/);
 }
@@ -401,14 +409,17 @@ async.eachLimit(files, 1, function (file, cb) {
         writeNameCache("props", cache);
     })();
 
+    var SCOPE_IS_NEEDED = COMPRESS || MANGLE || ARGS.lint
     var TL_CACHE = readNameCache("vars");
 
-    time_it("scope", function(){
-        TOPLEVEL.figure_out_scope({ screw_ie8: ARGS.screw_ie8, cache: TL_CACHE });
-        if (ARGS.lint) {
-            TOPLEVEL.scope_warnings();
-        }
-    });
+    if (SCOPE_IS_NEEDED) {
+        time_it("scope", function(){
+            TOPLEVEL.figure_out_scope({ screw_ie8: ARGS.screw_ie8, cache: TL_CACHE });
+            if (ARGS.lint) {
+                TOPLEVEL.scope_warnings();
+            }
+        });
+    }
 
     if (COMPRESS) {
         time_it("squeeze", function(){
@@ -416,12 +427,14 @@ async.eachLimit(files, 1, function (file, cb) {
         });
     }
 
-    time_it("scope", function(){
-        TOPLEVEL.figure_out_scope({ screw_ie8: ARGS.screw_ie8, cache: TL_CACHE });
-        if (MANGLE && !TL_CACHE) {
-            TOPLEVEL.compute_char_frequency(MANGLE);
-        }
-    });
+    if (SCOPE_IS_NEEDED) {
+        time_it("scope", function(){
+            TOPLEVEL.figure_out_scope({ screw_ie8: ARGS.screw_ie8, cache: TL_CACHE });
+            if (MANGLE && !TL_CACHE) {
+                TOPLEVEL.compute_char_frequency(MANGLE);
+            }
+        });
+    }
 
     if (MANGLE) time_it("mangle", function(){
         MANGLE.cache = TL_CACHE;
@@ -438,26 +451,30 @@ async.eachLimit(files, 1, function (file, cb) {
         }
     }
 
-    time_it("generate", function(){
-        TOPLEVEL.print(output);
-    });
-
-    output = output.get();
-
-    if (SOURCE_MAP) {
-        fs.writeFileSync(ARGS.source_map, SOURCE_MAP, "utf8");
-        var source_map_url = ARGS.source_map_url || (
-            P_RELATIVE
-                ? path.relative(path.dirname(OUTPUT_FILE), ARGS.source_map)
-                : ARGS.source_map
-        );
-        output += "\n//# sourceMappingURL=" + source_map_url;
-    }
-
-    if (OUTPUT_FILE) {
-        fs.writeFileSync(OUTPUT_FILE, output, "utf8");
+    if (ARGS.dump_spidermonkey_ast) {
+        print(JSON.stringify(TOPLEVEL.to_mozilla_ast(), null, 2));
     } else {
-        print(output);
+        time_it("generate", function(){
+            TOPLEVEL.print(output);
+        });
+
+        output = output.get();
+
+        if (SOURCE_MAP) {
+            fs.writeFileSync(ARGS.source_map, SOURCE_MAP, "utf8");
+            var source_map_url = ARGS.source_map_url || (
+                P_RELATIVE
+                    ? path.relative(path.dirname(OUTPUT_FILE), ARGS.source_map)
+                    : ARGS.source_map
+            );
+            output += "\n//# sourceMappingURL=" + source_map_url;
+        }
+
+        if (OUTPUT_FILE) {
+            fs.writeFileSync(OUTPUT_FILE, output, "utf8");
+        } else {
+            print(output);
+        }
     }
 
     if (ARGS.stats) {

lib/ast.js

@@ -85,7 +85,7 @@ function DEFNODE(type, props, methods, base) {
     return ctor;
 };
 
-var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before file", {
+var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before file raw", {
 }, null);
 
 var AST_Node = DEFNODE("Node", "start end", {
@@ -927,27 +927,36 @@ var AST_True = DEFNODE("True", null, {
 function TreeWalker(callback) {
     this.visit = callback;
     this.stack = [];
+    this.directives = Object.create(null);
 };
 TreeWalker.prototype = {
     _visit: function(node, descend) {
-        this.stack.push(node);
+        this.push(node);
         var ret = this.visit(node, descend ? function(){
             descend.call(node);
         } : noop);
         if (!ret && descend) {
             descend.call(node);
         }
-        this.stack.pop();
+        this.pop(node);
         return ret;
     },
     parent: function(n) {
         return this.stack[this.stack.length - 2 - (n || 0)];
     },
     push: function (node) {
+        if (node instanceof AST_Lambda) {
+            this.directives = Object.create(this.directives);
+        } else if (node instanceof AST_Directive) {
+            this.directives[node.value] = this.directives[node.value] ? "up" : true;
+        }
         this.stack.push(node);
     },
-    pop: function() {
-        return this.stack.pop();
+    pop: function(node) {
+        this.stack.pop();
+        if (node instanceof AST_Lambda) {
+            this.directives = Object.getPrototypeOf(this.directives);
+        }
     },
     self: function() {
         return this.stack[this.stack.length - 1];
@@ -960,7 +969,16 @@ TreeWalker.prototype = {
         }
     },
     has_directive: function(type) {
-        return this.find_parent(AST_Scope).has_directive(type);
+        var dir = this.directives[type];
+        if (dir) return dir;
+        var node = this.stack[this.stack.length - 1];
+        if (node instanceof AST_Scope) {
+            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;
+            }
+        }
     },
     in_boolean_context: function() {
         var stack = this.stack;

lib/compress.js

@@ -199,7 +199,7 @@ merge(Compressor.prototype, {
     };
 
     function tighten_body(statements, compressor) {
-        var CHANGED;
+        var CHANGED, max_iter = 10;
         do {
             CHANGED = false;
             if (compressor.option("angular")) {
@@ -218,7 +218,7 @@ merge(Compressor.prototype, {
             if (compressor.option("join_vars")) {
                 statements = join_consecutive_vars(statements, compressor);
             }
-        } while (CHANGED);
+        } while (CHANGED && max_iter-- > 0);
 
         if (compressor.option("negate_iife")) {
             negate_iifes(statements, compressor);
@@ -384,7 +384,12 @@ merge(Compressor.prototype, {
                             continue loop;
                         }
                         //---
-                        if (ret.length == 1 && in_lambda && ret[0] instanceof AST_SimpleStatement
+                        // XXX: what was the intention of this case?
+                        // if sequences is not enabled, this can lead to an endless loop (issue #866).
+                        // however, with sequences on this helps producing slightly better output for
+                        // the example code.
+                        if (compressor.option("sequences")
+                            && ret.length == 1 && in_lambda && ret[0] instanceof AST_SimpleStatement
                             && (!stat.alternative || stat.alternative instanceof AST_SimpleStatement)) {
                             CHANGED = true;
                             ret.push(make_node(AST_Return, ret[0], {
@@ -991,7 +996,7 @@ merge(Compressor.prototype, {
     /* -----[ optimizers ]----- */
 
     OPT(AST_Directive, function(self, compressor){
-        if (self.scope.has_directive(self.value) !== self.scope) {
+        if (compressor.has_directive(self.value) === "up") {
             return make_node(AST_EmptyStatement, self);
         }
         return self;
@@ -2519,4 +2524,11 @@ merge(Compressor.prototype, {
     OPT(AST_Object, literals_in_boolean_context);
     OPT(AST_RegExp, literals_in_boolean_context);
 
+    OPT(AST_Return, function(self, compressor){
+        if (self.value instanceof AST_Undefined) {
+            self.value = null;
+        }
+        return self;
+    });
+
 })();

lib/mozilla-ast.js

@@ -146,7 +146,14 @@
               case "boolean":
                 return new (val ? AST_True : AST_False)(args);
               default:
-                args.value = val;
+                var rx = M.regex;
+                if (rx && rx.pattern) {
+                    // RegExpLiteral as per ESTree AST spec
+                    args.value = new RegExp(rx.pattern, rx.flags).toString();
+                } else {
+                    // support legacy RegExp
+                    args.value = M.regex && M.raw ? M.raw : val;
+                }
                 return new AST_RegExp(args);
             }
         },
@@ -334,6 +341,19 @@
         };
     });
 
+    def_to_moz(AST_RegExp, function To_Moz_RegExpLiteral(M) {
+        var value = M.value;
+        return {
+            type: "Literal",
+            value: value,
+            raw: value.toString(),
+            regex: {
+                pattern: value.source,
+                flags: value.toString().match(/[gimuy]*$/)[0]
+            }
+        };
+    });
+
     def_to_moz(AST_Constant, function To_Moz_Literal(M) {
         var value = M.value;
         if (typeof value === 'number' && (value < 0 || (value === 0 && 1 / value < 0))) {
@@ -343,13 +363,15 @@
                 prefix: true,
                 argument: {
                     type: "Literal",
-                    value: -value
+                    value: -value,
+                    raw: M.start.raw
                 }
             };
         }
         return {
             type: "Literal",
-            value: value
+            value: value,
+            raw: M.start.raw
         };
     });
 
@@ -369,6 +391,12 @@
 
     /* -----[ tools ]----- */
 
+    function raw_token(moznode) {
+        if (moznode.type == "Literal") {
+            return moznode.raw != null ? moznode.raw : moznode.value + "";
+        }
+    }
+
     function my_start_token(moznode) {
         var loc = moznode.loc, start = loc && loc.start;
         var range = moznode.range;
@@ -379,7 +407,8 @@
             pos     : range ? range[0] : moznode.start,
             endline : start && start.line,
             endcol  : start && start.column,
-            endpos  : range ? range[0] : moznode.start
+            endpos  : range ? range[0] : moznode.start,
+            raw     : raw_token(moznode),
         });
     };
 
@@ -393,7 +422,8 @@
             pos     : range ? range[1] : moznode.end,
             endline : end && end.line,
             endcol  : end && end.column,
-            endpos  : range ? range[1] : moznode.end
+            endpos  : range ? range[1] : moznode.end,
+            raw     : raw_token(moznode),
         });
     };
 

lib/output.js

@@ -88,13 +88,14 @@ function OutputStream(options) {
 
     function make_string(str, quote) {
         var dq = 0, sq = 0;
-        str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029\0\ufeff]/g, function(s){
+        str = str.replace(/[\\\b\f\n\r\v\t\x22\x27\u2028\u2029\0\ufeff]/g, function(s){
             switch (s) {
               case "\\": return "\\\\";
               case "\b": return "\\b";
               case "\f": return "\\f";
               case "\n": return "\\n";
               case "\r": return "\\r";
+              case "\x0B": return options.screw_ie8 ? "\\v" : "\\x0B";
               case "\u2028": return "\\u2028";
               case "\u2029": return "\\u2029";
               case '"': ++dq; return '"';
@@ -125,8 +126,11 @@ function OutputStream(options) {
 
     function encode_string(str, quote) {
         var ret = make_string(str, quote);
-        if (options.inline_script)
+        if (options.inline_script) {
             ret = ret.replace(/<\x2fscript([>\/\t\n\f\r ])/gi, "<\\/script$1");
+            ret = ret.replace(/\x3c!--/g, "\\x3c!--");
+            ret = ret.replace(/--\x3e/g, "--\\x3e");
+        }
         return ret;
     };
 
@@ -378,8 +382,13 @@ function OutputStream(options) {
         nodetype.DEFMETHOD("_codegen", generator);
     };
 
+    var use_asm = false;
+
     AST_Node.DEFMETHOD("print", function(stream, force_parens){
-        var self = this, generator = self._codegen;
+        var self = this, generator = self._codegen, prev_use_asm = use_asm;
+        if (self instanceof AST_Directive && self.value == "use asm") {
+            use_asm = true;
+        }
         function doit() {
             self.add_comments(stream);
             self.add_source_map(stream);
@@ -392,6 +401,9 @@ function OutputStream(options) {
             doit();
         }
         stream.pop_node();
+        if (self instanceof AST_Lambda) {
+            use_asm = prev_use_asm;
+        }
     });
 
     AST_Node.DEFMETHOD("print_to_string", function(options){
@@ -1045,16 +1057,24 @@ function OutputStream(options) {
         output.print(self.operator);
     });
     DEFPRINT(AST_Binary, function(self, output){
+        var op = self.operator;
         self.left.print(output);
-        output.space();
-        output.print(self.operator);
-        if (self.operator == "<"
+        if (op[0] == ">" /* ">>" ">>>" ">" ">=" */
+            && self.left instanceof AST_UnaryPostfix
+            && self.left.operator == "--") {
+            // space is mandatory to avoid outputting -->
+            output.print(" ");
+        } else {
+            // the space is optional depending on "beautify"
+            output.space();
+        }
+        output.print(op);
+        if ((op == "<" || op == "<<")
             && self.right instanceof AST_UnaryPrefix
             && self.right.operator == "!"
             && self.right.expression instanceof AST_UnaryPrefix
             && self.right.expression.operator == "--") {
             // space is mandatory to avoid outputting <!--
-            // http://javascript.spec.whatwg.org/#comment-syntax
             output.print(" ");
         } else {
             // the space is optional depending on "beautify"
@@ -1158,10 +1178,8 @@ function OutputStream(options) {
         output.print_string(self.getValue(), self.quote);
     });
     DEFPRINT(AST_Number, function(self, output){
-        if (self.literal !== undefined
-            && +self.literal === self.value  /* paranoid check */
-            && self.scope && self.scope.has_directive('use asm')) {
-            output.print(self.literal);
+        if (use_asm && self.start.raw != null) {
+            output.print(self.start.raw);
         } else {
             output.print(make_num(self.getValue()));
         }
@@ -1340,6 +1358,12 @@ function OutputStream(options) {
     DEFMAP(AST_Finally, basic_sourcemap_gen);
     DEFMAP(AST_Definitions, basic_sourcemap_gen);
     DEFMAP(AST_Constant, basic_sourcemap_gen);
+    DEFMAP(AST_ObjectSetter, function(self, output){
+        output.add_mapping(self.start, self.key.name);
+    });
+    DEFMAP(AST_ObjectGetter, function(self, output){
+        output.add_mapping(self.start, self.key.name);
+    });
     DEFMAP(AST_ObjectProperty, function(self, output){
         output.add_mapping(self.start, self.key);
     });

lib/parse.js

@@ -59,7 +59,6 @@ var OPERATOR_CHARS = makePredicate(characters("+-*&%=<>!?|~^"));
 
 var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
 var RE_OCT_NUMBER = /^0[0-7]+$/;
-var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i;
 
 var OPERATORS = makePredicate([
     "in",
@@ -182,8 +181,9 @@ function parse_js_number(num) {
         return parseInt(num.substr(2), 16);
     } else if (RE_OCT_NUMBER.test(num)) {
         return parseInt(num.substr(1), 8);
-    } else if (RE_DEC_NUMBER.test(num)) {
-        return parseFloat(num);
+    } else {
+        var val = parseFloat(num);
+        if (val == num) return val;
     }
 };
 
@@ -285,6 +285,9 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             nlb     : S.newline_before,
             file    : filename
         };
+        if (/^(?:num|string|regexp)$/i.test(type)) {
+            ret.raw = $TEXT.substring(ret.pos, ret.endpos);
+        }
         if (!is_comment) {
             ret.comments_before = S.comments_before;
             S.comments_before = [];
@@ -335,11 +338,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         if (prefix) num = prefix + num;
         var valid = parse_js_number(num);
         if (!isNaN(valid)) {
-            var tok = token("num", valid);
-            if (num.indexOf('.') >= 0) {
-                tok.literal = num;
-            }
-            return tok;
+            return token("num", valid);
         } else {
             parse_error("Invalid syntax: " + num);
         }
@@ -1152,7 +1151,7 @@ function parse($TEXT, options) {
             ret = _make_symbol(AST_SymbolRef);
             break;
           case "num":
-            ret = new AST_Number({ start: tok, end: tok, value: tok.value, literal: tok.literal });
+            ret = new AST_Number({ start: tok, end: tok, value: tok.value });
             break;
           case "string":
             ret = new AST_String({

lib/scope.js

@@ -92,6 +92,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     // pass 1: setup scope chaining and handle definitions
     var self = this;
     var scope = self.parent_scope = null;
+    var labels = new Dictionary();
     var defun = null;
     var nesting = 0;
     var tw = new TreeWalker(function(node, descend){
@@ -108,20 +109,24 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             node.init_scope_vars(nesting);
             var save_scope = node.parent_scope = scope;
             var save_defun = defun;
+            var save_labels = labels;
             defun = scope = node;
+            labels = new Dictionary();
             ++nesting; descend(); --nesting;
             scope = save_scope;
             defun = save_defun;
+            labels = save_labels;
             return true;        // don't descend again in TreeWalker
         }
-        if (node instanceof AST_Directive) {
-            node.scope = scope;
-            push_uniq(scope.directives, node.value);
-            return true;
-        }
-        if (node instanceof AST_Number) {
-            node.scope = scope;
-            return true;
+        if (node instanceof AST_LabeledStatement) {
+            var l = node.label;
+            if (labels.has(l.name)) {
+                throw new Error(string_template("Label {name} defined twice", l));
+            }
+            labels.set(l.name, l);
+            descend();
+            labels.del(l.name);
+            return true;        // no descend again
         }
         if (node instanceof AST_With) {
             for (var s = scope; s; s = s.parent_scope)
@@ -131,6 +136,10 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
         if (node instanceof AST_Symbol) {
             node.scope = scope;
         }
+        if (node instanceof AST_Label) {
+            node.thedef = node;
+            node.references = [];
+        }
         if (node instanceof AST_SymbolLambda) {
             defun.def_function(node);
         }
@@ -152,6 +161,15 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             (options.screw_ie8 ? scope : defun)
                 .def_variable(node);
         }
+        else if (node instanceof AST_LabelRef) {
+            var sym = labels.get(node.name);
+            if (!sym) throw new Error(string_template("Undefined label {name} [{line},{col}]", {
+                name: node.name,
+                line: node.start.line,
+                col: node.start.col
+            }));
+            node.thedef = sym;
+        }
     });
     self.walk(tw);
 
@@ -166,6 +184,10 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             func = prev_func;
             return true;
         }
+        if (node instanceof AST_LoopControl && node.label) {
+            node.label.thedef.references.push(node);
+            return true;
+        }
         if (node instanceof AST_SymbolRef) {
             var name = node.name;
             var sym = node.scope.find_variable(name);
@@ -202,7 +224,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
 });
 
 AST_Scope.DEFMETHOD("init_scope_vars", function(nesting){
-    this.directives = [];     // contains the directives defined in this scope, i.e. "use strict"
     this.variables = new Dictionary(); // map name to AST_SymbolVar (variables defined in this scope; includes functions)
     this.functions = new Dictionary(); // map name to AST_SymbolDefun (functions defined in this scope)
     this.uses_with = false;   // will be set to true if this or some nested scope uses the `with` statement
@@ -213,10 +234,6 @@ AST_Scope.DEFMETHOD("init_scope_vars", function(nesting){
     this.nesting = nesting;   // the nesting level of this scope (0 means toplevel)
 });
 
-AST_Scope.DEFMETHOD("strict", function(){
-    return this.has_directive("use strict");
-});
-
 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
     AST_Scope.prototype.init_scope_vars.apply(this, arguments);
     this.uses_arguments = false;
@@ -240,11 +257,6 @@ AST_Scope.DEFMETHOD("find_variable", function(name){
         || (this.parent_scope && this.parent_scope.find_variable(name));
 });
 
-AST_Scope.DEFMETHOD("has_directive", function(value){
-    return this.parent_scope && this.parent_scope.has_directive(value)
-        || (this.directives.indexOf(value) >= 0 ? this : null);
-});
-
 AST_Scope.DEFMETHOD("def_function", function(symbol){
     this.functions.set(symbol.name, this.def_variable(symbol));
 });

lib/transform.js

@@ -70,7 +70,7 @@ TreeTransformer.prototype = new TreeWalker;
                     if (y !== undefined) x = y;
                 }
             }
-            tw.pop();
+            tw.pop(this);
             return x;
         });
     };

npm-shrinkwrap.json

@@ -115,9 +115,9 @@
       "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.2.tgz"
     },
     "yargs": {
-      "version": "3.5.4",
-      "from": "yargs@>=3.5.4 <3.6.0",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-3.5.4.tgz"
+      "version": "3.10.0",
+      "from": "yargs@>=3.10.0 <3.11.0",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-3.10.0.tgz"
     },
     "zeparser": {
       "version": "0.0.7",

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.5.0",
+  "version": "2.6.1",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -32,7 +32,7 @@
     "async": "~0.2.6",
     "source-map": "~0.5.1",
     "uglify-to-browserify": "~1.0.0",
-    "yargs": "~3.5.4"
+    "yargs": "~3.10.0"
   },
   "devDependencies": {
     "acorn": "~0.6.0",

test/compress/html_comments.js

@@ -0,0 +1,71 @@
+html_comment_in_expression: {
+    input: {
+        function f(a, b, x, y) { return a < !--b && x-- > y; }
+    }
+    expect_exact: "function f(a,b,x,y){return a< !--b&&x-- >y}";
+}
+
+html_comment_in_less_than: {
+    input: {
+        function f(a, b) { return a < !--b; }
+    }
+    expect_exact: "function f(a,b){return a< !--b}";
+}
+
+html_comment_in_left_shift: {
+    input: {
+        function f(a, b) { return a << !--b; }
+    }
+    expect_exact: "function f(a,b){return a<< !--b}";
+}
+
+html_comment_in_right_shift: {
+    input: {
+        function f(a, b) { return a-- >> b; }
+    }
+    expect_exact: "function f(a,b){return a-- >>b}";
+}
+
+html_comment_in_zero_fill_right_shift: {
+    input: {
+        function f(a, b) { return a-- >>> b; }
+    }
+    expect_exact: "function f(a,b){return a-- >>>b}";
+}
+
+html_comment_in_greater_than: {
+    input: {
+        function f(a, b) { return a-- > b; }
+    }
+    expect_exact: "function f(a,b){return a-- >b}";
+}
+
+html_comment_in_greater_than_or_equal: {
+    input: {
+        function f(a, b) { return a-- >= b; }
+    }
+    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-->"; }
+    }
+    expect_exact: 'function f(){return"\\x3c!--HTML--\\x3ecomment in\\x3c!--string literal--\\x3e"}';
+}

test/compress/return_undefined.js

@@ -0,0 +1,124 @@
+return_undefined: {
+    options = {
+        sequences     : false,
+        if_return     : true,
+        evaluate      : true,
+        dead_code     : true,
+        conditionals  : true,
+        comparisons   : true,
+        booleans      : true,
+        unused        : true,
+        side_effects  : true,
+        properties    : true,
+        drop_debugger : true,
+        loops         : true,
+        hoist_funs    : true,
+        keep_fargs    : true,
+        keep_fnames   : false,
+        hoist_vars    : true,
+        join_vars     : true,
+        cascade       : true,
+        negate_iife   : true
+    };
+    input: {
+        function f0() {
+        }
+        function f1() {
+            return undefined;
+        }
+        function f2() {
+            return void 0;
+        }
+        function f3() {
+            return void 123;
+        }
+        function f4() {
+            return;
+        }
+        function f5(a, b) {
+            console.log(a, b);
+            baz(a);
+            return;
+        }
+        function f6(a, b) {
+            console.log(a, b);
+            if (a) {
+                foo(b);
+                baz(a);
+                return a + b;
+            }
+            return undefined;
+        }
+        function f7(a, b) {
+            console.log(a, b);
+            if (a) {
+                foo(b);
+                baz(a);
+                return void 0;
+            }
+            return a + b;
+        }
+        function f8(a, b) {
+            foo(a);
+            bar(b);
+            return void 0;
+        }
+        function f9(a, b) {
+            foo(a);
+            bar(b);
+            return undefined;
+        }
+        function f10() {
+            return false;
+        }
+        function f11() {
+            return null;
+        }
+        function f12() {
+            return 0;
+        }
+    }
+    expect: {
+        function f0() {}
+        function f1() {}
+        function f2() {}
+        function f3() {}
+        function f4() {}
+        function f5(a, b) {
+            console.log(a, b);
+            baz(a);
+        }
+        function f6(a, b) {
+            console.log(a, b);
+            if (a) {
+                foo(b);
+                baz(a);
+                return a + b;
+            }
+        }
+        function f7(a, b) {
+            console.log(a, b);
+            if (!a)
+                return a + b;
+            foo(b);
+            baz(a);
+        }
+        function f8(a, b) {
+            foo(a);
+            bar(b);
+        }
+        function f9(a, b) {
+            foo(a);
+            bar(b);
+        }
+        function f10() {
+            return !1;
+        }
+        function f11() {
+            return null;
+        }
+        function f12() {
+            return 0;
+        }
+    }
+}

test/compress/screw-ie8.js

@@ -0,0 +1,18 @@
+do_screw: {
+    options = { screw_ie8: true };
+    beautify = {
+        screw_ie8: true,
+        ascii_only: true
+    };
+
+    input: f("\v");
+    expect_exact: 'f("\\v");';
+}
+
+dont_screw: {
+    options = { screw_ie8: false };
+    beautify = { screw_ie8: false, ascii_only: true };
+
+    input: f("\v");
+    expect_exact: 'f("\\x0B");';
+}

test/run-tests.js

@@ -4,7 +4,6 @@ var U = require("../tools/node");
 var path = require("path");
 var fs = require("fs");
 var assert = require("assert");
-var sys = require("util");
 
 var tests_dir = path.dirname(module.filename);
 var failures = 0;
@@ -12,11 +11,14 @@ var failed_files = {};
 
 run_compress_tests();
 if (failures) {
-    sys.error("\n!!! Failed " + failures + " test cases.");
-    sys.error("!!! " + Object.keys(failed_files).join(", "));
+    console.error("\n!!! Failed " + failures + " test cases.");
+    console.error("!!! " + Object.keys(failed_files).join(", "));
     process.exit(1);
 }
 
+var run_sourcemaps_tests = require('./sourcemaps');
+run_sourcemaps_tests();
+
 var run_ast_conversion_tests = require("./mozilla-ast");
 
 run_ast_conversion_tests({
@@ -84,20 +86,21 @@ function run_compress_tests() {
                 warnings: false
             });
             var cmp = new U.Compressor(options, true);
+            var output_options = test.beautify || {};
             var expect;
             if (test.expect) {
-                expect = make_code(as_toplevel(test.expect), false);
+                expect = make_code(as_toplevel(test.expect), output_options);
             } else {
                 expect = test.expect_exact;
             }
             var input = as_toplevel(test.input);
-            var input_code = make_code(test.input);
+            var input_code = make_code(test.input, { beautify: true });
             if (test.mangle_props) {
                 input = U.mangle_properties(input, test.mangle_props);
             }
             var output = input.transform(cmp);
             output.figure_out_scope();
-            output = make_code(output, false);
+            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,
@@ -141,7 +144,7 @@ function parse_test(file) {
             file: file,
             line: node.start.line,
             col: node.start.col,
-            code: make_code(node, false)
+            code: make_code(node, { beautify: false })
         }));
     }
 
@@ -188,15 +191,15 @@ function parse_test(file) {
     };
 }
 
-function make_code(ast, beautify) {
-    if (arguments.length == 1) beautify = true;
-    var stream = U.OutputStream({ beautify: beautify });
+function make_code(ast, options) {
+    options.inline_script = true;
+    var stream = U.OutputStream(options);
     ast.print(stream);
     return stream.get();
 }
 
 function evaluate(code) {
     if (code instanceof U.AST_Node)
-        code = make_code(code);
+        code = make_code(code, { beautify: true });
     return new Function("return(" + code + ")")();
 }

test/sourcemaps.js

@@ -0,0 +1,40 @@
+var UglifyJS = require("..");
+var ok = require("assert");
+
+module.exports = function () {
+    console.log("--- Sourcemaps tests");
+
+    var basic = source_map([
+        'var x = 1 + 1;'
+    ].join('\n'));
+
+    ok.equal(basic.version, 3);
+    ok.deepEqual(basic.names, ['x']);
+
+    var issue836 = source_map([
+        "({",
+        "    get enabled() {",
+        "        return 3;",
+        "    },",
+        "    set enabled(x) {",
+        "        ;",
+        "    }",
+        "});",
+    ].join("\n"));
+
+    ok.deepEqual(issue836.names, ['enabled', 'x']);
+}
+
+function source_map(js) {
+    var source_map = UglifyJS.SourceMap();
+    var stream = UglifyJS.OutputStream({ source_map: source_map });
+    var parsed = UglifyJS.parse(js);
+    parsed.print(stream);
+    return JSON.parse(source_map.toString());
+}
+
+// Run standalone
+if (module.parent === null) {
+    module.exports();
+}
+

tools/node.js

@@ -45,7 +45,6 @@ exports.minify = function(files, options) {
     UglifyJS.base54.reset();
 
     // 1. parse
-    var haveScope = false;
     var toplevel = null,
         sourcesContent = {};
 
@@ -74,7 +73,6 @@ exports.minify = function(files, options) {
         var compress = { warnings: options.warnings };
         UglifyJS.merge(compress, options.compress);
         toplevel.figure_out_scope();
-        haveScope = true;
         var sq = UglifyJS.Compressor(compress);
         toplevel = toplevel.transform(sq);
     }
@@ -82,17 +80,11 @@ exports.minify = function(files, options) {
     // 3. mangle
     if (options.mangle) {
         toplevel.figure_out_scope(options.mangle);
-        haveScope = true;
         toplevel.compute_char_frequency(options.mangle);
         toplevel.mangle_names(options.mangle);
     }
 
-    // 4. scope (if needed)
-    if (!haveScope) {
-        toplevel.figure_out_scope();
-    }
-
-    // 5. output
+    // 4. output
     var inMap = options.inSourceMap;
     var output = {};
     if (typeof options.inSourceMap == "string") {