terser 5.46.0 → 5.46.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## v5.46.2
+
+ - `unused` option: delete computed keys of concise methods and getters/setters.
+ - `Error.cause` added to DOM properties list
+ - Don't consider `foo.bar` and `foo["bar"]` to be equivalent when property mangler is enabled with `keep_quoted=strict` option.
+
+## v5.46.1
+
+ - Fix extremely slow (seemed like a freeze) `evaluate` of method chains
+ - Parse extremely large floating-point number literals as `Infinity`
+ - Remove parens from comma expressions in computed property access (`foo[(1, 2)]`)
+
 ## v5.46.0
 
  - Add "observedAttributes" domprop (#1652)

package/dist/bundle.min.js

@@ -2464,12 +2464,20 @@ function parse($TEXT, options) {
             ret = _make_symbol(AST_SymbolRef);
             break;
           case "num":
-            ret = new AST_Number({
-                start: tok,
-                end: tok,
-                value: tok.value,
-                raw: LATEST_RAW
-            });
+            if (tok.value === Infinity) {
+                // very large float values are parsed as Infinity
+                ret = new AST_Infinity({
+                    start: tok,
+                    end: tok,
+                });
+            } else {
+                ret = new AST_Number({
+                    start: tok,
+                    end: tok,
+                    value: tok.value,
+                    raw: LATEST_RAW
+                });
+            }
             break;
           case "big_int":
             ret = new AST_BigInt({
@@ -10272,21 +10280,21 @@ function OutputStream(options) {
 
     PARENS(AST_Sequence, function(output) {
         var p = output.parent();
-        return p instanceof AST_Call                          // (foo, bar)() or foo(1, (2, 3), 4)
-            || p instanceof AST_Unary                         // !(foo, bar, baz)
-            || p instanceof AST_Binary                        // 1 + (2, 3) + 4 ==> 8
-            || p instanceof AST_VarDefLike                    // var a = (1, 2), b = a + a; ==> b == 4
-            || p instanceof AST_PropAccess                    // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
-            || p instanceof AST_Array                         // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
-            || p instanceof AST_ObjectProperty                // { foo: (1, 2) }.foo ==> 2
-            || p instanceof AST_Conditional                   /* (false, true) ? (a = 10, b = 20) : (c = 30)
-                                                               * ==> 20 (side effect, set a := 10 and b := 20) */
-            || p instanceof AST_Arrow                         // x => (x, x)
-            || p instanceof AST_DefaultAssign                 // x => (x = (0, function(){}))
-            || p instanceof AST_Expansion                     // [...(a, b)]
-            || p instanceof AST_ForOf && this === p.object    // for (e of (foo, bar)) {}
-            || p instanceof AST_Yield                         // yield (foo, bar)
-            || p instanceof AST_Export                        // export default (foo, bar)
+        return p instanceof AST_Call                              // (foo, bar)() or foo(1, (2, 3), 4)
+            || p instanceof AST_Unary                             // !(foo, bar, baz)
+            || p instanceof AST_Binary                            // 1 + (2, 3) + 4 ==> 8
+            || p instanceof AST_VarDefLike                        // var a = (1, 2), b = a + a; ==> b == 4
+            || p instanceof AST_PropAccess && this !== p.property // (1, {foo:2}).foo, (1, {foo:2})["foo"], not foo[1, 2]
+            || p instanceof AST_Array                             // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
+            || p instanceof AST_ObjectProperty                    // { foo: (1, 2) }.foo ==> 2
+            || p instanceof AST_Conditional                       /* (false, true) ? (a = 10, b = 20) : (c = 30)
+                                                                   * ==> 20 (side effect, set a := 10 and b := 20) */
+            || p instanceof AST_Arrow                             // x => (x, x)
+            || p instanceof AST_DefaultAssign                     // x => (x = (0, function(){}))
+            || p instanceof AST_Expansion                         // [...(a, b)]
+            || p instanceof AST_ForOf && this === p.object        // for (e of (foo, bar)) {}
+            || p instanceof AST_Yield                             // yield (foo, bar)
+            || p instanceof AST_Export                            // export default (foo, bar)
         ;
     });
 
@@ -11905,7 +11913,10 @@ AST_PropAccess.prototype.shallow_cmp = pass_through;
 AST_Chain.prototype.shallow_cmp = pass_through;
 
 AST_Dot.prototype.shallow_cmp = function(other) {
-    return this.property === other.property;
+    return (
+        this.property === other.property
+        && !!this.quote === !!other.quote
+    );
 };
 
 AST_DotHash.prototype.shallow_cmp = function(other) {
@@ -14869,10 +14880,13 @@ var global_pure_fns = makePredicate("Boolean decodeURI decodeURIComponent Date e
 AST_Call.DEFMETHOD("is_callee_pure", function(compressor) {
     if (compressor.option("unsafe")) {
         var expr = this.expression;
-        var first_arg = (this.args && this.args[0] && this.args[0].evaluate(compressor));
+        var first_arg;
         if (
             expr.expression && expr.expression.name === "hasOwnProperty" &&
-            (first_arg == null || first_arg.thedef && first_arg.thedef.undeclared)
+            (
+                (first_arg = (this.args && this.args[0] && this.args[0].evaluate(compressor))) == null
+                || first_arg.thedef && first_arg.thedef.undeclared
+            )
         ) {
             return false;
         }
@@ -15375,6 +15389,15 @@ def_eval(AST_SymbolRef, function (compressor, depth) {
     return value;
 });
 
+def_eval(AST_Chain, function (compressor, depth) {
+    const evaluated = this.expression._eval(compressor, depth, /*ast_chain=*/true);
+    return evaluated === nullish
+        ? undefined
+        : evaluated === this.expression
+          ? this
+          : evaluated;
+});
+
 const global_objs = { Array, Math, Number, Object, String };
 
 const regexp_flags = new Set([
@@ -15386,9 +15409,13 @@ const regexp_flags = new Set([
     "unicode",
 ]);
 
-def_eval(AST_PropAccess, function (compressor, depth) {
-    let obj = this.expression._eval(compressor, depth + 1);
-    if (obj === nullish || (this.optional && obj == null)) return nullish;
+def_eval(AST_PropAccess, function (compressor, depth, ast_chain) {
+    let obj = (ast_chain || this.property === "length" || compressor.option("unsafe"))
+        && this.expression._eval(compressor, depth + 1, ast_chain);
+
+    if (ast_chain) {
+        if (obj === nullish || (this.optional && obj == null)) return nullish;
+    }
 
     // `.length` of strings and arrays is always safe
     if (this.property === "length") {
@@ -15459,26 +15486,19 @@ def_eval(AST_PropAccess, function (compressor, depth) {
     return this;
 });
 
-def_eval(AST_Chain, function (compressor, depth) {
-    const evaluated = this.expression._eval(compressor, depth);
-    return evaluated === nullish
-        ? undefined
-        : evaluated === this.expression
-          ? this
-          : evaluated;
-});
-
-def_eval(AST_Call, function (compressor, depth) {
+def_eval(AST_Call, function (compressor, depth, ast_chain) {
     var exp = this.expression;
 
-    const callee = exp._eval(compressor, depth);
-    if (callee === nullish || (this.optional && callee == null)) return nullish;
+    if (ast_chain) {
+        const callee = exp._eval(compressor, depth, ast_chain);
+        if (callee === nullish || (this.optional && callee == null)) return nullish;
+    }
 
     if (compressor.option("unsafe") && exp instanceof AST_PropAccess) {
         var key = exp.property;
         if (key instanceof AST_Node) {
             key = key._eval(compressor, depth);
-            if (key === exp.property)
+            if (typeof key !== "string" && typeof key !== "number")
                 return this;
         }
         var val;
@@ -15496,7 +15516,8 @@ def_eval(AST_Call, function (compressor, depth) {
             if (!is_pure_native_fn(e.name, key)) return this;
             val = global_objs[e.name];
         } else {
-            val = e._eval(compressor, depth + 1);
+            val = e._eval(compressor, depth + 1, /* don't pass ast_chain (exponential work) */);
+
             if (val === e || !val)
                 return this;
             if (!is_pure_native_method(val.constructor.name, key))
@@ -15791,8 +15812,8 @@ def_drop_side_effect_free([
     AST_ConciseMethod,
     AST_ObjectGetter,
     AST_ObjectSetter,
-], function () {
-    return this.computed_key() ? this.key : null;
+], function (compressor, first_in_statement) {
+    return this.computed_key() ? this.key.drop_side_effect_free(compressor, first_in_statement) : null;
 });
 
 def_drop_side_effect_free([
@@ -16014,6 +16035,7 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
         return scan_ref_scoped(node, descend);
     });
     self.walk(tw);
+
     // pass 2: for every used symbol we need to walk its
     // initialization code to figure out if it uses other
     // symbols (that may not be in_use).
@@ -16024,6 +16046,7 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
             init.walk(tw);
         });
     });
+
     // pass 3: we should drop declarations not in_use
     var tt = new TreeTransformer(
         function before(node, descend, in_list) {
@@ -27110,6 +27133,7 @@ var domprops = [
     "cast",
     "catch",
     "category",
+    "cause",
     "cbrt",
     "cd",
     "ceil",

package/lib/compress/drop-side-effect-free.js

@@ -312,8 +312,8 @@ def_drop_side_effect_free([
     AST_ConciseMethod,
     AST_ObjectGetter,
     AST_ObjectSetter,
-], function () {
-    return this.computed_key() ? this.key : null;
+], function (compressor, first_in_statement) {
+    return this.computed_key() ? this.key.drop_side_effect_free(compressor, first_in_statement) : null;
 });
 
 def_drop_side_effect_free([

package/lib/compress/drop-unused.js

@@ -212,6 +212,7 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
         return scan_ref_scoped(node, descend);
     });
     self.walk(tw);
+
     // pass 2: for every used symbol we need to walk its
     // initialization code to figure out if it uses other
     // symbols (that may not be in_use).
@@ -222,6 +223,7 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
             init.walk(tw);
         });
     });
+
     // pass 3: we should drop declarations not in_use
     var tt = new TreeTransformer(
         function before(node, descend, in_list) {

package/lib/compress/evaluate.js

@@ -371,6 +371,15 @@ def_eval(AST_SymbolRef, function (compressor, depth) {
     return value;
 });
 
+def_eval(AST_Chain, function (compressor, depth) {
+    const evaluated = this.expression._eval(compressor, depth, /*ast_chain=*/true);
+    return evaluated === nullish
+        ? undefined
+        : evaluated === this.expression
+          ? this
+          : evaluated;
+});
+
 const global_objs = { Array, Math, Number, Object, String };
 
 const regexp_flags = new Set([
@@ -382,9 +391,13 @@ const regexp_flags = new Set([
     "unicode",
 ]);
 
-def_eval(AST_PropAccess, function (compressor, depth) {
-    let obj = this.expression._eval(compressor, depth + 1);
-    if (obj === nullish || (this.optional && obj == null)) return nullish;
+def_eval(AST_PropAccess, function (compressor, depth, ast_chain) {
+    let obj = (ast_chain || this.property === "length" || compressor.option("unsafe"))
+        && this.expression._eval(compressor, depth + 1, ast_chain);
+
+    if (ast_chain) {
+        if (obj === nullish || (this.optional && obj == null)) return nullish;
+    }
 
     // `.length` of strings and arrays is always safe
     if (this.property === "length") {
@@ -455,26 +468,19 @@ def_eval(AST_PropAccess, function (compressor, depth) {
     return this;
 });
 
-def_eval(AST_Chain, function (compressor, depth) {
-    const evaluated = this.expression._eval(compressor, depth);
-    return evaluated === nullish
-        ? undefined
-        : evaluated === this.expression
-          ? this
-          : evaluated;
-});
-
-def_eval(AST_Call, function (compressor, depth) {
+def_eval(AST_Call, function (compressor, depth, ast_chain) {
     var exp = this.expression;
 
-    const callee = exp._eval(compressor, depth);
-    if (callee === nullish || (this.optional && callee == null)) return nullish;
+    if (ast_chain) {
+        const callee = exp._eval(compressor, depth, ast_chain);
+        if (callee === nullish || (this.optional && callee == null)) return nullish;
+    }
 
     if (compressor.option("unsafe") && exp instanceof AST_PropAccess) {
         var key = exp.property;
         if (key instanceof AST_Node) {
             key = key._eval(compressor, depth);
-            if (key === exp.property)
+            if (typeof key !== "string" && typeof key !== "number")
                 return this;
         }
         var val;
@@ -492,7 +498,8 @@ def_eval(AST_Call, function (compressor, depth) {
             if (!is_pure_native_fn(e.name, key)) return this;
             val = global_objs[e.name];
         } else {
-            val = e._eval(compressor, depth + 1);
+            val = e._eval(compressor, depth + 1, /* don't pass ast_chain (exponential work) */);
+
             if (val === e || !val)
                 return this;
             if (!is_pure_native_method(val.constructor.name, key))

package/lib/compress/import-export.js

@@ -0,0 +1,121 @@
+import {
+    AST_Export,
+    AST_Import,
+    AST_Toplevel,
+} from "../ast.js";
+
+AST_Toplevel.DEFMETHOD("optimize_import_export", function(compressor) {
+    if (!compressor.option("import_export")) return;
+
+    // We will compare `stat` against `prev` to see if it's a compatible import/export
+    // When compatible, merge!
+    let stat_i = 1;
+
+    while (stat_i < this.body.length) {
+        const stat = this.body[stat_i];
+        const prev = this.body[stat_i - 1];
+
+        const merged_import = 
+            (stat instanceof AST_Import && prev instanceof AST_Import)
+            && merge_imports(prev, stat);
+        const merged_export = 
+            (stat instanceof AST_Export && prev instanceof AST_Export)
+            && merge_exports(prev, stat);
+
+        if (merged_import || merged_export) {
+            this.body.splice(stat_i, 1);
+            // Don't stat_i++. We can stay here.
+        } else {
+            stat_i++;
+        }
+    }
+});
+
+/** Merge a compatible import statement. Or return false */
+function merge_imports(into, merge_from) {
+    if (
+        // same "from"
+        into.module_name.value === merge_from.module_name.value
+        // only one can have a default import
+        && !(into.imported_name && merge_from.imported_name)
+        // "*" not supported
+        && can_merge_name_mappings(into.imported_names, merge_from.imported_names)
+        // "with" not supported
+        && !into.attributes && !merge_from.attributes
+    ) {
+        into.imported_name = into.imported_name || merge_from.imported_name;
+        into.imported_names = merge_name_mappings(into.imported_names, merge_from.imported_names);
+
+        return true; // `merge_from` can be safely removed
+    } else {
+        return false;
+    }
+}
+
+/** Merge a compatible export statement. Or return false */
+function merge_exports(into, merge_from) {
+    if (
+        // "export function" not supported
+        !into.exported_value && !merge_from.exported_value
+        // "export from" not supported
+        && !into.module_name && !merge_from.module_name
+        // "export default" not supported
+        && !into.is_default && !merge_from.is_default
+        // "with" not supported
+        && !into.attributes && !merge_from.attributes
+    ) {
+        if (
+            // "export { a, b, c }"
+            into.exported_names && merge_from.exported_names
+            && can_merge_name_mappings(into.exported_names, merge_from.exported_names)
+        ) {
+            into.exported_names = merge_name_mappings(into.exported_names, merge_from.exported_names);
+
+            return true;
+        } else if (
+            // "export var xx"
+            into.exported_definition && merge_from.exported_definition
+            && can_merge_definitions(into.exported_definition, merge_from.exported_definition)
+        ) {
+            merge_definitions(into.exported_definition, merge_from.exported_definition);
+
+            return true;
+        } else {
+            return false;
+        }
+    } else {
+        return false;
+    }
+}
+
+/** Make sure a and b are optional AST_NameMapping*? arrays without the same names */
+function can_merge_name_mappings(a, b) {
+    for (const mapping_array of [a, b]) {
+        for (const mapping of (mapping_array || [])) {
+            if (mapping.name.name === "*") return false;
+            if (mapping.foreign_name.name === "*") return false;
+        }
+    }
+
+    return true;
+}
+
+function merge_name_mappings(our_names, their_names) {
+    const arr_our_names = our_names || [];
+    const arr_their_names = their_names || [];
+
+    if (arr_our_names.length + arr_their_names.length > 0) {
+        return arr_our_names.concat(arr_their_names);
+    } else {
+        return our_names;
+    }
+}
+
+function can_merge_definitions(our_defs, their_defs) {
+    return our_defs.TYPE === their_defs.TYPE;
+}
+
+/** Merge two AST_Definitions */
+function merge_definitions(our_defs, their_defs) {
+    our_defs.definitions.push(...their_defs.definitions);
+}

package/lib/compress/inference.js

@@ -958,10 +958,13 @@ var global_pure_fns = makePredicate("Boolean decodeURI decodeURIComponent Date e
 AST_Call.DEFMETHOD("is_callee_pure", function(compressor) {
     if (compressor.option("unsafe")) {
         var expr = this.expression;
-        var first_arg = (this.args && this.args[0] && this.args[0].evaluate(compressor));
+        var first_arg;
         if (
             expr.expression && expr.expression.name === "hasOwnProperty" &&
-            (first_arg == null || first_arg.thedef && first_arg.thedef.undeclared)
+            (
+                (first_arg = (this.args && this.args[0] && this.args[0].evaluate(compressor))) == null
+                || first_arg.thedef && first_arg.thedef.undeclared
+            )
         ) {
             return false;
         }

package/lib/equivalent-to.js

@@ -211,7 +211,10 @@ AST_PropAccess.prototype.shallow_cmp = pass_through;
 AST_Chain.prototype.shallow_cmp = pass_through;
 
 AST_Dot.prototype.shallow_cmp = function(other) {
-    return this.property === other.property;
+    return (
+        this.property === other.property
+        && !!this.quote === !!other.quote
+    );
 };
 
 AST_DotHash.prototype.shallow_cmp = function(other) {

package/lib/output.js

@@ -1043,21 +1043,21 @@ function OutputStream(options) {
 
     PARENS(AST_Sequence, function(output) {
         var p = output.parent();
-        return p instanceof AST_Call                          // (foo, bar)() or foo(1, (2, 3), 4)
-            || p instanceof AST_Unary                         // !(foo, bar, baz)
-            || p instanceof AST_Binary                        // 1 + (2, 3) + 4 ==> 8
-            || p instanceof AST_VarDefLike                    // var a = (1, 2), b = a + a; ==> b == 4
-            || p instanceof AST_PropAccess                    // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
-            || p instanceof AST_Array                         // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
-            || p instanceof AST_ObjectProperty                // { foo: (1, 2) }.foo ==> 2
-            || p instanceof AST_Conditional                   /* (false, true) ? (a = 10, b = 20) : (c = 30)
-                                                               * ==> 20 (side effect, set a := 10 and b := 20) */
-            || p instanceof AST_Arrow                         // x => (x, x)
-            || p instanceof AST_DefaultAssign                 // x => (x = (0, function(){}))
-            || p instanceof AST_Expansion                     // [...(a, b)]
-            || p instanceof AST_ForOf && this === p.object    // for (e of (foo, bar)) {}
-            || p instanceof AST_Yield                         // yield (foo, bar)
-            || p instanceof AST_Export                        // export default (foo, bar)
+        return p instanceof AST_Call                              // (foo, bar)() or foo(1, (2, 3), 4)
+            || p instanceof AST_Unary                             // !(foo, bar, baz)
+            || p instanceof AST_Binary                            // 1 + (2, 3) + 4 ==> 8
+            || p instanceof AST_VarDefLike                        // var a = (1, 2), b = a + a; ==> b == 4
+            || p instanceof AST_PropAccess && this !== p.property // (1, {foo:2}).foo, (1, {foo:2})["foo"], not foo[1, 2]
+            || p instanceof AST_Array                             // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
+            || p instanceof AST_ObjectProperty                    // { foo: (1, 2) }.foo ==> 2
+            || p instanceof AST_Conditional                       /* (false, true) ? (a = 10, b = 20) : (c = 30)
+                                                                   * ==> 20 (side effect, set a := 10 and b := 20) */
+            || p instanceof AST_Arrow                             // x => (x, x)
+            || p instanceof AST_DefaultAssign                     // x => (x = (0, function(){}))
+            || p instanceof AST_Expansion                         // [...(a, b)]
+            || p instanceof AST_ForOf && this === p.object        // for (e of (foo, bar)) {}
+            || p instanceof AST_Yield                             // yield (foo, bar)
+            || p instanceof AST_Export                            // export default (foo, bar)
         ;
     });
 

package/lib/parse.js

@@ -101,6 +101,7 @@ import {
     AST_If,
     AST_Import,
     AST_ImportMeta,
+    AST_Infinity,
     AST_IterationStatement,
     AST_Label,
     AST_LabeledStatement,
@@ -2313,12 +2314,20 @@ function parse($TEXT, options) {
             ret = _make_symbol(AST_SymbolRef);
             break;
           case "num":
-            ret = new AST_Number({
-                start: tok,
-                end: tok,
-                value: tok.value,
-                raw: LATEST_RAW
-            });
+            if (tok.value === Infinity) {
+                // very large float values are parsed as Infinity
+                ret = new AST_Infinity({
+                    start: tok,
+                    end: tok,
+                });
+            } else {
+                ret = new AST_Number({
+                    start: tok,
+                    end: tok,
+                    value: tok.value,
+                    raw: LATEST_RAW
+                });
+            }
             break;
           case "big_int":
             ret = new AST_BigInt({

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.46.0",
+  "version": "5.46.2",
   "engines": {
     "node": ">=10"
   },

package/tools/domprops.js

@@ -3797,6 +3797,7 @@ export var domprops = [
     "cast",
     "catch",
     "category",
+    "cause",
     "cbrt",
     "cd",
     "ceil",