terser 5.0.0-beta.2 → 5.2.1

package/lib/compress/index.js

@@ -78,6 +78,7 @@ import {
     AST_Call,
     AST_Case,
     AST_Catch,
+    AST_Chain,
     AST_Class,
     AST_ClassExpression,
     AST_ClassProperty,
@@ -216,7 +217,7 @@ const set_flag = (node, flag) => { node.flags |= flag; };
 const clear_flag = (node, flag) => { node.flags &= ~flag; };
 
 class Compressor extends TreeWalker {
-    constructor(options, false_by_default) {
+    constructor(options, { false_by_default = false, mangle_options = false }) {
         super();
         if (options.defaults !== undefined && !options.defaults) false_by_default = true;
         this.options = defaults(options, {
@@ -274,7 +275,7 @@ class Compressor extends TreeWalker {
             unsafe_regexp : false,
             unsafe_undefined: false,
             unused        : !false_by_default,
-            warnings      : false,  // legacy
+            warnings      : false  // legacy
         }, true);
         var global_defs = this.options["global_defs"];
         if (typeof global_defs == "object") for (var key in global_defs) {
@@ -324,6 +325,7 @@ class Compressor extends TreeWalker {
         this.sequences_limit = sequences == 1 ? 800 : sequences | 0;
         this.evaluated_regexps = new Map();
         this._toplevel = undefined;
+        this.mangle_options = mangle_options;
     }
 
     option(key) {
@@ -792,13 +794,53 @@ function is_modified(compressor, tw, node, value, level, immutable) {
         pop(tw);
         return true;
     });
+
+    def_reduce_vars(AST_Chain, function(tw, descend) {
+        // Chains' conditions apply left-to-right, cumulatively.
+        // If we walk normally we don't go in that order because we would pop before pushing again
+        // Solution: AST_PropAccess and AST_Call push when they are optional, and never pop.
+        // Then we pop everything when they are done being walked.
+        const safe_ids = tw.safe_ids;
+
+        descend();
+
+        // Unroll back to start
+        tw.safe_ids = safe_ids;
+        return true;
+    });
+    def_reduce_vars(AST_Call, function (tw) {
+        // TODO this block should just be { return } but
+        // for some reason the _walk function of AST_Call walks the callee last
+
+        this.expression.walk(tw);
+
+        if (this.optional) {
+            // Never pop -- it's popped at AST_Chain above
+            push(tw);
+        }
+
+        for (const arg of this.args) arg.walk(tw);
+
+        return true;
+    });
+    def_reduce_vars(AST_PropAccess, function (tw) {
+        if (!this.optional) return;
+
+        this.expression.walk(tw);
+
+        // Never pop -- it's popped at AST_Chain above
+        push(tw);
+
+        if (this.property instanceof AST_Node) this.property.walk(tw);
+
+        return true;
+    });
     def_reduce_vars(AST_Default, function(tw, descend) {
         push(tw);
         descend();
         pop(tw);
         return true;
     });
-
     function mark_lambda(tw, descend, compressor) {
         clear_flag(this, INLINED);
         push(tw);
@@ -1628,8 +1670,7 @@ function tighten_body(statements, compressor) {
                 extract_candidates(expr.condition);
                 extract_candidates(expr.consequent);
                 extract_candidates(expr.alternative);
-            } else if (expr instanceof AST_Definitions
-                && (compressor.option("unused") || !(expr instanceof AST_Const))) {
+            } else if (expr instanceof AST_Definitions) {
                 var len = expr.definitions.length;
                 // limit number of trailing variable definitions for consideration
                 var i = len - 200;
@@ -1797,7 +1838,9 @@ function tighten_body(statements, compressor) {
                 if (node === expr || node.body === expr) {
                     found = true;
                     if (node instanceof AST_VarDef) {
-                        node.value = null;
+                        node.value = node.name instanceof AST_SymbolConst
+                             ? make_node(AST_Undefined, node.value)  // `const` always needs value.
+                             : null;
                         return node;
                     }
                     return in_list ? MAP.skip : null;
@@ -2113,7 +2156,7 @@ function tighten_body(statements, compressor) {
         statements.length = n;
         CHANGED = n != len;
         if (has_quit) has_quit.forEach(function(stat) {
-            extract_declarations_from_unreachable_code(compressor, stat, statements);
+            trim_unreachable_code(compressor, stat, statements);
         });
     }
 
@@ -2371,7 +2414,7 @@ function tighten_body(statements, compressor) {
     }
 }
 
-function extract_declarations_from_unreachable_code(compressor, stat, target) {
+function trim_unreachable_code(compressor, stat, target) {
     walk(stat, node => {
         if (node instanceof AST_Var) {
             node.remove_initializers();
@@ -2392,6 +2435,10 @@ function extract_declarations_from_unreachable_code(compressor, stat, target) {
             }));
             return true;
         }
+        if (node instanceof AST_Export || node instanceof AST_Import) {
+            target.push(node);
+            return true;
+        }
         if (node instanceof AST_Scope) {
             return true;
         }
@@ -2443,6 +2490,10 @@ function is_undefined(node, compressor) {
             if (this.properties[i]._dot_throw(compressor)) return true;
         return false;
     });
+    // Do not be as strict with classes as we are with objects.
+    // Hopefully the community is not going to abuse static getters and setters.
+    // https://github.com/terser/terser/issues/724#issuecomment-643655656
+    def_may_throw_on_access(AST_Class, return_false);
     def_may_throw_on_access(AST_ObjectProperty, return_false);
     def_may_throw_on_access(AST_ObjectGetter, return_true);
     def_may_throw_on_access(AST_Expansion, function(compressor) {
@@ -2471,11 +2522,15 @@ function is_undefined(node, compressor) {
         if (this.expression instanceof AST_Function && this.property == "prototype") return false;
         return true;
     });
+    def_may_throw_on_access(AST_Chain, function(compressor) {
+        return this.expression._dot_throw(compressor);
+    });
     def_may_throw_on_access(AST_Sequence, function(compressor) {
         return this.tail_node()._dot_throw(compressor);
     });
     def_may_throw_on_access(AST_SymbolRef, function(compressor) {
-        if (is_undefined(this, compressor)) return true;
+        if (this.name === "arguments") return false;
+        if (has_flag(this, UNDEFINED)) return true;
         if (!is_strict(compressor)) return false;
         if (is_undeclared_ref(this) && this.is_declared(compressor)) return false;
         if (this.is_immutable()) return false;
@@ -2620,6 +2675,9 @@ function is_lhs(node, parent) {
         }));
     });
     def_find_defs(AST_Node, noop);
+    def_find_defs(AST_Chain, function(compressor, suffix) {
+        return this.expression._find_defs(compressor, suffix);
+    });
     def_find_defs(AST_Dot, function(compressor, suffix) {
         return this.expression._find_defs(compressor, "." + this.property + suffix);
     });
@@ -2877,13 +2935,33 @@ var static_fns = convert_to_predicate({
         return this;
     });
     var non_converting_binary = makePredicate("&& || ?? === !==");
+    const identity_comparison = makePredicate("== != === !==");
+    const has_identity = value =>
+        typeof value === "object"
+        || typeof value === "function"
+        || typeof value === "symbol";
+
     def_eval(AST_Binary, function(compressor, depth) {
         if (!non_converting_binary.has(this.operator)) depth++;
+
         var left = this.left._eval(compressor, depth);
         if (left === this.left) return this;
         var right = this.right._eval(compressor, depth);
         if (right === this.right) return this;
         var result;
+
+        if (
+            left != null
+            && right != null
+            && identity_comparison.has(this.operator)
+            && has_identity(left)
+            && has_identity(right)
+            && typeof left === typeof right
+        ) {
+            // Do not compare by reference
+            return this;
+        }
+
         switch (this.operator) {
           case "&&"  : result = left &&  right; break;
           case "||"  : result = left ||  right; break;
@@ -2924,34 +3002,29 @@ var static_fns = convert_to_predicate({
         var value = node._eval(compressor, depth);
         return value === node ? this : value;
     });
+
+    // Set of AST_SymbolRef which are currently being evaluated.
+    // Avoids infinite recursion of ._eval()
+    const reentrant_ref_eval = new Set();
     def_eval(AST_SymbolRef, function(compressor, depth) {
+        if (reentrant_ref_eval.has(this)) return this;
+
         var fixed = this.fixed_value();
         if (!fixed) return this;
-        var value;
-        if (HOP(fixed, "_eval")) {
-            value = fixed._eval();
-        } else {
-            this._eval = return_this;
-            value = fixed._eval(compressor, depth);
-            delete this._eval;
-            if (value === fixed) return this;
-            fixed._eval = function() {
-                return value;
-            };
-        }
+
+        reentrant_ref_eval.add(this);
+        const value = fixed._eval(compressor, depth);
+        reentrant_ref_eval.delete(this);
+
+        if (value === fixed) return this;
+
         if (value && typeof value == "object") {
             var escaped = this.definition().escaped;
             if (escaped && depth > escaped) return this;
         }
         return value;
     });
-    var global_objs = {
-        Array: Array,
-        Math: Math,
-        Number: Number,
-        Object: Object,
-        String: String,
-    };
+    var global_objs = { Array, Math, Number, Object, String };
     var static_values = convert_to_predicate({
         Math: [
             "E",
@@ -2972,6 +3045,10 @@ var static_fns = convert_to_predicate({
         ],
     });
     def_eval(AST_PropAccess, function(compressor, depth) {
+        if (this.optional) {
+            const obj = this.expression._eval(compressor, depth);
+            if (obj == null) return undefined;
+        }
         if (compressor.option("unsafe")) {
             var key = this.property;
             if (key instanceof AST_Node) {
@@ -3013,8 +3090,15 @@ var static_fns = convert_to_predicate({
         }
         return this;
     });
+    def_eval(AST_Chain, function(compressor, depth) {
+        return this.expression._eval(compressor, depth);
+    });
     def_eval(AST_Call, function(compressor, depth) {
         var exp = this.expression;
+        if (this.optional) {
+            const callee = this.expression._eval(compressor, depth);
+            if (callee == null) return undefined;
+        }
         if (compressor.option("unsafe") && exp instanceof AST_PropAccess) {
             var key = exp.property;
             if (key instanceof AST_Node) {
@@ -3216,9 +3300,11 @@ const pure_prop_access_globals = new Set([
         return any(this.body, compressor);
     });
     def_has_side_effects(AST_Call, function(compressor) {
-        if (!this.is_expr_pure(compressor)
+        if (
+            !this.is_expr_pure(compressor)
             && (!this.expression.is_call_pure(compressor)
-                || this.expression.has_side_effects(compressor))) {
+                || this.expression.has_side_effects(compressor))
+        ) {
             return true;
         }
         return any(this.args, compressor);
@@ -3301,14 +3387,21 @@ const pure_prop_access_globals = new Set([
         return any(this.elements, compressor);
     });
     def_has_side_effects(AST_Dot, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
+        return !this.optional && this.expression.may_throw_on_access(compressor)
             || this.expression.has_side_effects(compressor);
     });
     def_has_side_effects(AST_Sub, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
+        if (this.optional && is_nullish(this.expression)) {
+            return false;
+        }
+
+        return !this.optional && this.expression.may_throw_on_access(compressor)
             || this.expression.has_side_effects(compressor)
             || this.property.has_side_effects(compressor);
     });
+    def_has_side_effects(AST_Chain, function (compressor) {
+        return this.expression.has_side_effects(compressor);
+    });
     def_has_side_effects(AST_Sequence, function(compressor) {
         return any(this.expressions, compressor);
     });
@@ -3368,6 +3461,7 @@ const pure_prop_access_globals = new Set([
         return any(this.body, compressor);
     });
     def_may_throw(AST_Call, function(compressor) {
+        if (this.optional && is_nullish(this.expression)) return false;
         if (any(this.args, compressor)) return true;
         if (this.is_expr_pure(compressor)) return false;
         if (this.expression.may_throw(compressor)) return true;
@@ -3386,10 +3480,6 @@ const pure_prop_access_globals = new Set([
     def_may_throw(AST_Definitions, function(compressor) {
         return any(this.definitions, compressor);
     });
-    def_may_throw(AST_Dot, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
-            || this.expression.may_throw(compressor);
-    });
     def_may_throw(AST_If, function(compressor) {
         return this.condition.may_throw(compressor)
             || this.body && this.body.may_throw(compressor)
@@ -3429,11 +3519,20 @@ const pure_prop_access_globals = new Set([
     def_may_throw(AST_SimpleStatement, function(compressor) {
         return this.body.may_throw(compressor);
     });
+    def_may_throw(AST_Dot, function(compressor) {
+        return !this.optional && this.expression.may_throw_on_access(compressor)
+            || this.expression.may_throw(compressor);
+    });
     def_may_throw(AST_Sub, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
+        if (this.optional && is_nullish(this.expression)) return false;
+
+        return !this.optional && this.expression.may_throw_on_access(compressor)
             || this.expression.may_throw(compressor)
             || this.property.may_throw(compressor);
     });
+    def_may_throw(AST_Chain, function(compressor) {
+        return this.expression.may_throw(compressor);
+    });
     def_may_throw(AST_Switch, function(compressor) {
         return this.expression.may_throw(compressor)
             || any(this.body, compressor);
@@ -3591,9 +3690,9 @@ def_optimize(AST_Block, function(self, compressor) {
 
 function can_be_extracted_from_if_block(node) {
     return !(
-        node instanceof AST_Const ||
-        node instanceof AST_Let ||
-        node instanceof AST_Class
+        node instanceof AST_Const
+        || node instanceof AST_Let
+        || node instanceof AST_Class
     );
 }
 
@@ -4227,6 +4326,10 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
     def_drop_side_effect_free(AST_Constant, return_null);
     def_drop_side_effect_free(AST_This, return_null);
     def_drop_side_effect_free(AST_Call, function(compressor, first_in_statement) {
+        if (this.optional && is_nullish(this.expression)) {
+            return make_node(AST_Undefined, this);
+        }
+
         if (!this.is_expr_pure(compressor)) {
             if (this.expression.is_call_pure(compressor)) {
                 var exprs = this.args.slice();
@@ -4367,17 +4470,28 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
         return values && make_sequence(this, values);
     });
     def_drop_side_effect_free(AST_Dot, function(compressor, first_in_statement) {
+        if (this.optional) {
+            return is_nullish(this.expression) ? make_node(AST_Undefined, this) : this;
+        }
         if (this.expression.may_throw_on_access(compressor)) return this;
+
         return this.expression.drop_side_effect_free(compressor, first_in_statement);
     });
     def_drop_side_effect_free(AST_Sub, function(compressor, first_in_statement) {
+        if (this.optional) {
+            return is_nullish(this.expression) ? make_node(AST_Undefined, this): this;
+        }
         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);
         var property = this.property.drop_side_effect_free(compressor);
         if (!property) return expression;
         return make_sequence(this, [ expression, property ]);
     });
+    def_drop_side_effect_free(AST_Chain, function (compressor, first_in_statement) {
+        return this.expression.drop_side_effect_free(compressor, first_in_statement);
+    });
     def_drop_side_effect_free(AST_Sequence, function(compressor) {
         var last = this.tail_node();
         var expr = last.drop_side_effect_free(compressor);
@@ -4477,7 +4591,7 @@ function if_break_in_loop(self, compressor) {
                 body: self.condition
             }));
         }
-        extract_declarations_from_unreachable_code(compressor, self.body, body);
+        trim_unreachable_code(compressor, self.body, body);
         return make_node(AST_BlockStatement, self, {
             body: body
         });
@@ -4548,7 +4662,7 @@ def_optimize(AST_For, function(self, compressor) {
             if (cond instanceof AST_Node) cond = self.condition.tail_node().evaluate(compressor);
             if (!cond) {
                 var body = [];
-                extract_declarations_from_unreachable_code(compressor, self.body, body);
+                trim_unreachable_code(compressor, self.body, body);
                 if (self.init instanceof AST_Statement) {
                     body.push(self.init);
                 } else if (self.init) {
@@ -4584,7 +4698,7 @@ def_optimize(AST_If, function(self, compressor) {
         if (cond instanceof AST_Node) cond = self.condition.tail_node().evaluate(compressor);
         if (!cond) {
             var body = [];
-            extract_declarations_from_unreachable_code(compressor, self.body, body);
+            trim_unreachable_code(compressor, self.body, body);
             body.push(make_node(AST_SimpleStatement, self.condition, {
                 body: self.condition
             }));
@@ -4597,7 +4711,7 @@ def_optimize(AST_If, function(self, compressor) {
             }));
             body.push(self.body);
             if (self.alternative) {
-                extract_declarations_from_unreachable_code(compressor, self.alternative, body);
+                trim_unreachable_code(compressor, self.alternative, body);
             }
             return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);
         }
@@ -4809,7 +4923,7 @@ def_optimize(AST_Switch, function(self, compressor) {
         if (prev && !aborts(prev)) {
             prev.body = prev.body.concat(branch.body);
         } else {
-            extract_declarations_from_unreachable_code(compressor, branch, decl);
+            trim_unreachable_code(compressor, branch, decl);
         }
     }
 });
@@ -4820,7 +4934,7 @@ def_optimize(AST_Try, function(self, compressor) {
     if (compressor.option("dead_code") && self.body.every(is_empty)) {
         var body = [];
         if (self.bcatch) {
-            extract_declarations_from_unreachable_code(compressor, self.bcatch, body);
+            trim_unreachable_code(compressor, self.bcatch, body);
         }
         if (self.bfinally) body.push(...self.bfinally.body);
         return make_node(AST_BlockStatement, self, {
@@ -4918,6 +5032,10 @@ def_optimize(AST_Call, function(self, compressor) {
         }
     }
 
+    if (self.optional && is_nullish(fn)) {
+        return make_node(AST_Undefined, self);
+    }
+
     var is_func = fn instanceof AST_Lambda;
 
     if (is_func && fn.pinned()) return self;
@@ -5129,6 +5247,7 @@ def_optimize(AST_Call, function(self, compressor) {
                 return make_node(AST_Call, self, {
                     expression: make_node(AST_Dot, exp, {
                         expression: exp.expression,
+                        optional: false,
                         property: "call"
                     }),
                     args: args
@@ -5175,7 +5294,9 @@ def_optimize(AST_Call, function(self, compressor) {
                 var ast = parse(code);
                 var mangle = { ie8: compressor.option("ie8") };
                 ast.figure_out_scope(mangle);
-                var comp = new Compressor(compressor.options);
+                var comp = new Compressor(compressor.options, {
+                    mangle_options: compressor.mangle_options
+                });
                 ast = ast.transform(comp);
                 ast.figure_out_scope(mangle);
                 base54.reset();
@@ -6358,8 +6479,8 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
             }
 
             if (replace) {
-                const name_length = def.name.length;
-                const replace_size = replace.size();
+                const name_length = self.size(compressor);
+                const replace_size = replace.size(compressor);
 
                 let overhead = 0;
                 if (compressor.option("unused") && !compressor.exposed(def)) {
@@ -6564,6 +6685,10 @@ function is_nullish(node) {
             && (fixed = node.definition().fixed) instanceof AST_Node
             && is_nullish(fixed)
         )
+        // Recurse into those optional chains!
+        || node instanceof AST_PropAccess && node.optional && is_nullish(node.expression)
+        || node instanceof AST_Call && node.optional && is_nullish(node.expression)
+        || node instanceof AST_Chain && is_nullish(node.expression)
     );
 }
 
@@ -6946,6 +7071,41 @@ function safe_to_flatten(value, compressor) {
     return compressor.parent() instanceof AST_New;
 }
 
+AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
+    if (!compressor.option("properties")) return;
+    var arrows = compressor.option("unsafe_arrows") && compressor.option("ecma") >= 2015;
+    var expr = this.expression;
+    if (expr instanceof AST_Object) {
+        var props = expr.properties;
+        for (var i = props.length; --i >= 0;) {
+            var prop = props[i];
+            if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
+                if (!props.every((prop) => {
+                    return prop instanceof AST_ObjectKeyVal
+                        || arrows && prop instanceof AST_ConciseMethod && !prop.is_generator;
+                })) 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) {
+                            var v = prop.value;
+                            if (v instanceof AST_Accessor) v = make_node(AST_Function, v, v);
+                            var k = prop.key;
+                            if (k instanceof AST_Node && !(k instanceof AST_SymbolMethod)) {
+                                return make_sequence(prop, [ k, v ]);
+                            }
+                            return v;
+                        })
+                    }),
+                    property: make_node(AST_Number, this, {
+                        value: i
+                    })
+                });
+            }
+        }
+    }
+});
+
 def_optimize(AST_Sub, function(self, compressor) {
     var expr = self.expression;
     var prop = self.property;
@@ -6968,6 +7128,7 @@ def_optimize(AST_Sub, function(self, compressor) {
                 && property.length <= prop.size() + 1) {
                 return make_node(AST_Dot, self, {
                     expression: expr,
+                    optional: self.optional,
                     property: property,
                     quote: prop.quote,
                 }).optimize(compressor);
@@ -7070,6 +7231,14 @@ def_optimize(AST_Sub, function(self, compressor) {
         ev = make_node_from_constant(ev, self).optimize(compressor);
         return best_of(compressor, ev, self);
     }
+    if (self.optional && is_nullish(self.expression)) {
+        return make_node(AST_Undefined, self);
+    }
+    return self;
+});
+
+def_optimize(AST_Chain, function (self, compressor) {
+    self.expression = self.expression.optimize(compressor);
     return self;
 });
 
@@ -7086,41 +7255,6 @@ AST_Lambda.DEFMETHOD("contains_this", function() {
     });
 });
 
-AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
-    if (!compressor.option("properties")) return;
-    var arrows = compressor.option("unsafe_arrows") && compressor.option("ecma") >= 2015;
-    var expr = this.expression;
-    if (expr instanceof AST_Object) {
-        var props = expr.properties;
-        for (var i = props.length; --i >= 0;) {
-            var prop = props[i];
-            if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
-                if (!props.every((prop) => {
-                    return prop instanceof AST_ObjectKeyVal
-                        || arrows && prop instanceof AST_ConciseMethod && !prop.is_generator;
-                })) 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) {
-                            var v = prop.value;
-                            if (v instanceof AST_Accessor) v = make_node(AST_Function, v, v);
-                            var k = prop.key;
-                            if (k instanceof AST_Node && !(k instanceof AST_SymbolMethod)) {
-                                return make_sequence(prop, [ k, v ]);
-                            }
-                            return v;
-                        })
-                    }),
-                    property: make_node(AST_Number, this, {
-                        value: i
-                    })
-                });
-            }
-        }
-    }
-});
-
 def_optimize(AST_Dot, function(self, compressor) {
     const parent = compressor.parent();
     if (is_lhs(self, parent)) return self;
@@ -7171,6 +7305,9 @@ def_optimize(AST_Dot, function(self, compressor) {
         ev = make_node_from_constant(ev, self).optimize(compressor);
         return best_of(compressor, ev, self);
     }
+    if (self.optional && is_nullish(self.expression)) {
+        return make_node(AST_Undefined, self);
+    }
     return self;
 });
 
@@ -7254,10 +7391,10 @@ def_optimize(AST_Function, function(self, compressor) {
         && !self.is_generator
         && !self.uses_arguments
         && !self.pinned()) {
-        const has_special_symbol = walk(self, node => {
+        const uses_this = walk(self, node => {
             if (node instanceof AST_This) return walk_abort;
         });
-        if (!has_special_symbol) return make_node(AST_Arrow, self, self).optimize(compressor);
+        if (!uses_this) return make_node(AST_Arrow, self, self).optimize(compressor);
     }
     return self;
 });
@@ -7349,7 +7486,7 @@ function lift_key(self, compressor) {
     if (!compressor.option("computed_props")) return self;
     // save a comparison in the typical case
     if (!(self.key instanceof AST_Constant)) return self;
-    // whitelist acceptable props as not all AST_Constants are true constants
+    // allow certain acceptable props as not all AST_Constants are true constants
     if (self.key instanceof AST_String || self.key instanceof AST_Number) {
         if (self.key.value === "__proto__") return self;
         if (self.key.value == "constructor"

package/lib/equivalent-to.js

@@ -26,6 +26,7 @@ import {
     AST_ForOf,
     AST_If,
     AST_Import,
+    AST_ImportMeta,
     AST_Jump,
     AST_LabeledStatement,
     AST_Lambda,
@@ -209,6 +210,8 @@ AST_Import.prototype.shallow_cmp = mkshallow({
     imported_names: "exist"
 });
 
+AST_ImportMeta.prototype.shallow_cmp = pass_through;
+
 AST_Export.prototype.shallow_cmp = mkshallow({
     exported_definition: "exist",
     exported_value: "exist",

package/lib/minify.js

@@ -181,7 +181,11 @@ async function minify(files, options) {
         toplevel.expand_names(options.mangle);
     }
     if (timings) timings.compress = Date.now();
-    if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
+    if (options.compress) {
+        toplevel = new Compressor(options.compress, {
+            mangle_options: options.mangle
+        }).compress(toplevel);
+    }
     if (timings) timings.scope = Date.now();
     if (options.mangle) toplevel.figure_out_scope(options.mangle);
     if (timings) timings.mangle = Date.now();