terser 3.7.6 → 3.8.1

package/lib/compress.js

@@ -49,7 +49,7 @@ function Compressor(options, false_by_default) {
     TreeTransformer.call(this, this.before, this.after);
     if (options.defaults !== undefined && !options.defaults) false_by_default = true;
     this.options = defaults(options, {
-        arguments     : !false_by_default,
+        arguments     : false,
         arrows        : !false_by_default,
         booleans      : !false_by_default,
         collapse_vars : !false_by_default,
@@ -58,6 +58,7 @@ function Compressor(options, false_by_default) {
         conditionals  : !false_by_default,
         dead_code     : !false_by_default,
         defaults      : true,
+        directives    : !false_by_default,
         drop_console  : false,
         drop_debugger : !false_by_default,
         ecma          : 5,
@@ -149,11 +150,11 @@ function Compressor(options, false_by_default) {
     var sequences = this.options["sequences"];
     this.sequences_limit = sequences == 1 ? 800 : sequences | 0;
     this.warnings_produced = {};
-};
+}
 
 Compressor.prototype = new TreeTransformer;
 merge(Compressor.prototype, {
-    option: function(key) { return this.options[key] },
+    option: function(key) { return this.options[key]; },
     exposed: function(def) {
         if (def.export) return true;
         if (def.global) for (var i = 0, len = def.orig.length; i < len; i++)
@@ -264,10 +265,10 @@ merge(Compressor.prototype, {
     }
 });
 
-(function(){
+(function() {
 
     function OPT(node, optimizer) {
-        node.DEFMETHOD("optimize", function(compressor){
+        node.DEFMETHOD("optimize", function(compressor) {
             var self = this;
             if (self._optimized) return self;
             if (compressor.has_directive("use asm")) return self;
@@ -275,13 +276,13 @@ merge(Compressor.prototype, {
             opt._optimized = true;
             return opt;
         });
-    };
+    }
 
-    OPT(AST_Node, function(self, compressor){
+    OPT(AST_Node, function(self, compressor) {
         return self;
     });
 
-    AST_Node.DEFMETHOD("equivalent_to", function(node){
+    AST_Node.DEFMETHOD("equivalent_to", function(node) {
         return this.TYPE == node.TYPE && this.print_to_string() == node.print_to_string();
     });
 
@@ -377,7 +378,7 @@ merge(Compressor.prototype, {
         }
     }
 
-    (function(def){
+    (function(def) {
         def(AST_Node, noop);
 
         function reset_def(compressor, def) {
@@ -430,6 +431,7 @@ merge(Compressor.prototype, {
         }
 
         function safe_to_read(tw, def) {
+            if (def.single_use == "m") return false;
             if (tw.safe_ids[def.id]) {
                 if (def.fixed == null) {
                     var orig = def.orig[0];
@@ -532,14 +534,15 @@ merge(Compressor.prototype, {
             var sym = node.left;
             if (!(sym instanceof AST_SymbolRef)) return;
             var d = sym.definition();
+            var safe = safe_to_assign(tw, d, sym.scope, node.right);
+            d.assignments++;
+            if (!safe) return;
             var fixed = d.fixed;
             if (!fixed && node.operator != "=") return;
-            if (!safe_to_assign(tw, d, sym.scope, node.right)) return;
             var eq = node.operator == "=";
             var value = eq ? node.right : node;
             if (is_modified(compressor, tw, node, value, 0)) return;
             d.references.push(sym);
-            d.assignments++;
             if (!eq) d.chained = true;
             d.fixed = eq ? function() {
                 return node.right;
@@ -582,7 +585,7 @@ merge(Compressor.prototype, {
             descend();
             pop(tw);
             return true;
-        })
+        });
         def(AST_Conditional, function(tw) {
             this.condition.walk(tw);
             push(tw);
@@ -674,7 +677,7 @@ merge(Compressor.prototype, {
                 node.argnames.forEach(function(arg, i) {
                     if (!arg.definition) return;
                     var d = arg.definition();
-                    if (!node.uses_arguments && d.fixed === undefined) {
+                    if (d.fixed === undefined && (!node.uses_arguments || tw.has_directive("use strict"))) {
                         d.fixed = function() {
                             return iife.args[i] || make_node(AST_Undefined, iife);
                         };
@@ -721,7 +724,7 @@ merge(Compressor.prototype, {
                 tw.loop_ids[d.id] = tw.in_loop;
             }
             var value;
-            if (d.fixed === undefined || !safe_to_read(tw, d) || d.single_use == "m") {
+            if (d.fixed === undefined || !safe_to_read(tw, d)) {
                 d.fixed = false;
             } else if (d.fixed) {
                 value = this.fixed_value();
@@ -766,13 +769,15 @@ merge(Compressor.prototype, {
         def(AST_Unary, function(tw, descend) {
             var node = this;
             if (node.operator != "++" && node.operator != "--") return;
-            if (!(node.expression instanceof AST_SymbolRef)) return;
-            var d = node.expression.definition();
+            var exp = node.expression;
+            if (!(exp instanceof AST_SymbolRef)) return;
+            var d = exp.definition();
+            var safe = safe_to_assign(tw, d, true);
+            d.assignments++;
+            if (!safe) return;
             var fixed = d.fixed;
             if (!fixed) return;
-            if (!safe_to_assign(tw, d, true)) return;
-            d.references.push(node.expression);
-            d.assignments++;
+            d.references.push(exp);
             d.chained = true;
             d.fixed = function() {
                 return make_node(AST_Binary, node, {
@@ -821,7 +826,7 @@ merge(Compressor.prototype, {
             tw.in_loop = saved_loop;
             return true;
         });
-    })(function(node, func){
+    })(function(node, func) {
         node.DEFMETHOD("reduce_vars", func);
     });
 
@@ -901,7 +906,7 @@ merge(Compressor.prototype, {
             if (!props.end) props.end = orig.end;
         }
         return new ctor(props);
-    };
+    }
 
     function make_sequence(orig, expressions) {
         if (expressions.length == 1) return expressions[0];
@@ -943,7 +948,7 @@ merge(Compressor.prototype, {
                 type: typeof val
             }));
         }
-    };
+    }
 
     // we shouldn't compress (1,func)(something) to
     // func(something) because that changes the meaning of
@@ -972,14 +977,14 @@ merge(Compressor.prototype, {
         if (thing instanceof AST_EmptyStatement) return [];
         if (thing instanceof AST_Statement) return [ thing ];
         throw new Error("Can't convert thing to statement array");
-    };
+    }
 
     function is_empty(thing) {
         if (thing === null) return true;
         if (thing instanceof AST_EmptyStatement) return true;
         if (thing instanceof AST_BlockStatement) return thing.body.length == 0;
         return false;
-    };
+    }
 
     function can_be_evicted_from_block(node) {
         return !(
@@ -997,7 +1002,7 @@ merge(Compressor.prototype, {
             return x.body instanceof AST_BlockStatement ? x.body : x;
         }
         return x;
-    };
+    }
 
     function is_iife_call(node) {
         if (node.TYPE != "Call") return false;
@@ -1102,6 +1107,7 @@ merge(Compressor.prototype, {
                     || node instanceof AST_LoopControl
                     || node instanceof AST_Try
                     || node instanceof AST_With
+                    || node instanceof AST_Yield
                     || parent instanceof AST_For && node !== parent.init
                     || !replace_all
                         && (node instanceof AST_SymbolRef && !node.is_declared(compressor))) {
@@ -1384,7 +1390,13 @@ merge(Compressor.prototype, {
                     extract_candidates(expr.alternative);
                 } else if (expr instanceof AST_Definitions
                     && (compressor.option("unused") || !(expr instanceof AST_Const))) {
-                    expr.definitions.forEach(extract_candidates);
+                    var len = expr.definitions.length;
+                    // limit number of trailing variable definitions for consideration
+                    var i = len - 200;
+                    if (i < 0) i = 0;
+                    for (; i < len; i++) {
+                        extract_candidates(expr.definitions[i]);
+                    }
                 } else if (expr instanceof AST_DWLoop) {
                     extract_candidates(expr.condition);
                     if (!(expr.body instanceof AST_Block)) {
@@ -1921,7 +1933,7 @@ merge(Compressor.prototype, {
                 CHANGED = true;
                 var left = prev.body;
                 return make_sequence(left, [ left, right ]).transform(compressor);
-            };
+            }
             var n = 0, prev;
             for (var i = 0; i < statements.length; i++) {
                 var stat = statements[i];
@@ -2112,7 +2124,7 @@ merge(Compressor.prototype, {
         if (!(stat instanceof AST_Defun)) {
             compressor.warn("Dropping unreachable code [{file}:{line},{col}]", stat.start);
         }
-        stat.walk(new TreeWalker(function(node){
+        stat.walk(new TreeWalker(function(node) {
             if (node instanceof AST_Var) {
                 compressor.warn("Declarations in unreachable code! [{file}:{line},{col}]", node.start);
                 node.remove_initializers();
@@ -2134,7 +2146,7 @@ merge(Compressor.prototype, {
                 return true;
             }
         }));
-    };
+    }
 
     function get_value(key) {
         if (key instanceof AST_Constant) {
@@ -2193,15 +2205,15 @@ merge(Compressor.prototype, {
         def(AST_Binary, function(compressor) {
             return (this.operator == "&&" || this.operator == "||")
                 && (this.left._dot_throw(compressor) || this.right._dot_throw(compressor));
-        })
+        });
         def(AST_Assign, function(compressor) {
             return this.operator == "="
                 && this.right._dot_throw(compressor);
-        })
+        });
         def(AST_Conditional, function(compressor) {
             return this.consequent._dot_throw(compressor)
                 || this.alternative._dot_throw(compressor);
-        })
+        });
         def(AST_Dot, function(compressor) {
             if (!is_strict(compressor)) return false;
             if (this.expression instanceof AST_Function && this.property == "prototype") return false;
@@ -2225,86 +2237,86 @@ merge(Compressor.prototype, {
     /* -----[ boolean/negation helpers ]----- */
 
     // methods to determine whether an expression has a boolean result type
-    (function(def){
+    (function(def) {
         var unary_bool = [ "!", "delete" ];
         var binary_bool = [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ];
         def(AST_Node, return_false);
-        def(AST_UnaryPrefix, function(){
+        def(AST_UnaryPrefix, function() {
             return member(this.operator, unary_bool);
         });
-        def(AST_Binary, function(){
+        def(AST_Binary, function() {
             return member(this.operator, binary_bool)
                 || lazy_op(this.operator)
                     && this.left.is_boolean()
                     && this.right.is_boolean();
         });
-        def(AST_Conditional, function(){
+        def(AST_Conditional, function() {
             return this.consequent.is_boolean() && this.alternative.is_boolean();
         });
-        def(AST_Assign, function(){
+        def(AST_Assign, function() {
             return this.operator == "=" && this.right.is_boolean();
         });
-        def(AST_Sequence, function(){
+        def(AST_Sequence, function() {
             return this.tail_node().is_boolean();
         });
         def(AST_True, return_true);
         def(AST_False, return_true);
-    })(function(node, func){
+    })(function(node, func) {
         node.DEFMETHOD("is_boolean", func);
     });
 
     // methods to determine if an expression has a numeric result type
-    (function(def){
+    (function(def) {
         def(AST_Node, return_false);
         def(AST_Number, return_true);
         var unary = makePredicate("+ - ~ ++ --");
-        def(AST_Unary, function(){
+        def(AST_Unary, function() {
             return unary(this.operator);
         });
         var binary = makePredicate("- * / % & | ^ << >> >>>");
-        def(AST_Binary, function(compressor){
+        def(AST_Binary, function(compressor) {
             return binary(this.operator) || this.operator == "+"
                 && this.left.is_number(compressor)
                 && this.right.is_number(compressor);
         });
-        def(AST_Assign, function(compressor){
+        def(AST_Assign, function(compressor) {
             return binary(this.operator.slice(0, -1))
                 || this.operator == "=" && this.right.is_number(compressor);
         });
-        def(AST_Sequence, function(compressor){
+        def(AST_Sequence, function(compressor) {
             return this.tail_node().is_number(compressor);
         });
-        def(AST_Conditional, function(compressor){
+        def(AST_Conditional, function(compressor) {
             return this.consequent.is_number(compressor) && this.alternative.is_number(compressor);
         });
-    })(function(node, func){
+    })(function(node, func) {
         node.DEFMETHOD("is_number", func);
     });
 
     // methods to determine if an expression has a string result type
-    (function(def){
+    (function(def) {
         def(AST_Node, return_false);
         def(AST_String, return_true);
-        def(AST_TemplateString, function(){
+        def(AST_TemplateString, function() {
             return this.segments.length === 1;
         });
-        def(AST_UnaryPrefix, function(){
+        def(AST_UnaryPrefix, function() {
             return this.operator == "typeof";
         });
-        def(AST_Binary, function(compressor){
+        def(AST_Binary, function(compressor) {
             return this.operator == "+" &&
                 (this.left.is_string(compressor) || this.right.is_string(compressor));
         });
-        def(AST_Assign, function(compressor){
+        def(AST_Assign, function(compressor) {
             return (this.operator == "=" || this.operator == "+=") && this.right.is_string(compressor);
         });
-        def(AST_Sequence, function(compressor){
+        def(AST_Sequence, function(compressor) {
             return this.tail_node().is_string(compressor);
         });
-        def(AST_Conditional, function(compressor){
+        def(AST_Conditional, function(compressor) {
             return this.consequent.is_string(compressor) && this.alternative.is_string(compressor);
         });
-    })(function(node, func){
+    })(function(node, func) {
         node.DEFMETHOD("is_string", func);
     });
 
@@ -2316,7 +2328,7 @@ merge(Compressor.prototype, {
         if (parent instanceof AST_Assign && parent.left === node) return node;
     }
 
-    (function(def){
+    (function(def) {
         AST_Node.DEFMETHOD("resolve_defines", function(compressor) {
             if (!compressor.option("global_defs")) return;
             var def = this._find_defs(compressor, "");
@@ -2327,7 +2339,7 @@ merge(Compressor.prototype, {
                     parent = compressor.parent(level++);
                 } while (parent instanceof AST_PropAccess && parent.expression === node);
                 if (is_lhs(node, parent)) {
-                    compressor.warn('global_defs ' + this.print_to_string() + ' redefined [{file}:{line},{col}]', this.start);
+                    compressor.warn("global_defs " + this.print_to_string() + " redefined [{file}:{line},{col}]", this.start);
                 } else {
                     return def;
                 }
@@ -2355,10 +2367,10 @@ merge(Compressor.prototype, {
             return make_node_from_constant(value, orig);
         }
         def(AST_Node, noop);
-        def(AST_Dot, function(compressor, suffix){
+        def(AST_Dot, function(compressor, suffix) {
             return this.expression._find_defs(compressor, "." + this.property + suffix);
         });
-        def(AST_SymbolRef, function(compressor, suffix){
+        def(AST_SymbolRef, function(compressor, suffix) {
             if (!this.global()) return;
             var name;
             var defines = compressor.option("global_defs");
@@ -2374,7 +2386,7 @@ merge(Compressor.prototype, {
                 return node;
             }
         });
-    })(function(node, func){
+    })(function(node, func) {
         node.DEFMETHOD("_find_defs", func);
     });
 
@@ -2489,13 +2501,13 @@ merge(Compressor.prototype, {
     convert_to_predicate(static_fns);
 
     // methods to evaluate a constant expression
-    (function(def){
+    (function(def) {
         // If the node has been successfully reduced to a constant,
         // then its value is returned; otherwise the element itself
         // is returned.
         // They can be distinguished as constant value is never a
         // descendant of AST_Node.
-        AST_Node.DEFMETHOD("evaluate", function(compressor){
+        AST_Node.DEFMETHOD("evaluate", function(compressor) {
             if (!compressor.option("evaluate")) return this;
             var val = this._eval(compressor, 1);
             if (!val || val instanceof RegExp) return val;
@@ -2503,7 +2515,7 @@ merge(Compressor.prototype, {
             return val;
         });
         var unaryPrefix = makePredicate("! ~ - + void");
-        AST_Node.DEFMETHOD("is_constant", function(){
+        AST_Node.DEFMETHOD("is_constant", function() {
             // Accomodate when compress option evaluate=false
             // as well as the common constant expressions !0 and -1
             if (this instanceof AST_Constant) {
@@ -2514,13 +2526,13 @@ merge(Compressor.prototype, {
                     && unaryPrefix(this.operator);
             }
         });
-        def(AST_Statement, function(){
+        def(AST_Statement, function() {
             throw new Error(string_template("Cannot evaluate a statement [{file}:{line},{col}]", this.start));
         });
         def(AST_Lambda, return_this);
         def(AST_Class, return_this);
         def(AST_Node, return_this);
-        def(AST_Constant, function(){
+        def(AST_Constant, function() {
             return this.getValue();
         });
         def(AST_TemplateString, function() {
@@ -2564,7 +2576,7 @@ merge(Compressor.prototype, {
                         key = key._eval(compressor, depth);
                         if (key === prop.key) return this;
                     }
-                    if (typeof Object.prototype[key] === 'function') {
+                    if (typeof Object.prototype[key] === "function") {
                         return this;
                     }
                     if (prop.value instanceof AST_Function) continue;
@@ -2585,7 +2597,7 @@ merge(Compressor.prototype, {
                 && (e instanceof AST_Lambda
                     || e instanceof AST_SymbolRef
                         && e.fixed_value() instanceof AST_Lambda)) {
-                return typeof function(){};
+                return typeof function() {};
             }
             if (!non_converting_unary(this.operator)) depth++;
             e = e._eval(compressor, depth);
@@ -2765,12 +2777,12 @@ merge(Compressor.prototype, {
             return this;
         });
         def(AST_New, return_this);
-    })(function(node, func){
+    })(function(node, func) {
         node.DEFMETHOD("_eval", func);
     });
 
     // method to negate an expression
-    (function(def){
+    (function(def) {
         function basic_negation(exp) {
             return make_node(AST_UnaryPrefix, exp, {
                 operator: "!",
@@ -2787,35 +2799,35 @@ merge(Compressor.prototype, {
             }
             return best_of_expression(negated, alt);
         }
-        def(AST_Node, function(){
+        def(AST_Node, function() {
             return basic_negation(this);
         });
-        def(AST_Statement, function(){
+        def(AST_Statement, function() {
             throw new Error("Cannot negate a statement");
         });
-        def(AST_Function, function(){
+        def(AST_Function, function() {
             return basic_negation(this);
         });
-        def(AST_Arrow, function(){
+        def(AST_Arrow, function() {
             return basic_negation(this);
         });
-        def(AST_UnaryPrefix, function(){
+        def(AST_UnaryPrefix, function() {
             if (this.operator == "!")
                 return this.expression;
             return basic_negation(this);
         });
-        def(AST_Sequence, function(compressor){
+        def(AST_Sequence, function(compressor) {
             var expressions = this.expressions.slice();
             expressions.push(expressions.pop().negate(compressor));
             return make_sequence(this, expressions);
         });
-        def(AST_Conditional, function(compressor, first_in_statement){
+        def(AST_Conditional, function(compressor, first_in_statement) {
             var self = this.clone();
             self.consequent = self.consequent.negate(compressor);
             self.alternative = self.alternative.negate(compressor);
             return best(this, self, first_in_statement);
         });
-        def(AST_Binary, function(compressor, first_in_statement){
+        def(AST_Binary, function(compressor, first_in_statement) {
             var self = this.clone(), op = this.operator;
             if (compressor.option("unsafe_comps")) {
                 switch (op) {
@@ -2843,8 +2855,8 @@ merge(Compressor.prototype, {
             }
             return basic_negation(this);
         });
-    })(function(node, func){
-        node.DEFMETHOD("negate", function(compressor, first_in_statement){
+    })(function(node, func) {
+        node.DEFMETHOD("negate", function(compressor, first_in_statement) {
             return func.call(this, compressor, first_in_statement);
         });
     });
@@ -2884,7 +2896,7 @@ merge(Compressor.prototype, {
     });
 
     // determine if expression has side effects
-    (function(def){
+    (function(def) {
         def(AST_Node, return_true);
 
         def(AST_EmptyStatement, return_false);
@@ -2898,10 +2910,10 @@ merge(Compressor.prototype, {
             return false;
         }
 
-        def(AST_Block, function(compressor){
+        def(AST_Block, function(compressor) {
             return any(this.body, compressor);
         });
-        def(AST_Call, function(compressor){
+        def(AST_Call, function(compressor) {
             if (!this.is_expr_pure(compressor)
                 && (!this.expression.is_call_pure(compressor)
                     || this.expression.has_side_effects(compressor))) {
@@ -2909,91 +2921,91 @@ merge(Compressor.prototype, {
             }
             return any(this.args, compressor);
         });
-        def(AST_Switch, function(compressor){
+        def(AST_Switch, function(compressor) {
             return this.expression.has_side_effects(compressor)
                 || any(this.body, compressor);
         });
-        def(AST_Case, function(compressor){
+        def(AST_Case, function(compressor) {
             return this.expression.has_side_effects(compressor)
                 || any(this.body, compressor);
         });
-        def(AST_Try, function(compressor){
+        def(AST_Try, function(compressor) {
             return any(this.body, compressor)
                 || this.bcatch && this.bcatch.has_side_effects(compressor)
                 || this.bfinally && this.bfinally.has_side_effects(compressor);
         });
-        def(AST_If, function(compressor){
+        def(AST_If, function(compressor) {
             return this.condition.has_side_effects(compressor)
                 || this.body && this.body.has_side_effects(compressor)
                 || this.alternative && this.alternative.has_side_effects(compressor);
         });
-        def(AST_LabeledStatement, function(compressor){
+        def(AST_LabeledStatement, function(compressor) {
             return this.body.has_side_effects(compressor);
         });
-        def(AST_SimpleStatement, function(compressor){
+        def(AST_SimpleStatement, function(compressor) {
             return this.body.has_side_effects(compressor);
         });
         def(AST_Lambda, return_false);
         def(AST_Class, return_false);
         def(AST_DefClass, return_true);
-        def(AST_Binary, function(compressor){
+        def(AST_Binary, function(compressor) {
             return this.left.has_side_effects(compressor)
                 || this.right.has_side_effects(compressor);
         });
         def(AST_Assign, return_true);
-        def(AST_Conditional, function(compressor){
+        def(AST_Conditional, function(compressor) {
             return this.condition.has_side_effects(compressor)
                 || this.consequent.has_side_effects(compressor)
                 || this.alternative.has_side_effects(compressor);
         });
-        def(AST_Unary, function(compressor){
+        def(AST_Unary, function(compressor) {
             return unary_side_effects(this.operator)
                 || this.expression.has_side_effects(compressor);
         });
-        def(AST_SymbolRef, function(compressor){
+        def(AST_SymbolRef, function(compressor) {
             return !this.is_declared(compressor);
         });
         def(AST_SymbolDeclaration, return_false);
-        def(AST_Object, function(compressor){
+        def(AST_Object, function(compressor) {
             return any(this.properties, compressor);
         });
-        def(AST_ObjectProperty, function(compressor){
+        def(AST_ObjectProperty, function(compressor) {
             if (this.key instanceof AST_ObjectKeyVal &&
                     this.key.has_side_effects(compressor))
                 return true;
             return this.value.has_side_effects(compressor);
         });
-        def(AST_Array, function(compressor){
+        def(AST_Array, function(compressor) {
             return any(this.elements, compressor);
         });
-        def(AST_Dot, function(compressor){
+        def(AST_Dot, function(compressor) {
             return this.expression.may_throw_on_access(compressor)
                 || this.expression.has_side_effects(compressor);
         });
-        def(AST_Sub, function(compressor){
+        def(AST_Sub, function(compressor) {
             return this.expression.may_throw_on_access(compressor)
                 || this.expression.has_side_effects(compressor)
                 || this.property.has_side_effects(compressor);
         });
-        def(AST_Sequence, function(compressor){
+        def(AST_Sequence, function(compressor) {
             return any(this.expressions, compressor);
         });
-        def(AST_Definitions, function(compressor){
+        def(AST_Definitions, function(compressor) {
             return any(this.definitions, compressor);
         });
-        def(AST_VarDef, function(compressor){
+        def(AST_VarDef, function(compressor) {
             return this.value;
         });
         def(AST_TemplateSegment, return_false);
-        def(AST_TemplateString, function(compressor){
+        def(AST_TemplateString, function(compressor) {
             return any(this.segments, compressor);
         });
-    })(function(node, func){
+    })(function(node, func) {
         node.DEFMETHOD("has_side_effects", func);
     });
 
     // determine if expression may throw
-    (function(def){
+    (function(def) {
         def(AST_Node, return_true);
 
         def(AST_Class, return_false);
@@ -3010,10 +3022,10 @@ merge(Compressor.prototype, {
             return false;
         }
 
-        def(AST_Array, function(compressor){
+        def(AST_Array, function(compressor) {
             return any(this.elements, compressor);
         });
-        def(AST_Assign, function(compressor){
+        def(AST_Assign, function(compressor) {
             if (this.right.may_throw(compressor)) return true;
             if (!compressor.has_directive("use strict")
                 && this.operator == "="
@@ -3022,90 +3034,90 @@ merge(Compressor.prototype, {
             }
             return this.left.may_throw(compressor);
         });
-        def(AST_Binary, function(compressor){
+        def(AST_Binary, function(compressor) {
             return this.left.may_throw(compressor)
                 || this.right.may_throw(compressor);
         });
-        def(AST_Block, function(compressor){
+        def(AST_Block, function(compressor) {
             return any(this.body, compressor);
         });
-        def(AST_Call, function(compressor){
+        def(AST_Call, function(compressor) {
             if (any(this.args, compressor)) return true;
             if (this.is_expr_pure(compressor)) return false;
             if (this.expression.may_throw(compressor)) return true;
             return !(this.expression instanceof AST_Lambda)
                 || any(this.expression.body, compressor);
         });
-        def(AST_Case, function(compressor){
+        def(AST_Case, function(compressor) {
             return this.expression.may_throw(compressor)
                 || any(this.body, compressor);
         });
-        def(AST_Conditional, function(compressor){
+        def(AST_Conditional, function(compressor) {
             return this.condition.may_throw(compressor)
                 || this.consequent.may_throw(compressor)
                 || this.alternative.may_throw(compressor);
         });
-        def(AST_Definitions, function(compressor){
+        def(AST_Definitions, function(compressor) {
             return any(this.definitions, compressor);
         });
-        def(AST_Dot, function(compressor){
+        def(AST_Dot, function(compressor) {
             return this.expression.may_throw_on_access(compressor)
                 || this.expression.may_throw(compressor);
         });
-        def(AST_If, function(compressor){
+        def(AST_If, function(compressor) {
             return this.condition.may_throw(compressor)
                 || this.body && this.body.may_throw(compressor)
                 || this.alternative && this.alternative.may_throw(compressor);
         });
-        def(AST_LabeledStatement, function(compressor){
+        def(AST_LabeledStatement, function(compressor) {
             return this.body.may_throw(compressor);
         });
-        def(AST_Object, function(compressor){
+        def(AST_Object, function(compressor) {
             return any(this.properties, compressor);
         });
-        def(AST_ObjectProperty, function(compressor){
+        def(AST_ObjectProperty, function(compressor) {
             return this.value.may_throw(compressor);
         });
-        def(AST_Return, function(compressor){
+        def(AST_Return, function(compressor) {
             return this.value && this.value.may_throw(compressor);
         });
-        def(AST_Sequence, function(compressor){
+        def(AST_Sequence, function(compressor) {
             return any(this.expressions, compressor);
         });
-        def(AST_SimpleStatement, function(compressor){
+        def(AST_SimpleStatement, function(compressor) {
             return this.body.may_throw(compressor);
         });
-        def(AST_Sub, function(compressor){
+        def(AST_Sub, function(compressor) {
             return this.expression.may_throw_on_access(compressor)
                 || this.expression.may_throw(compressor)
                 || this.property.may_throw(compressor);
         });
-        def(AST_Switch, function(compressor){
+        def(AST_Switch, function(compressor) {
             return this.expression.may_throw(compressor)
                 || any(this.body, compressor);
         });
-        def(AST_SymbolRef, function(compressor){
+        def(AST_SymbolRef, function(compressor) {
             return !this.is_declared(compressor);
         });
-        def(AST_Try, function(compressor){
+        def(AST_Try, function(compressor) {
             return this.bcatch ? this.bcatch.may_throw(compressor) : any(this.body, compressor)
                 || this.bfinally && this.bfinally.may_throw(compressor);
         });
-        def(AST_Unary, function(compressor){
+        def(AST_Unary, function(compressor) {
             if (this.operator == "typeof" && this.expression instanceof AST_SymbolRef)
                 return false;
             return this.expression.may_throw(compressor);
         });
-        def(AST_VarDef, function(compressor){
+        def(AST_VarDef, function(compressor) {
             if (!this.value) return false;
             return this.value.may_throw(compressor);
         });
-    })(function(node, func){
+    })(function(node, func) {
         node.DEFMETHOD("may_throw", func);
     });
 
     // determine if expression is constant
-    (function(def){
+    (function(def) {
         function all(list) {
             for (var i = list.length; --i >= 0;)
                 if (!list[i].is_constant_expression())
@@ -3147,68 +3159,76 @@ merge(Compressor.prototype, {
 
         def(AST_Node, return_false);
         def(AST_Constant, return_true);
-        def(AST_Class, all_refs_local);
+        def(AST_Class, function(scope) {
+            var self = this;
+            if (self.extends && !self.extends.is_constant_expression(scope)) {
+                return false;
+            }
+            return all_refs_local.call(self, scope);
+        });
         def(AST_Lambda, all_refs_local);
-        def(AST_Unary, function(){
+        def(AST_Unary, function() {
             return this.expression.is_constant_expression();
         });
-        def(AST_Binary, function(){
+        def(AST_Binary, function() {
             return this.left.is_constant_expression() && this.right.is_constant_expression();
         });
-        def(AST_Array, function(){
+        def(AST_Array, function() {
             return all(this.elements);
         });
-        def(AST_Object, function(){
+        def(AST_Object, function() {
             return all(this.properties);
         });
-        def(AST_ObjectProperty, function(){
+        def(AST_ObjectProperty, function() {
             return !(this.key instanceof AST_Node) && this.value.is_constant_expression();
         });
-    })(function(node, func){
+    })(function(node, func) {
         node.DEFMETHOD("is_constant_expression", func);
     });
 
     // tell me if a statement aborts
     function aborts(thing) {
         return thing && thing.aborts();
-    };
-    (function(def){
+    }
+    (function(def) {
         def(AST_Statement, return_null);
         def(AST_Jump, return_this);
-        function block_aborts(){
+        function block_aborts() {
             for (var i = 0; i < this.body.length; i++) {
                 if (aborts(this.body[i])) {
                     return this.body[i];
                 }
             }
             return null;
-        };
-        def(AST_Import, function(){ return null; });
+        }
+        def(AST_Import, function() { return null; });
         def(AST_BlockStatement, block_aborts);
         def(AST_SwitchBranch, block_aborts);
-        def(AST_If, function(){
+        def(AST_If, function() {
             return this.alternative && aborts(this.body) && aborts(this.alternative) && this;
         });
-    })(function(node, func){
+    })(function(node, func) {
         node.DEFMETHOD("aborts", func);
     });
 
     /* -----[ optimizers ]----- */
 
-    OPT(AST_Directive, function(self, compressor){
-        if (compressor.has_directive(self.value) !== self) {
+    var directives = ["use asm", "use strict"];
+    OPT(AST_Directive, function(self, compressor) {
+        if (compressor.option("directives")
+            && (!member(self.value, directives) || compressor.has_directive(self.value) !== self)) {
             return make_node(AST_EmptyStatement, self);
         }
         return self;
     });
 
-    OPT(AST_Debugger, function(self, compressor){
+    OPT(AST_Debugger, function(self, compressor) {
         if (compressor.option("drop_debugger"))
             return make_node(AST_EmptyStatement, self);
         return self;
     });
 
-    OPT(AST_LabeledStatement, function(self, compressor){
+    OPT(AST_LabeledStatement, function(self, compressor) {
         if (self.body instanceof AST_Break
             && compressor.loopcontrol_target(self.body) === self.body) {
             return make_node(AST_EmptyStatement, self);
@@ -3216,7 +3236,7 @@ merge(Compressor.prototype, {
         return self.label.references.length == 0 ? self.body : self;
     });
 
-    OPT(AST_Block, function(self, compressor){
+    OPT(AST_Block, function(self, compressor) {
         tighten_body(self.body, compressor);
         return self;
     });
@@ -3229,7 +3249,7 @@ merge(Compressor.prototype, {
         );
     }
 
-    OPT(AST_BlockStatement, function(self, compressor){
+    OPT(AST_BlockStatement, function(self, compressor) {
         tighten_body(self.body, compressor);
         switch (self.body.length) {
           case 1:
@@ -3256,7 +3276,7 @@ merge(Compressor.prototype, {
     }
     OPT(AST_Lambda, opt_AST_Lambda);
 
-    AST_Scope.DEFMETHOD("drop_unused", function(compressor){
+    AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
         if (!compressor.option("unused")) return;
         if (compressor.has_directive("use asm")) return;
         var self = this;
@@ -3286,7 +3306,17 @@ merge(Compressor.prototype, {
         // pass 1: find out which symbols are directly used in
         // this scope (not in nested scopes).
         var scope = this;
-        var tw = new TreeWalker(function(node, descend){
+        var tw = new TreeWalker(function(node, descend) {
+            if (node instanceof AST_Lambda && node.uses_arguments && !tw.has_directive("use strict")) {
+                node.argnames.forEach(function(argname) {
+                    if (!(argname instanceof AST_SymbolDeclaration)) return;
+                    var def = argname.definition();
+                    if (!(def.id in in_use_ids)) {
+                        in_use_ids[def.id] = true;
+                        in_use.push(def);
+                    }
+                });
+            }
             if (node === self) return;
             if (node instanceof AST_Defun || node instanceof AST_DefClass) {
                 var node_def = node.name.definition();
@@ -3305,7 +3335,7 @@ merge(Compressor.prototype, {
             }
             if (node instanceof AST_Definitions && scope === self) {
                 var in_export = tw.parent() instanceof AST_Export;
-                node.definitions.forEach(function(def){
+                node.definitions.forEach(function(def) {
                     if (def.name instanceof AST_SymbolVar) {
                         var_defs_by_id.add(def.name.definition().id, def);
                     }
@@ -3327,7 +3357,7 @@ merge(Compressor.prototype, {
                             def.walk(tw);
                             destructuring_value = destructuring_cache;
                         } else {
-                            var node_def = def.name.definition();;
+                            var node_def = def.name.definition();
                             initializations.add(node_def.id, def.value);
                             if (!node_def.chained && def.name.fixed_value() === def.value) {
                                 fixed_ids[node_def.id] = def;
@@ -3382,8 +3412,7 @@ merge(Compressor.prototype, {
                     // any declarations with same name will overshadow
                     // name of this anonymous function and can therefore
                     // never be used anywhere
-                    if (!(def.id in in_use_ids) || def.orig.length > 1)
-                        node.name = null;
+                    if (!(def.id in in_use_ids) || def.orig.length > 1) node.name = null;
                 }
                 if (node instanceof AST_Lambda && !(node instanceof AST_Accessor)) {
                     var trim = !compressor.option("keep_fargs");
@@ -3406,8 +3435,7 @@ merge(Compressor.prototype, {
                                 a.pop();
                                 compressor[sym.unreferenced() ? "warn" : "info"]("Dropping unused function argument {name} [{file}:{line},{col}]", template(sym));
                             }
-                        }
-                        else {
+                        } else {
                             trim = false;
                         }
                     }
@@ -3605,7 +3633,7 @@ merge(Compressor.prototype, {
         }
     });
 
-    AST_Scope.DEFMETHOD("hoist_declarations", function(compressor){
+    AST_Scope.DEFMETHOD("hoist_declarations", function(compressor) {
         var self = this;
         if (compressor.has_directive("use asm")) return self;
         // Hoisting makes no sense in an arrow func
@@ -3620,7 +3648,7 @@ merge(Compressor.prototype, {
             var vars = new Dictionary(), vars_found = 0, var_decl = 0;
             // let's count var_decl first, we seem to waste a lot of
             // space if we hoist `var` when there's only one.
-            self.walk(new TreeWalker(function(node){
+            self.walk(new TreeWalker(function(node) {
                 if (node instanceof AST_Scope && node !== self)
                     return true;
                 if (node instanceof AST_Var) {
@@ -3643,7 +3671,7 @@ merge(Compressor.prototype, {
                             return make_node(AST_EmptyStatement, node);
                         }
                         if (hoist_vars && node instanceof AST_Var) {
-                            node.definitions.forEach(function(def){
+                            node.definitions.forEach(function(def) {
                                 if (def.name instanceof AST_Destructuring) return;
                                 vars.set(def.name.name, def);
                                 ++vars_found;
@@ -3674,9 +3702,9 @@ merge(Compressor.prototype, {
             if (vars_found > 0) {
                 // collect only vars which don't show up in self's arguments list
                 var defs = [];
-                vars.each(function(def, name){
+                vars.each(function(def, name) {
                     if (self instanceof AST_Lambda
-                        && find_if(function(x){ return x.name == def.name.name },
+                        && find_if(function(x) { return x.name == def.name.name; },
                                    self.args_as_names())) {
                         vars.del(name);
                     } else {
@@ -3734,7 +3762,7 @@ merge(Compressor.prototype, {
                         definitions: defs
                     });
                     hoisted.push(defs);
-                };
+                }
             }
             self.body = dirs.concat(hoisted, self.body);
         }
@@ -3764,7 +3792,7 @@ merge(Compressor.prototype, {
         return name;
     });
 
-    AST_Scope.DEFMETHOD("hoist_properties", function(compressor){
+    AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
         var self = this;
         if (!compressor.option("hoist_props") || compressor.has_directive("use asm")) return self;
         var top_retain = self instanceof AST_Toplevel && compressor.top_retain || return_false;
@@ -3825,7 +3853,7 @@ merge(Compressor.prototype, {
 
     // drop_side_effect_free()
     // remove side-effect-free parts which only affects return value
-    (function(def){
+    (function(def) {
         // Drop side-effect-free elements from an array of expressions.
         // Returns an array of expressions with side-effects or null
         // if all elements were dropped. Note: original array may be
@@ -3848,7 +3876,7 @@ merge(Compressor.prototype, {
         def(AST_Node, return_this);
         def(AST_Constant, return_null);
         def(AST_This, return_null);
-        def(AST_Call, function(compressor, first_in_statement){
+        def(AST_Call, function(compressor, first_in_statement) {
             if (!this.is_expr_pure(compressor)) {
                 if (this.expression.is_call_pure(compressor)) {
                     var exprs = this.args.slice();
@@ -3874,7 +3902,7 @@ merge(Compressor.prototype, {
         def(AST_Function, return_null);
         def(AST_Arrow, return_null);
         def(AST_ClassExpression, return_null);
-        def(AST_Binary, function(compressor, first_in_statement){
+        def(AST_Binary, function(compressor, first_in_statement) {
             var right = this.right.drop_side_effect_free(compressor);
             if (!right) return this.left.drop_side_effect_free(compressor, first_in_statement);
             if (lazy_op(this.operator)) {
@@ -3888,7 +3916,7 @@ merge(Compressor.prototype, {
                 return make_sequence(this, [ left, right ]);
             }
         });
-        def(AST_Assign, function(compressor){
+        def(AST_Assign, function(compressor) {
             var left = this.left;
             if (left.has_side_effects(compressor)
                 || compressor.has_directive("use strict")
@@ -3905,7 +3933,7 @@ merge(Compressor.prototype, {
             }
             return this;
         });
-        def(AST_Conditional, function(compressor){
+        def(AST_Conditional, function(compressor) {
             var consequent = this.consequent.drop_side_effect_free(compressor);
             var alternative = this.alternative.drop_side_effect_free(compressor);
             if (consequent === this.consequent && alternative === this.alternative) return this;
@@ -3924,7 +3952,7 @@ merge(Compressor.prototype, {
             node.alternative = alternative;
             return node;
         });
-        def(AST_Unary, function(compressor, first_in_statement){
+        def(AST_Unary, function(compressor, first_in_statement) {
             if (unary_side_effects(this.operator)) {
                 this.write_only = !this.expression.has_side_effects(compressor);
                 return this;
@@ -3940,22 +3968,22 @@ merge(Compressor.prototype, {
         def(AST_SymbolRef, function(compressor) {
             return this.is_declared(compressor) ? null : this;
         });
-        def(AST_Object, function(compressor, first_in_statement){
+        def(AST_Object, function(compressor, first_in_statement) {
             var values = trim(this.properties, compressor, first_in_statement);
             return values && make_sequence(this, values);
         });
-        def(AST_ObjectProperty, function(compressor, first_in_statement){
+        def(AST_ObjectProperty, function(compressor, first_in_statement) {
             return this.value.drop_side_effect_free(compressor, first_in_statement);
         });
-        def(AST_Array, function(compressor, first_in_statement){
+        def(AST_Array, function(compressor, first_in_statement) {
             var values = trim(this.elements, compressor, first_in_statement);
             return values && make_sequence(this, values);
         });
-        def(AST_Dot, function(compressor, first_in_statement){
+        def(AST_Dot, function(compressor, first_in_statement) {
             if (this.expression.may_throw_on_access(compressor)) return this;
             return this.expression.drop_side_effect_free(compressor, first_in_statement);
         });
-        def(AST_Sub, function(compressor, first_in_statement){
+        def(AST_Sub, function(compressor, first_in_statement) {
             if (this.expression.may_throw_on_access(compressor)) return this;
             var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
             if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement);
@@ -3963,7 +3991,7 @@ merge(Compressor.prototype, {
             if (!property) return expression;
             return make_sequence(this, [ expression, property ]);
         });
-        def(AST_Sequence, function(compressor){
+        def(AST_Sequence, function(compressor) {
             var last = this.tail_node();
             var expr = last.drop_side_effect_free(compressor);
             if (expr === last) return this;
@@ -3971,19 +3999,19 @@ merge(Compressor.prototype, {
             if (expr) expressions.push(expr);
             return make_sequence(this, expressions);
         });
-        def(AST_Expansion, function(compressor, first_in_statement){
+        def(AST_Expansion, function(compressor, first_in_statement) {
             return this.expression.drop_side_effect_free(compressor, first_in_statement);
         });
         def(AST_TemplateSegment, return_null);
-        def(AST_TemplateString, function(compressor){
+        def(AST_TemplateString, function(compressor) {
             var values = trim(this.segments, compressor, first_in_statement);
             return values && make_sequence(this, values);
         });
-    })(function(node, func){
+    })(function(node, func) {
         node.DEFMETHOD("drop_side_effect_free", func);
     });
 
-    OPT(AST_SimpleStatement, function(self, compressor){
+    OPT(AST_SimpleStatement, function(self, compressor) {
         if (compressor.option("side_effects")) {
             var body = self.body;
             var node = body.drop_side_effect_free(compressor, true);
@@ -3998,7 +4026,7 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    OPT(AST_While, function(self, compressor){
+    OPT(AST_While, function(self, compressor) {
         return compressor.option("loops") ? make_node(AST_For, self, self).optimize(compressor) : self;
     });
 
@@ -4016,7 +4044,7 @@ merge(Compressor.prototype, {
         return found;
     }
 
-    OPT(AST_Do, function(self, compressor){
+    OPT(AST_Do, function(self, compressor) {
         if (!compressor.option("loops")) return self;
         var cond = self.condition.tail_node().evaluate(compressor);
         if (!(cond instanceof AST_Node)) {
@@ -4112,7 +4140,7 @@ merge(Compressor.prototype, {
         }
     }
 
-    OPT(AST_For, function(self, compressor){
+    OPT(AST_For, function(self, compressor) {
         if (!compressor.option("loops")) return self;
         if (compressor.option("side_effects") && self.init) {
             self.init = self.init.drop_side_effect_free(compressor);
@@ -4149,7 +4177,7 @@ merge(Compressor.prototype, {
         return if_break_in_loop(self, compressor);
     });
 
-    OPT(AST_If, function(self, compressor){
+    OPT(AST_If, function(self, compressor) {
         if (is_empty(self.alternative)) self.alternative = null;
 
         if (!compressor.option("conditionals")) return self;
@@ -4293,7 +4321,7 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    OPT(AST_Switch, function(self, compressor){
+    OPT(AST_Switch, function(self, compressor) {
         if (!compressor.option("switches")) return self;
         var branch;
         var value = self.expression.evaluate(compressor);
@@ -4399,7 +4427,7 @@ merge(Compressor.prototype, {
         }
     });
 
-    OPT(AST_Try, function(self, compressor){
+    OPT(AST_Try, function(self, compressor) {
         tighten_body(self.body, compressor);
         if (self.bcatch && self.bfinally && all(self.bfinally.body, is_empty)) self.bfinally = null;
         if (compressor.option("dead_code") && all(self.body, is_empty)) {
@@ -4424,7 +4452,7 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    AST_Definitions.DEFMETHOD("remove_initializers", function(){
+    AST_Definitions.DEFMETHOD("remove_initializers", function() {
         var decls = [];
         this.definitions.forEach(function(def) {
             if (def.name instanceof AST_SymbolDeclaration) {
@@ -4442,9 +4470,9 @@ merge(Compressor.prototype, {
         this.definitions = decls;
     });
 
-    AST_Definitions.DEFMETHOD("to_assignments", function(compressor){
+    AST_Definitions.DEFMETHOD("to_assignments", function(compressor) {
         var reduce_vars = compressor.option("reduce_vars");
-        var assignments = this.definitions.reduce(function(a, def){
+        var assignments = this.definitions.reduce(function(a, def) {
             if (def.value && !(def.name instanceof AST_Destructuring)) {
                 var name = make_node(AST_SymbolRef, def.name, def.name);
                 a.push(make_node(AST_Assign, def, {
@@ -4473,7 +4501,7 @@ merge(Compressor.prototype, {
         return make_sequence(this, assignments);
     });
 
-    OPT(AST_Definitions, function(self, compressor){
+    OPT(AST_Definitions, function(self, compressor) {
         if (self.definitions.length == 0)
             return make_node(AST_EmptyStatement, self);
         return self;
@@ -4483,7 +4511,7 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    OPT(AST_Call, function(self, compressor){
+    OPT(AST_Call, function(self, compressor) {
         var exp = self.expression;
         var fn = exp;
         var simple_args = all(self.args, function(arg) {
@@ -4658,7 +4686,7 @@ merge(Compressor.prototype, {
                         } else {
                             first = make_node(AST_String, self, { value: "" });
                         }
-                        return elements.reduce(function(prev, el){
+                        return elements.reduce(function(prev, el) {
                             return make_node(AST_Binary, el, {
                                 operator : "+",
                                 left     : prev,
@@ -4923,7 +4951,8 @@ merge(Compressor.prototype, {
                 if (!safe_to_inject) return false;
                 for (var j = stat.definitions.length; --j >= 0;) {
                     var name = stat.definitions[j].name;
-                    if (block_scoped[name.name]
+                    if (name instanceof AST_Destructuring
+                        || block_scoped[name.name]
                         || identifier_atom(name.name)
                         || scope.var_names()[name.name]) {
                         return false;
@@ -5044,7 +5073,7 @@ merge(Compressor.prototype, {
         }
     });
 
-    OPT(AST_New, function(self, compressor){
+    OPT(AST_New, function(self, compressor) {
         if (compressor.option("unsafe")) {
             var exp = self.expression;
             if (is_undeclared_ref(exp)) {
@@ -5061,7 +5090,7 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    OPT(AST_Sequence, function(self, compressor){
+    OPT(AST_Sequence, function(self, compressor) {
         if (!compressor.option("side_effects")) return self;
         var expressions = [];
         filter_for_side_effects();
@@ -5099,7 +5128,7 @@ merge(Compressor.prototype, {
         }
     });
 
-    AST_Unary.DEFMETHOD("lift_sequences", function(compressor){
+    AST_Unary.DEFMETHOD("lift_sequences", function(compressor) {
         if (compressor.option("sequences")) {
             if (this.expression instanceof AST_Sequence) {
                 var x = this.expression.expressions.slice();
@@ -5112,11 +5141,11 @@ merge(Compressor.prototype, {
         return this;
     });
 
-    OPT(AST_UnaryPostfix, function(self, compressor){
+    OPT(AST_UnaryPostfix, function(self, compressor) {
         return self.lift_sequences(compressor);
     });
 
-    OPT(AST_UnaryPrefix, function(self, compressor){
+    OPT(AST_UnaryPrefix, function(self, compressor) {
         var e = self.expression;
         if (self.operator == "delete"
             && !(e instanceof AST_SymbolRef
@@ -5190,7 +5219,7 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    AST_Binary.DEFMETHOD("lift_sequences", function(compressor){
+    AST_Binary.DEFMETHOD("lift_sequences", function(compressor) {
         if (compressor.option("sequences")) {
             if (this.left instanceof AST_Sequence) {
                 var x = this.left.expressions.slice();
@@ -5232,7 +5261,7 @@ merge(Compressor.prototype, {
             || node instanceof AST_Class;
     }
 
-    OPT(AST_Binary, function(self, compressor){
+    OPT(AST_Binary, function(self, compressor) {
         function reversible() {
             return self.left.is_constant()
                 || self.right.is_constant()
@@ -5662,7 +5691,7 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    OPT(AST_SymbolExport, function(self, compressor){
+    OPT(AST_SymbolExport, function(self, compressor) {
         return self;
     });
 
@@ -5677,7 +5706,7 @@ merge(Compressor.prototype, {
         return node;
     }
 
-    OPT(AST_SymbolRef, function(self, compressor){
+    OPT(AST_SymbolRef, function(self, compressor) {
         var def = self.resolve_defines(compressor);
         if (def) {
             return def.optimize(compressor);
@@ -5813,7 +5842,7 @@ merge(Compressor.prototype, {
         return lhs instanceof AST_SymbolRef || lhs.TYPE === self.TYPE;
     }
 
-    OPT(AST_Undefined, function(self, compressor){
+    OPT(AST_Undefined, function(self, compressor) {
         if (compressor.option("unsafe_undefined")) {
             var undef = find_variable(compressor, "undefined");
             if (undef) {
@@ -5836,7 +5865,7 @@ merge(Compressor.prototype, {
         });
     });
 
-    OPT(AST_Infinity, function(self, compressor){
+    OPT(AST_Infinity, function(self, compressor) {
         var lhs = is_lhs(compressor.self(), compressor.parent());
         if (lhs && is_atomic(lhs, self)) return self;
         if (compressor.option("keep_infinity")
@@ -5854,7 +5883,7 @@ merge(Compressor.prototype, {
         });
     });
 
-    OPT(AST_NaN, function(self, compressor){
+    OPT(AST_NaN, function(self, compressor) {
         var lhs = is_lhs(compressor.self(), compressor.parent());
         if (lhs && !is_atomic(lhs, self)
             || find_variable(compressor, "NaN")) {
@@ -5892,9 +5921,9 @@ merge(Compressor.prototype, {
         return reachable;
     }
 
-    var ASSIGN_OPS = [ '+', '-', '/', '*', '%', '>>', '<<', '>>>', '|', '^', '&' ];
-    var ASSIGN_OPS_COMMUTATIVE = [ '*', '|', '^', '&' ];
-    OPT(AST_Assign, function(self, compressor){
+    var ASSIGN_OPS = [ "+", "-", "/", "*", "%", ">>", "<<", ">>>", "|", "^", "&" ];
+    var ASSIGN_OPS_COMMUTATIVE = [ "*", "|", "^", "&" ];
+    OPT(AST_Assign, function(self, compressor) {
         var def;
         if (compressor.option("dead_code")
             && self.left instanceof AST_SymbolRef
@@ -5954,7 +5983,7 @@ merge(Compressor.prototype, {
         }
     });
 
-    OPT(AST_DefaultAssign, function(self, compressor){
+    OPT(AST_DefaultAssign, function(self, compressor) {
         if (!compressor.option("evaluate")) {
             return self;
         }
@@ -5971,7 +6000,7 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    OPT(AST_Conditional, function(self, compressor){
+    OPT(AST_Conditional, function(self, compressor) {
         if (!compressor.option("conditionals")) return self;
         // This looks like lift_sequences(), should probably be under "sequences"
         if (self.condition instanceof AST_Sequence) {
@@ -6177,7 +6206,7 @@ merge(Compressor.prototype, {
         }
     });
 
-    OPT(AST_Boolean, function(self, compressor){
+    OPT(AST_Boolean, function(self, compressor) {
         if (compressor.in_boolean_context()) return make_node(AST_Number, self, {
             value: +self.value
         });
@@ -6206,7 +6235,17 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    OPT(AST_Sub, function(self, compressor){
+    function safe_to_flatten(value, compressor) {
+        if (value instanceof AST_SymbolRef) {
+            value = value.fixed_value();
+        }
+        if (!value) return false;
+        return !(value instanceof AST_Lambda || value instanceof AST_Class)
+            || compressor.parent() instanceof AST_New
+            || !value.contains_this();
+    }
+
+    OPT(AST_Sub, function(self, compressor) {
         var expr = self.expression;
         var prop = self.property;
         if (compressor.option("properties")) {
@@ -6233,6 +6272,51 @@ merge(Compressor.prototype, {
                 }
             }
         }
+        var fn;
+        OPT_ARGUMENTS: if (compressor.option("arguments")
+            && expr instanceof AST_SymbolRef
+            && expr.name == "arguments"
+            && expr.definition().orig.length == 1
+            && (fn = expr.scope) instanceof AST_Lambda
+            && fn.uses_arguments
+            && !(fn instanceof AST_Arrow)
+            && prop instanceof AST_Number) {
+            var index = prop.getValue();
+            var params = Object.create(null);
+            var argnames = fn.argnames;
+            for (var n = 0; n < argnames.length; n++) {
+                if (!(argnames[n] instanceof AST_SymbolFunarg)) {
+                    break OPT_ARGUMENTS; // destructuring parameter - bail
+                }
+                var param = argnames[n].name;
+                if (param in params) {
+                    break OPT_ARGUMENTS; // duplicate parameter - bail
+                }
+                params[param] = true;
+            }
+            var argname = fn.argnames[index];
+            if (argname && compressor.has_directive("use strict")) {
+                var def = argname.definition();
+                if (!compressor.option("reduce_vars") || def.assignments || def.orig.length > 1) {
+                    argname = null;
+                }
+            } else if (!argname && !compressor.option("keep_fargs") && index < fn.argnames.length + 5) {
+                while (index >= fn.argnames.length) {
+                    argname = make_node(AST_SymbolFunarg, fn, {
+                        name: fn.make_var_name("argument_" + fn.argnames.length),
+                        scope: fn
+                    });
+                    fn.argnames.push(argname);
+                    fn.enclosed.push(fn.def_variable(argname));
+                }
+            }
+            if (argname) {
+                var sym = make_node(AST_SymbolRef, self, argname);
+                sym.reference({});
+                delete argname.__unused;
+                return sym;
+            }
+        }
         if (is_lhs(self, compressor.parent())) return self;
         if (key !== prop) {
             var sub = self.flatten_object(property, compressor);
@@ -6245,7 +6329,8 @@ merge(Compressor.prototype, {
             && prop instanceof AST_Number && expr instanceof AST_Array) {
             var index = prop.getValue();
             var elements = expr.elements;
-            FLATTEN: if (index in elements) {
+            var retValue = elements[index];
+            FLATTEN: if (safe_to_flatten(retValue, compressor)) {
                 var flatten = true;
                 var values = [];
                 for (var i = elements.length; --i > index;) {
@@ -6255,7 +6340,6 @@ merge(Compressor.prototype, {
                         if (flatten && value.has_side_effects(compressor)) flatten = false;
                     }
                 }
-                var retValue = elements[index];
                 if (retValue instanceof AST_Expansion) break FLATTEN;
                 retValue = retValue instanceof AST_Hole ? make_node(AST_Undefined, retValue) : retValue;
                 if (!flatten) values.unshift(retValue);
@@ -6279,32 +6363,6 @@ merge(Compressor.prototype, {
                 });
             }
         }
-        var fn;
-        if (compressor.option("arguments")
-            && expr instanceof AST_SymbolRef
-            && expr.name == "arguments"
-            && expr.definition().orig.length == 1
-            && (fn = expr.scope) instanceof AST_Lambda
-            && !(fn instanceof AST_Arrow)
-            && prop instanceof AST_Number) {
-            var index = prop.getValue();
-            var argname = fn.argnames[index];
-            if (!argname && !compressor.option("keep_fargs")) {
-                while (index >= fn.argnames.length) {
-                    argname = make_node(AST_SymbolFunarg, fn, {
-                        name: fn.make_var_name("argument_" + fn.argnames.length),
-                        scope: fn
-                    });
-                    fn.argnames.push(argname);
-                    fn.enclosed.push(fn.def_variable(argname));
-                }
-            }
-            if (argname) {
-                var sym = make_node(AST_SymbolRef, self, argname);
-                sym.reference({});
-                return sym;
-            }
-        }
         var ev = self.evaluate(compressor);
         if (ev !== self) {
             ev = make_node_from_constant(ev, self).optimize(compressor);
@@ -6337,10 +6395,7 @@ merge(Compressor.prototype, {
                         return prop instanceof AST_ObjectKeyVal
                             || arrows && prop instanceof AST_ConciseMethod && !prop.is_generator;
                     })) break;
-                    var value = prop.value;
-                    if ((value instanceof AST_Accessor || value instanceof AST_Function)
-                        && !(compressor.parent() instanceof AST_New)
-                        && value.contains_this()) break;
+                    if (!safe_to_flatten(prop.value, compressor)) break;
                     return make_node(AST_Sub, this, {
                         expression: make_node(AST_Array, expr, {
                             elements: props.map(function(prop) {
@@ -6362,7 +6417,7 @@ merge(Compressor.prototype, {
         }
     });
 
-    OPT(AST_Dot, function(self, compressor){
+    OPT(AST_Dot, function(self, compressor) {
         if (self.property == "arguments" || self.property == "caller") {
             compressor.warn("Function.protoype.{prop} not supported [{file}:{line},{col}]", {
                 prop: self.property,
@@ -6432,19 +6487,19 @@ merge(Compressor.prototype, {
             ]).optimize(compressor));
         }
         return self;
-    };
+    }
     OPT(AST_Array, literals_in_boolean_context);
     OPT(AST_Object, literals_in_boolean_context);
     OPT(AST_RegExp, literals_in_boolean_context);
 
-    OPT(AST_Return, function(self, compressor){
+    OPT(AST_Return, function(self, compressor) {
         if (self.value && is_undefined(self.value, compressor)) {
             self.value = null;
         }
         return self;
     });
 
-    OPT(AST_Arrow, function(self, compressor){
+    OPT(AST_Arrow, function(self, compressor) {
         if (!(self.body instanceof AST_Node)) {
             self = opt_AST_Lambda(self, compressor);
         }
@@ -6457,7 +6512,7 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    OPT(AST_Function, function(self, compressor){
+    OPT(AST_Function, function(self, compressor) {
         self = opt_AST_Lambda(self, compressor);
         if (compressor.option("unsafe_arrows")
             && compressor.option("ecma") >= 6
@@ -6478,28 +6533,28 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    OPT(AST_Class, function(self, compressor){
+    OPT(AST_Class, function(self, compressor) {
         // HACK to avoid compress failure.
         // AST_Class is not really an AST_Scope/AST_Block as it lacks a body.
         return self;
     });
 
-    OPT(AST_Yield, function(self, compressor){
+    OPT(AST_Yield, function(self, compressor) {
         if (self.expression && !self.is_star && is_undefined(self.expression, compressor)) {
             self.expression = null;
         }
         return self;
     });
 
-    OPT(AST_VarDef, function(self, compressor){
+    OPT(AST_VarDef, function(self, compressor) {
         var defines = compressor.option("global_defs");
         if (defines && HOP(defines, self.name.name)) {
-            compressor.warn('global_defs ' + self.name.name + ' redefined [{file}:{line},{col}]', self.start);
+            compressor.warn("global_defs " + self.name.name + " redefined [{file}:{line},{col}]", self.start);
         }
         return self;
     });
 
-    OPT(AST_TemplateString, function(self, compressor){
+    OPT(AST_TemplateString, function(self, compressor) {
         if (!compressor.option("evaluate")
         || compressor.parent() instanceof AST_PrefixedTemplateString)
             return self;
@@ -6524,7 +6579,7 @@ merge(Compressor.prototype, {
         return segments.length == 1 ? make_node(AST_String, self, segments[0]) : self;
     });
 
-    OPT(AST_PrefixedTemplateString, function(self, compressor){
+    OPT(AST_PrefixedTemplateString, function(self, compressor) {
         return self;
     });
 
@@ -6551,7 +6606,7 @@ merge(Compressor.prototype, {
 
     OPT(AST_ObjectProperty, lift_key);
 
-    OPT(AST_ConciseMethod, function(self, compressor){
+    OPT(AST_ConciseMethod, function(self, compressor) {
         lift_key(self, compressor);
         // p(){return x;} ---> p:()=>x
         if (compressor.option("arrows")
@@ -6575,7 +6630,7 @@ merge(Compressor.prototype, {
         return self;
     });
 
-    OPT(AST_ObjectKeyVal, function(self, compressor){
+    OPT(AST_ObjectKeyVal, function(self, compressor) {
         lift_key(self, compressor);
         // p:function(){} ---> p(){}
         // p:function*(){} ---> *p(){}