terser 5.3.4 → 5.3.8

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## v5.3.8
+
+ - Restore node 13 support
+
+## 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

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++;
         }
     }
@@ -14372,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
                     });
 
@@ -16469,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)) {