terser 5.30.4 → 5.31.1

package/lib/compress/common.js

@@ -226,7 +226,17 @@ export function has_break_or_continue(loop, parent) {
 // func(something) because that changes the meaning of
 // the func (becomes lexical instead of global).
 export function maintain_this_binding(parent, orig, val) {
-    if (
+    if (requires_sequence_to_maintain_binding(parent, orig, val)) {
+        const zero = make_node(AST_Number, orig, { value: 0 });
+        return make_sequence(orig, [ zero, val ]);
+    } else {
+        return val;
+    }
+}
+
+/** Detect (1, x.noThis)(), (0, eval)(), which need sequences */
+export function requires_sequence_to_maintain_binding(parent, orig, val) {
+    return (
         parent instanceof AST_UnaryPrefix && parent.operator == "delete"
         || parent instanceof AST_Call && parent.expression === orig
             && (
@@ -234,12 +244,7 @@ export function maintain_this_binding(parent, orig, val) {
                 || val instanceof AST_PropAccess
                 || val instanceof AST_SymbolRef && val.name == "eval"
             )
-    ) {
-        const zero = make_node(AST_Number, orig, { value: 0 });
-        return make_sequence(orig, [ zero, val ]);
-    } else {
-        return val;
-    }
+    );
 }
 
 export function is_func_expr(node) {

package/lib/compress/drop-unused.js

@@ -63,6 +63,7 @@ import {
     AST_Lambda,
     AST_Number,
     AST_Scope,
+    AST_Sequence,
     AST_SimpleStatement,
     AST_SymbolBlockDeclaration,
     AST_SymbolCatch,
@@ -101,6 +102,7 @@ import {
     is_empty,
     is_ref_of,
     can_be_evicted_from_block,
+    requires_sequence_to_maintain_binding,
 } from "./common.js";
 
 const r_keep_assign = /keep_assign/;
@@ -231,7 +233,11 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
                     var in_use = in_use_ids.has(def.id);
                     if (node instanceof AST_Assign) {
                         if (!in_use || fixed_ids.has(def.id) && fixed_ids.get(def.id) !== node) {
-                            return maintain_this_binding(parent, node, node.right.transform(tt));
+                            const assignee = node.right.transform(tt);
+                            if (!in_use && !assignee.has_side_effects(compressor) && !is_used_in_expression(tt)) {
+                                return in_list ? MAP.skip : make_node(AST_Number, node, { value: 0 });
+                            }
+                            return maintain_this_binding(parent, node, assignee);
                         }
                     } else if (!in_use) {
                         return in_list ? MAP.skip : make_node(AST_Number, node, { value: 0 });
@@ -438,6 +444,14 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
                 scope = save_scope;
                 return node;
             }
+        },
+        function after(node, in_list) {
+            if (node instanceof AST_Sequence) {
+                switch (node.expressions.length) {
+                    case 0: return in_list ? MAP.skip : make_node(AST_Number, node, { value: 0 });
+                    case 1: return node.expressions[0];
+                }
+            }
         }
     );
 
@@ -484,3 +498,41 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
     }
 });
 
+/**
+ * Check if a node may be used by the expression it's in
+ * void (0, 1, {node}, 2) -> false
+ * console.log(0, {node}) -> true
+ */
+function is_used_in_expression(tw) {
+    for (let p = -1, node, parent; node = tw.parent(p), parent = tw.parent(p + 1); p++) {
+        if (parent instanceof AST_Sequence) {
+            const nth_expression = parent.expressions.indexOf(node);
+            if (nth_expression !== parent.expressions.length - 1) {
+                // Detect (0, x.noThis)() constructs
+                const grandparent = tw.parent(p + 2);
+                if (
+                    parent.expressions.length > 2
+                    || parent.expressions.length === 1
+                    || !requires_sequence_to_maintain_binding(grandparent, parent, parent.expressions[1])
+                ) {
+                    return false;
+                }
+                return true;
+            } else {
+                continue;
+            }
+        }
+        if (parent instanceof AST_Unary) {
+            const op = parent.operator;
+            if (op === "void") {
+                return false;
+            }
+            if (op === "typeof" || op === "+" || op === "-" || op === "!" || op === "~") {
+                continue;
+            }
+        }
+        return true;
+    }
+
+    return true;
+}

package/lib/compress/index.js

@@ -3758,7 +3758,7 @@ def_optimize(AST_Array, function(self, compressor) {
     return self;
 });
 
-function inline_object_prop_spread(props, compressor) {
+function inline_object_prop_spread(props) {
     for (var i = 0; i < props.length; i++) {
         var prop = props[i];
         if (prop instanceof AST_Expansion) {
@@ -3770,15 +3770,14 @@ function inline_object_prop_spread(props, compressor) {
                 props.splice(i, 1, ...expr.properties);
                 // Step back one, as the property at i is now new.
                 i--;
-            } else if (expr instanceof AST_Constant
-                && !(expr instanceof AST_String)) {
+            } else if ((
+                    // `expr.is_constant()` returns `false` for `AST_RegExp`, so need both.
+                    expr instanceof AST_Constant
+                    || expr.is_constant()
+                ) && !(expr instanceof AST_String)) {
                 // Unlike array-like spread, in object spread, spreading a
                 // non-iterable value silently does nothing; it is thus safe
-                // to remove. AST_String is the only iterable AST_Constant.
-                props.splice(i, 1);
-                i--;
-            } else if (is_nullish(expr, compressor)) {
-                // Likewise, null and undefined can be silently removed.
+                // to remove. AST_String is the only iterable constant.
                 props.splice(i, 1);
                 i--;
             }
@@ -3791,7 +3790,7 @@ def_optimize(AST_Object, function(self, compressor) {
     if (optimized !== self) {
         return optimized;
     }
-    inline_object_prop_spread(self.properties, compressor);
+    inline_object_prop_spread(self.properties);
     return self;
 });
 

package/package.json

@@ -4,7 +4,7 @@
   "homepage": "https://terser.org",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "5.30.4",
+  "version": "5.31.1",
   "engines": {
     "node": ">=10"
   },