terser 5.31.5 → 5.32.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## v5.32.0
+
+ - `import("module")` can now be input and output from ESTree AST (#1557)
+ - `BigInt` literals can now be input and output from ESTree AST (#1555)
+ - `typeof` an object or array (`typeof {}` and `typeof []`) can now be statically evaluated. (#1546)
+
+## v5.31.6
+ - Retain side effects in a `case` when the expression is a sequence (comma) expression
+
 ## v5.31.5
  - Revert v5.31.4, which created mysterious issues #1548, #1549
 

package/dist/bundle.min.js

@@ -2,7 +2,7 @@
 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@jridgewell/source-map')) :
 typeof define === 'function' && define.amd ? define(['exports', '@jridgewell/source-map'], factory) :
 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Terser = {}, global.sourceMap));
-})(this, (function (exports, sourceMap) { 'use strict';
+}(this, (function (exports, sourceMap) { 'use strict';
 
 /***********************************************************************
 
@@ -7571,6 +7571,19 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             });
         },
 
+        ImportExpression: function(M) {
+            return new AST_Call({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                expression: from_moz({
+                    type: "Identifier",
+                    name: "import"
+                }),
+                optional: false,
+                args: [from_moz(M.source)]
+            });
+        },
+
         ExportAllDeclaration: function(M) {
             var foreign_name = M.exported == null ? 
                 new AST_SymbolExportForeign({ name: "*" }) :
@@ -7638,6 +7651,11 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 args.value = { source, flags };
                 return new AST_RegExp(args);
             }
+            const bi = typeof M.value === "bigint" ? M.value.toString() : M.bigint;
+            if (typeof bi === "string") {
+                args.value = bi;
+                return new AST_BigInt(args);
+            }
             if (val === null) return new AST_Null(args);
             switch (typeof val) {
               case "string":
@@ -7705,14 +7723,6 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                         });
         },
 
-        BigIntLiteral(M) {
-            return new AST_BigInt({
-                start : my_start_token(M),
-                end   : my_end_token(M),
-                value : M.value
-            });
-        },
-
         EmptyStatement: function(M) {
             return new AST_EmptyStatement({
                 start: my_start_token(M),
@@ -8185,6 +8195,14 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         };
     });
     def_to_moz(AST_Call, function To_Moz_CallExpression(M) {
+        if (M.expression instanceof AST_SymbolRef && M.expression.name === "import") {
+            const [source] = M.args.map(to_moz);
+            return {
+                type: "ImportExpression",
+                source,
+            };
+        }
+
         return {
             type: "CallExpression",
             callee: to_moz(M.expression),
@@ -8730,8 +8748,13 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
     });
 
     def_to_moz(AST_BigInt, M => ({
-        type: "BigIntLiteral",
-        value: M.value
+        type: "Literal",
+        // value cannot be represented natively
+        // see: https://github.com/estree/estree/blob/master/es2020.md#bigintliteral
+        value: null,
+        // `M.value` is a string that may be a hex number representation.
+        // but "bigint" property should have only decimal digits
+        bigint: typeof BigInt === "function" ? BigInt(M.value).toString() : M.value,
     }));
 
     AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
@@ -13836,7 +13859,7 @@ function is_nullish(node, compressor) {
         return any(this.definitions, compressor);
     });
     def_has_side_effects(AST_VarDef, function() {
-        return this.value;
+        return this.value != null;
     });
     def_has_side_effects(AST_TemplateSegment, return_false);
     def_has_side_effects(AST_TemplateString, function(compressor) {
@@ -14579,14 +14602,25 @@ def_eval(AST_Object, function (compressor, depth) {
 var non_converting_unary = makePredicate("! typeof void");
 def_eval(AST_UnaryPrefix, function (compressor, depth) {
     var e = this.expression;
-    // Function would be evaluated to an array and so typeof would
-    // incorrectly return 'object'. Hence making is a special case.
     if (compressor.option("typeofs")
-        && this.operator == "typeof"
-        && (e instanceof AST_Lambda
+        && this.operator == "typeof") {
+        // Function would be evaluated to an array and so typeof would
+        // incorrectly return 'object'. Hence making is a special case.
+        if (e instanceof AST_Lambda
             || e instanceof AST_SymbolRef
-            && e.fixed_value() instanceof AST_Lambda)) {
-        return typeof function () { };
+            && e.fixed_value() instanceof AST_Lambda) {
+            return typeof function () { };
+        }
+        if (
+            (e instanceof AST_Object
+                || e instanceof AST_Array
+                || (e instanceof AST_SymbolRef
+                    && (e.fixed_value() instanceof AST_Object
+                        || e.fixed_value() instanceof AST_Array)))
+            && !e.has_side_effects(compressor)
+        ) {
+            return typeof {};
+        }
     }
     if (!non_converting_unary.has(this.operator))
         depth++;
@@ -19588,7 +19622,9 @@ def_optimize(AST_Switch, function(self, compressor) {
                 eliminate_branch(branch, body[body.length - 1]);
                 continue;
             }
-            if (exp instanceof AST_Node) exp = branch.expression.tail_node().evaluate(compressor);
+            if (exp instanceof AST_Node && !exp.has_side_effects(compressor)) {
+                exp = branch.expression.tail_node().evaluate(compressor);
+            }
             if (exp === value) {
                 exact_match = branch;
                 if (default_branch) {
@@ -19770,12 +19806,9 @@ def_optimize(AST_Switch, function(self, compressor) {
             break DEFAULT;
         }
 
-        let sideEffect = body.find(branch => {
-            return (
-                branch !== default_or_exact
-                && branch.expression.has_side_effects(compressor)
-            );
-        });
+        let sideEffect = body.find(
+            branch => branch !== default_or_exact && branch.expression.has_side_effects(compressor)
+        );
         // If no cases cause a side-effect, we can eliminate the switch entirely.
         if (!sideEffect) {
             return make_node(AST_BlockStatement, self, {
@@ -19883,9 +19916,10 @@ def_optimize(AST_Switch, function(self, compressor) {
                         right: branch.expression,
                     }),
                     body: consequent,
-                    alternative: null
-                })
-            ].concat(always)
+                    alternative: null,
+                }),
+                always,
+            ],
         }).optimize(compressor);
     }
     return self;
@@ -19908,13 +19942,12 @@ def_optimize(AST_Switch, function(self, compressor) {
         let pblock = make_node(AST_BlockStatement, prev, { body: pbody });
         return bblock.equivalent_to(pblock);
     }
-    function statement(expression) {
-        return make_node(AST_SimpleStatement, expression, {
-            body: expression
-        });
+    function statement(body) {
+        return make_node(AST_SimpleStatement, body, { body });
     }
     function has_nested_break(root) {
         let has_break = false;
+
         let tw = new TreeWalker(node => {
             if (has_break) return true;
             if (node instanceof AST_Lambda) return true;
@@ -32547,4 +32580,4 @@ exports._run_cli = run_cli;
 exports.minify = minify;
 exports.minify_sync = minify_sync;
 
-}));
+})));

package/lib/compress/evaluate.js

@@ -218,14 +218,25 @@ def_eval(AST_Object, function (compressor, depth) {
 var non_converting_unary = makePredicate("! typeof void");
 def_eval(AST_UnaryPrefix, function (compressor, depth) {
     var e = this.expression;
-    // Function would be evaluated to an array and so typeof would
-    // incorrectly return 'object'. Hence making is a special case.
     if (compressor.option("typeofs")
-        && this.operator == "typeof"
-        && (e instanceof AST_Lambda
+        && this.operator == "typeof") {
+        // Function would be evaluated to an array and so typeof would
+        // incorrectly return 'object'. Hence making is a special case.
+        if (e instanceof AST_Lambda
             || e instanceof AST_SymbolRef
-            && e.fixed_value() instanceof AST_Lambda)) {
-        return typeof function () { };
+            && e.fixed_value() instanceof AST_Lambda) {
+            return typeof function () { };
+        }
+        if (
+            (e instanceof AST_Object
+                || e instanceof AST_Array
+                || (e instanceof AST_SymbolRef
+                    && (e.fixed_value() instanceof AST_Object
+                        || e.fixed_value() instanceof AST_Array)))
+            && !e.has_side_effects(compressor)
+        ) {
+            return typeof {};
+        }
     }
     if (!non_converting_unary.has(this.operator))
         depth++;

package/lib/compress/index.js

@@ -1233,7 +1233,9 @@ def_optimize(AST_Switch, function(self, compressor) {
                 eliminate_branch(branch, body[body.length - 1]);
                 continue;
             }
-            if (exp instanceof AST_Node) exp = branch.expression.tail_node().evaluate(compressor);
+            if (exp instanceof AST_Node && !exp.has_side_effects(compressor)) {
+                exp = branch.expression.tail_node().evaluate(compressor);
+            }
             if (exp === value) {
                 exact_match = branch;
                 if (default_branch) {
@@ -1415,12 +1417,9 @@ def_optimize(AST_Switch, function(self, compressor) {
             break DEFAULT;
         }
 
-        let sideEffect = body.find(branch => {
-            return (
-                branch !== default_or_exact
-                && branch.expression.has_side_effects(compressor)
-            );
-        });
+        let sideEffect = body.find(
+            branch => branch !== default_or_exact && branch.expression.has_side_effects(compressor)
+        );
         // If no cases cause a side-effect, we can eliminate the switch entirely.
         if (!sideEffect) {
             return make_node(AST_BlockStatement, self, {
@@ -1528,9 +1527,10 @@ def_optimize(AST_Switch, function(self, compressor) {
                         right: branch.expression,
                     }),
                     body: consequent,
-                    alternative: null
-                })
-            ].concat(always)
+                    alternative: null,
+                }),
+                always,
+            ],
         }).optimize(compressor);
     }
     return self;
@@ -1553,13 +1553,12 @@ def_optimize(AST_Switch, function(self, compressor) {
         let pblock = make_node(AST_BlockStatement, prev, { body: pbody });
         return bblock.equivalent_to(pblock);
     }
-    function statement(expression) {
-        return make_node(AST_SimpleStatement, expression, {
-            body: expression
-        });
+    function statement(body) {
+        return make_node(AST_SimpleStatement, body, { body });
     }
     function has_nested_break(root) {
         let has_break = false;
+
         let tw = new TreeWalker(node => {
             if (has_break) return true;
             if (node instanceof AST_Lambda) return true;

package/lib/compress/inference.js

@@ -424,7 +424,7 @@ export function is_nullish(node, compressor) {
         return any(this.definitions, compressor);
     });
     def_has_side_effects(AST_VarDef, function() {
-        return this.value;
+        return this.value != null;
     });
     def_has_side_effects(AST_TemplateSegment, return_false);
     def_has_side_effects(AST_TemplateString, function(compressor) {

package/lib/mozilla-ast.js

@@ -595,6 +595,19 @@ import { is_basic_identifier_string } from "./parse.js";
             });
         },
 
+        ImportExpression: function(M) {
+            return new AST_Call({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                expression: from_moz({
+                    type: "Identifier",
+                    name: "import"
+                }),
+                optional: false,
+                args: [from_moz(M.source)]
+            });
+        },
+
         ExportAllDeclaration: function(M) {
             var foreign_name = M.exported == null ? 
                 new AST_SymbolExportForeign({ name: "*" }) :
@@ -662,6 +675,11 @@ import { is_basic_identifier_string } from "./parse.js";
                 args.value = { source, flags };
                 return new AST_RegExp(args);
             }
+            const bi = typeof M.value === "bigint" ? M.value.toString() : M.bigint;
+            if (typeof bi === "string") {
+                args.value = bi;
+                return new AST_BigInt(args);
+            }
             if (val === null) return new AST_Null(args);
             switch (typeof val) {
               case "string":
@@ -729,14 +747,6 @@ import { is_basic_identifier_string } from "./parse.js";
                         });
         },
 
-        BigIntLiteral(M) {
-            return new AST_BigInt({
-                start : my_start_token(M),
-                end   : my_end_token(M),
-                value : M.value
-            });
-        },
-
         EmptyStatement: function(M) {
             return new AST_EmptyStatement({
                 start: my_start_token(M),
@@ -1209,6 +1219,14 @@ import { is_basic_identifier_string } from "./parse.js";
         };
     });
     def_to_moz(AST_Call, function To_Moz_CallExpression(M) {
+        if (M.expression instanceof AST_SymbolRef && M.expression.name === "import") {
+            const [source] = M.args.map(to_moz);
+            return {
+                type: "ImportExpression",
+                source,
+            };
+        }
+
         return {
             type: "CallExpression",
             callee: to_moz(M.expression),
@@ -1754,8 +1772,13 @@ import { is_basic_identifier_string } from "./parse.js";
     });
 
     def_to_moz(AST_BigInt, M => ({
-        type: "BigIntLiteral",
-        value: M.value
+        type: "Literal",
+        // value cannot be represented natively
+        // see: https://github.com/estree/estree/blob/master/es2020.md#bigintliteral
+        value: null,
+        // `M.value` is a string that may be a hex number representation.
+        // but "bigint" property should have only decimal digits
+        bigint: typeof BigInt === "function" ? BigInt(M.value).toString() : M.value,
     }));
 
     AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);

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