terser 5.3.1 → 5.3.5

package/lib/compress/index.js

@@ -4140,9 +4140,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;
                         });
@@ -4222,8 +4225,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;
@@ -4969,10 +4971,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
@@ -4987,13 +4991,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);
 });
@@ -5020,7 +5024,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)
     );
@@ -5980,7 +5984,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")) {
@@ -6079,25 +6083,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
@@ -6306,10 +6291,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);
@@ -6382,7 +6367,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)) {
@@ -7326,12 +7313,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--;
@@ -7340,7 +7330,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) {
@@ -7348,21 +7337,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
@@ -7374,6 +7362,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;
 });
 

package/lib/minify.js

@@ -205,10 +205,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
@@ -246,6 +243,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 = {

package/lib/output.js

@@ -893,6 +893,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;
     });
 

package/lib/sourcemap.js

@@ -49,7 +49,7 @@ import {
 } from "./utils/index.js";
 
 // a small wrapper around fitzgen's source-map library
-function SourceMap(options) {
+async function SourceMap(options) {
     options = defaults(options, {
         file : null,
         root : null,
@@ -58,13 +58,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) {
@@ -94,10 +96,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();
+            }
+        }
     };
 }
 

package/lib/transform.js

@@ -51,6 +51,7 @@ import {
     AST_Call,
     AST_Case,
     AST_Catch,
+    AST_Chain,
     AST_Class,
     AST_Conditional,
     AST_Definitions,
@@ -236,6 +237,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);
 });

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.3.1",
+  "version": "5.3.5",
   "engines": {
     "node": ">=6.0.0"
   },
@@ -44,8 +44,8 @@
   ],
   "dependencies": {
     "commander": "^2.20.0",
-    "source-map": "~0.6.1",
-    "source-map-support": "~0.5.12"
+    "source-map": "~0.7.2",
+    "source-map-support": "~0.5.19"
   },
   "devDependencies": {
     "@ls-lint/ls-lint": "^1.9.2",

package/tools/terser.d.ts

@@ -144,6 +144,8 @@ export interface MinifyOptions {
     module?: boolean;
     nameCache?: object;
     format?: FormatOptions;
+    /** @deprecated */
+    output?: FormatOptions;
     parse?: ParseOptions;
     safari10?: boolean;
     sourceMap?: boolean | SourceMapOptions;