terser 5.20.0 → 5.21.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## v5.20.1
+ - Do not inline functions that would be retained in the toplevel (as this would cause code duplication).
+ - Fix precedence of arrow function and ternary operator when formatting output.
+
 ## v5.20.0
  - Passing `minify()` zero files will now throw a clean exception (#1450)
  - `drop_console` supports passing in an array of `console.*` method names (#1445)

package/dist/bundle.min.js

@@ -9742,7 +9742,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
@@ -13190,7 +13191,7 @@ 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());
 }
 
 /***********************************************************************
@@ -14039,80 +14040,6 @@ 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) {
@@ -15169,7 +15096,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);
             }
         });
@@ -15184,9 +15111,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;
@@ -15199,7 +15124,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);
                 }
             }
@@ -15207,10 +15132,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) {
@@ -15220,7 +15147,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);
                             }
                         }
@@ -17903,8 +17830,9 @@ function inline_into_symbolref(self, compressor) {
     return self;
 }
 
-function inline_into_call(self, fn, compressor) {
+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")
@@ -17912,9 +17840,15 @@ 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;
@@ -18245,6 +18179,80 @@ function inline_into_call(self, fn, compressor) {
     }
 }
 
+(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);
+});
+
 /***********************************************************************
 
   A JavaScript tokenizer / parser / beautifier / compressor.
@@ -19687,18 +19695,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;
@@ -20006,7 +20006,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) {
@@ -21839,10 +21839,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/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 }) {
@@ -1609,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;
@@ -1928,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) {
@@ -3761,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/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.20.0",
+  "version": "5.21.0",
   "engines": {
     "node": ">=10"
   },