terser 5.3.3 → 5.3.7

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## v5.3.7
+
+Hotfix release, fixes package.json "engines" syntax
+
+## v5.3.6
+
+ - Fixed parentheses when outputting `??` mixed with `||` and `&&`
+ - Improved hygiene of the symbol generator
+
+## 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).

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);
 });
@@ -7500,6 +7504,10 @@ function OutputStream(options) {
                 return true;
             }
 
+            if (po === "??" && (so === "||" || so === "&&")) {
+                return true;
+            }
+
             const pp = PRECEDENCE[po];
             const sp = PRECEDENCE[so];
             if (pp > sp
@@ -9409,6 +9417,13 @@ AST_Scope.DEFMETHOD("conflicting_def", function (name) {
     );
 });
 
+AST_Scope.DEFMETHOD("conflicting_def_shallow", function (name) {
+    return (
+        this.enclosed.find(def => def.name === name)
+        || this.variables.has(name)
+    );
+});
+
 AST_Scope.DEFMETHOD("add_child_scope", function (scope) {
     // `scope` is going to be moved into `this` right now.
     // Update the required scopes' information
@@ -9442,15 +9457,34 @@ AST_Scope.DEFMETHOD("add_child_scope", function (scope) {
     }
 });
 
+function find_scopes_visible_from(scopes) {
+    const found_scopes = new Set();
+
+    for (const scope of new Set(scopes)) {
+        (function bubble_up(scope) {
+            if (scope == null || found_scopes.has(scope)) return;
+
+            found_scopes.add(scope);
+
+            bubble_up(scope.parent_scope);
+        })(scope);
+    }
+
+    return [...found_scopes];
+}
+
 // Creates a symbol during compression
 AST_Scope.DEFMETHOD("create_symbol", function(SymClass, {
     source,
     tentative_name,
     scope,
+    conflict_scopes = [scope],
     init = null
 } = {}) {
     let symbol_name;
 
+    conflict_scopes = find_scopes_visible_from(conflict_scopes);
+
     if (tentative_name) {
         // Implement hygiene (no new names are conflicting with existing names)
         tentative_name =
@@ -9458,7 +9492,7 @@ AST_Scope.DEFMETHOD("create_symbol", function(SymClass, {
             tentative_name.replace(/(?:^[^a-z_$]|[^a-z0-9_$])/ig, "_");
 
         let i = 0;
-        while (this.conflicting_def(symbol_name)) {
+        while (conflict_scopes.find(s => s.conflicting_def_shallow(symbol_name))) {
             symbol_name = tentative_name + "$" + i++;
         }
     }
@@ -14242,9 +14276,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;
                         });
@@ -14324,8 +14361,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;
@@ -14370,9 +14406,14 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
                 const defs = new Map();
                 const assignments = [];
                 value.properties.forEach(({ key, value }) => {
+                    const scope = find_scope(hoister);
                     const symbol = self.create_symbol(sym.CTOR, {
                         source: sym,
-                        scope: find_scope(hoister),
+                        scope,
+                        conflict_scopes: new Set([
+                            scope,
+                            ...sym.definition().references.map(ref => ref.scope)
+                        ]),
                         tentative_name: sym.name + "_" + key
                     });
 
@@ -15071,10 +15112,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
@@ -15089,13 +15132,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);
 });
@@ -16465,7 +16508,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)) {