terser 5.3.1 → 5.3.5

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## v5.3.5
+
+ - Avoid moving named functions into default exports.
+ - Enabled transform() for chain expressions. This allows AST transformers to reach inside chain expressions.
+
+## v5.3.4
+
+ - Fixed a crash when hoisting (with `hoist_vars`) a destructuring variable declaration
+
+## v5.3.3
+
+ - `source-map` library has been updated, bringing memory usage and CPU time improvements when reading input source maps (the SourceMapConsumer is now WASM based).
+ - The `wrap_func_args` option now also wraps arrow functions, as opposed to only function expressions.
+
+## v5.3.2
+
+ - Prevented spread operations from being expanded when the expanded array/object contains getters, setters, or array holes.
+ - Fixed _very_ slow self-recursion in some cases of removing extraneous parentheses from `+` operations.
+
 ## v5.3.1
 
  - An issue with destructuring declarations when `pure_getters` is enabled has been fixed

package/bin/terser.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+"use strict";
+
+import "../tools/exit.cjs";
+
+import fs from "fs"
+import path from "path"
+import program from "commander"
+
+import { run_cli } from "../lib/cli.js"
+
+const packageJson = {
+    name: "terser",
+    version: "experimental module CLI"
+}
+
+run_cli({ program, packageJson, fs, path }).catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/dist/bundle.min.js

@@ -5363,6 +5363,10 @@ def_transform(AST_Sub, function(self, tw) {
     self.property = self.property.transform(tw);
 });
 
+def_transform(AST_Chain, function(self, tw) {
+    self.expression = self.expression.transform(tw);
+});
+
 def_transform(AST_Yield, function(self, tw) {
     if (self.expression) self.expression = self.expression.transform(tw);
 });
@@ -7422,6 +7426,14 @@ function OutputStream(options) {
 
     PARENS(AST_Arrow, function(output) {
         var p = output.parent();
+
+        if (
+            output.option("wrap_func_args")
+            && p instanceof AST_Call
+            && p.args.includes(this)
+        ) {
+            return true;
+        }
         return p instanceof AST_PropAccess && p.expression === this;
     });
 
@@ -14234,9 +14246,12 @@ AST_Scope.DEFMETHOD("hoist_declarations", function(compressor) {
                         hoisted.push(node);
                         return make_node(AST_EmptyStatement, node);
                     }
-                    if (hoist_vars && node instanceof AST_Var) {
+                    if (
+                        hoist_vars
+                        && node instanceof AST_Var
+                        && !node.definitions.some(def => def.name instanceof AST_Destructuring)
+                    ) {
                         node.definitions.forEach(function(def) {
-                            if (def.name instanceof AST_Destructuring) return;
                             vars.set(def.name.name, def);
                             ++vars_found;
                         });
@@ -14316,8 +14331,7 @@ AST_Scope.DEFMETHOD("hoist_declarations", function(compressor) {
                         continue;
                     }
                     if (self.body[i] instanceof AST_BlockStatement) {
-                        var tmp = [ i, 1 ].concat(self.body[i].body);
-                        self.body.splice.apply(self.body, tmp);
+                        self.body.splice(i, 1, ...self.body[i].body);
                         continue;
                     }
                     break;
@@ -15063,10 +15077,12 @@ AST_Definitions.DEFMETHOD("remove_initializers", function() {
 
 AST_Definitions.DEFMETHOD("to_assignments", function(compressor) {
     var reduce_vars = compressor.option("reduce_vars");
-    var assignments = this.definitions.reduce(function(a, def) {
-        if (def.value && !(def.name instanceof AST_Destructuring)) {
+    var assignments = [];
+
+    for (const def of this.definitions) {
+        if (def.value) {
             var name = make_node(AST_SymbolRef, def.name, def.name);
-            a.push(make_node(AST_Assign, def, {
+            assignments.push(make_node(AST_Assign, def, {
                 operator : "=",
                 left     : name,
                 right    : def.value
@@ -15081,13 +15097,13 @@ AST_Definitions.DEFMETHOD("to_assignments", function(compressor) {
             var var_ = make_node(AST_Var, def, {
                 definitions: [ varDef ]
             });
-            a.push(var_);
+            assignments.push(var_);
         }
-        def = def.name.definition();
-        def.eliminated++;
-        def.replaced--;
-        return a;
-    }, []);
+        const thedef = def.name.definition();
+        thedef.eliminated++;
+        thedef.replaced--;
+    }
+
     if (assignments.length == 0) return null;
     return make_sequence(this, assignments);
 });
@@ -15114,7 +15130,7 @@ function retain_top_func(fn, compressor) {
 def_optimize(AST_Call, function(self, compressor) {
     var exp = self.expression;
     var fn = exp;
-    inline_array_like_spread(self, compressor, self.args);
+    inline_array_like_spread(self.args);
     var simple_args = self.args.every((arg) =>
         !(arg instanceof AST_Expansion)
     );
@@ -16074,7 +16090,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             && self.left.left.getValue() == ""
             && self.right.is_string(compressor)) {
             self.left = self.left.right;
-            return self.transform(compressor);
+            return self;
         }
     }
     if (compressor.option("evaluate")) {
@@ -16173,25 +16189,6 @@ def_optimize(AST_Binary, function(self, compressor) {
         var associative = true;
         switch (self.operator) {
           case "+":
-            // "foo" + ("bar" + x) => "foobar" + x
-            if (self.left instanceof AST_Constant
-                && self.right instanceof AST_Binary
-                && self.right.operator == "+"
-                && self.right.is_string(compressor)) {
-                var binary = make_node(AST_Binary, self, {
-                    operator: "+",
-                    left: self.left,
-                    right: self.right.left,
-                });
-                var l = binary.optimize(compressor);
-                if (binary !== l) {
-                    self = make_node(AST_Binary, self, {
-                        operator: "+",
-                        left: l,
-                        right: self.right.right
-                    });
-                }
-            }
             // (x + "foo") + "bar" => x + "foobar"
             if (self.right instanceof AST_Constant
                 && self.left instanceof AST_Binary
@@ -16400,10 +16397,10 @@ def_optimize(AST_Binary, function(self, compressor) {
     ) {
         self.left = make_node(AST_Binary, self.left, {
             operator : self.operator,
-            left     : self.left,
-            right    : self.right.left
+            left     : self.left.transform(compressor),
+            right    : self.right.left.transform(compressor)
         });
-        self.right = self.right.right;
+        self.right = self.right.right.transform(compressor);
         return self.transform(compressor);
     }
     var ev = self.evaluate(compressor);
@@ -16476,7 +16473,9 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
             && !(parent instanceof AST_Call
                 && (parent.is_expr_pure(compressor))
                     || has_annotation(parent, _NOINLINE))
-            && !(fixed instanceof AST_Defun && parent instanceof AST_Export);
+            && !(parent instanceof AST_Export
+                && fixed instanceof AST_Lambda
+                && fixed.name);
 
         if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
             if (retain_top_func(fixed, compressor)) {
@@ -17420,12 +17419,15 @@ function literals_in_boolean_context(self, compressor) {
     return self;
 }
 
-function inline_array_like_spread(self, compressor, elements) {
+function inline_array_like_spread(elements) {
     for (var i = 0; i < elements.length; i++) {
         var el = elements[i];
         if (el instanceof AST_Expansion) {
             var expr = el.expression;
-            if ( expr instanceof AST_Array) {
+            if (
+                expr instanceof AST_Array
+                && !expr.elements.some(elm => elm instanceof AST_Hole)
+            ) {
                 elements.splice(i, 1, ...expr.elements);
                 // Step back one, as the element at i is now new.
                 i--;
@@ -17434,7 +17436,6 @@ function inline_array_like_spread(self, compressor, elements) {
             // We therefore can’t optimize anything else, unlike with object spread.
         }
     }
-    return self;
 }
 
 def_optimize(AST_Array, function(self, compressor) {
@@ -17442,21 +17443,20 @@ def_optimize(AST_Array, function(self, compressor) {
     if (optimized !== self) {
         return optimized;
     }
-    return inline_array_like_spread(self, compressor, self.elements);
+    inline_array_like_spread(self.elements);
+    return self;
 });
 
-def_optimize(AST_Object, function(self, compressor) {
-    var optimized = literals_in_boolean_context(self, compressor);
-    if (optimized !== self) {
-        return optimized;
-    }
-    var props = self.properties;
+function inline_object_prop_spread(props) {
     for (var i = 0; i < props.length; i++) {
         var prop = props[i];
         if (prop instanceof AST_Expansion) {
-            var expr = prop.expression;
-            if (expr instanceof AST_Object) {
-                props.splice.apply(props, [i, 1].concat(prop.expression.properties));
+            const expr = prop.expression;
+            if (
+                expr instanceof AST_Object
+                && expr.properties.every(prop => prop instanceof AST_ObjectKeyVal)
+            ) {
+                props.splice(i, 1, ...expr.properties);
                 // Step back one, as the property at i is now new.
                 i--;
             } else if (expr instanceof AST_Constant
@@ -17468,6 +17468,14 @@ def_optimize(AST_Object, function(self, compressor) {
             }
         }
     }
+}
+
+def_optimize(AST_Object, function(self, compressor) {
+    var optimized = literals_in_boolean_context(self, compressor);
+    if (optimized !== self) {
+        return optimized;
+    }
+    inline_object_prop_spread(self.properties);
     return self;
 });
 
@@ -17756,7 +17764,7 @@ def_optimize(AST_Destructuring, function(self, compressor) {
  ***********************************************************************/
 
 // a small wrapper around fitzgen's source-map library
-function SourceMap(options) {
+async function SourceMap(options) {
     options = defaults(options, {
         file : null,
         root : null,
@@ -17765,13 +17773,15 @@ function SourceMap(options) {
         orig_line_diff : 0,
         dest_line_diff : 0,
     });
+
+    var orig_map;
     var generator = new MOZ_SourceMap.SourceMapGenerator({
         file       : options.file,
         sourceRoot : options.root
     });
-    var orig_map = options.orig && new MOZ_SourceMap.SourceMapConsumer(options.orig);
 
-    if (orig_map) {
+    if (options.orig) {
+        orig_map = await new MOZ_SourceMap.SourceMapConsumer(options.orig);
         orig_map.sources.forEach(function(source) {
             var sourceContent = orig_map.sourceContentFor(source, true);
             if (sourceContent) {
@@ -17801,10 +17811,16 @@ function SourceMap(options) {
             name      : name
         });
     }
+
     return {
         add        : add,
         get        : function() { return generator; },
-        toString   : function() { return JSON.stringify(generator.toJSON()); }
+        toString   : function() { return generator.toString(); },
+        destroy    : function () {
+            if (orig_map && orig_map.destroy) {
+                orig_map.destroy();
+            }
+        }
     };
 }
 
@@ -26055,10 +26071,7 @@ async function minify(files, options) {
     }
     if (!HOP(options.format, "code") || options.format.code) {
         if (options.sourceMap) {
-            if (typeof options.sourceMap.content == "string") {
-                options.sourceMap.content = JSON.parse(options.sourceMap.content);
-            }
-            options.format.source_map = SourceMap({
+            options.format.source_map = await SourceMap({
                 file: options.sourceMap.filename,
                 orig: options.sourceMap.content,
                 root: options.sourceMap.root
@@ -26096,6 +26109,9 @@ async function minify(files, options) {
             options.nameCache.props = cache_to_json(options.mangle.properties.cache);
         }
     }
+    if (options.format && options.format.source_map) {
+        options.format.source_map.destroy();
+    }
     if (timings) {
         timings.end = Date.now();
         result.timings = {