terser 5.19.4 → 5.21.0

package/lib/compress/common.js

@@ -344,5 +344,5 @@ export function retain_top_func(fn, compressor) {
         && fn instanceof AST_Defun
         && has_flag(fn, TOP)
         && fn.name
-        && compressor.top_retain(fn.name);
+        && compressor.top_retain(fn.name.definition());
 }

package/lib/compress/drop-unused.js

@@ -128,7 +128,7 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
     var fixed_ids = new Map();
     if (self instanceof AST_Toplevel && compressor.top_retain) {
         self.variables.forEach(function(def) {
-            if (compressor.top_retain(def) && !in_use_ids.has(def.id)) {
+            if (compressor.top_retain(def)) {
                 in_use_ids.set(def.id, def);
             }
         });
@@ -143,9 +143,7 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
             node.argnames.forEach(function(argname) {
                 if (!(argname instanceof AST_SymbolDeclaration)) return;
                 var def = argname.definition();
-                if (!in_use_ids.has(def.id)) {
-                    in_use_ids.set(def.id, def);
-                }
+                in_use_ids.set(def.id, def);
             });
         }
         if (node === self) return;
@@ -158,7 +156,7 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
             var node_def = node.name.definition();
             const in_export = tw.parent() instanceof AST_Export;
             if (in_export || !drop_funcs && scope === self) {
-                if (node_def.global && !in_use_ids.has(node_def.id)) {
+                if (node_def.global) {
                     in_use_ids.set(node_def.id, node_def);
                 }
             }
@@ -166,10 +164,12 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
             map_add(initializations, node_def.id, node);
             return true; // don't go in nested scopes
         }
-        if (node instanceof AST_SymbolFunarg && scope === self) {
+        // In the root scope, we drop things. In inner scopes, we just check for uses.
+        const in_root_scope = scope === self;
+        if (node instanceof AST_SymbolFunarg && in_root_scope) {
             map_add(var_defs_by_id, node.definition().id, node);
         }
-        if (node instanceof AST_Definitions && scope === self) {
+        if (node instanceof AST_Definitions && in_root_scope) {
             const in_export = tw.parent() instanceof AST_Export;
             node.definitions.forEach(function(def) {
                 if (def.name instanceof AST_SymbolVar) {
@@ -179,7 +179,7 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
                     walk(def.name, node => {
                         if (node instanceof AST_SymbolDeclaration) {
                             const def = node.definition();
-                            if (def.global && !in_use_ids.has(def.id)) {
+                            if (def.global) {
                                 in_use_ids.set(def.id, def);
                             }
                         }

package/lib/compress/global-defs.js

@@ -0,0 +1,92 @@
+import {
+    AST_Array,
+    AST_Chain,
+    AST_Constant,
+    AST_Dot,
+    AST_ImportMeta,
+    AST_Node,
+    AST_Object,
+    AST_ObjectKeyVal,
+    AST_PropAccess,
+    AST_SymbolDeclaration,
+    AST_SymbolRef,
+    AST_Toplevel,
+    TreeTransformer,
+} from "../ast.js";
+import { make_node, noop, HOP } from "../utils/index.js";
+import { make_node_from_constant } from "./common.js";
+import { is_lhs } from "./inference.js";
+
+(function(def_find_defs) {
+    function to_node(value, orig) {
+        if (value instanceof AST_Node) {
+            if (!(value instanceof AST_Constant)) {
+                // Value may be a function, an array including functions and even a complex assign / block expression,
+                // so it should never be shared in different places.
+                // Otherwise wrong information may be used in the compression phase
+                value = value.clone(true);
+            }
+            return make_node(value.CTOR, orig, value);
+        }
+        if (Array.isArray(value)) return make_node(AST_Array, orig, {
+            elements: value.map(function(value) {
+                return to_node(value, orig);
+            })
+        });
+        if (value && typeof value == "object") {
+            var props = [];
+            for (var key in value) if (HOP(value, key)) {
+                props.push(make_node(AST_ObjectKeyVal, orig, {
+                    key: key,
+                    value: to_node(value[key], orig)
+                }));
+            }
+            return make_node(AST_Object, orig, {
+                properties: props
+            });
+        }
+        return make_node_from_constant(value, orig);
+    }
+
+    AST_Toplevel.DEFMETHOD("resolve_defines", function(compressor) {
+        if (!compressor.option("global_defs")) return this;
+        this.figure_out_scope({ ie8: compressor.option("ie8") });
+        return this.transform(new TreeTransformer(function(node) {
+            var def = node._find_defs(compressor, "");
+            if (!def) return;
+            var level = 0, child = node, parent;
+            while (parent = this.parent(level++)) {
+                if (!(parent instanceof AST_PropAccess)) break;
+                if (parent.expression !== child) break;
+                child = parent;
+            }
+            if (is_lhs(child, parent)) {
+                return;
+            }
+            return def;
+        }));
+    });
+    def_find_defs(AST_Node, noop);
+    def_find_defs(AST_Chain, function(compressor, suffix) {
+        return this.expression._find_defs(compressor, suffix);
+    });
+    def_find_defs(AST_Dot, function(compressor, suffix) {
+        return this.expression._find_defs(compressor, "." + this.property + suffix);
+    });
+    def_find_defs(AST_SymbolDeclaration, function() {
+        if (!this.global()) return;
+    });
+    def_find_defs(AST_SymbolRef, function(compressor, suffix) {
+        if (!this.global()) return;
+        var defines = compressor.option("global_defs");
+        var name = this.name + suffix;
+        if (HOP(defines, name)) return to_node(defines[name], this);
+    });
+    def_find_defs(AST_ImportMeta, function(compressor, suffix) {
+        var defines = compressor.option("global_defs");
+        var name = "import.meta" + suffix;
+        if (HOP(defines, name)) return to_node(defines[name], this);
+    });
+})(function(node, func) {
+    node.DEFMETHOD("_find_defs", func);
+});

package/lib/compress/index.js

@@ -204,11 +204,11 @@ import {
     is_reachable,
     can_be_evicted_from_block,
     as_statement_array,
-    retain_top_func,
     is_func_expr,
 } from "./common.js";
 import { tighten_body, trim_unreachable_code } from "./tighten-body.js";
 import { inline_into_symbolref, inline_into_call } from "./inline.js";
+import "./global-defs.js";
 
 class Compressor extends TreeWalker {
     constructor(options, { false_by_default = false, mangle_options = false }) {
@@ -385,7 +385,7 @@ class Compressor extends TreeWalker {
             this._toplevel.figure_out_scope(mangle);
             if (pass === 0 && this.option("drop_console")) {
                 // must be run before reduce_vars and compress pass
-                this._toplevel = this._toplevel.drop_console();
+                this._toplevel = this._toplevel.drop_console(this.option("drop_console"));
             }
             if (pass > 0 || this.option("reduce_vars")) {
                 this._toplevel.reset_opt_flags(this);
@@ -464,19 +464,30 @@ def_optimize(AST_Node, function(self) {
     return self;
 });
 
-AST_Toplevel.DEFMETHOD("drop_console", function() {
+AST_Toplevel.DEFMETHOD("drop_console", function(options) {
+    var isArray = Array.isArray(options);
+
     return this.transform(new TreeTransformer(function(self) {
-        if (self.TYPE == "Call") {
-            var exp = self.expression;
-            if (exp instanceof AST_PropAccess) {
-                var name = exp.expression;
-                while (name.expression) {
-                    name = name.expression;
-                }
-                if (is_undeclared_ref(name) && name.name == "console") {
-                    return make_node(AST_Undefined, self);
-                }
-            }
+        if (self.TYPE !== "Call") {
+            return;
+        }
+
+        var exp = self.expression;
+
+        if (!(exp instanceof AST_PropAccess)) {
+            return;
+        }
+
+        if (isArray && options.indexOf(exp.property) === -1) {
+            return;
+        }
+
+        var name = exp.expression;
+        while (name.expression) {
+            name = name.expression;
+        }
+        if (is_undeclared_ref(name) && name.name == "console") {
+            return make_node(AST_Undefined, self);
         }
     }));
 });
@@ -1598,18 +1609,10 @@ def_optimize(AST_Call, function(self, compressor) {
     var exp = self.expression;
     var fn = exp;
     inline_array_like_spread(self.args);
-    var simple_args = self.args.every((arg) =>
-        !(arg instanceof AST_Expansion)
-    );
+    var simple_args = self.args.every((arg) => !(arg instanceof AST_Expansion));
 
-    if (compressor.option("reduce_vars")
-        && fn instanceof AST_SymbolRef
-        && !has_annotation(self, _NOINLINE)
-    ) {
-        const fixed = fn.fixed_value();
-        if (!retain_top_func(fixed, compressor)) {
-            fn = fixed;
-        }
+    if (compressor.option("reduce_vars") && fn instanceof AST_SymbolRef) {
+        fn = fn.fixed_value();
     }
 
     var is_func = fn instanceof AST_Lambda;
@@ -1917,7 +1920,7 @@ def_optimize(AST_Call, function(self, compressor) {
         }
     }
 
-    return inline_into_call(self, fn, compressor);
+    return inline_into_call(self, compressor);
 });
 
 def_optimize(AST_New, function(self, compressor) {
@@ -3750,10 +3753,10 @@ def_optimize(AST_Destructuring, function(self, compressor) {
         if (def.references.length) return true;
         if (!def.global) return false;
         if (compressor.toplevel.vars) {
-             if (compressor.top_retain) {
-                 return compressor.top_retain(def);
-             }
-             return false;
+            if (compressor.top_retain) {
+                return compressor.top_retain(def);
+            }
+            return false;
         }
         return true;
     }

package/lib/compress/inference.js

@@ -98,7 +98,6 @@ import {
   AST_TemplateSegment,
   AST_TemplateString,
   AST_This,
-  AST_Toplevel,
   AST_True,
   AST_Try,
   AST_Unary,
@@ -107,7 +106,6 @@ import {
   AST_Undefined,
   AST_VarDef,
 
-  TreeTransformer,
   walk,
   walk_abort,
 
@@ -121,11 +119,9 @@ import {
     return_this,
     make_node,
     member,
-    noop,
     has_annotation,
-    HOP
 } from "../utils/index.js";
-import { make_node_from_constant, make_sequence, best_of_expression, read_property } from "./common.js";
+import { make_sequence, best_of_expression, read_property } from "./common.js";
 
 import { INLINED, UNDEFINED, has_flag } from "./compressor-flags.js";
 import { pure_prop_access_globals, is_pure_native_fn, is_pure_native_method } from "./native-objects.js";
@@ -728,80 +724,6 @@ export function is_lhs(node, parent) {
     if (parent instanceof AST_ForIn && parent.init === node) return node;
 }
 
-(function(def_find_defs) {
-    function to_node(value, orig) {
-        if (value instanceof AST_Node) {
-            if (!(value instanceof AST_Constant)) {
-                // Value may be a function, an array including functions and even a complex assign / block expression,
-                // so it should never be shared in different places.
-                // Otherwise wrong information may be used in the compression phase
-                value = value.clone(true);
-            }
-            return make_node(value.CTOR, orig, value);
-        }
-        if (Array.isArray(value)) return make_node(AST_Array, orig, {
-            elements: value.map(function(value) {
-                return to_node(value, orig);
-            })
-        });
-        if (value && typeof value == "object") {
-            var props = [];
-            for (var key in value) if (HOP(value, key)) {
-                props.push(make_node(AST_ObjectKeyVal, orig, {
-                    key: key,
-                    value: to_node(value[key], orig)
-                }));
-            }
-            return make_node(AST_Object, orig, {
-                properties: props
-            });
-        }
-        return make_node_from_constant(value, orig);
-    }
-
-    AST_Toplevel.DEFMETHOD("resolve_defines", function(compressor) {
-        if (!compressor.option("global_defs")) return this;
-        this.figure_out_scope({ ie8: compressor.option("ie8") });
-        return this.transform(new TreeTransformer(function(node) {
-            var def = node._find_defs(compressor, "");
-            if (!def) return;
-            var level = 0, child = node, parent;
-            while (parent = this.parent(level++)) {
-                if (!(parent instanceof AST_PropAccess)) break;
-                if (parent.expression !== child) break;
-                child = parent;
-            }
-            if (is_lhs(child, parent)) {
-                return;
-            }
-            return def;
-        }));
-    });
-    def_find_defs(AST_Node, noop);
-    def_find_defs(AST_Chain, function(compressor, suffix) {
-        return this.expression._find_defs(compressor, suffix);
-    });
-    def_find_defs(AST_Dot, function(compressor, suffix) {
-        return this.expression._find_defs(compressor, "." + this.property + suffix);
-    });
-    def_find_defs(AST_SymbolDeclaration, function() {
-        if (!this.global()) return;
-    });
-    def_find_defs(AST_SymbolRef, function(compressor, suffix) {
-        if (!this.global()) return;
-        var defines = compressor.option("global_defs");
-        var name = this.name + suffix;
-        if (HOP(defines, name)) return to_node(defines[name], this);
-    });
-    def_find_defs(AST_ImportMeta, function(compressor, suffix) {
-        var defines = compressor.option("global_defs");
-        var name = "import.meta" + suffix;
-        if (HOP(defines, name)) return to_node(defines[name], this);
-    });
-})(function(node, func) {
-    node.DEFMETHOD("_find_defs", func);
-});
-
 // method to negate an expression
 (function(def_negate) {
     function basic_negation(exp) {

package/lib/compress/inline.js

@@ -290,8 +290,9 @@ export function inline_into_symbolref(self, compressor) {
     return self;
 }
 
-export function inline_into_call(self, fn, compressor) {
+export function inline_into_call(self, compressor) {
     var exp = self.expression;
+    var fn = exp;
     var simple_args = self.args.every((arg) => !(arg instanceof AST_Expansion));
 
     if (compressor.option("reduce_vars")
@@ -299,9 +300,15 @@ export function inline_into_call(self, fn, compressor) {
         && !has_annotation(self, _NOINLINE)
     ) {
         const fixed = fn.fixed_value();
-        if (!retain_top_func(fixed, compressor)) {
-            fn = fixed;
+
+        if (
+            retain_top_func(fixed, compressor)
+            || !compressor.toplevel.funcs && exp.definition().global
+        ) {
+            return self;
         }
+
+        fn = fixed;
     }
 
     var is_func = fn instanceof AST_Lambda;

package/lib/minify.js

@@ -230,6 +230,9 @@ async function minify(files, options, _fs_module) {
                 }
             }
         }
+        if (options.parse.toplevel === null) {
+            throw new Error("no source file given");
+        }
 
         toplevel = options.parse.toplevel;
     }

package/lib/mozilla-ast.js

@@ -166,17 +166,15 @@ import { is_basic_identifier_string } from "./parse.js";
 (function() {
 
     var normalize_directives = function(body) {
-        var in_directive = true;
-
         for (var i = 0; i < body.length; i++) {
-            if (in_directive && body[i] instanceof AST_Statement && body[i].body instanceof AST_String) {
+            if (body[i] instanceof AST_Statement && body[i].body instanceof AST_String) {
                 body[i] = new AST_Directive({
                     start: body[i].start,
                     end: body[i].end,
                     value: body[i].body.value
                 });
-            } else if (in_directive && !(body[i] instanceof AST_Statement && body[i].body instanceof AST_String)) {
-                in_directive = false;
+            } else {
+                return body;
             }
         }
 

package/lib/output.js

@@ -980,7 +980,8 @@ function OutputStream(options) {
         ) {
             return true;
         }
-        return p instanceof AST_PropAccess && p.expression === this;
+        return p instanceof AST_PropAccess && p.expression === this
+            || p instanceof AST_Conditional && p.condition === this;
     });
 
     // same goes for an object literal (as in AST_Function), because

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.19.4",
+  "version": "5.21.0",
   "engines": {
     "node": ">=10"
   },