terser 5.38.2 → 5.39.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## v5.39.1
+
+ - Fix bitwise operations that could mix `BigInt` and `number`
+
+## v5.39.0
+
+ - Remove unnecessary `console.assert` calls (#1590)
+
 ## v5.38.2
 
  - internal: Flatten inheritance tree for object/class members

package/README.md

@@ -871,7 +871,8 @@ If you happen to need the source map as a raw object, set `sourceMap.asObject` t
   allow improved compression. This might be unsafe when an at least one of two
   operands is an object with computed values due the use of methods like `get`,
   or `valueOf`. This could cause change in execution order after operands in the
-  comparison are switching. Compression only works if both `comparisons` and
+  comparison are switching. Or if one of two operands is `NaN`, the result is always
+  `false`. Compression only works if both `comparisons` and
   `unsafe_comps` are both set to true.
 
 - `unsafe_Function` (default: `false`) -- compress and mangle `Function(args, code)`

package/dist/bundle.min.js

@@ -13045,7 +13045,6 @@ const TRUTHY = 0b00000010;
 const FALSY = 0b00000100;
 const UNDEFINED = 0b00001000;
 const INLINED = 0b00010000;
-
 // Nodes to which values are ever written. Used when keep_assign is part of the unused option string.
 const WRITE_ONLY = 0b00100000;
 
@@ -13677,18 +13676,24 @@ const unary_side_effects = makePredicate("delete ++ --");
     def_is_number(AST_Node, return_false);
     def_is_number(AST_Number, return_true);
     const unary = makePredicate("+ - ~ ++ --");
-    def_is_number(AST_Unary, function() {
-        return unary.has(this.operator) && !(this.expression instanceof AST_BigInt);
+    def_is_number(AST_Unary, function(compressor) {
+        return unary.has(this.operator) && this.expression.is_number(compressor);
     });
     const numeric_ops = makePredicate("- * / % & | ^ << >> >>>");
     def_is_number(AST_Binary, function(compressor) {
-        return numeric_ops.has(this.operator) || this.operator == "+"
-            && this.left.is_number(compressor)
-            && this.right.is_number(compressor);
+        if (this.operator === "+") {
+            // Both sides need to be `number`. Or one is a `number` and the other is number-ish.
+            return this.left.is_number(compressor) && this.right.is_number_or_bigint(compressor)
+                || this.right.is_number(compressor) && this.left.is_number_or_bigint(compressor);
+        } else if (numeric_ops.has(this.operator)) {
+            return this.left.is_number(compressor) || this.right.is_number(compressor);
+        } else {
+            return false;
+        }
     });
     def_is_number(AST_Assign, function(compressor) {
-        return numeric_ops.has(this.operator.slice(0, -1))
-            || this.operator == "=" && this.right.is_number(compressor);
+        return (this.operator === "=" || numeric_ops.has(this.operator.slice(0, -1)))
+            && this.right.is_number(compressor);
     });
     def_is_number(AST_Sequence, function(compressor) {
         return this.tail_node().is_number(compressor);
@@ -13700,19 +13705,83 @@ const unary_side_effects = makePredicate("delete ++ --");
     node.DEFMETHOD("is_number", func);
 });
 
+// methods to determine if an expression returns a BigInt
+(function(def_is_bigint) {
+    def_is_bigint(AST_Node, return_false);
+    def_is_bigint(AST_BigInt, return_true);
+    const unary = makePredicate("+ - ~ ++ --");
+    def_is_bigint(AST_Unary, function(compressor) {
+        return unary.has(this.operator) && this.expression.is_bigint(compressor);
+    });
+    const numeric_ops = makePredicate("- * / % & | ^ << >>");
+    def_is_bigint(AST_Binary, function(compressor) {
+        if (this.operator === "+") {
+            return this.left.is_bigint(compressor) && this.right.is_number_or_bigint(compressor)
+                || this.right.is_bigint(compressor) && this.left.is_number_or_bigint(compressor);
+        } else if (numeric_ops.has(this.operator)) {
+            return this.left.is_bigint(compressor) || this.right.is_bigint(compressor);
+        } else {
+            return false;
+        }
+    });
+    def_is_bigint(AST_Assign, function(compressor) {
+        return (numeric_ops.has(this.operator.slice(0, -1)) || this.operator == "=")
+            && this.right.is_bigint(compressor);
+    });
+    def_is_bigint(AST_Sequence, function(compressor) {
+        return this.tail_node().is_bigint(compressor);
+    });
+    def_is_bigint(AST_Conditional, function(compressor) {
+        return this.consequent.is_bigint(compressor) && this.alternative.is_bigint(compressor);
+    });
+})(function(node, func) {
+    node.DEFMETHOD("is_bigint", func);
+});
+
+// methods to determine if an expression is a number or a bigint
+(function(def_is_number_or_bigint) {
+    def_is_number_or_bigint(AST_Node, return_false);
+    def_is_number_or_bigint(AST_Number, return_true);
+    def_is_number_or_bigint(AST_BigInt, return_true);
+    const numeric_unary_ops = makePredicate("+ - ~ ++ --");
+    def_is_number_or_bigint(AST_Unary, function(_compressor) {
+        return numeric_unary_ops.has(this.operator);
+    });
+    const numeric_ops = makePredicate("- * / % & | ^ << >>");
+    def_is_number_or_bigint(AST_Binary, function(compressor) {
+        return this.operator === "+"
+            ? this.left.is_number_or_bigint(compressor) && this.right.is_number_or_bigint(compressor)
+            : numeric_ops.has(this.operator);
+    });
+    def_is_number_or_bigint(AST_Assign, function(compressor) {
+        return numeric_ops.has(this.operator.slice(0, -1))
+            || this.operator == "=" && this.right.is_number_or_bigint(compressor);
+    });
+    def_is_number_or_bigint(AST_Sequence, function(compressor) {
+        return this.tail_node().is_number_or_bigint(compressor);
+    });
+    def_is_number_or_bigint(AST_Conditional, function(compressor) {
+        return this.consequent.is_number_or_bigint(compressor) && this.alternative.is_number_or_bigint(compressor);
+    });
+}(function (node, func) {
+    node.DEFMETHOD("is_number_or_bigint", func);
+}));
+
+
 // methods to determine if an expression is a 32 bit integer (IE results from bitwise ops, or is an integer constant fitting in that size
 (function(def_is_32_bit_integer) {
     def_is_32_bit_integer(AST_Node, return_false);
-    def_is_32_bit_integer(AST_Number, function() {
+    def_is_32_bit_integer(AST_Number, function(_compressor) {
         return this.value === (this.value | 0);
     });
-    def_is_32_bit_integer(AST_UnaryPrefix, function() {
-        return this.operator == "~" ? this.expression.is_number()
-            : this.operator === "+" ? this.expression.is_32_bit_integer()
+    def_is_32_bit_integer(AST_UnaryPrefix, function(compressor) {
+        return this.operator == "~" ? this.expression.is_number(compressor)
+            : this.operator === "+" ? this.expression.is_32_bit_integer(compressor)
             : false;
     });
-    def_is_32_bit_integer(AST_Binary, function() {
-        return bitwise_binop.has(this.operator);
+    def_is_32_bit_integer(AST_Binary, function(compressor) {
+        return bitwise_binop.has(this.operator)
+            && (this.left.is_number(compressor) || this.right.is_number(compressor));
     });
 }(function (node, func) {
     node.DEFMETHOD("is_32_bit_integer", func);
@@ -14349,30 +14418,36 @@ function is_lhs(node, parent) {
 });
 
 (function (def_bitwise_negate) {
-    function basic_negation(exp) {
+    function basic_bitwise_negation(exp) {
         return make_node(AST_UnaryPrefix, exp, {
             operator: "~",
             expression: exp
         });
     }
 
-    def_bitwise_negate(AST_Node, function() {
-        return basic_negation(this);
+    def_bitwise_negate(AST_Node, function(_compressor) {
+        return basic_bitwise_negation(this);
     });
 
-    def_bitwise_negate(AST_Number, function() {
+    def_bitwise_negate(AST_Number, function(_compressor) {
         const neg = ~this.value;
         if (neg.toString().length > this.value.toString().length) {
-            return basic_negation(this);
+            return basic_bitwise_negation(this);
         }
         return make_node(AST_Number, this, { value: neg });
     });
 
-    def_bitwise_negate(AST_UnaryPrefix, function(in_32_bit_context) {
-        if (this.operator == "~" && (in_32_bit_context || this.expression.is_32_bit_integer())) {
+    def_bitwise_negate(AST_UnaryPrefix, function(compressor, in_32_bit_context) {
+        if (
+            this.operator == "~"
+            && (
+                this.expression.is_32_bit_integer(compressor) ||
+                (in_32_bit_context != null ? in_32_bit_context : compressor.in_32_bit_context())
+            )
+        ) {
             return this.expression;
         } else {
-            return basic_negation(this);
+            return basic_bitwise_negation(this);
         }
     });
 })(function (node, func) {
@@ -18909,12 +18984,16 @@ class Compressor extends TreeWalker {
         }
     }
 
-    in_32_bit_context() {
+    in_32_bit_context(other_operand_must_be_number) {
         if (!this.option("evaluate")) return false;
         var self = this.self();
         for (var i = 0, p; p = this.parent(i); i++) {
             if (p instanceof AST_Binary && bitwise_binop.has(p.operator)) {
-                return true;
+                if (other_operand_must_be_number) {
+                    return (self === p.left ? p.right : p.left).is_number(this);
+                } else {
+                    return true;
+                }
             }
             if (p instanceof AST_UnaryPrefix) {
                 return p.operator === "~";
@@ -19029,6 +19108,7 @@ class Compressor extends TreeWalker {
     }
 }
 
+
 function def_optimize(node, optimizer) {
     node.DEFMETHOD("optimize", function(compressor) {
         var self = this;
@@ -20253,6 +20333,23 @@ def_optimize(AST_Call, function(self, compressor) {
         self.args.length = last;
     }
 
+    if (
+        exp instanceof AST_Dot
+        && exp.expression instanceof AST_SymbolRef
+        && exp.expression.name === "console"
+        && exp.expression.definition().undeclared
+        && exp.property === "assert"
+    ) {
+        const condition = self.args[0];
+        if (condition) {
+            const value = condition.evaluate(compressor);
+    
+            if (value === 1 || value === true) {
+                return make_node(AST_Undefined, self);
+            }
+        }
+    }    
+
     if (compressor.option("unsafe") && !exp.contains_optional()) {
         if (exp instanceof AST_Dot && exp.start.value === "Array" && exp.property === "from" && self.args.length === 1) {
             const [argument] = self.args;
@@ -20667,7 +20764,7 @@ def_optimize(AST_UnaryPrefix, function(self, compressor) {
             self.operator === "~"
             && self.expression instanceof AST_UnaryPrefix
             && self.expression.operator === "~"
-            && (compressor.in_32_bit_context() || self.expression.expression.is_32_bit_integer())
+            && (compressor.in_32_bit_context(false) || self.expression.expression.is_32_bit_integer(compressor))
         ) {
             return self.expression.expression;
         }
@@ -20680,9 +20777,9 @@ def_optimize(AST_UnaryPrefix, function(self, compressor) {
         ) {
             if (e.left instanceof AST_UnaryPrefix && e.left.operator === "~") {
                 // ~(~x ^ y) => x ^ y
-                e.left = e.left.bitwise_negate(true);
+                e.left = e.left.bitwise_negate(compressor, true);
             } else {
-                e.right = e.right.bitwise_negate(true);
+                e.right = e.right.bitwise_negate(compressor, true);
             }
             return e;
         }
@@ -20777,10 +20874,13 @@ def_optimize(AST_Binary, function(self, compressor) {
       case "===":
       case "!==":
         var is_strict_comparison = true;
-        if ((self.left.is_string(compressor) && self.right.is_string(compressor)) ||
+        if (
+            (self.left.is_string(compressor) && self.right.is_string(compressor)) ||
             (self.left.is_number(compressor) && self.right.is_number(compressor)) ||
+            (self.left.is_bigint(compressor) && self.right.is_bigint(compressor)) ||
             (self.left.is_boolean() && self.right.is_boolean()) ||
-            self.left.equivalent_to(self.right)) {
+            self.left.equivalent_to(self.right)
+        ) {
             self.operator = self.operator.substr(0, 2);
         }
 
@@ -20825,7 +20925,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             && self.left.definition() === self.right.definition()
             && is_object(self.left.fixed_value())) {
             return make_node(self.operator[0] == "=" ? AST_True : AST_False, self);
-        } else if (self.left.is_32_bit_integer() && self.right.is_32_bit_integer()) {
+        } else if (self.left.is_32_bit_integer(compressor) && self.right.is_32_bit_integer(compressor)) {
             const not = node => make_node(AST_UnaryPrefix, node, {
                 operator: "!",
                 expression: node
@@ -20858,7 +20958,7 @@ def_optimize(AST_Binary, function(self, compressor) {
                 && (mask = and_op === self.left ? self.right : self.left)
                 && and_op.operator === "&"
                 && mask instanceof AST_Number
-                && mask.is_32_bit_integer()
+                && mask.is_32_bit_integer(compressor)
                 && (x =
                     and_op.left.equivalent_to(mask) ? and_op.right
                     : and_op.right.equivalent_to(mask) ? and_op.left : null)
@@ -21101,7 +21201,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             // a + -b => a - b
             if (self.right instanceof AST_UnaryPrefix
                 && self.right.operator == "-"
-                && self.left.is_number(compressor)) {
+                && self.left.is_number_or_bigint(compressor)) {
                 self = make_node(AST_Binary, self, {
                     operator: "-",
                     left: self.left,
@@ -21113,7 +21213,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             if (self.left instanceof AST_UnaryPrefix
                 && self.left.operator == "-"
                 && reversible()
-                && self.right.is_number(compressor)) {
+                && self.right.is_number_or_bigint(compressor)) {
                 self = make_node(AST_Binary, self, {
                     operator: "-",
                     left: self.right,
@@ -21157,8 +21257,9 @@ def_optimize(AST_Binary, function(self, compressor) {
           case "|":
           case "^":
             // a + +b => +b + a
-            if (self.left.is_number(compressor)
-                && self.right.is_number(compressor)
+            if (
+                self.left.is_number_or_bigint(compressor)
+                && self.right.is_number_or_bigint(compressor)
                 && reversible()
                 && !(self.left instanceof AST_Binary
                     && self.left.operator != self.operator
@@ -21175,7 +21276,7 @@ def_optimize(AST_Binary, function(self, compressor) {
                     self = best_of(compressor, self, reversed);
                 }
             }
-            if (associative && self.is_number(compressor)) {
+            if (associative && self.is_number_or_bigint(compressor)) {
                 // a + (b + c) => (a + b) + c
                 if (self.right instanceof AST_Binary
                     && self.right.operator == self.operator) {
@@ -21294,18 +21395,31 @@ def_optimize(AST_Binary, function(self, compressor) {
                 }
             }
 
-            // x ^ x => 0
             // x | x => 0 | x
             // x & x => 0 | x
-            const same_operands = self.left.equivalent_to(self.right) && !self.left.has_side_effects(compressor);
-            if (same_operands) {
-                if (self.operator === "^") {
-                    return make_node(AST_Number, self, { value: 0 });
-                }
-                if (self.operator === "|" || self.operator === "&") {
-                    self.left = make_node(AST_Number, self, { value: 0 });
-                    self.operator = "|";
-                }
+            if (
+                (self.operator === "|" || self.operator === "&")
+                && self.left.equivalent_to(self.right)
+                && !self.left.has_side_effects(compressor)
+                && compressor.in_32_bit_context(true)
+            ) {
+                self.left = make_node(AST_Number, self, { value: 0 });
+                self.operator = "|";
+            }
+
+            // ~x ^ ~y => x ^ y
+            if (
+                self.operator === "^"
+                && self.left instanceof AST_UnaryPrefix
+                && self.left.operator === "~"
+                && self.right instanceof AST_UnaryPrefix
+                && self.right.operator === "~"
+            ) {
+                self = make_node(AST_Binary, self, {
+                    operator: "^",
+                    left: self.left.expression,
+                    right: self.right.expression
+                });
             }
 
 
@@ -21329,7 +21443,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             if (
                 zero_side
                 && (self.operator === "|" || self.operator === "^")
-                && (non_zero_side.is_32_bit_integer() || compressor.in_32_bit_context())
+                && (non_zero_side.is_32_bit_integer(compressor) || compressor.in_32_bit_context(true))
             ) {
                 return non_zero_side;
             }
@@ -21339,65 +21453,48 @@ def_optimize(AST_Binary, function(self, compressor) {
                 zero_side
                 && self.operator === "&"
                 && !non_zero_side.has_side_effects(compressor)
+                && non_zero_side.is_32_bit_integer(compressor)
             ) {
                 return zero_side;
             }
 
+            // ~0 is all ones, as well as -1.
+            // We can ellide some operations with it.
             const is_full_mask = (node) =>
                 node instanceof AST_Number && node.value === -1
                 ||
-                    node instanceof AST_UnaryPrefix && (
-                        node.operator === "-"
-                            && node.expression instanceof AST_Number
-                            && node.expression.value === 1
-                        || node.operator === "~"
-                            && node.expression instanceof AST_Number
-                            && node.expression.value === 0);
+                    node instanceof AST_UnaryPrefix
+                    && node.operator === "-"
+                    && node.expression instanceof AST_Number
+                    && node.expression.value === 1;
 
             const full_mask = is_full_mask(self.right) ? self.right
                 : is_full_mask(self.left) ? self.left
                 : null;
-            const non_full_mask_side = full_mask && (full_mask === self.right ? self.left : self.right);
-
-            switch (self.operator) {
-              case "|":
-                // {anything} | -1 => -1
-                if (full_mask && !non_full_mask_side.has_side_effects(compressor)) {
-                    return full_mask;
-                }
-
-                break;
-              case "&":
-                // {32 bit integer} & -1 => {32 bit integer}
-                if (
-                    full_mask
-                    && (non_full_mask_side.is_32_bit_integer() || compressor.in_32_bit_context())
-                ) {
-                    return non_full_mask_side;
-                }
+            const other_side = (full_mask === self.right ? self.left : self.right);
 
-                break;
-              case "^":
-                // {anything} ^ -1 => ~{anything}
-                if (full_mask) {
-                    return non_full_mask_side.bitwise_negate(compressor.in_32_bit_context());
-                }
-
-                // ~x ^ ~y => x ^ y
-                if (
-                    self.left instanceof AST_UnaryPrefix
-                    && self.left.operator === "~"
-                    && self.right instanceof AST_UnaryPrefix
-                    && self.right.operator === "~"
-                ) {
-                    self = make_node(AST_Binary, self, {
-                        operator: "^",
-                        left: self.left.expression,
-                        right: self.right.expression
-                    });
-                }
+            // {32 bit integer} & -1 => {32 bit integer}
+            if (
+                full_mask
+                && self.operator === "&"
+                && (
+                    other_side.is_32_bit_integer(compressor)
+                    || compressor.in_32_bit_context(true)
+                )
+            ) {
+                return other_side;
+            }
 
-                break;
+            // {anything} ^ -1 => ~{anything}
+            if (
+                full_mask
+                && self.operator === "^"
+                && (
+                    other_side.is_32_bit_integer(compressor)
+                    || compressor.in_32_bit_context(true)
+                )
+            ) {
+                return other_side.bitwise_negate(compressor);
             }
         }
     }
@@ -22448,7 +22545,7 @@ def_optimize(AST_TemplateString, function(self, compressor) {
         && segments[1] instanceof AST_Node
         && (
             segments[1].is_string(compressor)
-            || segments[1].is_number(compressor)
+            || segments[1].is_number_or_bigint(compressor)
             || is_nullish(segments[1], compressor)
             || compressor.option("unsafe")
         )

package/lib/compress/compressor-flags.js

@@ -48,7 +48,6 @@ export const TRUTHY = 0b00000010;
 export const FALSY = 0b00000100;
 export const UNDEFINED = 0b00001000;
 export const INLINED = 0b00010000;
-
 // Nodes to which values are ever written. Used when keep_assign is part of the unused option string.
 export const WRITE_ONLY = 0b00100000;
 

package/lib/compress/index.js

@@ -188,7 +188,6 @@ import {
     UNUSED,
     TRUTHY,
     FALSY,
-
     has_flag,
     set_flag,
     clear_flag,
@@ -377,12 +376,16 @@ class Compressor extends TreeWalker {
         }
     }
 
-    in_32_bit_context() {
+    in_32_bit_context(other_operand_must_be_number) {
         if (!this.option("evaluate")) return false;
         var self = this.self();
         for (var i = 0, p; p = this.parent(i); i++) {
             if (p instanceof AST_Binary && bitwise_binop.has(p.operator)) {
-                return true;
+                if (other_operand_must_be_number) {
+                    return (self === p.left ? p.right : p.left).is_number(this);
+                } else {
+                    return true;
+                }
             }
             if (p instanceof AST_UnaryPrefix) {
                 return p.operator === "~";
@@ -497,6 +500,7 @@ class Compressor extends TreeWalker {
     }
 }
 
+
 function def_optimize(node, optimizer) {
     node.DEFMETHOD("optimize", function(compressor) {
         var self = this;
@@ -1721,6 +1725,23 @@ def_optimize(AST_Call, function(self, compressor) {
         self.args.length = last;
     }
 
+    if (
+        exp instanceof AST_Dot
+        && exp.expression instanceof AST_SymbolRef
+        && exp.expression.name === "console"
+        && exp.expression.definition().undeclared
+        && exp.property === "assert"
+    ) {
+        const condition = self.args[0];
+        if (condition) {
+            const value = condition.evaluate(compressor);
+    
+            if (value === 1 || value === true) {
+                return make_node(AST_Undefined, self);
+            }
+        }
+    }    
+
     if (compressor.option("unsafe") && !exp.contains_optional()) {
         if (exp instanceof AST_Dot && exp.start.value === "Array" && exp.property === "from" && self.args.length === 1) {
             const [argument] = self.args;
@@ -2135,7 +2156,7 @@ def_optimize(AST_UnaryPrefix, function(self, compressor) {
             self.operator === "~"
             && self.expression instanceof AST_UnaryPrefix
             && self.expression.operator === "~"
-            && (compressor.in_32_bit_context() || self.expression.expression.is_32_bit_integer())
+            && (compressor.in_32_bit_context(false) || self.expression.expression.is_32_bit_integer(compressor))
         ) {
             return self.expression.expression;
         }
@@ -2148,9 +2169,9 @@ def_optimize(AST_UnaryPrefix, function(self, compressor) {
         ) {
             if (e.left instanceof AST_UnaryPrefix && e.left.operator === "~") {
                 // ~(~x ^ y) => x ^ y
-                e.left = e.left.bitwise_negate(true);
+                e.left = e.left.bitwise_negate(compressor, true);
             } else {
-                e.right = e.right.bitwise_negate(true);
+                e.right = e.right.bitwise_negate(compressor, true);
             }
             return e;
         }
@@ -2245,10 +2266,13 @@ def_optimize(AST_Binary, function(self, compressor) {
       case "===":
       case "!==":
         var is_strict_comparison = true;
-        if ((self.left.is_string(compressor) && self.right.is_string(compressor)) ||
+        if (
+            (self.left.is_string(compressor) && self.right.is_string(compressor)) ||
             (self.left.is_number(compressor) && self.right.is_number(compressor)) ||
+            (self.left.is_bigint(compressor) && self.right.is_bigint(compressor)) ||
             (self.left.is_boolean() && self.right.is_boolean()) ||
-            self.left.equivalent_to(self.right)) {
+            self.left.equivalent_to(self.right)
+        ) {
             self.operator = self.operator.substr(0, 2);
         }
 
@@ -2293,7 +2317,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             && self.left.definition() === self.right.definition()
             && is_object(self.left.fixed_value())) {
             return make_node(self.operator[0] == "=" ? AST_True : AST_False, self);
-        } else if (self.left.is_32_bit_integer() && self.right.is_32_bit_integer()) {
+        } else if (self.left.is_32_bit_integer(compressor) && self.right.is_32_bit_integer(compressor)) {
             const not = node => make_node(AST_UnaryPrefix, node, {
                 operator: "!",
                 expression: node
@@ -2326,7 +2350,7 @@ def_optimize(AST_Binary, function(self, compressor) {
                 && (mask = and_op === self.left ? self.right : self.left)
                 && and_op.operator === "&"
                 && mask instanceof AST_Number
-                && mask.is_32_bit_integer()
+                && mask.is_32_bit_integer(compressor)
                 && (x =
                     and_op.left.equivalent_to(mask) ? and_op.right
                     : and_op.right.equivalent_to(mask) ? and_op.left : null)
@@ -2569,7 +2593,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             // a + -b => a - b
             if (self.right instanceof AST_UnaryPrefix
                 && self.right.operator == "-"
-                && self.left.is_number(compressor)) {
+                && self.left.is_number_or_bigint(compressor)) {
                 self = make_node(AST_Binary, self, {
                     operator: "-",
                     left: self.left,
@@ -2581,7 +2605,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             if (self.left instanceof AST_UnaryPrefix
                 && self.left.operator == "-"
                 && reversible()
-                && self.right.is_number(compressor)) {
+                && self.right.is_number_or_bigint(compressor)) {
                 self = make_node(AST_Binary, self, {
                     operator: "-",
                     left: self.right,
@@ -2625,8 +2649,9 @@ def_optimize(AST_Binary, function(self, compressor) {
           case "|":
           case "^":
             // a + +b => +b + a
-            if (self.left.is_number(compressor)
-                && self.right.is_number(compressor)
+            if (
+                self.left.is_number_or_bigint(compressor)
+                && self.right.is_number_or_bigint(compressor)
                 && reversible()
                 && !(self.left instanceof AST_Binary
                     && self.left.operator != self.operator
@@ -2643,7 +2668,7 @@ def_optimize(AST_Binary, function(self, compressor) {
                     self = best_of(compressor, self, reversed);
                 }
             }
-            if (associative && self.is_number(compressor)) {
+            if (associative && self.is_number_or_bigint(compressor)) {
                 // a + (b + c) => (a + b) + c
                 if (self.right instanceof AST_Binary
                     && self.right.operator == self.operator) {
@@ -2762,18 +2787,31 @@ def_optimize(AST_Binary, function(self, compressor) {
                 }
             }
 
-            // x ^ x => 0
             // x | x => 0 | x
             // x & x => 0 | x
-            const same_operands = self.left.equivalent_to(self.right) && !self.left.has_side_effects(compressor);
-            if (same_operands) {
-                if (self.operator === "^") {
-                    return make_node(AST_Number, self, { value: 0 });
-                }
-                if (self.operator === "|" || self.operator === "&") {
-                    self.left = make_node(AST_Number, self, { value: 0 });
-                    self.operator = "|";
-                }
+            if (
+                (self.operator === "|" || self.operator === "&")
+                && self.left.equivalent_to(self.right)
+                && !self.left.has_side_effects(compressor)
+                && compressor.in_32_bit_context(true)
+            ) {
+                self.left = make_node(AST_Number, self, { value: 0 });
+                self.operator = "|";
+            }
+
+            // ~x ^ ~y => x ^ y
+            if (
+                self.operator === "^"
+                && self.left instanceof AST_UnaryPrefix
+                && self.left.operator === "~"
+                && self.right instanceof AST_UnaryPrefix
+                && self.right.operator === "~"
+            ) {
+                self = make_node(AST_Binary, self, {
+                    operator: "^",
+                    left: self.left.expression,
+                    right: self.right.expression
+                });
             }
 
 
@@ -2797,7 +2835,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             if (
                 zero_side
                 && (self.operator === "|" || self.operator === "^")
-                && (non_zero_side.is_32_bit_integer() || compressor.in_32_bit_context())
+                && (non_zero_side.is_32_bit_integer(compressor) || compressor.in_32_bit_context(true))
             ) {
                 return non_zero_side;
             }
@@ -2807,65 +2845,48 @@ def_optimize(AST_Binary, function(self, compressor) {
                 zero_side
                 && self.operator === "&"
                 && !non_zero_side.has_side_effects(compressor)
+                && non_zero_side.is_32_bit_integer(compressor)
             ) {
                 return zero_side;
             }
 
+            // ~0 is all ones, as well as -1.
+            // We can ellide some operations with it.
             const is_full_mask = (node) =>
                 node instanceof AST_Number && node.value === -1
                 ||
-                    node instanceof AST_UnaryPrefix && (
-                        node.operator === "-"
-                            && node.expression instanceof AST_Number
-                            && node.expression.value === 1
-                        || node.operator === "~"
-                            && node.expression instanceof AST_Number
-                            && node.expression.value === 0);
+                    node instanceof AST_UnaryPrefix
+                    && node.operator === "-"
+                    && node.expression instanceof AST_Number
+                    && node.expression.value === 1;
 
             const full_mask = is_full_mask(self.right) ? self.right
                 : is_full_mask(self.left) ? self.left
                 : null;
-            const non_full_mask_side = full_mask && (full_mask === self.right ? self.left : self.right);
-
-            switch (self.operator) {
-              case "|":
-                // {anything} | -1 => -1
-                if (full_mask && !non_full_mask_side.has_side_effects(compressor)) {
-                    return full_mask;
-                }
-
-                break;
-              case "&":
-                // {32 bit integer} & -1 => {32 bit integer}
-                if (
-                    full_mask
-                    && (non_full_mask_side.is_32_bit_integer() || compressor.in_32_bit_context())
-                ) {
-                    return non_full_mask_side;
-                }
-
-                break;
-              case "^":
-                // {anything} ^ -1 => ~{anything}
-                if (full_mask) {
-                    return non_full_mask_side.bitwise_negate(compressor.in_32_bit_context());
-                }
+            const other_side = (full_mask === self.right ? self.left : self.right);
 
-                // ~x ^ ~y => x ^ y
-                if (
-                    self.left instanceof AST_UnaryPrefix
-                    && self.left.operator === "~"
-                    && self.right instanceof AST_UnaryPrefix
-                    && self.right.operator === "~"
-                ) {
-                    self = make_node(AST_Binary, self, {
-                        operator: "^",
-                        left: self.left.expression,
-                        right: self.right.expression
-                    });
-                }
+            // {32 bit integer} & -1 => {32 bit integer}
+            if (
+                full_mask
+                && self.operator === "&"
+                && (
+                    other_side.is_32_bit_integer(compressor)
+                    || compressor.in_32_bit_context(true)
+                )
+            ) {
+                return other_side;
+            }
 
-                break;
+            // {anything} ^ -1 => ~{anything}
+            if (
+                full_mask
+                && self.operator === "^"
+                && (
+                    other_side.is_32_bit_integer(compressor)
+                    || compressor.in_32_bit_context(true)
+                )
+            ) {
+                return other_side.bitwise_negate(compressor);
             }
         }
     }
@@ -3916,7 +3937,7 @@ def_optimize(AST_TemplateString, function(self, compressor) {
         && segments[1] instanceof AST_Node
         && (
             segments[1].is_string(compressor)
-            || segments[1].is_number(compressor)
+            || segments[1].is_number_or_bigint(compressor)
             || is_nullish(segments[1], compressor)
             || compressor.option("unsafe")
         )

package/lib/compress/inference.js

@@ -175,18 +175,24 @@ export const unary_side_effects = makePredicate("delete ++ --");
     def_is_number(AST_Node, return_false);
     def_is_number(AST_Number, return_true);
     const unary = makePredicate("+ - ~ ++ --");
-    def_is_number(AST_Unary, function() {
-        return unary.has(this.operator) && !(this.expression instanceof AST_BigInt);
+    def_is_number(AST_Unary, function(compressor) {
+        return unary.has(this.operator) && this.expression.is_number(compressor);
     });
     const numeric_ops = makePredicate("- * / % & | ^ << >> >>>");
     def_is_number(AST_Binary, function(compressor) {
-        return numeric_ops.has(this.operator) || this.operator == "+"
-            && this.left.is_number(compressor)
-            && this.right.is_number(compressor);
+        if (this.operator === "+") {
+            // Both sides need to be `number`. Or one is a `number` and the other is number-ish.
+            return this.left.is_number(compressor) && this.right.is_number_or_bigint(compressor)
+                || this.right.is_number(compressor) && this.left.is_number_or_bigint(compressor);
+        } else if (numeric_ops.has(this.operator)) {
+            return this.left.is_number(compressor) || this.right.is_number(compressor);
+        } else {
+            return false;
+        }
     });
     def_is_number(AST_Assign, function(compressor) {
-        return numeric_ops.has(this.operator.slice(0, -1))
-            || this.operator == "=" && this.right.is_number(compressor);
+        return (this.operator === "=" || numeric_ops.has(this.operator.slice(0, -1)))
+            && this.right.is_number(compressor);
     });
     def_is_number(AST_Sequence, function(compressor) {
         return this.tail_node().is_number(compressor);
@@ -198,19 +204,83 @@ export const unary_side_effects = makePredicate("delete ++ --");
     node.DEFMETHOD("is_number", func);
 });
 
+// methods to determine if an expression returns a BigInt
+(function(def_is_bigint) {
+    def_is_bigint(AST_Node, return_false);
+    def_is_bigint(AST_BigInt, return_true);
+    const unary = makePredicate("+ - ~ ++ --");
+    def_is_bigint(AST_Unary, function(compressor) {
+        return unary.has(this.operator) && this.expression.is_bigint(compressor);
+    });
+    const numeric_ops = makePredicate("- * / % & | ^ << >>");
+    def_is_bigint(AST_Binary, function(compressor) {
+        if (this.operator === "+") {
+            return this.left.is_bigint(compressor) && this.right.is_number_or_bigint(compressor)
+                || this.right.is_bigint(compressor) && this.left.is_number_or_bigint(compressor);
+        } else if (numeric_ops.has(this.operator)) {
+            return this.left.is_bigint(compressor) || this.right.is_bigint(compressor);
+        } else {
+            return false;
+        }
+    });
+    def_is_bigint(AST_Assign, function(compressor) {
+        return (numeric_ops.has(this.operator.slice(0, -1)) || this.operator == "=")
+            && this.right.is_bigint(compressor);
+    });
+    def_is_bigint(AST_Sequence, function(compressor) {
+        return this.tail_node().is_bigint(compressor);
+    });
+    def_is_bigint(AST_Conditional, function(compressor) {
+        return this.consequent.is_bigint(compressor) && this.alternative.is_bigint(compressor);
+    });
+})(function(node, func) {
+    node.DEFMETHOD("is_bigint", func);
+});
+
+// methods to determine if an expression is a number or a bigint
+(function(def_is_number_or_bigint) {
+    def_is_number_or_bigint(AST_Node, return_false);
+    def_is_number_or_bigint(AST_Number, return_true);
+    def_is_number_or_bigint(AST_BigInt, return_true);
+    const numeric_unary_ops = makePredicate("+ - ~ ++ --");
+    def_is_number_or_bigint(AST_Unary, function(_compressor) {
+        return numeric_unary_ops.has(this.operator);
+    });
+    const numeric_ops = makePredicate("- * / % & | ^ << >>");
+    def_is_number_or_bigint(AST_Binary, function(compressor) {
+        return this.operator === "+"
+            ? this.left.is_number_or_bigint(compressor) && this.right.is_number_or_bigint(compressor)
+            : numeric_ops.has(this.operator);
+    });
+    def_is_number_or_bigint(AST_Assign, function(compressor) {
+        return numeric_ops.has(this.operator.slice(0, -1))
+            || this.operator == "=" && this.right.is_number_or_bigint(compressor);
+    });
+    def_is_number_or_bigint(AST_Sequence, function(compressor) {
+        return this.tail_node().is_number_or_bigint(compressor);
+    });
+    def_is_number_or_bigint(AST_Conditional, function(compressor) {
+        return this.consequent.is_number_or_bigint(compressor) && this.alternative.is_number_or_bigint(compressor);
+    });
+}(function (node, func) {
+    node.DEFMETHOD("is_number_or_bigint", func);
+}));
+
+
 // methods to determine if an expression is a 32 bit integer (IE results from bitwise ops, or is an integer constant fitting in that size
 (function(def_is_32_bit_integer) {
     def_is_32_bit_integer(AST_Node, return_false);
-    def_is_32_bit_integer(AST_Number, function() {
+    def_is_32_bit_integer(AST_Number, function(_compressor) {
         return this.value === (this.value | 0);
     });
-    def_is_32_bit_integer(AST_UnaryPrefix, function() {
-        return this.operator == "~" ? this.expression.is_number()
-            : this.operator === "+" ? this.expression.is_32_bit_integer()
+    def_is_32_bit_integer(AST_UnaryPrefix, function(compressor) {
+        return this.operator == "~" ? this.expression.is_number(compressor)
+            : this.operator === "+" ? this.expression.is_32_bit_integer(compressor)
             : false;
     });
-    def_is_32_bit_integer(AST_Binary, function() {
-        return bitwise_binop.has(this.operator);
+    def_is_32_bit_integer(AST_Binary, function(compressor) {
+        return bitwise_binop.has(this.operator)
+            && (this.left.is_number(compressor) || this.right.is_number(compressor));
     });
 }(function (node, func) {
     node.DEFMETHOD("is_32_bit_integer", func);
@@ -847,30 +917,36 @@ export function is_lhs(node, parent) {
 });
 
 (function (def_bitwise_negate) {
-    function basic_negation(exp) {
+    function basic_bitwise_negation(exp) {
         return make_node(AST_UnaryPrefix, exp, {
             operator: "~",
             expression: exp
         });
     }
 
-    def_bitwise_negate(AST_Node, function() {
-        return basic_negation(this);
+    def_bitwise_negate(AST_Node, function(_compressor) {
+        return basic_bitwise_negation(this);
     });
 
-    def_bitwise_negate(AST_Number, function() {
+    def_bitwise_negate(AST_Number, function(_compressor) {
         const neg = ~this.value;
         if (neg.toString().length > this.value.toString().length) {
-            return basic_negation(this);
+            return basic_bitwise_negation(this);
         }
         return make_node(AST_Number, this, { value: neg });
     });
 
-    def_bitwise_negate(AST_UnaryPrefix, function(in_32_bit_context) {
-        if (this.operator == "~" && (in_32_bit_context || this.expression.is_32_bit_integer())) {
+    def_bitwise_negate(AST_UnaryPrefix, function(compressor, in_32_bit_context) {
+        if (
+            this.operator == "~"
+            && (
+                this.expression.is_32_bit_integer(compressor) ||
+                (in_32_bit_context != null ? in_32_bit_context : compressor.in_32_bit_context())
+            )
+        ) {
             return this.expression;
         } else {
-            return basic_negation(this);
+            return basic_bitwise_negation(this);
         }
     });
 })(function (node, func) {

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.38.2",
+  "version": "5.39.1",
   "engines": {
     "node": ">=10"
   },
@@ -128,7 +128,8 @@
       "no-unused-vars": [
         "error",
         {
-          "varsIgnorePattern": "^_"
+          "varsIgnorePattern": "^_",
+          "argsIgnorePattern": "^_"
         }
       ],
       "no-tabs": "error",