terser 5.3.0 → 5.3.4

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 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
+ - Fixed a crash when chain expressions need to be shallowly compared
+ - Made inlining functions more conservative to make sure a function that contains a reference to itself isn't moved into a place that can create multiple instances of itself.
+
 ## v5.3.0
 
  - Fixed a crash when compressing object spreads in some cases

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

@@ -7422,6 +7422,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;
     });
 
@@ -8895,6 +8903,8 @@ AST_Sequence.prototype.shallow_cmp = pass_through;
 
 AST_PropAccess.prototype.shallow_cmp = pass_through;
 
+AST_Chain.prototype.shallow_cmp = pass_through;
+
 AST_Dot.prototype.shallow_cmp = mkshallow({
     property: "eq"
 });
@@ -14232,9 +14242,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;
                         });
@@ -14314,8 +14327,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;
@@ -15061,10 +15073,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
@@ -15079,13 +15093,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);
 });
@@ -15112,7 +15126,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)
     );
@@ -16072,7 +16086,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")) {
@@ -16171,25 +16185,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
@@ -16398,10 +16393,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);
@@ -16504,7 +16499,8 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
                     && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
                 || parent instanceof AST_Call
                     && parent.expression === self
-                    && !scope_encloses_variables_in_this_scope(nearest_scope, fixed);
+                    && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
+                    && !(fixed.name && fixed.name.definition().recursive_refs > 0);
         }
         if (single_use && fixed instanceof AST_Class) {
             const extends_inert = !fixed.extends
@@ -17417,12 +17413,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--;
@@ -17431,7 +17430,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) {
@@ -17439,21 +17437,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
@@ -17465,6 +17462,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;
 });
 
@@ -17664,7 +17669,8 @@ def_optimize(AST_Destructuring, function(self, compressor) {
         && compressor.option("unused")
         && !self.is_array
         && Array.isArray(self.names)
-        && !is_destructuring_export_decl(compressor)) {
+        && !is_destructuring_export_decl(compressor)
+        && !(self.names[self.names.length - 1] instanceof AST_Expansion)) {
         var keep = [];
         for (var i = 0; i < self.names.length; i++) {
             var elem = self.names[i];
@@ -17752,7 +17758,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,
@@ -17761,13 +17767,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) {
@@ -17797,10 +17805,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();
+            }
+        }
     };
 }
 
@@ -26051,10 +26065,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
@@ -26092,6 +26103,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 = {