v2.7.5

If using `inSourceMap` this fix will ensure the copying of `sourcesContent` is based on potentially normalized `sources` values (https://github.com/mozilla/source-map/blob/master/lib/source-map-consumer.js#L304-L309).

For example `normalize` (https://github.com/mozilla/source-map/blob/master/lib/util.js#L80-L123) will rewrite `./dist/mySource.js` to `dist/mySource.js` in the target `_sources` of the `SourceMapConsumer`. As a result `orig_map.sourceContentFor(source, true);` would return `null` since the orginal `source` was no longer available in the consumer. By using the keys generating from the `SourceMapConsumer.constructor` consistency is ensured.

README.md

@@ -62,6 +62,7 @@ The available options are:
   --source-map-include-sources  Pass this flag if you want to include the
                                 content of source files in the source map as
                                 sourcesContent property.
+  --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.
@@ -97,8 +98,8 @@ The available options are:
                                 "@preserve". You can optionally pass one of the
                                 following arguments to this flag:
                                 - "all" to keep all comments
-                                - a valid JS regexp (needs to start with a
+                                - a valid JS RegExp like `/foo/` or `/^!/` to
-                                slash) to keep only comments that match.
+                                keep only matching comments.
                                 Note that currently not *all* comments can be
                                 kept when compression is on, because of dead
                                 code removal or cascading statements into
@@ -284,6 +285,21 @@ of mangled property names.
 Using the name cache is not necessary if you compress all your files in a
 single call to UglifyJS.
 
+#### Debugging property name mangling
+
+You can also pass `--mangle-props-debug` in order to mangle property names
+without completely obscuring them. For example the property `o.foo`
+would mangle to `o._$foo$_` with this option. This allows property mangling
+of a large codebase while still being able to debug the code and identify
+where mangling is breaking things.
+
+You can also pass a custom suffix using `--mangle-props-debug=XYZ`. This would then
+mangle `o.foo` to `o._$foo$XYZ_`. You can change this each time you compile a
+script to identify how a property got mangled. One technique is to pass a
+random number on every compile to simulate mangling changing with different
+inputs (e.g. as you update the input script with new properties), and to help
+identify mistakes like writing mangled keys to storage.
+
 ## Compressor options
 
 You need to pass `--compress` (`-c`) to enable the compressor.  Optionally
@@ -348,6 +364,9 @@ to set `true`; it's effectively a shortcut for `foo=true`).
 - `collapse_vars` -- default `false`. Collapse single-use `var` and `const`
   definitions when possible.
 
+- `reduce_vars` -- default `false`. Improve optimization on variables assigned
+  with and used as constant values.
+
 - `warnings` -- display warnings when dropping unreachable code or unused
   declarations etc.
 
@@ -632,13 +651,22 @@ To generate a source map with the fromString option, you can also use an object:
 ```javascript
 var result = UglifyJS.minify({"file1.js": "var a = function () {};"}, {
   outSourceMap: "out.js.map",
+  outFileName: "out.js",
   fromString: true
 });
 ```
 
 Note that the source map is not saved in a file, it's just returned in
-`result.map`.  The value passed for `outSourceMap` is only used to set the
+`result.map`.  The value passed for `outSourceMap` is only used to set
-`file` attribute in the source map (see [the spec][sm-spec]).
+`//# sourceMappingURL=out.js.map` in `result.code`. The value of
+`outFileName` is only used to set `file` attribute in source map file.
+
+The `file` attribute in the source map (see [the spec][sm-spec]) will
+use `outFileName` firstly, if it's falsy, then will be deduced from
+`outSourceMap` (by removing `'.map'`).
+
+You can set option `sourceMapInline` to be `true` and source map will
+be appended to code.
 
 You can also specify sourceRoot property to be included in source map:
 ```javascript
@@ -743,6 +771,7 @@ Other options:
 
  - `regex` — Pass a RegExp to only mangle certain names (maps to the `--mangle-regex` CLI arguments option)
  - `ignore_quoted` – Only mangle unquoted property names (maps to the `--mangle-props 2` CLI arguments option)
+ - `debug` – Mangle names with the original name still present (maps to the `--mangle-props-debug` CLI arguments option). Defaults to `false`. Pass an empty string to enable, or a non-empty string to set the suffix.
 
 We could add more options to `UglifyJS.minify` — if you need additional
 functionality please suggest!
@@ -849,8 +878,11 @@ which we care about here are `source_map` and `comments`.
 #### Keeping comments in the output
 
 In order to keep certain comments in the output you need to pass the
-`comments` option.  Pass a RegExp or a function.  If you pass a RegExp, only
+`comments` option.  Pass a RegExp (as string starting and closing with `/`
-those comments whose body matches the regexp will be kept.  Note that body
+or pass a RegExp object), a boolean or a function.  Stringified options
+`all` and `some` can be passed too, where `some` behaves like it's cli
+equivalent `--comments` without passing a value. If you pass a RegExp,
+only those comments whose body matches the RegExp will be kept.  Note that body
 means without the initial `//` or `/*`.  If you pass a function, it will be
 called for every comment in the tree and will receive two arguments: the
 node that the comment is attached to, and the comment token itself.

bin/uglifyjs

@@ -23,6 +23,7 @@ mangling you need to use `-c` and `-m`.\
     .describe("source-map", "Specify an output file where to generate source map.")
     .describe("source-map-root", "The path to the original source to be included in the source map.")
     .describe("source-map-url", "The path to the source map to be added in //# sourceMappingURL.  Defaults to the value passed with --source-map.")
+    .describe("source-map-inline", "Write base64-encoded source map to the end of js output.  Disabled by default")
     .describe("source-map-include-sources", "Pass this flag if you want to include the content of source files in the source map as sourcesContent property.")
     .describe("in-source-map", "Input source map, useful if you're compressing JS that was generated from some other original code.")
     .describe("screw-ie8", "Do not support Internet Explorer 6-8 quirks. This flag is enabled by default.")
@@ -46,7 +47,7 @@ Use -c with no argument to use the default compression options.")
 By default this works like Google Closure, keeping JSDoc-style comments that contain \"@license\" or \"@preserve\". \
 You can optionally pass one of the following arguments to this flag:\n\
 - \"all\" to keep all comments\n\
-- a valid JS regexp (needs to start with a slash) to keep only comments that match.\n\
+- a valid JS RegExp like `/foo/`or `/^!/` to keep only matching comments.\n\
 \
 Note that currently not *all* comments can be kept when compression is on, \
 because of dead code removal or cascading statements into sequences.")
@@ -76,6 +77,7 @@ You need to pass an argument to this option to specify the name that your module
     .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.")
+    .describe("wrap-iife", "Wrap IIFEs in parenthesis. Note: this disables the negate_iife compression option")
 
     .alias("p", "prefix")
     .alias("o", "output")
@@ -96,6 +98,7 @@ You need to pass an argument to this option to specify the name that your module
     .string("beautify")
     .string("m")
     .string("mangle")
+    .string("mangle-props-debug")
     .string("c")
     .string("compress")
     .string("d")
@@ -112,6 +115,7 @@ You need to pass an argument to this option to specify the name that your module
     .array("pure-funcs")
 
     .boolean("expr")
+    .boolean("source-map-inline")
     .boolean("source-map-include-sources")
     .boolean("screw-ie8")
     .boolean("support-ie8")
@@ -130,6 +134,7 @@ You need to pass an argument to this option to specify the name that your module
     .boolean("bare-returns")
     .boolean("keep-fnames")
     .boolean("reserve-domprops")
+    .boolean("wrap-iife")
 
     .wrap(80)
 
@@ -247,28 +252,18 @@ if (ARGS.keep_fnames) {
     if (MANGLE) MANGLE.keep_fnames = true;
 }
 
+if (ARGS.wrap_iife) {
+    if (COMPRESS) COMPRESS.negate_iife = false;
+    OUTPUT_OPTIONS.wrap_iife = true;
+}
+
 if (BEAUTIFY)
     UglifyJS.merge(OUTPUT_OPTIONS, BEAUTIFY);
 
-if (ARGS.comments != null) {
+if (ARGS.comments === "") {
-    if (/^\/.*\/[a-zA-Z]*$/.test(ARGS.comments)) {
+    OUTPUT_OPTIONS.comments = "some";
-        try {
+} else {
-            OUTPUT_OPTIONS.comments = extractRegex(ARGS.comments);
+    OUTPUT_OPTIONS.comments = ARGS.comments;
-        } catch (e) {
-            print_error("ERROR: Invalid --comments: " + e.message);
-        }
-    } else if (ARGS.comments == "all") {
-        OUTPUT_OPTIONS.comments = true;
-    } else {
-        OUTPUT_OPTIONS.comments = function(node, comment) {
-            var text = comment.value;
-            var type = comment.type;
-            if (type == "comment2") {
-                // multiline comment
-                return /@preserve|@license|@cc_on/i.test(text);
-            }
-        }
-    }
 }
 
 var files = ARGS._.slice();
@@ -317,7 +312,7 @@ var TOPLEVEL = null;
 var P_RELATIVE = ARGS.p && ARGS.p == "relative";
 var SOURCES_CONTENT = {};
 
-var SOURCE_MAP = ARGS.source_map ? UglifyJS.SourceMap({
+var SOURCE_MAP = (ARGS.source_map || ARGS.source_map_inline) ? UglifyJS.SourceMap({
     file: P_RELATIVE ? path.relative(path.dirname(ARGS.source_map), OUTPUT_FILE) : OUTPUT_FILE,
     root: ARGS.source_map_root,
     orig: ORIG_MAP,
@@ -425,7 +420,8 @@ async.eachLimit(files, 1, function (file, cb) {
             cache         : cache,
             only_cache    : !ARGS.mangle_props,
             regex         : regex,
-            ignore_quoted : ARGS.mangle_props == 2
+            ignore_quoted : ARGS.mangle_props == 2,
+            debug         : typeof ARGS.mangle_props_debug === "undefined" ? false : ARGS.mangle_props_debug
         });
         writeNameCache("props", cache);
     })();
@@ -482,13 +478,18 @@ async.eachLimit(files, 1, function (file, cb) {
         output = output.get();
 
         if (SOURCE_MAP) {
-            fs.writeFileSync(ARGS.source_map, SOURCE_MAP, "utf8");
+            if (ARGS.source_map_inline) {
-            var source_map_url = ARGS.source_map_url || (
+                var base64_string = new Buffer(SOURCE_MAP.toString()).toString('base64');
-                P_RELATIVE
+                output += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + base64_string;
-                    ? path.relative(path.dirname(OUTPUT_FILE), ARGS.source_map)
+            } else {
-                    : ARGS.source_map
+                fs.writeFileSync(ARGS.source_map, SOURCE_MAP, "utf8");
-            );
+                var source_map_url = ARGS.source_map_url || (
-            output += "\n//# sourceMappingURL=" + 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) {

lib/compress.js

@@ -67,6 +67,7 @@ function Compressor(options, false_by_default) {
         if_return     : !false_by_default,
         join_vars     : !false_by_default,
         collapse_vars : false,
+        reduce_vars   : false,
         cascade       : !false_by_default,
         side_effects  : !false_by_default,
         pure_getters  : false,
@@ -831,6 +832,13 @@ merge(Compressor.prototype, {
         };
 
         function negate_iifes(statements, compressor) {
+            function is_iife_call(node) {
+                if (node instanceof AST_Call) {
+                    return node.expression instanceof AST_Function || is_iife_call(node.expression);
+                }
+                return false;
+            }
+
             statements.forEach(function(stat){
                 if (stat instanceof AST_SimpleStatement) {
                     stat.body = (function transform(thing) {
@@ -838,7 +846,7 @@ merge(Compressor.prototype, {
                             if (node instanceof AST_New) {
                                 return node;
                             }
-                            if (node instanceof AST_Call && node.expression instanceof AST_Function) {
+                            if (is_iife_call(node)) {
                                 return make_node(AST_UnaryPrefix, node, {
                                     operator: "!",
                                     expression: node
@@ -908,7 +916,7 @@ merge(Compressor.prototype, {
     (function (def){
         var unary_bool = [ "!", "delete" ];
         var binary_bool = [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ];
-        def(AST_Node, function(){ return false });
+        def(AST_Node, return_false);
         def(AST_UnaryPrefix, function(){
             return member(this.operator, unary_bool);
         });
@@ -926,16 +934,16 @@ merge(Compressor.prototype, {
         def(AST_Seq, function(){
             return this.cdr.is_boolean();
         });
-        def(AST_True, function(){ return true });
+        def(AST_True, return_true);
-        def(AST_False, function(){ return true });
+        def(AST_False, return_true);
     })(function(node, func){
         node.DEFMETHOD("is_boolean", func);
     });
 
     // methods to determine if an expression has a string result type
     (function (def){
-        def(AST_Node, function(){ return false });
+        def(AST_Node, return_false);
-        def(AST_String, function(){ return true });
+        def(AST_String, return_true);
         def(AST_UnaryPrefix, function(){
             return this.operator == "typeof";
         });
@@ -1100,7 +1108,7 @@ merge(Compressor.prototype, {
             this._evaluating = true;
             try {
                 var d = this.definition();
-                if (d && d.constant && d.init) {
+                if (d && (d.constant || compressor.option("reduce_vars") && !d.modified) && d.init) {
                     return ev(d.init, compressor);
                 }
             } finally {
@@ -1189,11 +1197,11 @@ merge(Compressor.prototype, {
 
     // determine if expression has side effects
     (function(def){
-        def(AST_Node, function(compressor){ return true });
+        def(AST_Node, return_true);
 
-        def(AST_EmptyStatement, function(compressor){ return false });
+        def(AST_EmptyStatement, return_false);
-        def(AST_Constant, function(compressor){ return false });
+        def(AST_Constant, return_false);
-        def(AST_This, function(compressor){ return false });
+        def(AST_This, return_false);
 
         def(AST_Call, function(compressor){
             var pure = compressor.option("pure_funcs");
@@ -1213,13 +1221,13 @@ merge(Compressor.prototype, {
         def(AST_SimpleStatement, function(compressor){
             return this.body.has_side_effects(compressor);
         });
-        def(AST_Defun, function(compressor){ return true });
+        def(AST_Defun, return_true);
-        def(AST_Function, function(compressor){ return false });
+        def(AST_Function, return_false);
         def(AST_Binary, function(compressor){
             return this.left.has_side_effects(compressor)
                 || this.right.has_side_effects(compressor);
         });
-        def(AST_Assign, function(compressor){ return true });
+        def(AST_Assign, return_true);
         def(AST_Conditional, function(compressor){
             return this.condition.has_side_effects(compressor)
                 || this.consequent.has_side_effects(compressor)
@@ -2306,6 +2314,12 @@ merge(Compressor.prototype, {
                 // typeof always returns a non-empty string, thus it's
                 // always true in booleans
                 compressor.warn("Boolean expression always true [{file}:{line},{col}]", self.start);
+                if (self.expression.has_side_effects(compressor)) {
+                    return make_node(AST_Seq, self, {
+                        car: self.expression,
+                        cdr: make_node(AST_True, self)
+                    });
+                }
                 return make_node(AST_True, self);
             }
             if (e instanceof AST_Binary && self.operator == "!") {
@@ -2492,8 +2506,8 @@ merge(Compressor.prototype, {
           case "+":
             var ll = self.left.evaluate(compressor);
             var rr = self.right.evaluate(compressor);
-            if ((ll.length > 1 && ll[0] instanceof AST_String && ll[1]) ||
+            if ((ll.length > 1 && ll[0] instanceof AST_String && ll[1] && !self.right.has_side_effects(compressor)) ||
-                (rr.length > 1 && rr[0] instanceof AST_String && rr[1])) {
+                (rr.length > 1 && rr[0] instanceof AST_String && rr[1] && !self.left.has_side_effects(compressor))) {
                 compressor.warn("+ in boolean context always true [{file}:{line},{col}]", self.start);
                 return make_node(AST_True, self);
             }
@@ -2648,16 +2662,26 @@ merge(Compressor.prototype, {
     });
 
     var ASSIGN_OPS = [ '+', '-', '/', '*', '%', '>>', '<<', '>>>', '|', '^', '&' ];
+    var ASSIGN_OPS_COMMUTATIVE = [ '*', '|', '^', '&' ];
     OPT(AST_Assign, function(self, compressor){
         self = self.lift_sequences(compressor);
-        if (self.operator == "="
+        if (self.operator == "=" && self.left instanceof AST_SymbolRef && self.right instanceof AST_Binary) {
-            && self.left instanceof AST_SymbolRef
+            // x = expr1 OP expr2
-            && self.right instanceof AST_Binary
+            if (self.right.left instanceof AST_SymbolRef
-            && self.right.left instanceof AST_SymbolRef
+                && self.right.left.name == self.left.name
-            && self.right.left.name == self.left.name
+                && member(self.right.operator, ASSIGN_OPS)) {
-            && member(self.right.operator, ASSIGN_OPS)) {
+                // x = x - 2  --->  x -= 2
-            self.operator = self.right.operator + "=";
+                self.operator = self.right.operator + "=";
-            self.right = self.right.right;
+                self.right = self.right.right;
+            }
+            else if (self.right.right instanceof AST_SymbolRef
+                && self.right.right.name == self.left.name
+                && member(self.right.operator, ASSIGN_OPS_COMMUTATIVE)
+                && !self.right.left.has_side_effects(compressor)) {
+                // x = 2 & x  --->  x &= 2
+                self.operator = self.right.operator + "=";
+                self.right = self.right.left;
+            }
         }
         return self;
     });

lib/output.js

@@ -45,6 +45,20 @@
 
 var EXPECT_DIRECTIVE = /^$|[;{][\s\n]*$/;
 
+function is_some_comments(comment) {
+    var text = comment.value;
+    var type = comment.type;
+    if (type == "comment2") {
+        // multiline comment
+        return /@preserve|@license|@cc_on/i.test(text);
+    }
+    return type == "comment5";
+}
+
+function is_comment5(comment) {
+    return comment.type == "comment5";
+}
+
 function OutputStream(options) {
 
     options = defaults(options, {
@@ -67,9 +81,38 @@ function OutputStream(options) {
         screw_ie8        : true,
         preamble         : null,
         quote_style      : 0,
-        keep_quoted_props: false
+        keep_quoted_props: false,
+        wrap_iife        : false,
     }, true);
 
+    // Convert comment option to RegExp if neccessary and set up comments filter
+    var comment_filter = options.shebang ? is_comment5 : return_false; // Default case, throw all comments away except shebangs
+    if (options.comments) {
+        var comments = options.comments;
+        if (typeof options.comments === "string" && /^\/.*\/[a-zA-Z]*$/.test(options.comments)) {
+            var regex_pos = options.comments.lastIndexOf("/");
+            comments = new RegExp(
+                options.comments.substr(1, regex_pos - 1),
+                options.comments.substr(regex_pos + 1)
+            );
+        }
+        if (comments instanceof RegExp) {
+            comment_filter = function(comment) {
+                return comment.type == "comment5" || comments.test(comment.value);
+            };
+        }
+        else if (typeof comments === "function") {
+            comment_filter = function(comment) {
+                return comment.type == "comment5" || comments(this, comment);
+            };
+        }
+        else if (comments === "some") {
+            comment_filter = is_some_comments;
+        } else { // NOTE includes "all" option
+            comment_filter = return_true;
+        }
+    }
+
     var indentation = 0;
     var current_col = 0;
     var current_line = 1;
@@ -376,6 +419,7 @@ function OutputStream(options) {
         with_square     : with_square,
         add_mapping     : add_mapping,
         option          : function(opt) { return options[opt] },
+        comment_filter  : comment_filter,
         line            : function() { return current_line },
         col             : function() { return current_col },
         pos             : function() { return current_pos },
@@ -435,7 +479,7 @@ function OutputStream(options) {
 
     AST_Node.DEFMETHOD("add_comments", function(output){
         if (output._readonly) return;
-        var c = output.option("comments"), self = this;
+        var self = this;
         var start = self.start;
         if (start && !start._comments_dumped) {
             start._comments_dumped = true;
@@ -458,19 +502,7 @@ function OutputStream(options) {
                 }));
             }
 
-            if (!c) {
+            comments = comments.filter(output.comment_filter, self);
-                comments = comments.filter(function(comment) {
-                    return comment.type == "comment5";
-                });
-            } else if (c.test) {
-                comments = comments.filter(function(comment){
-                    return comment.type == "comment5" || c.test(comment.value);
-                });
-            } else if (typeof c == "function") {
-                comments = comments.filter(function(comment){
-                    return comment.type == "comment5" || c(self, comment);
-                });
-            }
 
             // Keep single line comments after nlb, after nlb
             if (!output.option("beautify") && comments.length > 0 &&
@@ -521,7 +553,16 @@ function OutputStream(options) {
     // a function expression needs parens around it when it's provably
     // the first token to appear in a statement.
     PARENS(AST_Function, function(output){
-        return first_in_statement(output);
+        if (first_in_statement(output)) {
+            return true;
+        }
+
+        if (output.option('wrap_iife')) {
+            var p = output.parent();
+            return p instanceof AST_Call && p.expression === this;
+        }
+
+        return false;
     });
 
     // same goes for an object literal, because otherwise it would be

lib/propmangle.js

@@ -66,7 +66,8 @@ function mangle_properties(ast, options) {
         cache : null,
         only_cache : false,
         regex : null,
-        ignore_quoted : false
+        ignore_quoted : false,
+        debug : false
     });
 
     var reserved = options.reserved;
@@ -84,6 +85,15 @@ function mangle_properties(ast, options) {
     var regex = options.regex;
     var ignore_quoted = options.ignore_quoted;
 
+    // note debug is either false (disabled), or a string of the debug suffix to use (enabled).
+    // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
+    // the same as passing an empty string.
+    var debug = (options.debug !== false);
+    var debug_name_suffix;
+    if (debug) {
+        debug_name_suffix = (options.debug === true ? "" : options.debug);
+    }
+
     var names_to_mangle = [];
     var unmangleable = [];
     var ignored = {};
@@ -177,9 +187,25 @@ function mangle_properties(ast, options) {
 
         var mangled = cache.props.get(name);
         if (!mangled) {
-            do {
+            if (debug) {
-                mangled = base54(++cache.cname);
+                // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_.
-            } while (!can_mangle(mangled));
+                var debug_mangled = "_$" + name + "$" + debug_name_suffix + "_";
+
+                if (can_mangle(debug_mangled) && !(ignore_quoted && debug_mangled in ignored)) {
+                    mangled = debug_mangled;
+                }
+            }
+
+            // either debug mode is off, or it is on and we could not use the mangled name
+            if (!mangled) {
+                // note can_mangle() does not check if the name collides with the 'ignored' set
+                // (filled with quoted properties when ignore_quoted set). Make sure we add this
+                // check so we don't collide with a quoted name.
+                do {
+                    mangled = base54(++cache.cname);
+                } while (!can_mangle(mangled) || (ignore_quoted && mangled in ignored));
+            }
+
             cache.props.set(name, mangled);
         }
         return mangled;

lib/scope.js

@@ -197,12 +197,16 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
         }
         if (node instanceof AST_SymbolRef) {
             var name = node.name;
-            if (name == "eval" && tw.parent() instanceof AST_Call) {
+            var parent = tw.parent();
+            if (name == "eval" && parent instanceof AST_Call) {
                 for (var s = node.scope; s && !s.uses_eval; s = s.parent_scope) {
                     s.uses_eval = true;
                 }
             }
             var sym = node.scope.find_variable(name);
+            if (node.scope instanceof AST_Lambda && name == "arguments") {
+                node.scope.uses_arguments = true;
+            }
             if (!sym) {
                 var g;
                 if (globals.has(name)) {
@@ -213,12 +217,12 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
                     g.global = true;
                     globals.set(name, g);
                 }
-                node.thedef = g;
+                sym = g;
-                if (func && name == "arguments") {
+            }
-                    func.uses_arguments = true;
+            node.thedef = sym;
-                }
+            if (parent instanceof AST_Unary && (parent.operator === '++' || parent.operator === '--')
-            } else {
+             || parent instanceof AST_Assign && parent.left === node) {
-                node.thedef = sym;
+                sym.modified = true;
             }
             node.reference();
             return true;

lib/sourcemap.js

@@ -60,7 +60,7 @@ function SourceMap(options) {
     var orig_map = options.orig && new MOZ_SourceMap.SourceMapConsumer(options.orig);
 
     if (orig_map && Array.isArray(options.orig.sources)) {
-        options.orig.sources.forEach(function(source) {
+        orig_map._sources.toArray().forEach(function(source) {
             var sourceContent = orig_map.sourceContentFor(source, true);
             if (sourceContent) {
                 generator.setSourceContent(source, sourceContent);

lib/utils.js

@@ -112,6 +112,8 @@ function merge(obj, ext) {
 };
 
 function noop() {};
+function return_false() { return false; }
+function return_true() { return true; }
 
 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.7.1",
+  "version": "2.7.5",
   "engines": {
     "node": ">=0.8.0"
   },

test/compress/asm.js

@@ -90,13 +90,13 @@ asm_mixed: {
         }
         function no_asm_GeometricMean(stdlib, foreign, buffer) {
             function logSum(start, end) {
-                start = 0 | start, end = 0 | end;
+                start |= 0, end |= 0;
                 var sum = 0, p = 0, q = 0;
                 for (p = start << 3, q = end << 3; (0 | p) < (0 | q); p = p + 8 | 0) sum += +log(values[p >> 3]);
                 return +sum;
             }
             function geometricMean(start, end) {
-                return start = 0 | start, end = 0 | end, +exp(+logSum(start, end) / +(end - start | 0));
+                return start |= 0, end |= 0, +exp(+logSum(start, end) / +(end - start | 0));
             }
             var exp = stdlib.Math.exp, log = stdlib.Math.log, values = new stdlib.Float64Array(buffer);
             return { geometricMean: geometricMean };

test/compress/assignment.js

@@ -0,0 +1,238 @@
+op_equals_left_local_var: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var x;
+
+        x = x +   3;
+        x = x -   3;
+        x = x /   3;
+        x = x *   3;
+        x = x >>  3;
+        x = x <<  3;
+        x = x >>> 3;
+        x = x |   3;
+        x = x ^   3;
+        x = x %   3;
+        x = x &   3;
+
+        x = x +   g();
+        x = x -   g();
+        x = x /   g();
+        x = x *   g();
+        x = x >>  g();
+        x = x <<  g();
+        x = x >>> g();
+        x = x |   g();
+        x = x ^   g();
+        x = x %   g();
+        x = x &   g();
+    }
+    expect: {
+        var x;
+
+        x   += 3;
+        x   -= 3;
+        x   /= 3;
+        x   *= 3;
+        x  >>= 3;
+        x  <<= 3;
+        x >>>= 3;
+        x   |= 3;
+        x   ^= 3;
+        x   %= 3;
+        x   &= 3;
+
+        x   += g();
+        x   -= g();
+        x   /= g();
+        x   *= g();
+        x  >>= g();
+        x  <<= g();
+        x >>>= g();
+        x   |= g();
+        x   ^= g();
+        x   %= g();
+        x   &= g();
+    }
+}
+
+op_equals_right_local_var: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var x;
+
+        x = (x -= 2) ^ x;
+
+        x = 3 +   x;
+        x = 3 -   x;
+        x = 3 /   x;
+        x = 3 *   x;
+        x = 3 >>  x;
+        x = 3 <<  x;
+        x = 3 >>> x;
+        x = 3 |   x;
+        x = 3 ^   x;
+        x = 3 %   x;
+        x = 3 &   x;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+    expect: {
+        var x;
+
+        x = (x -= 2) ^ x;
+
+        x = 3 + x;
+        x = 3 - x;
+        x = 3 / x;
+        x *= 3;
+        x = 3 >> x;
+        x = 3 << x;
+        x = 3 >>> x;
+        x |= 3;
+        x ^= 3;
+        x = 3 % x;
+        x &= 3;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+}
+op_equals_left_global_var: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        x = x +   3;
+        x = x -   3;
+        x = x /   3;
+        x = x *   3;
+        x = x >>  3;
+        x = x <<  3;
+        x = x >>> 3;
+        x = x |   3;
+        x = x ^   3;
+        x = x %   3;
+        x = x &   3;
+
+        x = x +   g();
+        x = x -   g();
+        x = x /   g();
+        x = x *   g();
+        x = x >>  g();
+        x = x <<  g();
+        x = x >>> g();
+        x = x |   g();
+        x = x ^   g();
+        x = x %   g();
+        x = x &   g();
+    }
+    expect: {
+        x   += 3;
+        x   -= 3;
+        x   /= 3;
+        x   *= 3;
+        x  >>= 3;
+        x  <<= 3;
+        x >>>= 3;
+        x   |= 3;
+        x   ^= 3;
+        x   %= 3;
+        x   &= 3;
+
+        x   += g();
+        x   -= g();
+        x   /= g();
+        x   *= g();
+        x  >>= g();
+        x  <<= g();
+        x >>>= g();
+        x   |= g();
+        x   ^= g();
+        x   %= g();
+        x   &= g();
+    }
+}
+
+op_equals_right_global_var: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        x = (x -= 2) ^ x;
+
+        x = 3 +   x;
+        x = 3 -   x;
+        x = 3 /   x;
+        x = 3 *   x;
+        x = 3 >>  x;
+        x = 3 <<  x;
+        x = 3 >>> x;
+        x = 3 |   x;
+        x = 3 ^   x;
+        x = 3 %   x;
+        x = 3 &   x;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+    expect: {
+        x = (x -= 2) ^ x;
+
+        x = 3 +   x;
+        x = 3 -   x;
+        x = 3 /   x;
+        x *= 3;
+        x = 3 >>  x;
+        x = 3 <<  x;
+        x = 3 >>> x;
+        x |= 3;
+        x ^= 3;
+        x = 3 %   x;
+        x &= 3;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+}

test/compress/issue-1275.js

@@ -0,0 +1,49 @@
+string_plus_optimization: {
+    options = {
+        side_effects  : true,
+        evaluate      : true,
+        conditionals  : true,
+        comparisons   : true,
+        dead_code     : true,
+        booleans      : true,
+        unused        : true,
+        if_return     : true,
+        join_vars     : true,
+        cascade       : true,
+        hoist_funs    : true,
+    };
+    input: {
+        function foo(anything) {
+            function throwing_function() {
+                throw "nope";
+            }
+            try {
+                console.log('0' + throwing_function() ? "yes" : "no");
+            } catch (ex) {
+                console.log(ex);
+            }
+            console.log('0' + anything ? "yes" : "no");
+            console.log(anything + '0' ? "Yes" : "No");
+            console.log('' + anything);
+            console.log(anything + '');
+        }
+        foo();
+    }
+    expect: {
+        function foo(anything) {
+            function throwing_function() {
+                throw "nope";
+            }
+            try {
+                console.log('0' + throwing_function() ? "yes" : "no");
+            } catch (ex) {
+                console.log(ex);
+            }
+            console.log("yes");
+            console.log("Yes");
+            console.log('' + anything);
+            console.log(anything + '');
+        }
+        foo();
+    }
+}

test/compress/issue-1321.js

@@ -0,0 +1,54 @@
+issue_1321_no_debug: {
+    mangle_props = {
+        ignore_quoted: true
+    }
+    input: {
+        var x = {};
+        x.foo = 1;
+        x["a"] = 2 * x.foo;
+        console.log(x.foo, x["a"]);
+    }
+    expect: {
+        var x = {};
+        x.b = 1;
+        x["a"] = 2 * x.b;
+        console.log(x.b, x["a"]);
+    }
+}
+
+issue_1321_debug: {
+    mangle_props = {
+        ignore_quoted: true,
+        debug: ""
+    }
+    input: {
+        var x = {};
+        x.foo = 1;
+        x["_$foo$_"] = 2 * x.foo;
+        console.log(x.foo, x["_$foo$_"]);
+    }
+    expect: {
+        var x = {};
+        x.a = 1;
+        x["_$foo$_"] = 2 * x.a;
+        console.log(x.a, x["_$foo$_"]);
+    }
+}
+
+issue_1321_with_quoted: {
+    mangle_props = {
+        ignore_quoted: false
+    }
+    input: {
+        var x = {};
+        x.foo = 1;
+        x["a"] = 2 * x.foo;
+        console.log(x.foo, x["a"]);
+    }
+    expect: {
+        var x = {};
+        x.a = 1;
+        x["b"] = 2 * x.a;
+        console.log(x.a, x["b"]);
+    }
+}

test/compress/negate-iife.js

@@ -130,3 +130,45 @@ negate_iife_issue_1073: {
         }(7))();
     }
 }
+
+issue_1254_negate_iife_false: {
+    options = {
+        negate_iife: false,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: '(function(){return function(){console.log("test")}})()();'
+}
+
+issue_1254_negate_iife_true: {
+    options = {
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: '!function(){return function(){console.log("test")}}()();'
+}
+
+issue_1254_negate_iife_nested: {
+    options = {
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()()()()();
+    }
+    expect_exact: '!function(){return function(){console.log("test")}}()()()()();'
+}

test/compress/new.js

@@ -75,3 +75,10 @@ call_with_unary_arguments: {
     }
     expect_exact: "x();x(-1);x(-1,-2);x(void 1,+2,-3,~4,!5,--a,++b,c--,d++,typeof e,delete f);(-1)();(-1)(-2);"
 }
+
+new_with_unary_prefix: {
+    input: {
+        var bar = (+new Date()).toString(32);
+    }
+    expect_exact: 'var bar=(+new Date).toString(32);';
+}

test/compress/properties.js

@@ -142,6 +142,98 @@ mangle_unquoted_properties: {
     }
 }
 
+mangle_debug: {
+    mangle_props = {
+        debug: ""
+    };
+    input: {
+        a.foo = "bar";
+        x = { baz: "ban" };
+    }
+    expect: {
+        a._$foo$_ = "bar";
+        x = { _$baz$_: "ban" };
+    }
+}
+
+mangle_debug_true: {
+    mangle_props = {
+        debug: true
+    };
+    input: {
+        a.foo = "bar";
+        x = { baz: "ban" };
+    }
+    expect: {
+        a._$foo$_ = "bar";
+        x = { _$baz$_: "ban" };
+    }
+}
+
+mangle_debug_suffix: {
+    mangle_props = {
+        debug: "XYZ"
+    };
+    input: {
+        a.foo = "bar";
+        x = { baz: "ban" };
+    }
+    expect: {
+        a._$foo$XYZ_ = "bar";
+        x = { _$baz$XYZ_: "ban" };
+    }
+}
+
+mangle_debug_suffix_ignore_quoted: {
+    options = {
+        properties: false
+    }
+    mangle_props = {
+        ignore_quoted: true,
+        debug: "XYZ",
+        reserved: []
+    }
+    beautify = {
+        beautify: false,
+        quote_style: 3,
+        keep_quoted_props: true,
+    }
+    input: {
+        a.top = 1;
+        function f1() {
+            a["foo"] = "bar";
+            a.color = "red";
+            a.stuff = 2;
+            x = {"bar": 10, size: 7};
+            a.size = 9;
+        }
+        function f2() {
+            a.foo = "bar";
+            a['color'] = "red";
+            x = {bar: 10, size: 7};
+            a.size = 9;
+            a.stuff = 3;
+        }
+    }
+    expect: {
+        a._$top$XYZ_ = 1;
+        function f1() {
+            a["foo"] = "bar";
+            a.color = "red";
+            a._$stuff$XYZ_ = 2;
+            x = {"bar": 10, _$size$XYZ_: 7};
+            a._$size$XYZ_ = 9;
+        }
+        function f2() {
+            a.foo = "bar";
+            a['color'] = "red";
+            x = {bar: 10, _$size$XYZ_: 7};
+            a._$size$XYZ_ = 9;
+            a._$stuff$XYZ_ = 3;
+        }
+    }
+}
+
 first_256_chars_as_properties: {
     beautify = {
         ascii_only: true,

test/compress/reduce_vars.js

@@ -0,0 +1,171 @@
+reduce_vars: {
+    options = {
+        conditionals  : true,
+        evaluate      : true,
+        global_defs   : {
+            C : 0
+        },
+        reduce_vars   : true,
+        unused        : true
+    }
+    input: {
+        var A = 1;
+        (function f0() {
+            var a = 2;
+            console.log(a - 5);
+            console.log(A - 5);
+        })();
+        (function f1() {
+            var a = 2;
+            console.log(a - 5);
+            eval("console.log(a);");
+        })();
+        (function f2(eval) {
+            var a = 2;
+            console.log(a - 5);
+            eval("console.log(a);");
+        })(eval);
+        (function f3() {
+            var b = typeof C !== "undefined";
+            var c = 4;
+            if (b) {
+                return 'yes';
+            } else {
+                return 'no';
+            }
+        })();
+        console.log(A + 1);
+    }
+    expect: {
+        var A = 1;
+        (function() {
+            console.log(-3);
+            console.log(-4);
+        })();
+        (function f1() {
+            var a = 2;
+            console.log(-3);
+            eval("console.log(a);");
+        })();
+        (function f2(eval) {
+            var a = 2;
+            console.log(-3);
+            eval("console.log(a);");
+        })(eval);
+        (function() {
+            return "yes";
+        })();
+        console.log(2);
+    }
+}
+
+modified: {
+    options = {
+        conditionals  : true,
+        evaluate      : true,
+        reduce_vars   : true,
+        unused        : true
+    }
+    input: {
+        function f0() {
+            var a = 1, b = 2;
+            b++;
+            console.log(a + 1);
+            console.log(b + 1);
+        }
+
+        function f1() {
+            var a = 1, b = 2;
+            --b;
+            console.log(a + 1);
+            console.log(b + 1);
+        }
+
+        function f2() {
+            var a = 1, b = 2, c = 3;
+            b = c;
+            console.log(a + b);
+            console.log(b + c);
+            console.log(a + c);
+            console.log(a + b + c);
+        }
+
+        function f3() {
+            var a = 1, b = 2, c = 3;
+            b *= c;
+            console.log(a + b);
+            console.log(b + c);
+            console.log(a + c);
+            console.log(a + b + c);
+        }
+
+        function f4() {
+            var a = 1, b = 2, c = 3;
+            if (a) {
+                b = c;
+            } else {
+                c = b;
+            }
+            console.log(a + b);
+            console.log(b + c);
+            // TODO: as "modified" is determined in "figure_out_scope",
+            // even "passes" wouldn't improve this any further
+            console.log(a + c);
+            console.log(a + b + c);
+        }
+
+        function f5(a) {
+            B = a;
+            console.log(A ? 'yes' : 'no');
+            console.log(B ? 'yes' : 'no');
+        }
+    }
+    expect: {
+        function f0() {
+            var b = 2;
+            b++;
+            console.log(2);
+            console.log(b + 1);
+        }
+
+        function f1() {
+            var b = 2;
+            --b;
+            console.log(2);
+            console.log(b + 1);
+        }
+
+        function f2() {
+            var a = 1, b = 2, c = 3;
+            b = c;
+            console.log(a + b);
+            console.log(b + c);
+            console.log(4);
+            console.log(a + b + c);
+        }
+
+        function f3() {
+            var a = 1, b = 2, c = 3;
+            b *= c;
+            console.log(a + b);
+            console.log(b + c);
+            console.log(4);
+            console.log(a + b + c);
+        }
+
+        function f4() {
+            var a = 1, b = 2, c = 3;
+            b = c;
+            console.log(a + b);
+            console.log(b + c);
+            console.log(a + c);
+            console.log(a + b + c);
+        }
+
+        function f5(a) {
+            B = a;
+            console.log(A ? 'yes' : 'no');
+            console.log(B ? 'yes' : 'no');
+        }
+   }
+}

test/compress/screw-ie8.js

@@ -15,4 +15,116 @@ dont_screw: {
 
     input: f("\v");
     expect_exact: 'f("\\x0B");';
-}
+}
+
+do_screw_try_catch: {
+    options = { screw_ie8: true };
+    mangle = { screw_ie8: true };
+    beautify = { screw_ie8: true };
+    input: {
+        good = function(e){
+            return function(error){
+                try{
+                    e()
+                } catch(e) {
+                    error(e)
+                }
+            }
+        };
+    }
+    expect: {
+        good = function(n){
+            return function(t){
+                try{
+                    n()
+                } catch(n) {
+                    t(n)
+                }
+            }
+        };
+    }
+}
+
+dont_screw_try_catch: {
+    options = { screw_ie8: false };
+    mangle = { screw_ie8: false };
+    beautify = { screw_ie8: false };
+    input: {
+        bad = function(e){
+            return function(error){
+                try{
+                    e()
+                } catch(e) {
+                    error(e)
+                }
+            }
+        };
+    }
+    expect: {
+        bad = function(n){
+            return function(n){
+                try{
+                    t()
+                } catch(t) {
+                    n(t)
+                }
+            }
+        };
+    }
+}
+
+do_screw_try_catch_undefined: {
+    options = { screw_ie8: true };
+    mangle = { screw_ie8: true };
+    beautify = { screw_ie8: true };
+    input: {
+        function a(b){
+            try {
+                throw 'Stuff';
+            } catch (undefined) {
+                console.log('caught: ' + undefined);
+            }
+            console.log('undefined is ' + undefined);
+            return b === undefined;
+        };
+    }
+    expect: {
+        function a(o){
+            try{
+                throw "Stuff"
+            } catch (o) {
+                console.log("caught: "+o)
+            }
+            console.log("undefined is " + void 0);
+            return void 0===o
+        }
+    }
+}
+
+dont_screw_try_catch_undefined: {
+    options = { screw_ie8: false };
+    mangle = { screw_ie8: false };
+    beautify = { screw_ie8: false };
+    input: {
+        function a(b){
+            try {
+                throw 'Stuff';
+            } catch (undefined) {
+                console.log('caught: ' + undefined);
+            }
+            console.log('undefined is ' + undefined);
+            return b === undefined;
+        };
+    }
+    expect: {
+        function a(o){
+            try{
+                throw "Stuff"
+            } catch (n) {
+                console.log("caught: "+n)
+            }
+            console.log("undefined is " + void 0);
+            return void 0===o
+        }
+    }
+}

test/compress/typeof.js

@@ -23,3 +23,25 @@ typeof_evaluation: {
         h='undefined';
     }
 }
+
+typeof_in_boolean_context: {
+    options = {
+        booleans     : true,
+        evaluate     : true,
+        conditionals : true,
+    };
+    input: {
+        function f1(x) { return typeof x ? "yes" : "no"; }
+        function f2() { return typeof g()? "Yes" : "No"; }
+        typeof 0 ? foo() : bar();
+        !typeof console.log(1);
+        var a = !typeof console.log(2);
+    }
+    expect: {
+        function f1(x) { return "yes"; }
+        function f2() { return g(), "Yes"; }
+        foo();
+        !(console.log(1), !0);
+        var a = !(console.log(2), !0);
+    }
+}

test/compress/wrap_iife.js

@@ -0,0 +1,48 @@
+wrap_iife: {
+    options = {
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: '(function(){return function(){console.log("test")}})()();'
+}
+
+wrap_iife_in_expression: {
+    options = {
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        foo = (function () {
+            return bar();
+        })();
+    }
+    expect_exact: 'foo=(function(){return bar()})();'
+}
+
+wrap_iife_in_return_call: {
+    options = {
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        (function() {
+            return (function() {
+                console.log('test')
+            })();
+        })()();
+    }
+    expect_exact: '(function(){return(function(){console.log("test")})()})()();'
+}

test/input/comments/filter.js

@@ -0,0 +1,3 @@
+// foo
+/*@preserve*/
+// bar

test/input/issue-1323/sample.js

@@ -0,0 +1,7 @@
+var bar = (function () {
+    function foo (bar) {
+        return bar;
+    }
+
+    return foo;
+})();

test/mocha/arguments.js

@@ -19,4 +19,12 @@ describe("arguments", function() {
             value // Select function as scope
         );
     });
+
+    it("Should recognize when a function uses arguments", function() {
+        var ast = UglifyJS.parse("function a(){function b(){function c(){}; return arguments[0];}}");
+        ast.figure_out_scope();
+        assert.strictEqual(ast.body[0].uses_arguments, false);
+        assert.strictEqual(ast.body[0].body[0].uses_arguments, true);
+        assert.strictEqual(ast.body[0].body[0].body[0].uses_arguments, false);
+    });
 });

test/mocha/cli.js

@@ -2,11 +2,11 @@ var assert = require("assert");
 var exec = require("child_process").exec;
 
 describe("bin/uglifyjs", function () {
+    var uglifyjscmd = '"' + process.argv[0] + '" bin/uglifyjs';
     it("should produce a functional build when using --self", function (done) {
         this.timeout(5000);
 
-        var uglifyjs = '"' + process.argv[0] + '" bin/uglifyjs';
+        var command = uglifyjscmd + ' --self -cm --wrap WrappedUglifyJS';
-        var command = uglifyjs + ' --self -cm --wrap WrappedUglifyJS';
 
         exec(command, function (err, stdout) {
             if (err) throw err;
@@ -19,4 +19,55 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("Should be able to filter comments correctly with `--comment all`", function (done) {
+        var command = uglifyjscmd + ' test/input/comments/filter.js --comments all';
+
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, "// foo\n/*@preserve*/\n// bar\n\n");
+            done();
+        });
+    });
+    it("Should be able to filter comments correctly with `--comment <RegExp>`", function (done) {
+        var command = uglifyjscmd + ' test/input/comments/filter.js --comments /r/';
+
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, "/*@preserve*/\n// bar\n\n");
+            done();
+        });
+    });
+    it("Should be able to filter comments correctly with just `--comment`", function (done) {
+        var command = uglifyjscmd + ' test/input/comments/filter.js --comments';
+
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, "/*@preserve*/\n\n");
+            done();
+        });
+    });
+    it("Should append source map to output when using --source-map-inline", function (done) {
+       var command = uglifyjscmd + ' test/input/issue-1323/sample.js --source-map-inline';
+
+       exec(command, function (err, stdout) {
+           if (err) throw err;
+
+           assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n" + 
+               "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=\n");
+           done();
+       });
+    });
+    it("should not append source map to output when not using --source-map-inline", function (done) {
+        var command = uglifyjscmd + ' test/input/issue-1323/sample.js';
+
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n");
+            done();
+        });
+    });
 });

test/mocha/comment-filter.js

@@ -2,11 +2,21 @@ var UglifyJS = require('../../');
 var assert = require("assert");
 
 describe("comment filters", function() {
-    it("Should be able to filter comments by passing regex", function() {
+    it("Should be able to filter comments by passing regexp", function() {
         var ast = UglifyJS.parse("/*!test1*/\n/*test2*/\n//!test3\n//test4\n<!--test5\n<!--!test6\n-->test7\n-->!test8");
         assert.strictEqual(ast.print_to_string({comments: /^!/}), "/*!test1*/\n//!test3\n//!test6\n//!test8\n");
     });
 
+    it("Should be able to filter comments with the 'all' option", function() {
+        var ast = UglifyJS.parse("/*!test1*/\n/*test2*/\n//!test3\n//test4\n<!--test5\n<!--!test6\n-->test7\n-->!test8");
+        assert.strictEqual(ast.print_to_string({comments: "all"}), "/*!test1*/\n/*test2*/\n//!test3\n//test4\n//test5\n//!test6\n//test7\n//!test8\n");
+    });
+
+    it("Should be able to filter commments with the 'some' option", function() {
+        var ast = UglifyJS.parse("// foo\n/*@preserve*/\n// bar\n/*@license*/\n//@license with the wrong comment type\n/*@cc_on something*/");
+        assert.strictEqual(ast.print_to_string({comments: "some"}), "/*@preserve*/\n/*@license*/\n/*@cc_on something*/\n");
+    });
+
     it("Should be able to filter comments by passing a function", function() {
         var ast = UglifyJS.parse("/*TEST 123*/\n//An other comment\n//8 chars.");
         var f = function(node, comment) {
@@ -16,6 +26,11 @@ describe("comment filters", function() {
         assert.strictEqual(ast.print_to_string({comments: f}), "/*TEST 123*/\n//8 chars.\n");
     });
 
+    it("Should be able to filter comments by passing regex in string format", function() {
+        var ast = UglifyJS.parse("/*!test1*/\n/*test2*/\n//!test3\n//test4\n<!--test5\n<!--!test6\n-->test7\n-->!test8");
+        assert.strictEqual(ast.print_to_string({comments: "/^!/"}), "/*!test1*/\n//!test3\n//!test6\n//!test8\n");
+    });
+
     it("Should be able to get the comment and comment type when using a function", function() {
         var ast = UglifyJS.parse("/*!test1*/\n/*test2*/\n//!test3\n//test4\n<!--test5\n<!--!test6\n-->test7\n-->!test8");
         var f = function(node, comment) {
@@ -42,4 +57,19 @@ describe("comment filters", function() {
 
         assert.strictEqual(ast.print_to_string({comments: f}), "#!Random comment\n//test1\n/*test2*/\n");
     });
+
+    it("Should never be able to filter comment5 when using 'some' as filter", function() {
+        var ast = UglifyJS.parse("#!foo\n//foo\n/*@preserve*/\n/* please hide me */");
+        assert.strictEqual(ast.print_to_string({comments: "some"}), "#!foo\n/*@preserve*/\n");
+    });
+
+    it("Should have no problem on multiple calls", function() {
+        const options = {
+            comments: /ok/
+        };
+
+        assert.strictEqual(UglifyJS.parse("/* ok */ function a(){}").print_to_string(options), "/* ok */function a(){}");
+        assert.strictEqual(UglifyJS.parse("/* ok */ function a(){}").print_to_string(options), "/* ok */function a(){}");
+        assert.strictEqual(UglifyJS.parse("/* ok */ function a(){}").print_to_string(options), "/* ok */function a(){}");
+    });
 });

test/mocha/input-sourcemaps.js

@@ -3,32 +3,55 @@ var assert = require("assert");
 var SourceMapConsumer = require("source-map").SourceMapConsumer;
 
 describe("input sourcemaps", function() {
-    var transpiled = '"use strict";\n\n' +
+    var transpilemap, map;
-        'var foo = function foo(x) {\n  return "foo " + x;\n};\n' +
-        'console.log(foo("bar"));\n\n' +
-        '//# sourceMappingURL=bundle.js.map';
 
-    var transpilemap = {
+    function getMap() {
-        "version": 3,
+      return {
-        "sources": ["index.js"],
+          "version": 3,
-        "names": [],
+          "sources": ["index.js"],
-        "mappings": ";;AAAA,IAAI,MAAM,SAAN,GAAM;AAAA,SAAK,SAAS,CAAd;AAAA,CAAV;AACA,QAAQ,GAAR,CAAY,IAAI,KAAJ,CAAZ",
+          "names": [],
-        "file": "bundle.js",
+          "mappings": ";;AAAA,IAAI,MAAM,SAAN,GAAM;AAAA,SAAK,SAAS,CAAd;AAAA,CAAV;AACA,QAAQ,GAAR,CAAY,IAAI,KAAJ,CAAZ",
-        "sourcesContent": ["let foo = x => \"foo \" + x;\nconsole.log(foo(\"bar\"));"]
+          "file": "bundle.js",
-    };
+          "sourcesContent": ["let foo = x => \"foo \" + x;\nconsole.log(foo(\"bar\"));"]
+      };
+    }
 
-    var result = Uglify.minify(transpiled, {
+    function prepareMap(sourceMap) {
-        fromString: true,
+        var transpiled = '"use strict";\n\n' +
-        inSourceMap: transpilemap,
+            'var foo = function foo(x) {\n  return "foo " + x;\n};\n' +
-        outSourceMap: true
+            'console.log(foo("bar"));\n\n' +
+            '//# sourceMappingURL=bundle.js.map';
+
+        transpilemap = sourceMap || getMap();
+
+        var result = Uglify.minify(transpiled, {
+            fromString: true,
+            inSourceMap: transpilemap,
+            outSourceMap: true
+        });
+
+        map = new SourceMapConsumer(result.map);
+    }
+
+    beforeEach(function () {
+      prepareMap();
     });
-    var map = new SourceMapConsumer(result.map);
 
     it("Should copy over original sourcesContent", function() {
         assert.equal(map.sourceContentFor("index.js"), transpilemap.sourcesContent[0]);
     });
 
-    it("Final sourcemap should not have invalid mappings from inputSourceMap (issue #882) ", function() {
+    it("Should copy sourcesContent if sources are relative", function () {
+        var relativeMap = getMap();
+        relativeMap.sources = ['./index.js'];
+
+        prepareMap(relativeMap);
+        assert.notEqual(map.sourcesContent, null);
+        assert.equal(map.sourcesContent.length, 1);
+        assert.equal(map.sourceContentFor("index.js"), transpilemap.sourcesContent[0]);
+    });
+
+    it("Final sourcemap should not have invalid mappings from inputSourceMap (issue #882)", function() {
         // The original source has only 2 lines, check that mappings don't have more lines
 
         var msg = "Mapping should not have higher line number than the original file had";

test/mocha/minify-file-map.js

@@ -7,10 +7,18 @@ describe("Input file as map", function() {
             '/scripts/foo.js': 'var foo = {"x": 1, y: 2, \'z\': 3};'
         };
         var result = Uglify.minify(jsMap, {fromString: true, outSourceMap: true});
-        
+
         var map = JSON.parse(result.map);
         assert.strictEqual(result.code, 'var foo={x:1,y:2,z:3};');
         assert.deepEqual(map.sources, ['/scripts/foo.js']);
+        assert.strictEqual(map.file, undefined);
+
+        result = Uglify.minify(jsMap, {fromString: true, outFileName: 'out.js'});
+        assert.strictEqual(result.map, null);
+
+        result = Uglify.minify(jsMap, {fromString: true, outFileName: 'out.js', outSourceMap: true});
+        map = JSON.parse(result.map);
+        assert.strictEqual(map.file, 'out.js');
     });
 
     it("Should accept array of objects and strings", function() {
@@ -19,7 +27,7 @@ describe("Input file as map", function() {
             'var bar = 15;'
         ];
         var result = Uglify.minify(jsSeq, {fromString: true, outSourceMap: true});
-        
+
         var map = JSON.parse(result.map);
         assert.strictEqual(result.code, 'var foo={x:1,y:2,z:3},bar=15;');
         assert.strictEqual(map.sources[0], '/scripts/foo.js');
@@ -31,7 +39,7 @@ describe("Input file as map", function() {
             'var bar = 15;'
         ];
         var result = Uglify.minify(jsSeq, {fromString: true, outSourceMap: true, sourceMapIncludeSources: true});
-        
+
         var map = JSON.parse(result.map);
         assert.strictEqual(result.code, 'var foo={x:1,y:2,z:3},bar=15;');
         assert.deepEqual(map.sourcesContent, ['var foo = {"x": 1, y: 2, \'z\': 3};', 'var bar = 15;']);

test/mocha/minify.js

@@ -63,16 +63,36 @@ describe("minify", function() {
     describe("inSourceMap", function() {
         it("Should read the given string filename correctly when sourceMapIncludeSources is enabled (#1236)", function() {
             var result = Uglify.minify('./test/input/issue-1236/simple.js', {
-                outSourceMap: "simple.js.min.map",
+                outSourceMap: "simple.min.js.map",
                 inSourceMap: "./test/input/issue-1236/simple.js.map",
                 sourceMapIncludeSources: true
             });
 
             var map = JSON.parse(result.map);
 
+            assert.equal(map.file, 'simple.min.js');
             assert.equal(map.sourcesContent.length, 1);
             assert.equal(map.sourcesContent[0],
                 'let foo = x => "foo " + x;\nconsole.log(foo("bar"));');
         });
     });
+
+    describe("sourceMapInline", function() {
+        it("should append source map to output js when sourceMapInline is enabled", function() {
+            var result = Uglify.minify('var a = function(foo) { return foo; };', {
+                fromString: true,
+                sourceMapInline: true
+            });
+            var code = result.code;
+            assert.strictEqual(code, "var a=function(n){return n};\n" +
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIj8iXSwibmFtZXMiOlsiYSIsImZvbyJdLCJtYXBwaW5ncyI6IkFBQUEsR0FBSUEsR0FBSSxTQUFTQyxHQUFPLE1BQU9BIn0=");
+        });
+        it("should not append source map to output js when sourceMapInline is not enabled", function() {
+            var result = Uglify.minify('var a = function(foo) { return foo; };', {
+                fromString: true
+            });
+            var code = result.code;
+            assert.strictEqual(code, "var a=function(n){return n};");
+        });
+    });
 });

test/mocha/screw-ie8.js

@@ -0,0 +1,23 @@
+var assert = require("assert");
+var uglify = require("../../");
+
+describe("screw-ie8", function () {
+    it("Should be able to minify() with undefined as catch parameter in a try...catch statement", function () {
+        assert.strictEqual(
+            uglify.minify(
+                "function a(b){\
+                    try {\
+                        throw 'Stuff';\
+                    } catch (undefined) {\
+                        console.log('caught: ' + undefined);\
+                    }\
+                    console.log('undefined is ' + undefined);\
+                    return b === undefined;\
+                };", {
+                    fromString: true
+                }
+            ).code,
+            'function a(o){try{throw"Stuff"}catch(o){console.log("caught: "+o)}return console.log("undefined is "+void 0),void 0===o}'
+        );
+    });
+});

test/run-tests.js

@@ -117,7 +117,7 @@ function run_compress_tests() {
                 input = U.mangle_properties(input, test.mangle_props);
             }
             var output = cmp.compress(input);
-            output.figure_out_scope();
+            output.figure_out_scope(test.mangle);
             if (test.mangle) {
                 output.compute_char_frequency(test.mangle);
                 output.mangle_names(test.mangle);

tools/node.js

@@ -41,9 +41,11 @@ exports.minify = function(files, options) {
     options = UglifyJS.defaults(options, {
         spidermonkey     : false,
         outSourceMap     : null,
+        outFileName      : null,
         sourceRoot       : null,
         inSourceMap      : null,
         sourceMapUrl     : null,
+        sourceMapInline  : false,
         fromString       : false,
         warnings         : false,
         mangle           : {},
@@ -117,9 +119,10 @@ exports.minify = function(files, options) {
     if (typeof options.inSourceMap == "string") {
         inMap = JSON.parse(fs.readFileSync(options.inSourceMap, "utf8"));
     }
-    if (options.outSourceMap) {
+    if (options.outSourceMap || options.sourceMapInline) {
         output.source_map = UglifyJS.SourceMap({
-            file: options.outSourceMap,
+            // prefer outFileName, otherwise use outSourceMap without .map suffix
+            file: options.outFileName || (typeof options.outSourceMap === 'string' ? options.outSourceMap.replace(/\.map$/i, '') : null),
             orig: inMap,
             root: options.sourceRoot
         });
@@ -138,16 +141,19 @@ exports.minify = function(files, options) {
     var stream = UglifyJS.OutputStream(output);
     toplevel.print(stream);
 
-    var mappingUrlPrefix = "\n//# sourceMappingURL=";
-    if (options.outSourceMap && typeof options.outSourceMap === "string" && options.sourceMapUrl !== false) {
-        stream += mappingUrlPrefix + (typeof options.sourceMapUrl === "string" ? options.sourceMapUrl : options.outSourceMap);
-    }
 
     var source_map = output.source_map;
     if (source_map) {
         source_map = source_map + "";
     }
 
+    var mappingUrlPrefix = "\n//# sourceMappingURL=";
+    if (options.sourceMapInline) {
+        stream += mappingUrlPrefix + "data:application/json;charset=utf-8;base64," + new Buffer(source_map).toString("base64");
+    } else if (options.outSourceMap && typeof options.outSourceMap === "string" && options.sourceMapUrl !== false) {
+        stream += mappingUrlPrefix + (typeof options.sourceMapUrl === "string" ? options.sourceMapUrl : options.outSourceMap);
+    }
+
     return {
         code : stream + "",
         map  : source_map