npm - terser - Versions diffs - 5.39.0 → 5.39.1 - Mend

terser 5.39.0 → 5.39.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/CHANGELOG.md +4 -0
package/README.md +2 -1
package/dist/bundle.min.js +173 -93
package/lib/compress/index.js +76 -72
package/lib/compress/inference.js +97 -21
package/package.json +3 -2

package/CHANGELOG.md CHANGED Viewed

@@ -1,5 +1,9 @@
 # Changelog
+## v5.39.1
+ - Fix bitwise operations that could mix `BigInt` and `number`
 ## v5.39.0
  - Remove unnecessary `console.assert` calls (#1590)

package/README.md CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -13676,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);
@@ -13699,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);
@@ -14348,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) {
@@ -18908,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 === "~";
@@ -20684,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;
         }
@@ -20697,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;
         }
@@ -20794,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);
         }
@@ -20842,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
@@ -20875,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)
@@ -21118,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,
@@ -21130,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,
@@ -21174,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
@@ -21192,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) {
@@ -21311,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
+                });
             }
@@ -21346,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;
             }
@@ -21356,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;
-                }
+            const other_side = (full_mask === self.right ? self.left : self.right);
-                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());
-                }
-                // ~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);
             }
         }
     }
@@ -22465,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/index.js CHANGED Viewed

@@ -376,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 === "~";
@@ -2152,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;
         }
@@ -2165,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;
         }
@@ -2262,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);
         }
@@ -2310,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
@@ -2343,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)
@@ -2586,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,
@@ -2598,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,
@@ -2642,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
@@ -2660,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) {
@@ -2779,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
+                });
             }
@@ -2814,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;
             }
@@ -2824,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);
+            const other_side = (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());
-                }
-                // ~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);
             }
         }
     }
@@ -3933,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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -4,7 +4,7 @@
   "homepage": "https://terser.org",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "5.39.0",
+  "version": "5.39.1",
   "engines": {
     "node": ">=10"
   },
@@ -128,7 +128,8 @@
       "no-unused-vars": [
         "error",
         {
-          "varsIgnorePattern": "^_"
+          "varsIgnorePattern": "^_",
+          "argsIgnorePattern": "^_"
         }
       ],
       "no-tabs": "error",