v3.3.23

fixes #3096

.github/ISSUE_TEMPLATE.md

@@ -1,11 +1,7 @@
-**Bug report or feature request?** 
+**Bug report or feature request?**
 
 <!-- Note: sub-optimal but correct code is not a bug -->
 
-**ES5 or ES6+ input?** 
-
-<!-- Note: for ES6 see: https://github.com/mishoo/UglifyJS2/tree/harmony#harmony -->
-
 **Uglify version (`uglifyjs -V`)**
 
 **JavaScript input**
@@ -24,6 +20,6 @@
 **JavaScript output or error produced.**
 
 <!--
-    Note: `uglify-js` only supports ES5. 
+    Note: `uglify-js` only supports JavaScript.
-    Those wishing to minify ES6 should use `uglify-es`.
+    Those wishing to minify ES6+ should transpile first.
 -->

README.md

@@ -1041,8 +1041,9 @@ var result = UglifyJS.minify(ast, {
 ### Working with Uglify AST
 
 Transversal and transformation of the native AST can be performed through
-[`TreeWalker`](http://lisperator.net/uglifyjs/walk) and
+[`TreeWalker`](https://github.com/mishoo/UglifyJS2/blob/master/lib/ast.js) and
-[`TreeTransformer`](http://lisperator.net/uglifyjs/transform) respectively.
+[`TreeTransformer`](https://github.com/mishoo/UglifyJS2/blob/master/lib/transform.js)
+respectively.
 
 ### ESTree / SpiderMonkey AST
 

lib/compress.js

@@ -295,6 +295,51 @@ merge(Compressor.prototype, {
         self.transform(tt);
     });
 
+    function read_property(obj, key) {
+        key = get_value(key);
+        if (key instanceof AST_Node) return;
+        var value;
+        if (obj instanceof AST_Array) {
+            var elements = obj.elements;
+            if (key == "length") return make_node_from_constant(elements.length, obj);
+            if (typeof key == "number" && key in elements) value = elements[key];
+        } else if (obj instanceof AST_Object) {
+            key = "" + key;
+            var props = obj.properties;
+            for (var i = props.length; --i >= 0;) {
+                var prop = props[i];
+                if (!(prop instanceof AST_ObjectKeyVal)) return;
+                if (!value && props[i].key === key) value = props[i].value;
+            }
+        }
+        return value instanceof AST_SymbolRef && value.fixed_value() || value;
+    }
+
+    function is_modified(compressor, tw, node, value, level, immutable) {
+        var parent = tw.parent(level);
+        var lhs = is_lhs(node, parent);
+        if (lhs) return lhs;
+        if (!immutable
+            && parent instanceof AST_Call
+            && parent.expression === node
+            && !parent.is_expr_pure(compressor)
+            && (!(value instanceof AST_Function)
+                || !(parent instanceof AST_New) && value.contains_this())) {
+            return true;
+        }
+        if (parent instanceof AST_Array) {
+            return is_modified(compressor, tw, parent, parent, level + 1);
+        }
+        if (parent instanceof AST_ObjectKeyVal && node === parent.value) {
+            var obj = tw.parent(level + 1);
+            return is_modified(compressor, tw, obj, obj, level + 2);
+        }
+        if (parent instanceof AST_PropAccess && parent.expression === node) {
+            var prop = read_property(value, parent.property);
+            return !immutable && is_modified(compressor, tw, parent, prop, level + 1);
+        }
+    }
+
     (function(def){
         def(AST_Node, noop);
 
@@ -385,45 +430,6 @@ merge(Compressor.prototype, {
                 || value instanceof AST_This;
         }
 
-        function read_property(obj, key) {
-            key = get_value(key);
-            if (key instanceof AST_Node) return;
-            var value;
-            if (obj instanceof AST_Array) {
-                var elements = obj.elements;
-                if (key == "length") return make_node_from_constant(elements.length, obj);
-                if (typeof key == "number" && key in elements) value = elements[key];
-            } else if (obj instanceof AST_Object) {
-                key = "" + key;
-                var props = obj.properties;
-                for (var i = props.length; --i >= 0;) {
-                    var prop = props[i];
-                    if (!(prop instanceof AST_ObjectKeyVal)) return;
-                    if (!value && props[i].key === key) value = props[i].value;
-                }
-            }
-            return value instanceof AST_SymbolRef && value.fixed_value() || value;
-        }
-
-        function is_modified(tw, node, value, level, immutable) {
-            var parent = tw.parent(level);
-            if (is_lhs(node, parent)
-                || !immutable
-                    && parent instanceof AST_Call
-                    && parent.expression === node
-                    && (!(value instanceof AST_Function)
-                        || !(parent instanceof AST_New) && value.contains_this())) {
-                return true;
-            } else if (parent instanceof AST_Array) {
-                return is_modified(tw, parent, parent, level + 1);
-            } else if (parent instanceof AST_ObjectKeyVal && node === parent.value) {
-                var obj = tw.parent(level + 1);
-                return is_modified(tw, obj, obj, level + 2);
-            } else if (parent instanceof AST_PropAccess && parent.expression === node) {
-                return !immutable && is_modified(tw, parent, read_property(value, parent.property), level + 1);
-            }
-        }
-
         function mark_escaped(tw, d, scope, node, value, level, depth) {
             var parent = tw.parent(level);
             if (value && value.is_constant()) return;
@@ -644,7 +650,7 @@ merge(Compressor.prototype, {
                 } else {
                     d.single_use = false;
                 }
-                if (is_modified(tw, this, value, 0, is_immutable(value))) {
+                if (is_modified(compressor, tw, this, value, 0, is_immutable(value))) {
                     if (d.single_use) {
                         d.single_use = "m";
                     } else {
@@ -974,24 +980,12 @@ merge(Compressor.prototype, {
                 }
                 // Stop immediately if these node types are encountered
                 var parent = scanner.parent();
-                if (node instanceof AST_Assign && node.operator != "=" && lhs.equivalent_to(node.left)
+                if (should_stop(node, parent)) {
-                    || node instanceof AST_Call && lhs instanceof AST_PropAccess && lhs.equivalent_to(node.expression)
-                    || node instanceof AST_Debugger
-                    || node instanceof AST_IterationStatement && !(node instanceof AST_For)
-                    || node instanceof AST_LoopControl
-                    || node instanceof AST_Try
-                    || node instanceof AST_With
-                    || parent instanceof AST_For && node !== parent.init
-                    || !replace_all
-                        && (node instanceof AST_SymbolRef && !node.is_declared(compressor))) {
                     abort = true;
                     return node;
                 }
                 // Stop only if candidate is found within conditional branches
-                if (!stop_if_hit
+                if (!stop_if_hit && in_conditional(node, parent)) {
-                    && (parent instanceof AST_Binary && lazy_op[parent.operator] && parent.left !== node
-                        || parent instanceof AST_Conditional && parent.condition !== node
-                        || parent instanceof AST_If && parent.condition !== node)) {
                     stop_if_hit = parent;
                 }
                 // Replace variable with assignment when found
@@ -1025,19 +1019,14 @@ merge(Compressor.prototype, {
                             return node;
                         }
                         var def = candidate.name.definition();
-                        var value = candidate.value;
                         if (def.references.length - def.replaced == 1 && !compressor.exposed(def)) {
                             def.replaced++;
-                            if (funarg && is_identifier_atom(value)) {
+                            return maintain_this_binding(parent, node, candidate.value);
-                                return value.transform(compressor);
-                            } else {
-                                return maintain_this_binding(parent, node, value);
-                            }
                         }
                         return make_node(AST_Assign, candidate, {
                             operator: "=",
                             left: make_node(AST_SymbolRef, candidate.name, candidate.name),
-                            right: value
+                            right: candidate.value
                         });
                     }
                     candidate.write_only = false;
@@ -1046,20 +1035,7 @@ merge(Compressor.prototype, {
                 // These node types have child nodes that execute sequentially,
                 // but are otherwise not safe to scan into or beyond them.
                 var sym;
-                if (node instanceof AST_Call
+                if (is_last_node(node, parent) || may_throw(node)) {
-                    || node instanceof AST_Exit
-                        && (side_effects || lhs instanceof AST_PropAccess || may_modify(lhs))
-                    || node instanceof AST_PropAccess
-                        && (side_effects || node.expression.may_throw_on_access(compressor))
-                    || node instanceof AST_SymbolRef
-                        && (symbol_in_lvalues(node) || side_effects && may_modify(node))
-                    || node instanceof AST_This && symbol_in_lvalues(node)
-                    || node instanceof AST_VarDef && node.value
-                        && (node.name.name in lvalues || side_effects && may_modify(node.name))
-                    || (sym = is_lhs(node.left, node))
-                        && (sym instanceof AST_PropAccess || sym.name in lvalues)
-                    || may_throw
-                        && (in_try ? node.has_side_effects(compressor) : side_effects_external(node))) {
                     stop_after = node;
                     if (node instanceof AST_Scope) abort = true;
                 }
@@ -1118,7 +1094,9 @@ merge(Compressor.prototype, {
                     var lhs_local = is_lhs_local(lhs);
                     if (!side_effects) side_effects = value_has_side_effects(candidate);
                     var replace_all = replace_all_symbols();
-                    var may_throw = candidate.may_throw(compressor);
+                    var may_throw = candidate.may_throw(compressor) ? in_try ? function(node) {
+                        return node.has_side_effects(compressor);
+                    } : side_effects_external : return_false;
                     var funarg = candidate.name instanceof AST_SymbolFunarg;
                     var hit = funarg;
                     var abort = false, replaced = 0, can_replace = !args || !hit;
@@ -1170,6 +1148,51 @@ merge(Compressor.prototype, {
                 }
             }
 
+            function should_stop(node, parent) {
+                if (node instanceof AST_Assign) return node.operator != "=" && lhs.equivalent_to(node.left);
+                if (node instanceof AST_Call) {
+                    return lhs instanceof AST_PropAccess && lhs.equivalent_to(node.expression);
+                }
+                if (node instanceof AST_Debugger) return true;
+                if (node instanceof AST_IterationStatement) return !(node instanceof AST_For);
+                if (node instanceof AST_LoopControl) return true;
+                if (node instanceof AST_Try) return true;
+                if (node instanceof AST_With) return true;
+                if (parent instanceof AST_For) return node !== parent.init;
+                if (replace_all) return false;
+                return node instanceof AST_SymbolRef && !node.is_declared(compressor);
+            }
+
+            function in_conditional(node, parent) {
+                if (parent instanceof AST_Binary) return lazy_op[parent.operator] && parent.left !== node;
+                if (parent instanceof AST_Conditional) return parent.condition !== node;
+                return parent instanceof AST_If && parent.condition !== node;
+            }
+
+            function is_last_node(node, parent) {
+                if (node instanceof AST_Call) return true;
+                if (node instanceof AST_Exit) {
+                    return side_effects || lhs instanceof AST_PropAccess || may_modify(lhs);
+                }
+                if (node instanceof AST_PropAccess) {
+                    return side_effects || node.expression.may_throw_on_access(compressor);
+                }
+                if (node instanceof AST_SymbolRef) {
+                    if (symbol_in_lvalues(node, parent)) {
+                        return !parent || parent.operator != "=" || parent.left !== node;
+                    }
+                    return side_effects && may_modify(node);
+                }
+                if (node instanceof AST_This) return symbol_in_lvalues(node, parent);
+                if (node instanceof AST_VarDef) {
+                    if (!node.value) return false;
+                    return node.name.name in lvalues || side_effects && may_modify(node.name);
+                }
+                var sym = is_lhs(node.left, node);
+                if (sym && sym.name in lvalues) return true;
+                if (sym instanceof AST_PropAccess) return true;
+            }
+
             function extract_args() {
                 var iife, fn = compressor.self();
                 if (fn instanceof AST_Function
@@ -1348,8 +1371,9 @@ merge(Compressor.prototype, {
                 if (expr instanceof AST_VarDef) {
                     var def = expr.name.definition();
                     if (!member(expr.name, def.orig)) return;
-                    var declared = def.orig.length - def.eliminated;
                     var referenced = def.references.length - def.replaced;
+                    if (!referenced) return;
+                    var declared = def.orig.length - def.eliminated;
                     if (declared > 1 && !(expr.name instanceof AST_SymbolFunarg)
                         || (referenced > 1 ? mangleable_var(expr) : !compressor.exposed(def))) {
                         return make_node(AST_SymbolRef, expr.name, expr.name);
@@ -1418,7 +1442,7 @@ merge(Compressor.prototype, {
                 var tw = new TreeWalker(function(node) {
                     var sym = root_expr(node);
                     if (sym instanceof AST_SymbolRef || sym instanceof AST_This) {
-                        lvalues[sym.name] = lvalues[sym.name] || is_lhs(node, tw.parent());
+                        lvalues[sym.name] = lvalues[sym.name] || is_modified(compressor, tw, node, node, 0);
                     }
                 });
                 expr.walk(tw);
@@ -1480,10 +1504,10 @@ merge(Compressor.prototype, {
                 return false;
             }
 
-            function symbol_in_lvalues(sym) {
+            function symbol_in_lvalues(sym, parent) {
                 var lvalue = lvalues[sym.name];
                 if (!lvalue) return;
-                if (lvalue !== lhs) return true;
+                if (lvalue !== lhs) return !(parent instanceof AST_Call);
                 scan_rhs = false;
             }
 

lib/output.js

@@ -173,7 +173,7 @@ function OutputStream(options) {
           default:
             return dq > sq ? quote_single() : quote_double();
         }
-    };
+    }
 
     function encode_string(str, quote) {
         var ret = make_string(str, quote);
@@ -183,17 +183,17 @@ function OutputStream(options) {
             ret = ret.replace(/--\x3e/g, "--\\x3e");
         }
         return ret;
-    };
+    }
 
     function make_name(name) {
         name = name.toString();
         name = to_utf8(name, true);
         return name;
-    };
+    }
 
     function make_indent(back) {
         return repeat_string(" ", options.indent_start + indentation - back * options.indent_level);
-    };
+    }
 
     /* -----[ beautification/minification ]----- */
 
@@ -351,7 +351,7 @@ function OutputStream(options) {
             current_col = a[n].length;
         }
         last = str;
-    };
+    }
 
     var space = options.beautify ? function() {
         print(" ");
@@ -374,6 +374,11 @@ function OutputStream(options) {
         return ret;
     } : function(col, cont) { return cont() };
 
+    var may_add_newline = options.max_line_len ? function() {
+        ensure_line_len();
+        might_add_newline = OUTPUT.length;
+    } : noop;
+
     var newline = options.beautify ? function() {
         if (newline_insert < 0) return print("\n");
         if (OUTPUT[newline_insert] != "\n") {
@@ -382,10 +387,7 @@ function OutputStream(options) {
             current_line++;
         }
         newline_insert++;
-    } : options.max_line_len ? function() {
+    } : may_add_newline;
-        ensure_line_len();
-        might_add_newline = OUTPUT.length;
-    } : noop;
 
     var semicolon = options.beautify ? function() {
         print(";");
@@ -396,11 +398,11 @@ function OutputStream(options) {
     function force_semicolon() {
         might_need_semicolon = false;
         print(";");
-    };
+    }
 
     function next_indent() {
         return indentation + options.indent_level;
-    };
+    }
 
     function with_block(cont) {
         var ret;
@@ -412,34 +414,40 @@ function OutputStream(options) {
         indent();
         print("}");
         return ret;
-    };
+    }
 
     function with_parens(cont) {
         print("(");
+        may_add_newline();
         //XXX: still nice to have that for argument lists
         //var ret = with_indent(current_col, cont);
         var ret = cont();
+        may_add_newline();
         print(")");
         return ret;
-    };
+    }
 
     function with_square(cont) {
         print("[");
+        may_add_newline();
         //var ret = with_indent(current_col, cont);
         var ret = cont();
+        may_add_newline();
         print("]");
         return ret;
-    };
+    }
 
     function comma() {
+        may_add_newline();
         print(",");
+        may_add_newline();
         space();
-    };
+    }
 
     function colon() {
         print(":");
         space();
-    };
+    }
 
     var add_mapping = mappings ? function(token, name) {
         mapping_token = token;
@@ -451,7 +459,7 @@ function OutputStream(options) {
             ensure_line_len();
         }
         return OUTPUT;
-    };
+    }
 
     function has_nlb() {
         var index = OUTPUT.lastIndexOf("\n");
@@ -619,8 +627,7 @@ function OutputStream(options) {
             return stack[stack.length - 2 - (n || 0)];
         }
     };
-
+}
-};
 
 /* -----[ code generators ]----- */
 
@@ -630,7 +637,7 @@ function OutputStream(options) {
 
     function DEFPRINT(nodetype, generator) {
         nodetype.DEFMETHOD("_codegen", generator);
-    };
+    }
 
     var in_directive = false;
     var active_scope = null;
@@ -679,7 +686,7 @@ function OutputStream(options) {
         } else {
             nodetype.DEFMETHOD("needs_parens", func);
         }
-    };
+    }
 
     PARENS(AST_Node, return_false);
 
@@ -865,7 +872,7 @@ function OutputStream(options) {
             }
         });
         in_directive = false;
-    };
+    }
 
     AST_StatementWithBody.DEFMETHOD("_do_print_body", function(output){
         force_statement(this.body, output);
@@ -901,7 +908,7 @@ function OutputStream(options) {
                 display_body(self.body, false, output, allow_directives);
             });
         } else print_braced_empty(self, output);
-    };
+    }
     DEFPRINT(AST_BlockStatement, function(self, output){
         print_braced(self, output);
     });
@@ -1064,7 +1071,7 @@ function OutputStream(options) {
             else break;
         }
         force_statement(self.body, output);
-    };
+    }
     DEFPRINT(AST_If, function(self, output){
         output.print("if");
         output.space();
@@ -1184,7 +1191,7 @@ function OutputStream(options) {
             }
         }));
         node.print(output, parens);
-    };
+    }
 
     DEFPRINT(AST_VarDef, function(self, output){
         self.name.print(output);
@@ -1430,7 +1437,7 @@ function OutputStream(options) {
             else
                 stat.print(output);
         }
-    };
+    }
 
     // self should be AST_New.  decide if we want to show parens or not.
     function need_constructor_parens(self, output) {
@@ -1438,7 +1445,7 @@ function OutputStream(options) {
         if (self.args.length > 0) return true;
 
         return output.option("beautify");
-    };
+    }
 
     function best_of(a) {
         var best = a[0], len = best.length;
@@ -1449,27 +1456,31 @@ function OutputStream(options) {
             }
         }
         return best;
-    };
+    }
 
     function make_num(num) {
-        var str = num.toString(10), a = [ str.replace(/^0\./, ".").replace('e+', 'e') ], m;
+        var str = num.toString(10).replace(/^0\./, ".").replace("e+", "e");
+        var candidates = [ str ];
         if (Math.floor(num) === num) {
-            if (num >= 0) {
+            if (num < 0) {
-                a.push("0x" + num.toString(16).toLowerCase(), // probably pointless
+                candidates.push("-0x" + (-num).toString(16).toLowerCase());
-                       "0" + num.toString(8)); // same.
             } else {
-                a.push("-0x" + (-num).toString(16).toLowerCase(), // probably pointless
+                candidates.push("0x" + num.toString(16).toLowerCase());
-                       "-0" + (-num).toString(8)); // same.
             }
-            if ((m = /^(.*?)(0+)$/.exec(num))) {
-                a.push(m[1] + "e" + m[2].length);
-            }
-        } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) {
-            a.push(m[2] + "e-" + (m[1].length + m[2].length),
-                   str.substr(str.indexOf(".")));
         }
-        return best_of(a);
+        var match, len, digits;
-    };
+        if (match = /^\.0+/.exec(str)) {
+            len = match[0].length;
+            digits = str.slice(len);
+            candidates.push(digits + "e-" + (digits.length + len - 1));
+        } else if (match = /0+$/.exec(str)) {
+            len = match[0].length;
+            candidates.push(str.slice(0, -len) + "e" + len);
+        } else if (match = /^(\d)\.(\d+)e(-?\d+)$/.exec(str)) {
+            candidates.push(match[1] + match[2] + "e" + (match[3] - match[2].length));
+        }
+        return best_of(candidates);
+    }
 
     function make_block(stmt, output) {
         if (!stmt || stmt instanceof AST_EmptyStatement)
@@ -1481,7 +1492,7 @@ function OutputStream(options) {
             stmt.print(output);
             output.newline();
         });
-    };
+    }
 
     /* -----[ source map generators ]----- */
 

lib/scope.js

@@ -55,7 +55,7 @@ function SymbolDef(scope, orig, init) {
     this.mangled_name = null;
     this.undeclared = false;
     this.id = SymbolDef.next_id++;
-};
+}
 
 SymbolDef.next_id = 1;
 
@@ -556,17 +556,21 @@ AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
 });
 
 var base54 = (function() {
-    var leading = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_".split("");
+    var freq = Object.create(null);
-    var digits = "0123456789".split("");
+    function init(chars) {
+        var array = [];
+        for (var i = 0, len = chars.length; i < len; i++) {
+            var ch = chars[i];
+            array.push(ch);
+            freq[ch] = -1e-2 * i;
+        }
+        return array;
+    }
+    var digits = init("0123456789");
+    var leading = init("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_");
     var chars, frequency;
     function reset() {
-        frequency = Object.create(null);
+        frequency = Object.create(freq);
-        leading.forEach(function(ch) {
-            frequency[ch] = 0;
-        });
-        digits.forEach(function(ch) {
-            frequency[ch] = 0;
-        });
     }
     base54.consider = function(str, delta) {
         for (var i = str.length; --i >= 0;) {
@@ -577,7 +581,7 @@ var base54 = (function() {
         return frequency[b] - frequency[a];
     }
     base54.sort = function() {
-        chars = mergeSort(leading, compare).concat(mergeSort(digits, compare));
+        chars = leading.sort(compare).concat(digits.sort(compare));
     };
     base54.reset = reset;
     reset();
@@ -591,6 +595,6 @@ var base54 = (function() {
             base = 64;
         } while (num > 0);
         return ret;
-    };
+    }
     return base54;
 })();

lib/utils.js

@@ -45,27 +45,25 @@
 
 function characters(str) {
     return str.split("");
-};
+}
 
 function member(name, array) {
     return array.indexOf(name) >= 0;
-};
+}
 
 function find_if(func, array) {
     for (var i = 0, n = array.length; i < n; ++i) {
-        if (func(array[i]))
+        if (func(array[i])) return array[i];
-            return array[i];
     }
-};
+}
 
 function repeat_string(str, i) {
     if (i <= 0) return "";
     if (i == 1) return str;
     var d = repeat_string(str, i >> 1);
     d += d;
-    if (i & 1) d += str;
+    return i & 1 ? d + str : d;
-    return d;
+}
-};
 
 function configure_error_stack(fn) {
     Object.defineProperty(fn.prototype, "stack", {
@@ -84,27 +82,23 @@ function configure_error_stack(fn) {
 function DefaultsError(msg, defs) {
     this.message = msg;
     this.defs = defs;
-};
+}
 DefaultsError.prototype = Object.create(Error.prototype);
 DefaultsError.prototype.constructor = DefaultsError;
 DefaultsError.prototype.name = "DefaultsError";
 configure_error_stack(DefaultsError);
 
-DefaultsError.croak = function(msg, defs) {
-    throw new DefaultsError(msg, defs);
-};
-
 function defaults(args, defs, croak) {
-    if (args === true)
+    if (args === true) args = {};
-        args = {};
     var ret = args || {};
-    if (croak) for (var i in ret) if (HOP(ret, i) && !HOP(defs, i))
+    if (croak) for (var i in ret) if (HOP(ret, i) && !HOP(defs, i)) {
-        DefaultsError.croak("`" + i + "` is not a supported option", defs);
+        throw new DefaultsError("`" + i + "` is not a supported option", defs);
+    }
     for (var i in defs) if (HOP(defs, i)) {
         ret[i] = (args && HOP(args, i)) ? args[i] : defs[i];
     }
     return ret;
-};
+}
 
 function merge(obj, ext) {
     var count = 0;
@@ -113,7 +107,7 @@ function merge(obj, ext) {
         count++;
     }
     return count;
-};
+}
 
 function noop() {}
 function return_false() { return false; }
@@ -172,43 +166,19 @@ var MAP = (function(){
 function push_uniq(array, el) {
     if (array.indexOf(el) < 0)
         array.push(el);
-};
+}
 
 function string_template(text, props) {
     return text.replace(/\{(.+?)\}/g, function(str, p){
         return props && props[p];
     });
-};
+}
 
 function remove(array, el) {
     for (var i = array.length; --i >= 0;) {
         if (array[i] === el) array.splice(i, 1);
     }
-};
+}
-
-function mergeSort(array, cmp) {
-    if (array.length < 2) return array.slice();
-    function merge(a, b) {
-        var r = [], ai = 0, bi = 0, i = 0;
-        while (ai < a.length && bi < b.length) {
-            cmp(a[ai], b[bi]) <= 0
-                ? r[i++] = a[ai++]
-                : r[i++] = b[bi++];
-        }
-        if (ai < a.length) r.push.apply(r, a.slice(ai));
-        if (bi < b.length) r.push.apply(r, b.slice(bi));
-        return r;
-    };
-    function _ms(a) {
-        if (a.length <= 1)
-            return a;
-        var m = Math.floor(a.length / 2), left = a.slice(0, m), right = a.slice(m);
-        left = _ms(left);
-        right = _ms(right);
-        return merge(left, right);
-    };
-    return _ms(array);
-};
 
 function makePredicate(words) {
     if (!Array.isArray(words)) words = words.split(" ");
@@ -224,12 +194,12 @@ function all(array, predicate) {
         if (!predicate(array[i]))
             return false;
     return true;
-};
+}
 
 function Dictionary() {
     this._values = Object.create(null);
     this._size = 0;
-};
+}
 Dictionary.prototype = {
     set: function(key, val) {
         if (!this.has(key)) ++this._size;
@@ -290,20 +260,22 @@ function HOP(obj, prop) {
 // a statement.
 function first_in_statement(stack) {
     var node = stack.parent(-1);
-    for (var i = 0, p; p = stack.parent(i); i++) {
+    for (var i = 0, p; p = stack.parent(i++); node = p) {
-        if (p instanceof AST_Statement && p.body === node)
+        if (p.TYPE == "Call") {
-            return true;
+            if (p.expression === node) continue;
-        if ((p instanceof AST_Sequence      && p.expressions[0] === node) ||
+        } else if (p instanceof AST_Binary) {
-            (p.TYPE == "Call"               && p.expression === node ) ||
+            if (p.left === node) continue;
-            (p instanceof AST_Dot           && p.expression === node ) ||
+        } else if (p instanceof AST_Conditional) {
-            (p instanceof AST_Sub           && p.expression === node ) ||
+            if (p.condition === node) continue;
-            (p instanceof AST_Conditional   && p.condition === node  ) ||
+        } else if (p instanceof AST_PropAccess) {
-            (p instanceof AST_Binary        && p.left === node       ) ||
+            if (p.expression === node) continue;
-            (p instanceof AST_UnaryPostfix  && p.expression === node ))
+        } else if (p instanceof AST_Sequence) {
-        {
+            if (p.expressions[0] === node) continue;
-            node = p;
+        } else if (p instanceof AST_Statement) {
-        } else {
+            return p.body === node;
-            return false;
+        } else if (p instanceof AST_UnaryPostfix) {
+            if (p.expression === node) continue;
         }
+        return false;
     }
 }

package.json

@@ -3,7 +3,7 @@
   "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.3.21",
+  "version": "3.3.23",
   "engines": {
     "node": ">=0.8.0"
   },

test/compress/collapse_vars.js

@@ -5327,3 +5327,24 @@ issue_3032: {
     }
     expect_stdout: "42"
 }
+
+issue_3096: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var ar = ["a", "b"];
+            var first = ar.pop();
+            return ar + "" + first;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var ar = ["a", "b"];
+            var first = ar.pop();
+            return ar + "" + first;
+        }());
+    }
+    expect_stdout: "ab"
+}

test/compress/max_line_len.js

@@ -8,14 +8,14 @@ too_short: {
         }
     }
     expect_exact: [
-        'function f(a){',
+        "function f(",
-        'return{',
+        "a){return{",
-        'c:42,',
+        "c:42,d:a(",
-        'd:a(),',
+        '),e:"foo"}',
-        'e:"foo"}}',
+        "}",
     ]
     expect_warnings: [
-        "WARN: Output exceeds 10 characters"
+        "WARN: Output exceeds 10 characters",
     ]
 }
 
@@ -29,11 +29,25 @@ just_enough: {
         }
     }
     expect_exact: [
-        'function f(a){',
+        "function f(a){",
-        'return{c:42,',
+        "return{c:42,",
         'd:a(),e:"foo"}',
-        '}',
+        "}",
-    ]
-    expect_warnings: [
     ]
+    expect_warnings: []
+}
+
+issue_304: {
+    beautify = {
+        max_line_len: 10,
+    }
+    input: {
+        var a = 0, b = 0, c = 0, d = 0, e = 0;
+    }
+    expect_exact: [
+        "var a=0,",
+        "b=0,c=0,",
+        "d=0,e=0;",
+    ]
+    expect_warnings: []
 }

test/compress/numbers.js

@@ -1,21 +1,49 @@
 hex_numbers_in_parentheses_for_prototype_functions: {
-    input: {
+    beautify = {
-        (-2);
+        beautify: true,
-        (-2).toFixed(0);
-
-        (2);
-        (2).toFixed(0);
-
-        (0.2);
-        (0.2).toFixed(0);
-
-        (0.00000002);
-        (0.00000002).toFixed(0);
-
-        (1000000000000000128);
-        (1000000000000000128).toFixed(0);
     }
-    expect_exact: "-2;(-2).toFixed(0);2;2..toFixed(0);.2;.2.toFixed(0);2e-8;2e-8.toFixed(0);0xde0b6b3a7640080;(0xde0b6b3a7640080).toFixed(0);"
+    input: {
+        function f() {
+            (-2);
+            (-2).toFixed(0);
+
+            (2);
+            (2).toFixed(0);
+
+            (0.2);
+            (0.2).toFixed(0);
+
+            (2.34e20);
+            (2.34e20).toFixed(0);
+
+            (0.00000002);
+            (0.00000002).toFixed(0);
+
+            (1000000000000000128);
+            (1000000000000000128).toFixed(0);
+
+            (-1000000000000000128);
+            (-1000000000000000128).toFixed(0);
+        }
+    }
+    expect_exact: [
+        "function f() {",
+        "    -2;",
+        "    (-2).toFixed(0);",
+        "    2;",
+        "    2..toFixed(0);",
+        "    .2;",
+        "    .2.toFixed(0);",
+        "    234e18;",
+        "    234e18.toFixed(0);",
+        "    2e-8;",
+        "    2e-8.toFixed(0);",
+        "    0xde0b6b3a7640080;",
+        "    (0xde0b6b3a7640080).toFixed(0);",
+        "    -0xde0b6b3a7640080;",
+        "    (-0xde0b6b3a7640080).toFixed(0);",
+        "}",
+    ]
 }
 
 comparisons: {

test/input/issue-505/output.js

@@ -1,5 +1,5 @@
 function test(a){
 "aaaaaaaaaaaaaaaa"
-;a(err,data),a(err,data)
+;a(err,data),a(err,
-}
+data)}
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsidGVzdCIsImNhbGxiYWNrIiwiZXJyIiwiZGF0YSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsS0FBS0M7QUFDVjtDQUNBQSxFQUFTQyxJQUFLQyxNQUNkRixFQUFTQyxJQUFLQyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsidGVzdCIsImNhbGxiYWNrIiwiZXJyIiwiZGF0YSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsS0FBS0M7QUFDVjtDQUNBQSxFQUFTQyxJQUFLQyxNQUNkRixFQUFTQztBQUFLQyJ9

test/mocha/cli.js

@@ -100,8 +100,8 @@ describe("bin/uglifyjs", function () {
         exec(command, function (err, stdout, stderr) {
             if (err) throw err;
 
-            var stderrLines = stderr.split('\n');
+            var stderrLines = stderr.split("\n");
-            assert.strictEqual(stderrLines[0], 'INFO: Using input source map: test/input/issue-2082/sample.js.map');
+            assert.strictEqual(stderrLines[0], "INFO: Using input source map: test/input/issue-2082/sample.js.map");
             assert.notStrictEqual(stderrLines[1], 'INFO: Using input source map: {"version": 3,"sources": ["index.js"],"mappings": ";"}');
             done();
         });
@@ -244,7 +244,8 @@ describe("bin/uglifyjs", function () {
                 "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DLElBTEQifQ==",
                 "",
             ].join("\n"));
-            assert.strictEqual(stderr, "WARN: inline source map not found: test/input/issue-1323/sample.js\n");
+            var stderrLines = stderr.split("\n");
+            assert.strictEqual(stderrLines[0], "WARN: inline source map not found: test/input/issue-1323/sample.js");
             done();
         });
     });
@@ -264,7 +265,8 @@ describe("bin/uglifyjs", function () {
                 "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIiwidGVzdC9pbnB1dC9pc3N1ZS0xMzIzL3NhbXBsZS5qcyJdLCJuYW1lcyI6WyJGb28iLCJjb25zb2xlIiwibG9nIiwiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFNQSxJQUFJLFNBQUFBLE1BQWdCQyxRQUFRQyxJQUFJLEVBQUUsSUFBTyxJQUFJRixJQ0FuRCxJQUFJRyxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DLElBTEQifQ==",
                 "",
             ].join("\n"));
-            assert.strictEqual(stderr, "WARN: inline source map not found: test/input/issue-1323/sample.js\n");
+            var stderrLines = stderr.split("\n");
+            assert.strictEqual(stderrLines[0], "WARN: inline source map not found: test/input/issue-1323/sample.js");
             done();
         });
     });

test/mocha/parentheses.js

@@ -91,7 +91,7 @@ describe("parentheses", function() {
             "(function(){}).name;",
         ];
         for (var i = 16; --i >= 0;) {
-            [].push.apply(code, code);
+            code = code.concat(code);
         }
         code = code.join("");
         var result = uglify.minify(code, {

test/run-tests.js

@@ -172,7 +172,7 @@ function run_compress_tests() {
             }
             if (test.expect_stdout
                 && (!test.node_version || semver.satisfies(process.version, test.node_version))) {
-                var stdout = sandbox.run_code(input_code, true);
+                var stdout = run_code(input_code);
                 if (test.expect_stdout === true) {
                     test.expect_stdout = stdout;
                 }
@@ -186,7 +186,7 @@ function run_compress_tests() {
                     });
                     return false;
                 }
-                stdout = sandbox.run_code(output, true);
+                stdout = run_code(output);
                 if (!sandbox.same_stdout(test.expect_stdout, stdout)) {
                     log("!!! failed\n---INPUT---\n{input}\n---EXPECTED {expected_type}---\n{expected}\n---ACTUAL {actual_type}---\n{actual}\n\n", {
                         input: input_formatted,
@@ -344,6 +344,11 @@ function evaluate(code) {
     return new Function("return(" + code + ")")();
 }
 
+function run_code(code) {
+    var result = sandbox.run_code(code, true);
+    return typeof result == "string" ? result.replace(/\u001b\[\d+m/g, "") : result;
+}
+
 // Try to reminify original input with standard options
 // to see if it matches expect_stdout.
 function reminify(orig_options, input_code, input_formatted, expect_stdout) {
@@ -367,7 +372,7 @@ function reminify(orig_options, input_code, input_formatted, expect_stdout) {
             });
             return false;
         } else {
-            var stdout = sandbox.run_code(result.code, true);
+            var stdout = run_code(result.code);
             if (typeof expect_stdout != "string" && typeof stdout != "string" && expect_stdout.name == stdout.name) {
                 stdout = expect_stdout;
             }

test/sandbox.js

@@ -2,24 +2,18 @@ var semver = require("semver");
 var vm = require("vm");
 
 function createContext() {
-    var context = Object.create(null);
+    return vm.createContext(Object.defineProperty({}, "console", {
-    Object.defineProperty(context, "console", {
+        value: {
-        value: function() {
+            log: function(msg) {
-            var con = Object.create(null);
+                if (arguments.length == 1 && typeof msg == "string") {
-            Object.defineProperty(con, "log", {
+                    return console.log("%s", msg);
-                value: function(msg) {
-                    if (arguments.length == 1 && typeof msg == "string") {
-                        return console.log("%s", msg);
-                    }
-                    return console.log.apply(console, [].map.call(arguments, function(arg) {
-                        return safe_log(arg, 3);
-                    }));
                 }
-            });
+                return console.log.apply(console, [].map.call(arguments, function(arg) {
-            return con;
+                    return safe_log(arg, 3);
-        }()
+                }));
-    });
+            }
-    return vm.createContext(context);
+        }
+    }));
 }
 
 function safe_log(arg, level) {
@@ -40,7 +34,7 @@ function safe_log(arg, level) {
 }
 
 function strip_func_ids(text) {
-    return text.toString().replace(/F[0-9]{6}N/g, "<F<>N>");
+    return ("" + text).replace(/F[0-9]{6}N/g, "<F<>N>");
 }
 
 var context;