v3.16.1

fixes #5512

.github/workflows/ufuzz.yml

@@ -17,13 +17,13 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - node: latest
+          - node: '16'
             os: macos-latest
-          - node: '8'
+          - node: '12'
             os: ubuntu-latest
           - node: '8'
             os: ubuntu-latest
-          - node: '8'
+          - node: '12'
             os: windows-latest
           - node: '8'
             os: windows-latest

README.md

@@ -118,6 +118,7 @@ a double dash to prevent input files being used as option arguments:
     --keep-fargs                Do not mangle/drop function arguments.
     --keep-fnames               Do not mangle/drop function names.  Useful for
                                 code relying on Function.prototype.name.
+    --module                    Process input as ES module (implies --toplevel)
     --name-cache <file>         File to hold mangled name mappings.
     --self                      Build UglifyJS as a library (implies --wrap UglifyJS)
     --source-map [options]      Enable source map/specify source map options:
@@ -146,7 +147,7 @@ a double dash to prevent input files being used as option arguments:
     --warn                      Print warning messages.
     --webkit                    Support non-standard Safari/Webkit.
                                 Equivalent to setting `webkit: true` in `minify()`
-                                for `mangle` and `output` options.
+                                for `compress`, `mangle` and `output` options.
                                 By default UglifyJS will not try to be Safari-proof.
     --wrap <name>               Embed everything in a big function, making the
                                 “exports” and “global” variables available. You
@@ -517,6 +518,10 @@ if (result.error) throw result.error;
   - `mangle.properties` (default: `false`) — a subcategory of the mangle option.
     Pass an object to specify custom [mangle property options](#mangle-properties-options).
 
+- `module` (default: `false`) — set to `true` if you wish to process input as
+  ES module, i.e. implicit `"use strict";` and support for top-level `await`,
+  alongside with `toplevel` enabled.
+
 - `nameCache` (default: `null`) — pass an empty object `{}` or a previously
   used `nameCache` object if you wish to cache mangled variable and
   property names across multiple invocations of `minify()`. Note: this is
@@ -628,7 +633,13 @@ to be `false` and all symbol names will be omitted.
 
 - `bare_returns` (default: `false`) — support top level `return` statements
 
-- `html5_comments` (default: `true`)
+- `expression` (default: `false`) — parse as a single expression, e.g. JSON
+
+- `html5_comments` (default: `true`) — process HTML comment as workaround for
+  browsers which do not recognise `<script>` tags
+
+- `module` (default: `false`) — set to `true` if you wish to process input as
+  ES module, i.e. implicit `"use strict";` and support for top-level `await`.
 
 - `shebang` (default: `true`) — support `#!command` as the first line
 
@@ -728,6 +739,9 @@ to be `false` and all symbol names will be omitted.
 
 - `merge_vars` (default: `true`) — combine and reuse variables.
 
+- `module` (default: `false`) — set to `true` if you wish to process input as
+  ES module, i.e. implicit `"use strict";` alongside with `toplevel` enabled.
+
 - `negate_iife` (default: `true`) — negate "Immediately-Called Function Expressions"
   where the return value is discarded, to avoid the parens that the
   code generator would insert.
@@ -804,8 +818,9 @@ to be `false` and all symbol names will be omitted.
 
 - `unsafe` (default: `false`) — apply "unsafe" transformations (discussion below)
 
-- `unsafe_comps` (default: `false`) — compress expressions like `a <= b` assuming
-  none of the operands can be (coerced to) `NaN`.
+- `unsafe_comps` (default: `false`) — assume operands cannot be (coerced to) `NaN`
+  in numeric comparisons, e.g. `a <= b`. In addition, expressions involving `in`
+  or `instanceof` would never throw.
 
 - `unsafe_Function` (default: `false`) — compress and mangle `Function(args, code)`
   when both `args` and `code` are string literals.
@@ -1331,10 +1346,8 @@ To allow for better optimizations, the compiler makes various assumptions:
 - Later versions of JavaScript will throw `SyntaxError` with the following:
   ```javascript
   var await;
-  async function f() {
-      class A {
-          static p = await;
-      }
+  class A {
+      static p = await;
   }
   // SyntaxError: Unexpected reserved word
   ```
@@ -1373,3 +1386,57 @@ To allow for better optimizations, the compiler makes various assumptions:
   // TypeError: const 'a' has already been declared
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  try {
+      class A {
+          static 42;
+          static get 42() {}
+      }
+      console.log("PASS");
+  } catch (e) {
+      console.log("FAIL");
+  }
+  // Expected: "PASS"
+  // Actual:   "FAIL"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  (async function(a) {
+      (function() {
+          var b = await => console.log("PASS");
+          b();
+      })();
+  })().catch(console.error);
+  // Expected: "PASS"
+  // Actual:   SyntaxError: Unexpected reserved word
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  try {
+      f();
+      function f() {
+          throw 42;
+      }
+  } catch (e) {
+      console.log(typeof f, e);
+  }
+  // Expected: "function 42"
+  // Actual:   "undefined 42"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  "use strict";
+  console.log(function f() {
+      return f = "PASS";
+  }());
+  // Expected: "PASS"
+  // Actual:   TypeError: invalid assignment to const 'f'
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.

bin/uglifyjs

@@ -107,6 +107,7 @@ function process_option(name, no_value) {
                 "  --ie                                     Support non-standard Internet Explorer.",
                 "  --keep-fargs                             Do not mangle/drop function arguments.",
                 "  --keep-fnames                            Do not mangle/drop function names. Useful for code relying on Function.prototype.name.",
+                "  --module                                 Process input as ES module (implies --toplevel)",
                 "  --name-cache <file>                      File to hold mangled name mappings.",
                 "  --rename                                 Force symbol expansion.",
                 "  --no-rename                              Disable symbol expansion.",
@@ -152,6 +153,7 @@ function process_option(name, no_value) {
       case "annotations":
       case "ie":
       case "ie8":
+      case "module":
       case "timings":
       case "toplevel":
       case "v8":

lib/ast.js

@@ -534,7 +534,7 @@ var AST_With = DEFNODE("With", "expression", {
 /* -----[ scope and functions ]----- */
 
 var AST_Scope = DEFNODE("Scope", "fn_defs may_call_this uses_eval uses_with", {
-    $documentation: "Base class for all statements introducing a lexical scope",
+    $documentation: "Base class for all statements introducing a lambda scope",
     $propdoc: {
         uses_eval: "[boolean/S] tells whether this scope contains a direct call to the global `eval`",
         uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
@@ -592,6 +592,10 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
     }
 }, AST_Scope);
 
+var AST_ClassInitBlock = DEFNODE("ClassInitBlock", null, {
+    $documentation: "Value for `class` static initialization blocks",
+}, AST_Scope);
+
 var AST_Lambda = DEFNODE("Lambda", "argnames length_read rest safe_ids uses_arguments", {
     $documentation: "Base class for functions",
     $propdoc: {
@@ -827,6 +831,9 @@ var AST_Class = DEFNODE("Class", "extends name properties", {
         extends: "[AST_Node?] the super class, or null if not specified",
         properties: "[AST_ClassProperty*] array of class properties",
     },
+    resolve: function(def_class) {
+        return def_class ? this : this.parent_scope.resolve();
+    },
     walk: function(visitor) {
         var node = this;
         visitor.visit(node, function() {
@@ -871,7 +878,7 @@ var AST_ClassExpression = DEFNODE("ClassExpression", null, {
 var AST_ClassProperty = DEFNODE("ClassProperty", "key private static value", {
     $documentation: "Base class for `class` properties",
     $propdoc: {
-        key: "[string|AST_Node] property name (AST_Node for computed property)",
+        key: "[string|AST_Node?] property name (AST_Node for computed property, null for initialization block)",
         private: "[boolean] whether this is a private property",
         static: "[boolean] whether this is a static property",
         value: "[AST_Node?] property value (AST_Accessor for getters/setters, AST_LambdaExpression for methods, null if not specified for fields)",
@@ -885,7 +892,9 @@ var AST_ClassProperty = DEFNODE("ClassProperty", "key private static value", {
     },
     _validate: function() {
         if (this.TYPE == "ClassProperty") throw new Error("should not instantiate AST_ClassProperty");
-        if (typeof this.key != "string") {
+        if (this instanceof AST_ClassInit) {
+            if (this.key != null) throw new Error("key must be null");
+        } else if (typeof this.key != "string") {
             if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node");
             must_be_expression(this, "key");
         }
@@ -925,6 +934,17 @@ var AST_ClassMethod = DEFNODE("ClassMethod", null, {
     },
 }, AST_ClassProperty);
 
+var AST_ClassInit = DEFNODE("ClassInit", null, {
+    $documentation: "A `class` static initialization block",
+    _validate: function() {
+        if (!this.static) throw new Error("static must be true");
+        if (!(this.value instanceof AST_ClassInitBlock)) throw new Error("value must be AST_ClassInitBlock");
+    },
+    initialize: function() {
+        this.static = true;
+    },
+}, AST_ClassProperty);
+
 /* -----[ JUMPS ]----- */
 
 var AST_Jump = DEFNODE("Jump", null, {
@@ -1834,7 +1854,7 @@ var AST_Label = DEFNODE("Label", "references", {
     initialize: function() {
         this.references = [];
         this.thedef = this;
-    }
+    },
 }, AST_Symbol);
 
 var AST_SymbolRef = DEFNODE("SymbolRef", "fixed in_arg redef", {
@@ -2036,16 +2056,21 @@ TreeWalker.prototype = {
         return this.stack[this.stack.length - 2 - (n || 0)];
     },
     push: function(node) {
-        if (node instanceof AST_Lambda) {
+        var value;
+        if (node instanceof AST_Class) {
+            this.directives = Object.create(this.directives);
+            value = "use strict";
+        } else if (node instanceof AST_Directive) {
+            value = node.value;
+        } else if (node instanceof AST_Lambda) {
             this.directives = Object.create(this.directives);
-        } else if (node instanceof AST_Directive && !this.directives[node.value]) {
-            this.directives[node.value] = node;
         }
+        if (value && !this.directives[value]) this.directives[value] = node;
         this.stack.push(node);
     },
     pop: function() {
         var node = this.stack.pop();
-        if (node instanceof AST_Lambda) {
+        if (node instanceof AST_Class || node instanceof AST_Lambda) {
             this.directives = Object.getPrototypeOf(this.directives);
         }
     },
@@ -2085,33 +2110,40 @@ TreeWalker.prototype = {
         }
     },
     in_boolean_context: function() {
-        var self = this.self();
-        for (var i = 0, p; p = this.parent(i); i++) {
-            if (p instanceof AST_Conditional && p.condition === self
-                || p instanceof AST_DWLoop && p.condition === self
-                || p instanceof AST_For && p.condition === self
-                || p instanceof AST_If && p.condition === self
-                || p instanceof AST_Return && p.in_bool
-                || p instanceof AST_Sequence && p.tail_node() !== self
-                || p instanceof AST_SimpleStatement
-                || p instanceof AST_UnaryPrefix && p.operator == "!" && p.expression === self) {
-                return true;
-            }
-            if (p instanceof AST_Binary && (p.operator == "&&" || p.operator == "||")
-                || p instanceof AST_Conditional
-                || p.tail_node() === self) {
-                self = p;
-            } else if (p instanceof AST_Return) {
-                for (var call, fn = p; call = this.parent(++i); fn = call) {
-                    if (call.TYPE == "Call") {
-                        if (!(fn instanceof AST_Lambda) || fn.name) return false;
-                    } else if (fn instanceof AST_Lambda) {
-                        return false;
-                    }
-                }
-            } else {
+        for (var drop = true, level = 0, parent, self = this.self(); parent = this.parent(level++); self = parent) {
+            if (parent instanceof AST_Binary) switch (parent.operator) {
+              case "&&":
+              case "||":
+                if (parent.left === self) drop = false;
+                continue;
+              default:
                 return false;
             }
+            if (parent instanceof AST_Conditional) {
+                if (parent.condition === self) return true;
+                continue;
+            }
+            if (parent instanceof AST_DWLoop) return parent.condition === self;
+            if (parent instanceof AST_For) return parent.condition === self;
+            if (parent instanceof AST_If) return parent.condition === self;
+            if (parent instanceof AST_Return) {
+                if (parent.in_bool) return true;
+                while (parent = this.parent(level++)) {
+                    if (parent instanceof AST_Lambda) {
+                        if (parent.name) return false;
+                        parent = this.parent(level++);
+                        if (parent.TYPE != "Call") return false;
+                        break;
+                    }
+                }
+            }
+            if (parent instanceof AST_Sequence) {
+                if (parent.tail_node() === self) continue;
+                return drop ? "d" : true;
+            }
+            if (parent instanceof AST_SimpleStatement) return drop ? "d" : true;
+            if (parent instanceof AST_UnaryPrefix) return parent.operator == "!";
+            return false;
         }
     }
 };

lib/minify.js

@@ -81,13 +81,14 @@ function minify(files, options) {
             keep_fargs: false,
             keep_fnames: false,
             mangle: {},
+            module: false,
             nameCache: null,
             output: {},
             parse: {},
             rename: undefined,
             sourceMap: false,
             timings: false,
-            toplevel: false,
+            toplevel: !!(options && options["module"]),
             v8: false,
             validate: false,
             warnings: false,
@@ -96,15 +97,15 @@ function minify(files, options) {
         }, true);
         if (options.validate) AST_Node.enable_validation();
         var timings = options.timings && { start: Date.now() };
-        if (options.rename === undefined) options.rename = options.compress && options.mangle;
         if (options.annotations !== undefined) set_shorthand("annotations", options, [ "compress", "output" ]);
         if (options.ie8) options.ie = options.ie || options.ie8;
-        if (options.ie) set_shorthand("ie", options, [ "compress", "mangle", "output" ]);
-        if (options.keep_fargs) set_shorthand("keep_fargs", options, [ "compress", "mangle" ]);
-        if (options.keep_fnames) set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
-        if (options.toplevel) set_shorthand("toplevel", options, [ "compress", "mangle" ]);
-        if (options.v8) set_shorthand("v8", options, [ "mangle", "output" ]);
-        if (options.webkit) set_shorthand("webkit", options, [ "compress", "mangle", "output" ]);
+        if (options.ie) set_shorthand("ie", options, [ "compress", "mangle", "output", "rename" ]);
+        if (options.keep_fargs) set_shorthand("keep_fargs", options, [ "compress", "mangle", "rename" ]);
+        if (options.keep_fnames) set_shorthand("keep_fnames", options, [ "compress", "mangle", "rename" ]);
+        if (options.module) set_shorthand("module", options, [ "compress", "parse" ]);
+        if (options.toplevel) set_shorthand("toplevel", options, [ "compress", "mangle", "rename" ]);
+        if (options.v8) set_shorthand("v8", options, [ "mangle", "output", "rename" ]);
+        if (options.webkit) set_shorthand("webkit", options, [ "compress", "mangle", "output", "rename" ]);
         var quoted_props;
         if (options.mangle) {
             options.mangle = defaults(options.mangle, {
@@ -135,6 +136,7 @@ function minify(files, options) {
             init_cache(options.mangle.cache);
             init_cache(options.mangle.properties.cache);
         }
+        if (options.rename === undefined) options.rename = options.compress && options.mangle;
         if (options.sourceMap) {
             options.sourceMap = defaults(options.sourceMap, {
                 content: null,
@@ -190,8 +192,8 @@ function minify(files, options) {
         if (options.validate) toplevel.validate_ast();
         if (timings) timings.rename = Date.now();
         if (options.rename) {
-            toplevel.figure_out_scope(options.mangle);
-            toplevel.expand_names(options.mangle);
+            toplevel.figure_out_scope(options.rename);
+            toplevel.expand_names(options.rename);
         }
         if (timings) timings.compress = Date.now();
         if (options.compress) {

lib/output.js

@@ -260,6 +260,15 @@ function OutputStream(options) {
 
     var require_semicolon = makePredicate("( [ + * / - , .");
 
+    function require_space(prev, ch, str) {
+        return is_identifier_char(prev) && (is_identifier_char(ch) || ch == "\\")
+            || (ch == "/" && ch == prev)
+            || ((ch == "+" || ch == "-") && ch == last)
+            || last == "--" && ch == ">"
+            || last == "!" && str == "--"
+            || prev == "/" && (str == "in" || str == "instanceof");
+    }
+
     var print = options.beautify
         || options.comments
         || options.max_line_len
@@ -312,12 +321,7 @@ function OutputStream(options) {
         }
 
         if (might_need_space) {
-            if (is_identifier_char(prev) && (is_identifier_char(ch) || ch == "\\")
-                || (ch == "/" && ch == prev)
-                || ((ch == "+" || ch == "-") && ch == last)
-                || str == "--" && last == "!"
-                || str == "in" && prev == "/"
-                || last == "--" && ch == ">") {
+            if (require_space(prev, ch, str)) {
                 output += " ";
                 current_col++;
             }
@@ -355,14 +359,7 @@ function OutputStream(options) {
             }
         }
         if (might_need_space) {
-            if (is_identifier_char(prev) && (is_identifier_char(ch) || ch == "\\")
-                || (ch == "/" && ch == prev)
-                || ((ch == "+" || ch == "-") && ch == last)
-                || str == "--" && last == "!"
-                || str == "in" && prev == "/"
-                || last == "--" && ch == ">") {
-                output += " ";
-            }
+            if (require_space(prev, ch, str)) output += " ";
             if (prev != "<" || str != "!") might_need_space = false;
         }
         output += str;
@@ -1257,6 +1254,11 @@ function OutputStream(options) {
         }
         print_method(self, output);
     });
+    DEFPRINT(AST_ClassInit, function(output) {
+        output.print("static");
+        output.space();
+        print_braced(this.value, output);
+    });
 
     /* -----[ jumps ]----- */
     function print_jump(kind, prop) {
@@ -1814,9 +1816,6 @@ function OutputStream(options) {
               case "\u2029": return "\\u2029";
             }
         }));
-        var p = output.parent();
-        if (p instanceof AST_Binary && /^in/.test(p.operator) && p.left === this)
-            output.print(" ");
     });
 
     function force_statement(stat, output) {

lib/parse.js

@@ -237,8 +237,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         newline_before  : false,
         regex_allowed   : false,
         comments_before : [],
-        directives      : {},
-        directive_stack : [],
+        directives      : Object.create(null),
         read_template   : with_eof_error("Unterminated template literal", function(strings) {
             var s = "";
             for (;;) {
@@ -635,24 +634,19 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     };
 
     next_token.add_directive = function(directive) {
-        S.directive_stack[S.directive_stack.length - 1].push(directive);
-        if (S.directives[directive]) S.directives[directive]++;
-        else S.directives[directive] = 1;
+        S.directives[directive] = true;
     }
 
     next_token.push_directives_stack = function() {
-        S.directive_stack.push([]);
+        S.directives = Object.create(S.directives);
     }
 
     next_token.pop_directives_stack = function() {
-        var directives = S.directive_stack.pop();
-        for (var i = directives.length; --i >= 0;) {
-            S.directives[directives[i]]--;
-        }
+        S.directives = Object.getPrototypeOf(S.directives);
     }
 
     next_token.has_directive = function(directive) {
-        return S.directives[directive] > 0;
+        return !!S.directives[directive];
     }
 
     return next_token;
@@ -699,6 +693,7 @@ function parse($TEXT, options) {
         expression     : false,
         filename       : null,
         html5_comments : true,
+        module         : false,
         shebang        : true,
         strict         : false,
         toplevel       : null,
@@ -1124,6 +1119,18 @@ function parse($TEXT, options) {
                 }));
                 continue;
             }
+            if (fixed && is("punc", "{")) {
+                props.push(new AST_ClassInit({
+                    start: start,
+                    value: new AST_ClassInitBlock({
+                        start: start,
+                        body: block_(),
+                        end: prev(),
+                    }),
+                    end: prev(),
+                }));
+                continue;
+            }
             var internal = is("name") && /^#/.test(S.token.value);
             var key = as_property_key();
             if (is("punc", "(")) {
@@ -1194,10 +1201,10 @@ function parse($TEXT, options) {
     }
 
     function for_() {
-        var await = is("name", "await") && next();
+        var await_token = is("name", "await") && next();
         expect("(");
         var init = null;
-        if (await || !is("punc", ";")) {
+        if (await_token || !is("punc", ";")) {
             init = is("keyword", "const")
                 ? (next(), const_(true))
                 : is("name", "let") && is_vardefs()
@@ -1206,7 +1213,7 @@ function parse($TEXT, options) {
                 ? (next(), var_(true))
                 : expression(true);
             var ctor;
-            if (await) {
+            if (await_token) {
                 expect_token("name", "of");
                 ctor = AST_ForAwaitOf;
             } else if (is("operator", "in")) {
@@ -1340,11 +1347,11 @@ function parse($TEXT, options) {
         var loop = S.in_loop;
         var labels = S.labels;
         ++S.in_function;
-        S.in_directives = true;
         S.input.push_directives_stack();
         S.in_loop = 0;
         S.labels = [];
         if (is("punc", "{")) {
+            S.in_directives = true;
             body = block_();
             value = null;
         } else {
@@ -1412,7 +1419,7 @@ function parse($TEXT, options) {
             name: name,
             argnames: argnames,
             rest: argnames.rest || null,
-            body: body
+            body: body,
         });
         if (is_strict) {
             if (name) strict_verify_symbol(name);
@@ -2550,6 +2557,10 @@ function parse($TEXT, options) {
     return function() {
         var start = S.token;
         var body = [];
+        if (options.module) {
+            S.in_async = true;
+            S.input.add_directive("use strict");
+        }
         S.input.push_directives_stack();
         while (!is("eof"))
             body.push(statement());

lib/scope.js

@@ -64,19 +64,20 @@ SymbolDef.prototype = {
         this.references.forEach(fn);
     },
     mangle: function(options) {
-        var cache = options.cache && options.cache.props;
-        if (this.global && cache && cache.has(this.name)) {
+        if (this.mangled_name) return;
+        var cache = this.global && options.cache && options.cache.props;
+        if (cache && cache.has(this.name)) {
             this.mangled_name = cache.get(this.name);
-        } else if (!this.mangled_name && !this.unmangleable(options)) {
+        } else if (this.unmangleable(options)) {
+            names_in_use(this.scope, options).set(this.name, true);
+        } else {
             var def = this.redefined();
             if (def) {
                 this.mangled_name = def.mangled_name || def.name;
             } else {
                 this.mangled_name = next_mangled_name(this, options);
             }
-            if (this.global && cache) {
-                cache.set(this.name, this.mangled_name);
-            }
+            if (cache) cache.set(this.name, this.mangled_name);
         }
     },
     redefined: function() {
@@ -226,7 +227,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             defun.def_variable(node);
         } else if (node instanceof AST_SymbolLambda) {
             var def = defun.def_function(node, node.name == "arguments" ? undefined : defun);
-            if (options.ie) def.defun = defun.parent_scope.resolve();
+            if (options.ie && node.name != "arguments") def.defun = defun.parent_scope.resolve();
         } else if (node instanceof AST_SymbolLet) {
             var def = scope.def_variable(node);
             if (exported) def.exported = true;
@@ -469,6 +470,7 @@ AST_Lambda.DEFMETHOD("init_vars", function(parent_scope) {
     this.uses_arguments = false;
     this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
+        scope: this,
         start: this.start,
         end: this.end,
     }));
@@ -616,18 +618,14 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             mangled_names.set(mangled_name, true);
         });
     }
-    var cutoff = 10;
+    var cutoff = 36;
     var lname = -1;
     var redefined = [];
     var tw = new TreeWalker(function(node, descend) {
-        if (node instanceof AST_LabeledStatement) {
-            // `lname` is incremented when we get to the `AST_Label`
-            var save_nesting = lname;
-            descend();
-            if (!options.v8 || !in_label(tw)) lname = save_nesting;
-            return true;
-        }
+        var save_nesting;
         if (node instanceof AST_BlockScope) {
+            // `lname` is incremented when we get to the `AST_Label`
+            if (node instanceof AST_LabeledStatement) save_nesting = lname;
             if (options.webkit && node instanceof AST_IterationStatement && node.init instanceof AST_Let) {
                 node.init.definitions.forEach(function(defn) {
                     defn.name.match_symbol(function(sym) {
@@ -673,6 +671,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
                 }));
             }
             to_mangle.forEach(mangle);
+            if (node instanceof AST_LabeledStatement && !(options.v8 && in_label(tw))) lname = save_nesting;
             return true;
         }
         if (node instanceof AST_Label) {

package.json

@@ -3,7 +3,7 @@
   "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.15.1",
+  "version": "3.16.1",
   "engines": {
     "node": ">=0.8.0"
   },

test/benchmark.js

@@ -17,6 +17,7 @@ var urls = [
     "https://unpkg.com/mathjs@6.2.3/dist/math.js",
     "https://unpkg.com/react@15.3.2/dist/react.js",
     "https://cdnjs.cloudflare.com/ajax/libs/d3/6.7.0/d3.js",
+    "https://cdnjs.cloudflare.com/ajax/libs/antd/4.18.7/antd.js",
     "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.js",
     "https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.js",
     "https://cdnjs.cloudflare.com/ajax/libs/ember.js/2.12.2/ember.prod.js",

test/compress.js

@@ -69,9 +69,7 @@ function make_code(ast, options) {
 function parse_test(file) {
     var script = fs.readFileSync(file, "utf8");
     try {
-        var ast = U.parse(script, {
-            filename: file
-        });
+        var ast = U.parse(script, { filename: file });
     } catch (e) {
         console.error("Caught error while parsing tests in " + file);
         console.error(e);
@@ -98,14 +96,14 @@ function parse_test(file) {
             file: file,
             line: node.start.line,
             col: node.start.col,
-            code: make_code(node, { beautify: false })
+            code: make_code(node, { beautify: false }),
         }));
     }
 
     function read_string(stat) {
         if (stat.TYPE == "SimpleStatement") {
             var body = stat.body;
-            switch(body.TYPE) {
+            switch (body.TYPE) {
               case "String":
                 return body.value;
               case "Array":
@@ -142,7 +140,7 @@ function parse_test(file) {
                 ].indexOf(label.name) >= 0, tmpl("Unsupported label {name} [{line},{col}]", {
                     name: label.name,
                     line: label.start.line,
-                    col: label.start.col
+                    col: label.start.col,
                 }));
                 var stat = node.body;
                 if (label.name == "expect_exact" || label.name == "node_version") {
@@ -155,12 +153,12 @@ function parse_test(file) {
                         var ctor = global[body.expression.name];
                         assert.ok(ctor === Error || ctor.prototype instanceof Error, tmpl("Unsupported expect_stdout format [{line},{col}]", {
                             line: label.start.line,
-                            col: label.start.col
+                            col: label.start.col,
                         }));
                         test[label.name] = ctor.apply(null, body.args.map(function(node) {
                             assert.ok(node instanceof U.AST_Constant, tmpl("Unsupported expect_stdout format [{line},{col}]", {
                                 line: label.start.line,
-                                col: label.start.col
+                                col: label.start.col,
                             }));
                             return node.value;
                         }));
@@ -183,13 +181,11 @@ function parse_test(file) {
 function reminify(orig_options, input_code, input_formatted, stdout) {
     for (var i = 0; i < minify_options.length; i++) {
         var options = JSON.parse(minify_options[i]);
-        if (options.compress) [
+        [
             "keep_fargs",
             "keep_fnames",
         ].forEach(function(name) {
-            if (name in orig_options) {
-                options.compress[name] = orig_options[name];
-            }
+            if (name in orig_options) options[name] = orig_options[name];
         });
         var options_formatted = JSON.stringify(options, null, 4);
         options.validate = true;

test/compress/arrows.js

@@ -1002,3 +1002,121 @@ issue_5342_2: {
     expect_stdout: "undefined"
     node_version: ">=4"
 }
+
+issue_5356: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log((a => a++)(console));
+    }
+    expect: {
+        console.log((a => +a)(console));
+    }
+    expect_stdout: "NaN"
+    node_version: ">=4"
+}
+
+issue_5414_1: {
+    options = {
+        arrows: true,
+        if_return: true,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        (() => {
+            (() => {
+                if (!console)
+                    var arguments = 42;
+                while (console.log(arguments));
+            })();
+        })();
+    }
+    expect: {
+        (() => {
+            if (!console)
+                var arguments = 42;
+            while (console.log(arguments));
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_5414_2: {
+    options = {
+        arrows: true,
+        inline: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        (() => {
+            (() => {
+                if (!console)
+                    var arguments = 42;
+                while (console.log(arguments));
+            })();
+        })();
+    }
+    expect: {
+        (() => {
+            if (!console)
+                var arguments = 42;
+            while (console.log(arguments));
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_5416: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        loops: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            while ((() => {
+                console;
+                var a = function g(arguments) {
+                    console.log(arguments);
+                }();
+            })());
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            {
+                arguments = void 0;
+                console;
+                console.log(arguments);
+                var arguments;
+            }
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5495: {
+    input: {
+        console.log((() => {
+            "use strict";
+            return function() {
+                return this;
+            }();
+        })());
+    }
+    expect_exact: 'console.log((()=>{"use strict";return function(){return this}()})());'
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}

test/compress/awaits.js

@@ -1293,6 +1293,21 @@ functions_inner_var: {
     node_version: ">=8"
 }
 
+instanceof_lambda: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(42 instanceof async function() {});
+    }
+    expect: {
+        console.log(false);
+    }
+    expect_stdout: "false"
+    node_version: ">=8"
+}
+
 issue_4335_1: {
     options = {
         inline: true,
@@ -1748,8 +1763,8 @@ issue_4454_2: {
     expect: {
         function f(a) {
             (async function(c = console.log(a)) {})();
-            var a = 42..toString();
-            console.log(a);
+            var b = 42..toString();
+            console.log(b);
         }
         f("PASS");
     }
@@ -2427,80 +2442,6 @@ issue_5023_2: {
     node_version: ">=8"
 }
 
-issue_5032_normal: {
-    options = {
-        merge_vars: true,
-        webkit: false,
-    }
-    input: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        async function f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS");
-    }
-    expect: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        async function f(a) {
-            var a = log(a), c = a;
-            log(a);
-            log(c);
-        }
-        f("PASS");
-    }
-    expect_stdout: [
-        "PASS",
-        "PASS",
-        "PASS",
-    ]
-    node_version: ">=8"
-}
-
-issue_5032_webkit: {
-    options = {
-        merge_vars: true,
-        webkit: true,
-    }
-    input: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        async function f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS");
-    }
-    expect: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        async function f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS");
-    }
-    expect_stdout: [
-        "PASS",
-        "PASS",
-        "PASS",
-    ]
-    node_version: ">=8"
-}
-
 issue_5034: {
     options = {
         functions: true,
@@ -2959,3 +2900,124 @@ issue_5305_3: {
     expect_stdout: "PASS"
     node_version: ">=8"
 }
+
+issue_5456: {
+    options = {
+        inline: true,
+        merge_vars: true,
+    }
+    input: {
+        var a = true;
+        (function() {
+            (function(b, c) {
+                var d = async function() {
+                    c = await null;
+                }();
+                var e = function() {
+                    if (c)
+                        console.log(typeof d);
+                    while (b);
+                }();
+            })(function(i) {
+                return console.log("foo") && i;
+            }(a));
+        })();
+    }
+    expect: {
+        var a = true;
+        (function() {
+            b = (i = a, console.log("foo") && i),
+            d = async function() {
+                c = await null;
+            }(),
+            e = function() {
+                if (c) console.log(typeof d);
+                while (b);
+            }(),
+            void 0;
+            var b, c, d, e;
+            var i;
+        })();
+    }
+    expect_stdout: "foo"
+    node_version: ">=8"
+}
+
+issue_5478: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        A = {
+            get then() {
+                a = "FAIL";
+            },
+        };
+        var a = "PASS";
+        (async function() {
+            for (var b in "foo")
+                return void A;
+        })();
+        console.log(a);
+    }
+    expect: {
+        A = {
+            get then() {
+                a = "FAIL";
+            },
+        };
+        var a = "PASS";
+        (async function() {
+            for (var b in "foo")
+                return !A;
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_5493: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+    }
+    input: {
+        (async function(a) {
+            var b = await [ 42 || b, a = b ];
+            console.log(a);
+        })();
+    }
+    expect: {
+        (async function(a) {
+            var b = await [ 42 || b, a = b ];
+            console.log(a);
+        })();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=8"
+}
+
+issue_5506: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(function(a) {
+            (async function() {
+                a = null in (a = "PASS");
+            })();
+            return a;
+        }("FAIL"));
+    }
+    expect: {
+        console.log(function(a) {
+            (async function() {
+                a = null in (a = "PASS");
+            })();
+            return a;
+        }("FAIL"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}

test/compress/booleans.js

@@ -427,6 +427,44 @@ negated_if: {
     expect_stdout: "PASS"
 }
 
+concat_truthy: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        console.log("foo") + (console.log("bar"), "baz") || console.log("moo");
+    }
+    expect: {
+        console.log("foo") + (console.log("bar"), "baz");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    expect_warnings: [
+        "WARN: + in boolean context always true [test/compress/booleans.js:1,8]",
+        "WARN: Condition left of || always true [test/compress/booleans.js:1,8]",
+    ]
+}
+
+process_returns: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        (function() {
+            return 42;
+        })() && console.log("PASS");
+    }
+    expect: {
+        (function() {
+            return 42;
+        })() && console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
 issue_3465_1: {
     options = {
         booleans: true,
@@ -724,3 +762,27 @@ issue_5228: {
     }
     expect_stdout: "true"
 }
+
+issue_5469: {
+    options = {
+        assignments: true,
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        console.log(function f(a) {
+            a && 42[a = A && null];
+        }());
+    }
+    expect: {
+        console.log(function f(a) {
+            a && A,
+            0;
+        }());
+    }
+    expect_stdout: "undefined"
+}

test/compress/classes.js

@@ -241,6 +241,208 @@ class_super: {
     node_version: ">=4"
 }
 
+static_init: {
+    input: {
+        var a = "foo";
+        var b = null;
+        class A {
+            static {
+                var a = "bar";
+                b = true;
+                var c = 42;
+                console.log(a, b, c);
+            }
+        }
+        console.log(a, b, typeof c);
+    }
+    expect_exact: 'var a="foo";var b=null;class A{static{var a="bar";b=true;var c=42;console.log(a,b,c)}}console.log(a,b,typeof c);'
+    expect_stdout: [
+        "bar true 42",
+        "foo true undefined",
+    ]
+    node_version: ">=16"
+}
+
+static_field_init: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (class {
+            static [console.log("foo")] = console.log("bar");
+            static {
+                console.log("baz");
+            }
+            static [console.log("moo")] = console.log("moz");
+        });
+    }
+    expect: {
+        (class {
+            static [(console.log("foo"), console.log("moo"))] = (
+                console.log("bar"),
+                (() => {
+                    console.log("baz");
+                })(),
+                console.log("moz")
+            );
+        });
+    }
+    expect_stdout: [
+        "foo",
+        "moo",
+        "bar",
+        "baz",
+        "moz",
+    ]
+    node_version: ">=16"
+}
+
+static_field_init_strict: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        (class {
+            static [console.log("foo")] = console.log("bar");
+            static {
+                console.log("baz");
+            }
+            static [console.log("moo")] = console.log("moz");
+        });
+    }
+    expect: {
+        "use strict";
+        console.log("foo"),
+        console.log("moo"),
+        (() => (
+            console.log("bar"),
+            (() => {
+                console.log("baz");
+            })(),
+            console.log("moz")
+        ))();
+    }
+    expect_stdout: [
+        "foo",
+        "moo",
+        "bar",
+        "baz",
+        "moz",
+    ]
+    node_version: ">=16"
+}
+
+static_init_side_effects_1: {
+    options = {
+        merge_vars: true,
+        side_effects: true,
+    }
+    input: {
+        var a = "FAIL";
+        (class {
+            static {
+                a = "PASS";
+            }
+        });
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (class {
+            static {
+                a = "PASS";
+            }
+        });
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=16"
+}
+
+static_init_side_effects_1_strict: {
+    options = {
+        merge_vars: true,
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        var a = "FAIL";
+        (class {
+            static {
+                a = "PASS";
+            }
+        });
+        console.log(a);
+    }
+    expect: {
+        "use strict";
+        var a = "FAIL";
+        (() => (() => {
+            a = "PASS";
+        })())();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=16"
+}
+
+static_init_side_effects_2: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        var a = "FAIL";
+        (class {
+            static {
+                a = "PASS";
+            }
+        });
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (class {
+            static {
+                a = "PASS";
+            }
+        });
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=16"
+}
+
+static_init_side_effects_2_strict: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        var a = "FAIL";
+        (class {
+            static {
+                a = "PASS";
+            }
+        });
+        console.log(a);
+    }
+    expect: {
+        "use strict";
+        var a = "FAIL";
+        (() => (() => {
+            a = "PASS";
+        })())();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=16"
+}
+
 block_scoped: {
     options = {
         evaluate: true,
@@ -341,7 +543,7 @@ drop_extends: {
     node_version: ">=4"
 }
 
-keep_extends: {
+keep_extends_1: {
     options = {
         toplevel: true,
         unused: true,
@@ -366,6 +568,43 @@ keep_extends: {
     node_version: ">=4"
 }
 
+keep_extends_2: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        (class extends Function {});
+        console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        (class extends Function {});
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+keep_extends_3: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        class A extends Function {}
+        console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        (class extends Function {});
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 drop_name: {
     options = {
         unused: true,
@@ -670,6 +909,58 @@ single_use_7: {
     node_version: ">=4"
 }
 
+single_use_extends: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        class A extends class B {
+            f() {
+                return "PASS";
+            }
+        } {}
+        console.log(new A().f());
+    }
+    expect: {
+        "use strict";
+        console.log(new class extends class {
+            f() {
+                return "PASS";
+            }
+        } {}().f());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+single_use_extends_non_strict: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        class A extends class B {
+            f() {
+                return "PASS";
+            }
+        } {}
+        console.log(new A().f());
+    }
+    expect: {
+        console.log(new class extends class {
+            f() {
+                return "PASS";
+            }
+        } {}().f());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 collapse_non_strict: {
     options = {
         collapse_vars: true,
@@ -742,6 +1033,38 @@ collapse_rhs_static: {
     node_version: ">=12"
 }
 
+inline_non_strict: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            return a.p = "PASS";
+        }
+        class A {
+            g() {
+                return f(42);
+            }
+        }
+        console.log(new A().g());
+    }
+    expect: {
+        function f(a) {
+            return a.p = "PASS";
+        }
+        console.log(new class {
+            g() {
+                return f(42);
+            }
+        }().g());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 self_comparison: {
     options = {
         booleans: true,
@@ -939,6 +1262,107 @@ keep_fnames: {
         class Foo {}
         console.log(Foo.name, class Bar {}.name);
     }
+    expect_stdout: "Foo Bar"
+    node_version: ">=4"
+}
+
+instanceof_lambda: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        console.log(42 instanceof class {});
+    }
+    expect: {
+        "use strict";
+        console.log(false);
+    }
+    expect_stdout: "false"
+    node_version: ">=4"
+}
+
+drop_instanceof: {
+    options = {
+        booleans: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        class A {}
+        console.log({} instanceof A, Math instanceof A);
+    }
+    expect: {
+        "use strict";
+        console.log(!1, (Math, !1));
+    }
+    expect_stdout: "false false"
+    node_version: ">=4"
+}
+
+keep_instanceof_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        class A {}
+        var A;
+        console.log({} instanceof A, Math instanceof A);
+    }
+    expect: {
+        "use strict";
+        class A {}
+        var A;
+        console.log({} instanceof A, Math instanceof A);
+    }
+    expect_stdout: SyntaxError("Identifier has already been declared")
+    node_version: ">=4"
+}
+
+keep_instanceof_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var A = Object;
+        class A {}
+        console.log({} instanceof A, Math instanceof A);
+    }
+    expect: {
+        "use strict";
+        var A = Object;
+        class A {}
+        console.log({} instanceof A, Math instanceof A);
+    }
+    expect_stdout: SyntaxError("Identifier has already been declared")
+    node_version: ">=4"
+}
+
+keep_instanceof_3: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        class A {}
+        A = Object;
+        console.log({} instanceof A, Math instanceof A);
+    }
+    expect: {
+        "use strict";
+        class A {}
+        A = Object;
+        console.log({} instanceof A, Math instanceof A);
+    }
+    expect_stdout: "true true"
+    node_version: ">=4"
 }
 
 issue_805_1: {
@@ -1756,12 +2180,14 @@ issue_4962_1: {
         })(function g() {});
     }
     expect: {
-        (function g() {}),
-        void class {
-            static c = function() {
+        (function() {
+            function f() {
                 while (console.log(typeof g));
-            }();
-        };
+            }
+            (class {
+                static c = f();
+            });
+        })(function g() {});
     }
     expect_stdout: "undefined"
     node_version: ">=12"
@@ -1794,6 +2220,37 @@ issue_4962_1_strict: {
     node_version: ">=12"
 }
 
+issue_4962_1_strict_direct: {
+    options = {
+        ie: true,
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            function f() {
+                "use strict";
+                while (console.log(typeof g));
+            }
+            class A {
+                static p = f();
+            }
+        })(function g() {});
+    }
+    expect: {
+        (function g() {}),
+        void class {
+            static c = function() {
+                "use strict";
+                while (console.log(typeof g));
+            }();
+        };
+    }
+    expect_stdout: "undefined"
+    node_version: ">=12"
+}
+
 issue_4962_2: {
     options = {
         ie: true,
@@ -1813,8 +2270,11 @@ issue_4962_2: {
     }
     expect: {
         console.log(function f() {}(function g() {
+            function h() {
+                f;
+            }
             (class {
-                static c = f;
+                static c = h();
             });
         }));
     }
@@ -1850,6 +2310,69 @@ issue_4962_2_strict: {
     node_version: ">=12"
 }
 
+issue_4962_2_strict_direct: {
+    options = {
+        ie: true,
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function f() {}(function g() {
+            function h() {
+                "use strict";
+                f;
+            }
+            class A {
+                static p = h();
+            }
+        }, typeof g));
+    }
+    expect: {
+        console.log(function f() {}(function g() {
+            (class {
+                static c = function() {
+                    "use strict";
+                    f;
+                }();
+            });
+        }));
+    }
+    expect_stdout: "undefined"
+    node_version: ">=12"
+}
+
+issue_4962_2_strict_direct_inline: {
+    options = {
+        directives: true,
+        ie: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function f() {}(function g() {
+            function h() {
+                "use strict";
+                f;
+            }
+            class A {
+                static p = h();
+            }
+        }, typeof g));
+    }
+    expect: {
+        console.log(function f() {}(function g() {
+            (class {
+                static c = f;
+            });
+        }));
+    }
+    expect_stdout: "undefined"
+    node_version: ">=12"
+}
+
 issue_4982_1: {
     options = {
         dead_code: true,
@@ -2476,3 +2999,334 @@ issue_5322: {
     expect_stdout: "42"
     node_version: ">=12"
 }
+
+issue_5352: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a) {
+            var b;
+            new class {
+                [b = console.log(a)] = b;
+            }(a.p);
+        }
+        f("PASS");
+    }
+    expect: {
+        function f(a) {
+            var b;
+            new class {
+                [b = console.log(a)] = b;
+            }(a.p);
+        }
+        f("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+issue_5387: {
+    options = {
+        properties: true,
+    }
+    input: {
+        "use strict";
+        (function(a) {
+            try {
+                class A extends a {}
+            } catch (e) {
+                console.log("PASS");
+            }
+        })({
+            f() {
+                return this;
+            }
+        }.f);
+    }
+    expect: {
+        "use strict";
+        (function(a) {
+            try {
+                class A extends a {}
+            } catch (e) {
+                console.log("PASS");
+            }
+        })({
+            f() {
+                return this;
+            }
+        }.f);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_5389_1: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        function log(m, n) {
+            console.log(m, n);
+        }
+        var a = log;
+        class A {
+            [a = "FAIL"] = a = "PASS";
+        }
+        var b = new A();
+        log(a, b.FAIL);
+    }
+    expect: {
+        function log(m, n) {
+            console.log(m, n);
+        }
+        var a = log;
+        class A {
+            [a = "FAIL"] = a = "PASS";
+        }
+        var b = new A();
+        log(a, b.FAIL);
+    }
+    expect_stdout: "PASS PASS"
+    node_version: ">=12"
+}
+
+issue_5389_2: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        function log(m, n) {
+            console.log(m, n);
+        }
+        var a = log;
+        var A = class {
+            [a = "FAIL"] = a = "PASS";
+        };
+        var b = new A();
+        log(a, b.FAIL);
+    }
+    expect: {
+        function log(m, n) {
+            console.log(m, n);
+        }
+        var a = log;
+        var A;
+        var b = new class {
+            [a = "FAIL"] = a = "PASS";
+        }();
+        log(a, b.FAIL);
+    }
+    expect_stdout: "PASS PASS"
+    node_version: ">=12"
+}
+
+issue_5436: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a) {
+            class A {
+                p = a;
+            }
+            var b = "FAIL";
+            A == b && b();
+            return new A();
+        }
+        console.log(f("PASS").p);
+    }
+    expect: {
+        function f(a) {
+            class A {
+                p = a;
+            }
+            var b = "FAIL";
+            A == b && b();
+            return new A();
+        }
+        console.log(f("PASS").p);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+issue_5481: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = "FAIL 1", log = console.log;
+        try {
+            a = "PASS";
+            (class extends 42 {});
+            log("FAIL 2", a);
+        } catch (e) {
+            log(a);
+        }
+    }
+    expect: {
+        "use strict";
+        var a = "FAIL 1", log = console.log;
+        try {
+            a = "PASS";
+            (class extends 42 {});
+            log("FAIL 2", a);
+        } catch (e) {
+            log(a);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_5489: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (class {
+            [console.log("foo")];
+            static {
+                console.log("bar");
+            }
+            static [console.log("baz")]() {}
+        });
+    }
+    expect: {
+        (class {
+            [(console.log("foo"), console.log("baz"))];
+            static {
+                console.log("bar");
+            }
+        });
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+        "bar",
+    ]
+    node_version: ">=16"
+}
+
+issue_5489_strict: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        (class {
+            [console.log("foo")];
+            static {
+                console.log("bar");
+            }
+            static [console.log("baz")]() {}
+        });
+    }
+    expect: {
+        "use strict";
+        console.log("foo"),
+        console.log("baz"),
+        (() => (() => {
+            console.log("bar");
+        })())();
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+        "bar",
+    ]
+    node_version: ">=16"
+}
+
+issue_5502: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = "FAIL";
+        class A {
+            static p = a;
+            [a = "PASS"];
+        }
+        try {
+            b++;
+        } finally {
+            var a, b = 42;
+        }
+        console.log(a, b);
+    }
+    expect: {
+        "use strict";
+        var a = "FAIL";
+        class A {
+            static p = a;
+            [a = "PASS"];
+        }
+        try {
+            b++;
+        } finally {
+            var a, b = 42;
+        }
+        console.log(a, b);
+    }
+    expect_stdout: "PASS 42"
+    node_version: ">=12"
+}
+
+issue_5504: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        var a;
+        console.log((a = 42, class {
+            static p;
+        }).p);
+    }
+    expect: {
+        "use strict";
+        var a;
+        console.log((a = 42, class {
+            static p;
+        }).p);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=12"
+}
+
+issue_5512: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        a = "PASS";
+        class A {
+            static {
+                console.log(a);
+            }
+            static p = "PASS";
+        }
+        var a;
+    }
+    expect: {
+        "use strict";
+        a = "PASS";
+        class A {
+            static {
+                console.log(a);
+            }
+            static p = "PASS";
+        }
+        var a;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=16"
+}

test/compress/collapse_vars.js

@@ -9925,3 +9925,57 @@ issue_5309_2: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5394: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+    }
+    input: {
+        try {
+            throw A.p = (console.log("FAIL"), []), !1;
+        } catch (e) {
+            console.log(typeof e);
+        }
+    }
+    expect: {
+        try {
+            throw !(A.p = (console.log("FAIL"), []));
+        } catch (e) {
+            console.log(typeof e);
+        }
+    }
+    expect_stdout: "object"
+}
+
+issue_5396: {
+    options = {
+        collapse_vars: true,
+        merge_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a, b;
+        function f() {}
+        b = 0;
+        new function g(c) {
+            var d = a && g(e), e = ++d, i = [ 42 ];
+            for (var j in i)
+                console.log("PASS"),
+                i;
+        }();
+    }
+    expect: {
+        var a, b;
+        function f() {}
+        b = 0;
+        (function g(c) {
+            a && g();
+            for (var j in [ 42 ])
+                console.log("PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+}

test/compress/comparisons.js

@@ -40,6 +40,22 @@ unsafe_comps: {
     }
 }
 
+unsafe_in_instanceof: {
+    options = {
+        side_effects: true,
+        unsafe_comps: true,
+    }
+    input: {
+        var a;
+        42 in a;
+        f() instanceof "foo";
+    }
+    expect: {
+        var a;
+        f();
+    }
+}
+
 dont_change_in_or_instanceof_expressions: {
     input: {
         1 in 1;
@@ -489,7 +505,36 @@ issue_3413: {
     }
     expect: {
         var b;
-        void 0 !== ("" < b || void 0) || console.log("PASS");
+        void 0 === ("" < b || void 0) && console.log("PASS");
     }
     expect_stdout: "PASS"
 }
+
+nullish_assign: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        var a;
+        void 0 !== (a = "PASS".split("")) && null !== a && console.log(a.join("-"));
+    }
+    expect: {
+        var a;
+        null != (a = "PASS".split("")) && console.log(a.join("-"));
+    }
+    expect_stdout: "P-A-S-S"
+}
+
+nullish_chain: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        var a;
+        A || B || void 0 === a || null === a || C;
+    }
+    expect: {
+        var a;
+        A || B || null == a || C;
+    }
+}

test/compress/conditionals.js

@@ -82,14 +82,14 @@ ifs_3_should_warn: {
         "WARN: Boolean && always false [test/compress/conditionals.js:3,12]",
         "WARN: Condition left of && always false [test/compress/conditionals.js:3,12]",
         "WARN: Condition always false [test/compress/conditionals.js:3,12]",
+        "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:3,12]",
         "WARN: Dropping unreachable code [test/compress/conditionals.js:3,34]",
         "WARN: + in boolean context always true [test/compress/conditionals.js:10,19]",
         "WARN: Boolean || always true [test/compress/conditionals.js:10,12]",
         "WARN: Condition left of || always true [test/compress/conditionals.js:10,12]",
         "WARN: Condition always true [test/compress/conditionals.js:10,12]",
-        "WARN: Dropping unreachable code [test/compress/conditionals.js:12,15]",
-        "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:3,12]",
         "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:10,12]",
+        "WARN: Dropping unreachable code [test/compress/conditionals.js:12,15]",
     ]
 }
 

test/compress/const.js

@@ -597,8 +597,7 @@ do_if_continue_1: {
     }
     expect: {
         do {
-            if (!console);
-            else {
+            if (console) {
                 console.log("PASS");
                 {
                     const a = 0;
@@ -628,8 +627,7 @@ do_if_continue_2: {
     }
     expect: {
         do {
-            if (!console);
-            else {
+            if (console) {
                 console.log("PASS");
                 {
                     const a = 0;
@@ -1518,6 +1516,7 @@ issue_4689: {
 
 issue_4691: {
     options = {
+        conditionals: true,
         if_return: true,
         toplevel: true,
     }
@@ -1856,3 +1855,20 @@ issue_5338: {
     }
     expect_stdout: true
 }
+
+issue_5476: {
+    mangle = {
+        keep_fargs: true,
+    }
+    input: {
+        console.log(function(n) {
+            const a = 42;
+        }());
+    }
+    expect: {
+        console.log(function(n) {
+            const o = 42;
+        }());
+    }
+    expect_stdout: "undefined"
+}

test/compress/dead-code.js

@@ -1669,3 +1669,41 @@ issue_5106_2: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5506: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        try {
+            (function(a) {
+                var b = 1;
+                (function f() {
+                    try {
+                        b-- && f();
+                    } catch (c) {}
+                    console.log(a);
+                    a = 42 in (a = "bar");
+                })();
+            })("foo");
+        } catch (e) {}
+    }
+    expect: {
+        try {
+            (function(a) {
+                var b = 1;
+                (function f() {
+                    try {
+                        b-- && f();
+                    } catch (c) {}
+                    console.log(a);
+                    a = 42 in (a = "bar");
+                })();
+            })("foo");
+        } catch (e) {}
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}

test/compress/default-values.js

@@ -2209,3 +2209,256 @@ issue_5340_3: {
     expect_stdout: "undefined"
     node_version: ">=6"
 }
+
+issue_5407: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function(a) {
+            for (var i = 0; i < 2; i++)
+                (function(b = 4) {
+                    console.log(b);
+                    a = 2;
+                })(a);
+        })();
+    }
+    expect: {
+        (function(a) {
+            for (var i = 0; i < 2; i++)
+                (function(b = 4) {
+                    console.log(b);
+                    a = 2;
+                })(a);
+        })();
+    }
+    expect_stdout: [
+        "4",
+        "2",
+    ]
+    node_version: ">=6"
+}
+
+issue_5444_1: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 42;
+        var b = function({} = setImmediate(function() {
+            console.log(a++);
+        })) {
+            return this;
+        }();
+        console.log(typeof b);
+    }
+    expect: {
+        var a = 42;
+        var b = function({} = setImmediate(function() {
+            console.log(a++);
+        })) {
+            return this;
+        }();
+        console.log(typeof b);
+    }
+    expect_stdout: [
+        "object",
+        "42",
+    ]
+    node_version: ">=6"
+}
+
+issue_5444_2: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a, b = a++) {
+            return b;
+        }
+        console.log(f("FAIL") || "PASS");
+    }
+    expect: {
+        function f(a, b = a++) {
+            return b;
+        }
+        console.log(f("FAIL") || "PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5444_3: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a, b = function(c = a *= this) {
+            return c;
+        }()) {
+            return b;
+        }
+        console.log(f("FAIL") || "PASS");
+    }
+    expect: {
+        function f(a, b = function(c = a *= this) {
+            return c;
+        }()) {
+            return b;
+        }
+        console.log(f("FAIL") || "PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5448_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a = typeof console.log) {
+            do {
+                var b = [ ...a ];
+            } while (console.log("PASS"));
+        })();
+    }
+    expect: {
+        (function(a = console.log) {
+            do {} while (console.log("PASS"));
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5448_2: {
+    options = {
+        keep_fargs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a = typeof console) {
+            do {
+                var b = [ ...a ];
+            } while (console.log("PASS"));
+        })();
+    }
+    expect: {
+        (function(a = 0) {
+            do {} while (console.log("PASS"));
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5448_3: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var [ a = typeof console ] = [ void console.log("PASS") ];
+        var b = [ ...a ];
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5448_4: {
+    options = {
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var { p: a = typeof console } = { p: void console.log("PASS") };
+        var b = [ ...a ];
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5463: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        if (console.log("PASS"))
+            var a = void 0,
+                b = void 0,
+                b = ([ a = FAIL ] = b && b);
+    }
+    expect: {
+        var a, b, b;
+        console.log("PASS") && (
+            b = a = void 0,
+            b = [a = FAIL] = a && a
+        );
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5465: {
+    options = {
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a, b) {
+            (function(c = b = "FAIL 2") {
+                this && console.log(b || "PASS");
+            })(42 - a && a);
+        }
+        f("FAIL 1");
+    }
+    expect: {
+        a = "FAIL 1",
+        void function(c = b = "FAIL 2") {
+            this && console.log(b || "PASS");
+        }(42 - a && a);
+        var a, b;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5485: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        (function f(f, a = console.log(void 0 === f ? "PASS" : "FAIL")) {})();
+    }
+    expect: {
+        (function f(f, a = console.log(void 0 === f ? "PASS" : "FAIL")) {})();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}

test/compress/destructured.js

@@ -692,7 +692,7 @@ funarg_inline: {
     node_version: ">=6"
 }
 
-process_boolean_returns: {
+process_returns: {
     options = {
         booleans: true,
     }
@@ -706,9 +706,7 @@ process_boolean_returns: {
     expect: {
         console.log(function({ length }) {
             return length ? "FAIL" : "PASS";
-        }(function() {
-            return 42;
-        }));
+        }(function() {}));
     }
     expect_stdout: "PASS"
     node_version: ">=6"
@@ -1850,8 +1848,8 @@ issue_4294: {
             }) {}({
                 [a]: 0,
             });
-            var a = A;
-            console.log(a);
+            var b = A;
+            console.log(b);
         })();
     }
     expect_stdout: "PASS"
@@ -3022,6 +3020,7 @@ issue_5074_method_pure_getters: {
 issue_5085_1: {
     options = {
         evaluate: true,
+        passes: 2,
         reduce_vars: true,
         toplevel: true,
         unsafe: true,
@@ -3034,8 +3033,7 @@ issue_5085_1: {
     }
     expect: {
         var a = "PASS";
-        var b = [ 42 ][0];
-        b;
+        42;
         console.log(a);
     }
     expect_stdout: "PASS"
@@ -3045,6 +3043,7 @@ issue_5085_1: {
 issue_5085_2: {
     options = {
         evaluate: true,
+        passes: 2,
         reduce_vars: true,
         side_effects: true,
         unsafe: true,
@@ -3061,7 +3060,7 @@ issue_5085_2: {
     expect: {
         var a = "PASS";
         (function(b) {
-            b = [ 42 ][0];
+            0;
         })();
         console.log(a);
     }
@@ -3402,7 +3401,7 @@ issue_5222: {
     node_version: ">=6"
 }
 
-issue_5288: {
+issue_5288_1: {
     options = {
         conditionals: true,
         inline: true,
@@ -3422,7 +3421,37 @@ issue_5288: {
         }() ]));
     }
     expect: {
-        while (console ? console.log("PASS") : 0, void 0);
+        while (function() {
+            if (console)
+                console.log("PASS");
+        }(), void 0);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5288_2: {
+    options = {
+        conditionals: true,
+        inline: true,
+        keep_fargs: false,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        while (function([]) {}([ function f() {
+            if (console)
+                return console.log("PASS");
+            else {
+                let a = 0;
+            }
+        }() ]));
+    }
+    expect: {
+        while (console && console.log("PASS"), void 0);
     }
     expect_stdout: "PASS"
     node_version: ">=6"
@@ -3475,3 +3504,145 @@ issue_5314_2: {
     expect_stdout: "PASS"
     node_version: ">=6"
 }
+
+issue_5370: {
+    options = {
+        dead_code: true,
+        ie: true,
+        unused: true,
+    }
+    input: {
+        console.log(function arguments({}) {
+            return arguments;
+            try {} catch (e) {
+                var arguments;
+            }
+        }(42));
+    }
+    expect: {
+        console.log(function arguments({}) {
+            return arguments;
+            var arguments;
+        }(42));
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_5405_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var [ a ] = [ {} ];
+        console.log(a === a ? "PASS" : "FAIL");
+    }
+    expect: {
+        var [ a ] = [ {} ];
+        console.log(true ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5405_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+    }
+    input: {
+        var { p: a } = { p: [] };
+        console.log(a === a ? "PASS" : "FAIL");
+    }
+    expect: {
+        var { p: a } = { p: [] };
+        console.log(true ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5423: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b;
+        function f({
+            [function() {
+                if (++a)
+                    return 42;
+            }()]: c
+        }) {}
+        f(b = f);
+        console.log(typeof b);
+    }
+    expect: {
+        var a, b;
+        function f({
+            [function() {
+                if (++a)
+                    return 42;
+            }()]: c
+        }) {}
+        f(b = f);
+        console.log(typeof b);
+    }
+    expect_stdout: "function"
+    node_version: ">=6"
+}
+
+issue_5454: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var a = 42, a = {
+                p: [ a ] = [],
+            };
+            return "PASS";
+        }
+        console.log(f());
+    }
+    expect: {
+        console.log(function(a) {
+            a = 42, a = {
+                p: [ a ] = [],
+            };
+            return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5485: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        (function f({
+            p: f,
+            [console.log(void 0 === f ? "PASS" : "FAIL")]: a,
+        }) {})(42);
+    }
+    expect: {
+        (function f({
+            p: f,
+            [console.log(void 0 === f ? "PASS" : "FAIL")]: a,
+        }) {})(42);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}

test/compress/directives.js

@@ -129,3 +129,32 @@ valid_after_invalid_2: {
     }
     expect_stdout: "undefined"
 }
+
+issue_5368_1: {
+    options = {
+        directives: true,
+        expression: true,
+    }
+    input: {
+        "foo";
+    }
+    expect: {
+        "foo";
+    }
+}
+
+issue_5368_2: {
+    options = {
+        directives: true,
+        expression: true,
+    }
+    input: {
+        "foo";
+        (function() {
+            "bar";
+        })();
+    }
+    expect: {
+        (function() {})();
+    }
+}

test/compress/drop-unused.js

@@ -671,6 +671,76 @@ iife: {
     }
 }
 
+drop_instanceof: {
+    options = {
+        booleans: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {}
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        console.log(!1, (Math, !1));
+    }
+    expect_stdout: "false false"
+}
+
+keep_instanceof_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {}
+        var f;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        function f() {}
+        var f;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect_stdout: "false false"
+}
+
+keep_instanceof_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {}
+        var f = Object;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        function f() {}
+        var f = Object;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect_stdout: "true true"
+}
+
+keep_instanceof_3: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        f = Object;
+        function f() {}
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        f = Object;
+        function f() {}
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect_stdout: "true true"
+}
+
 issue_1539: {
     options = {
         collapse_vars: true,
@@ -3358,6 +3428,7 @@ issue_4806_1: {
 issue_4806_2: {
     options = {
         sequences: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }

test/compress/evaluate.js

@@ -745,7 +745,7 @@ call_args: {
     expect: {
         var a = 1;
         console.log(1);
-        +(1, 1);
+        1, 1;
     }
     expect_stdout: true
 }
@@ -769,7 +769,7 @@ call_args_drop_param: {
     }
     expect: {
         console.log(1);
-        +(b, 1);
+        b, 1;
     }
     expect_stdout: true
 }
@@ -888,6 +888,39 @@ unsafe_charAt_noop: {
     expect_stdout: "f  n"
 }
 
+chained_side_effects: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log("foo") || (console.log("bar"), "baz") || console.log("moo");
+    }
+    expect: {
+        console.log("foo") || (console.log("bar"), "baz");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    expect_warnings: [
+        "WARN: Condition left of || always true [test/compress/evaluate.js:1,8]",
+    ]
+}
+
+instanceof_lambda: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(42 instanceof function() {});
+    }
+    expect: {
+        console.log(false);
+    }
+    expect_stdout: "false"
+}
+
 issue_1649: {
     options = {
         evaluate: true,
@@ -3241,3 +3274,119 @@ issue_4886_2: {
     }
     expect_stdout: "true"
 }
+
+issue_5354: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        function f(a) {
+            return +a.toExponential(1);
+        }
+        function g(b) {
+            return 0 + b.toFixed(2);
+        }
+        function h(c) {
+            return 1 * c.toPrecision(3);
+        }
+        console.log(typeof f(45), typeof g(67), typeof h(89));
+    }
+    expect: {
+        function f(a) {
+            return +a.toExponential(1);
+        }
+        function g(b) {
+            return 0 + b.toFixed(2);
+        }
+        function h(c) {
+            return +c.toPrecision(3);
+        }
+        console.log(typeof f(45), typeof g(67), typeof h(89));
+    }
+    expect_stdout: "number string number"
+}
+
+issue_5356: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            return a++;
+            var a = a;
+        }());
+    }
+    expect: {
+        console.log(+a);
+        var a;
+    }
+    expect_stdout: "NaN"
+}
+
+issue_5362_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = -console;
+        console.log(delete +a);
+    }
+    expect: {
+        var a = -console;
+        console.log((+a, true));
+    }
+    expect_stdout: "true"
+}
+
+issue_5362_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var a = -console;
+        console.log(delete +a);
+    }
+    expect: {
+        console.log(true);
+    }
+    expect_stdout: "true"
+}
+
+issue_5380: {
+    options = {
+        evaluate: true,
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f(b) {
+            return function g() {
+                for (b in { PASS: 42 });
+            }(), b;
+        }("FAIL");
+        console.log(a);
+    }
+    expect: {
+        var a = function f(b) {
+            return function g() {
+                for (b in { PASS: 42 });
+            }(), b;
+        }("FAIL");
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}

test/compress/exports.js

@@ -417,6 +417,46 @@ hoist_funs: {
     expect_exact: "export function f(){}export default async function*g(){}"
 }
 
+instanceof_default_class: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class A {
+            f(a) {
+                return a instanceof A;
+            }
+        }
+    }
+    expect: {
+        export default class A {
+            f(a) {
+                return a instanceof A;
+            }
+        }
+    }
+}
+
+instanceof_default_function: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f() {
+            if (!(this instanceof f))
+                throw new Error("must instantiate");
+        }
+    }
+    expect: {
+        export default function f() {
+            if (!(this instanceof f))
+                throw new Error("must instantiate");
+        }
+    }
+}
+
 issue_4742_join_vars_1: {
     options = {
         join_vars: true,
@@ -496,3 +536,16 @@ issue_4766: {
         export var a = "bar";
     }
 }
+
+issue_5444: {
+    options = {
+        unused: true,
+    }
+    input: {
+        export var a = (console, console);
+    }
+    expect: {
+        console;
+        export var a = console;
+    }
+}

test/compress/functions.js

@@ -1508,6 +1508,48 @@ unsafe_call_3: {
     expect_stdout: "3"
 }
 
+inline_eval_inner: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (function() {
+            console.log(typeof eval("arguments"));
+        })();
+    }
+    expect: {
+        (function() {
+            console.log(typeof eval("arguments"));
+        })();
+    }
+    expect_stdout: "object"
+}
+
+inline_eval_outer: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        A = 42;
+        (function(a) {
+            console.log(a);
+        })(A);
+        console.log(eval("typeof a"));
+    }
+    expect: {
+        A = 42;
+        (function(a) {
+            console.log(a);
+        })(A);
+        console.log(eval("typeof a"));
+    }
+    expect_stdout: [
+        "42",
+        "undefined",
+    ]
+}
+
 issue_2616: {
     options = {
         evaluate: true,
@@ -3515,6 +3557,27 @@ functions_inner_var: {
     expect_stdout: "undefined undefined"
 }
 
+functions_keep_fnames: {
+    options = {
+        functions: true,
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var FAIL = function PASS() {};
+        FAIL.p = 42;
+        console.log(FAIL.name, FAIL.p);
+    }
+    expect: {
+        var FAIL = function PASS() {};
+        FAIL.p = 42;
+        console.log(FAIL.name, FAIL.p);
+    }
+    expect_stdout: "PASS 42"
+}
+
 issue_2437: {
     options = {
         collapse_vars: true,
@@ -6135,6 +6198,7 @@ issue_4265: {
         dead_code: true,
         inline: true,
         sequences: true,
+        side_effects: true,
     }
     input: {
         function f() {
@@ -6340,7 +6404,7 @@ issue_4612_4: {
     expect: {
         console.log(function() {
             function f() {
-                return h();
+                h();
             }
             function g() {
                 return h();
@@ -7980,6 +8044,7 @@ issue_5264_2: {
 
 issue_5283: {
     options = {
+        conditionals: true,
         if_return: true,
         inline: true,
         pure_getters: "strict",
@@ -8004,11 +8069,10 @@ issue_5283: {
         var a = "FAIL 1";
         (function() {
             a = "PASS";
-            if (!console)
-                (function(a) {
-                    console.log("FAIL 2");
-                    a.p;
-                })();
+            console || function(a) {
+                console.log("FAIL 2");
+                a.p;
+            }();
         })();
         console.log(a);
     }
@@ -8206,3 +8270,379 @@ issue_5332_2: {
     }
     expect_stdout: "NaN"
 }
+
+issue_5366: {
+    options = {
+        inline: true,
+    }
+    input: {
+        for (console.log("foo") || function() {
+            while (console.log("bar"));
+        }(); console.log("baz") ;);
+    }
+    expect: {
+        if (!console.log("foo"))
+            while (console.log("bar"));
+        for (;console.log("baz"););
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
+}
+
+issue_5376_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var a;
+        for (;42;)
+            var b = function() {
+                var c;
+                throw new Error(c++);
+            }();
+    }
+    expect: {
+        "use strict";
+        for (;;) {
+            42;
+            throw new Error(NaN);
+        }
+    }
+    expect_stdout: Error("NaN")
+}
+
+issue_5376_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        loops: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var a;
+        for (;42;)
+            var b = function() {
+                var c;
+                c++;
+                throw new Error("PASS");
+            }();
+    }
+    expect: {
+        "use strict";
+        for (;;) {
+            0;
+            throw new Error("PASS");
+        }
+    }
+    expect_stdout: Error("PASS")
+}
+
+issue_5401: {
+    options = {
+        inline: true,
+    }
+    input: {
+        L: for (var a in function() {
+            while (console.log("PASS"));
+        }(), a) do {
+            continue L;
+        } while (console.log("FAIL"));
+    }
+    expect: {
+        while (console.log("PASS"));
+        L: for (var a in a) do {
+            continue L;
+        } while (console.log("FAIL"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5409: {
+    options = {
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            (a = console) || FAIL(a);
+            (function(b) {
+                console.log(b && b);
+                while (!console);
+            })();
+        })();
+    }
+    expect: {
+        (function(a) {
+            (a = console) || FAIL(a);
+            a = void 0;
+            console.log(a && a);
+            while (!console);
+            return;
+        })();
+    }
+    expect_stdout: "undefined"
+}
+
+mixed_mode_inline_1: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return this;
+        }
+        console.log(function() {
+            return f();
+        }() ? "PASS" : "FAIL");
+    }
+    expect: {
+        console.log(function() {
+            return this;
+        }() ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_1_strict: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            return this;
+        }
+        console.log(function() {
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            return this;
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_2: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            "use strict";
+            return this;
+        }
+        console.log(function() {
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        console.log(function() {
+            "use strict";
+            return this;
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_2_strict: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            "use strict";
+            return this;
+        }
+        console.log(function() {
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            return this;
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_3: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            return this;
+        }
+        console.log(function() {
+            "use strict";
+            return f();
+        }() ? "PASS" : "FAIL");
+    }
+    expect: {
+        function f() {
+            return this;
+        }
+        console.log(function() {
+            "use strict";
+            return f();
+        }() ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_3_strict: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            return this;
+        }
+        console.log(function() {
+            "use strict";
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            return this;
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_4: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            "use strict";
+            return this;
+        }
+        console.log(function() {
+            "use strict";
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        console.log(function() {
+            "use strict";
+            return function() {
+                "use strict";
+                return this;
+            }();
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+mixed_mode_inline_4_strict: {
+    options = {
+        directives: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            "use strict";
+            return this;
+        }
+        console.log(function() {
+            "use strict";
+            return f();
+        }() ? "FAIL" : "PASS");
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            return this;
+        }() ? "FAIL" : "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+module_inline: {
+    options = {
+        inline: true,
+        module: true,
+        reduce_vars: true,
+    }
+    input: {
+        var a = f;
+        function f() {
+            return a;
+        }
+        console.log(f() === a);
+    }
+    expect: {
+        var a = f;
+        function f() {
+            return a;
+        }
+        console.log(a === a);
+    }
+    expect_stdout: "true"
+}

test/compress/hoist_props.js

@@ -1176,3 +1176,51 @@ issue_5182: {
         "42",
     ]
 }
+
+issue_5441: {
+    options = {
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(a) {
+            (function() {
+                a = { p: this };
+            })();
+            return typeof a;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            (function() {
+                a_p = this;
+            })();
+            var a_p;
+            return typeof {};
+        }());
+    }
+    expect_stdout: "object"
+}
+
+issue_5498: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            __proto__: 42,
+        };
+        while (console.log(typeof o.__proto__));
+    }
+    expect: {
+        var o = {
+            __proto__: 42,
+        };
+        while (console.log(typeof o.__proto__));
+    }
+    expect_stdout: "object"
+}

test/compress/hoist_vars.js

@@ -224,8 +224,7 @@ issue_4489: {
         console.log(k);
     }
     expect: {
-        !(A = 0);
-        for (var k in true);
+        for (var k in !(A = 0));
         console.log(k);
     }
     expect_stdout: "undefined"
@@ -407,9 +406,9 @@ issue_4893_2: {
     expect: {
         try{
             (function() {
-                var b;
-                b = null;
-                b.p += 42;
+                var a;
+                a = null;
+                a.p += 42;
             })();
         } catch (e) {
             console.log("PASS");
@@ -499,3 +498,108 @@ issue_5195: {
     }
     expect_stdout: "[object Object]"
 }
+
+issue_5378: {
+    options = {
+        hoist_vars: true,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 2;
+        while (a--)
+            (function() {
+                var b;
+                var c;
+                while (console.log(b));
+                --b;
+            })();
+    }
+    expect: {
+        var a = 2;
+        while (a--) {
+            b = void 0;
+            var b, c;
+            while (console.log(b));
+            --b;
+        }
+    }
+    expect_stdout: [
+        "undefined",
+        "undefined",
+    ]
+}
+
+issue_5411_1: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        b++;
+        b = a;
+        var b = b, c = c && c[b];
+        console.log(b);
+    }
+    expect: {
+        var b, c, a = "PASS";
+        b++;
+        b = a;
+        c = c && c[b];
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5411_2: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        b++;
+        b = a;
+        var b = b, c = c && c[b];
+        console.log(b);
+    }
+    expect: {
+        var b, c;
+        b++;
+        b = "PASS",
+        c = c && c[b];
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5411_3: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = console;
+        a++;
+        var a = A = a;
+        console.log(A);
+    }
+    expect: {
+        var a = console;
+        a = A = ++a;
+        console.log(A);
+    }
+    expect_stdout: "NaN"
+}

test/compress/ie.js

@@ -2631,13 +2631,14 @@ issue_3999: {
     ]
 }
 
-issue_4001: {
+issue_4001_1: {
     options = {
         collapse_vars: true,
         ie: true,
         inline: true,
         reduce_vars: true,
         sequences: true,
+        side_effects: false,
         toplevel: true,
         unused: true,
     }
@@ -2660,7 +2661,42 @@ issue_4001: {
             return a;
         }
         var a;
-        console.log((a = 42, void f()[42], void function a() {}));
+        console.log((a = 42, f()[42], void f, void function a() {}));
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4001_2: {
+    options = {
+        collapse_vars: true,
+        ie: true,
+        inline: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            function f() {
+                return a;
+                var b;
+            }
+            var c = f();
+            (function g() {
+                c[42];
+                f;
+            })();
+            (function a() {});
+        }(42));
+    }
+    expect: {
+        function f() {
+            return a;
+        }
+        var a;
+        console.log((a = 42, void f()[42]));
     }
     expect_stdout: "undefined"
 }
@@ -3408,3 +3444,33 @@ issue_5269_3_ie: {
         "bar",
     ]
 }
+
+issue_5350: {
+    options = {
+        ie: false,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(typeof f, [ 42, function f() {} ][0]);
+    }
+    expect: {
+        console.log(typeof f, 42);
+    }
+    expect_stdout: "undefined 42"
+}
+
+issue_5350_ie: {
+    options = {
+        ie: true,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(typeof f, [ 42, function f() {} ][0]);
+    }
+    expect: {
+        console.log(typeof f, (function f() {}, 42));
+    }
+    expect_stdout: "undefined 42"
+}

test/compress/if_return.js

@@ -698,7 +698,9 @@ iife_if_return_simple: {
 
 nested_if_break: {
     options = {
+        conditionals: true,
         if_return: true,
+        side_effects: true,
     }
     input: {
         for (var i = 0; i < 3; i++)
@@ -709,8 +711,7 @@ nested_if_break: {
     }
     expect: {
         for (var i = 0; i < 3; i++)
-            L1: if ("number" == typeof i)
-                if (0 !== i) console.log(i);
+            L1: "number" == typeof i && 0 !== i && console.log(i);
     }
     expect_stdout: [
         "1",
@@ -749,11 +750,11 @@ nested_if_continue: {
         function f(n) {
             for (var i = 0;
                 "number" == typeof n
-                    && (0 !== n
-                        ? 1 !== n
-                            ? i++
-                            : console.log("odd", i)
-                        : console.log("even", i)),
+                    && (0 === n
+                        ? console.log("even", i)
+                        : 1 === n
+                        ? console.log("odd", i)
+                        : i++),
                 0 <= (n -= 2););
         }
         f(37);

test/compress/issue-1052.js

@@ -4,22 +4,21 @@ multiple_functions: {
         if_return: true,
     }
     input: {
-        ( function() {
-            if ( !window ) {
+        (function() {
+            if (!window)
                 return;
-            }
             function f() {}
             function g() {}
-        } )();
+        })();
     }
     expect: {
-        ( function() {
+        (function() {
             // NOTE: other compression steps will reduce this
             // down to just `window`.
-            if ( !window );
+            if (!window);
             function f() {}
             function g() {}
-        } )();
+        })();
     }
 }
 
@@ -29,18 +28,17 @@ single_function: {
         if_return: true,
     }
     input: {
-        ( function() {
-            if ( !window ) {
+        (function() {
+            if (!window)
                 return;
-            }
             function f() {}
-        } )();
+        })();
     }
     expect: {
-        ( function() {
-            if ( !window );
+        (function() {
+            if (!window);
             function f() {}
-        } )();
+        })();
     }
 }
 
@@ -50,28 +48,26 @@ deeply_nested: {
         if_return: true,
     }
     input: {
-        ( function() {
-            if ( !window ) {
+        (function() {
+            if (!window)
                 return;
-            }
             function f() {}
             function g() {}
-            if ( !document ) {
+            if (!document)
                 return;
-            }
             function h() {}
-        } )();
+        })();
     }
     expect: {
-        ( function() {
+        (function() {
             // NOTE: other compression steps will reduce this
             // down to just `window`.
-            if ( window )
-                if ( !document );
+            if (!window);
+            else if (!document);
             function f() {}
             function g() {}
             function h() {}
-        } )();
+        })();
     }
 }
 
@@ -81,18 +77,18 @@ not_hoisted_when_already_nested: {
         if_return: true,
     }
     input: {
-        ( function() {
-            if ( !window ) {
+        (function() {
+            if (!window)
                 return;
-            }
-            if ( foo ) function f() {}
-        } )();
+            if (foo) function f() {}
+        })();
     }
     expect: {
-        ( function() {
-            if ( window )
-                if ( foo ) function f() {}
-        } )();
+        (function() {
+            if (!window);
+            else if (foo)
+                function f() {}
+        })();
     }
 }
 
@@ -104,15 +100,19 @@ defun_if_return: {
     input: {
         function e() {
             function f() {}
-            if (!window) return;
-            else function g() {}
+            if (!window)
+                return;
+            else
+                function g() {}
             function h() {}
         }
     }
     expect: {
         function e() {
             function f() {}
-            if (window) function g() {}
+            if (!window);
+            else
+                function g() {}
             function h() {}
         }
     }
@@ -126,8 +126,10 @@ defun_hoist_funs: {
     input: {
         function e() {
             function f() {}
-            if (!window) return;
-            else function g() {}
+            if (!window)
+                return;
+            else
+                function g() {}
             function h() {}
         }
     }
@@ -136,7 +138,7 @@ defun_hoist_funs: {
             function f() {}
             function g() {}
             function h() {}
-            if (window);
+            if (!window);
         }
     }
 }
@@ -149,15 +151,18 @@ defun_else_if_return: {
     input: {
         function e() {
             function f() {}
-            if (window) function g() {}
-            else return;
+            if (window)
+                function g() {}
+            else
+                return;
             function h() {}
         }
     }
     expect: {
         function e() {
             function f() {}
-            if (window) function g() {}
+            if (window)
+                function g() {}
             function h() {}
         }
     }

test/compress/issue-1447.js

@@ -40,6 +40,9 @@ conditional_false_stray_else_in_loop: {
             console.log(i);
         }
     }
-    expect_exact: "for(var i=1;i<=4;++i)if(!(i<=2))console.log(i);"
-    expect_stdout: true
+    expect_exact: "for(var i=1;i<=4;++i)if(i<=2);else console.log(i);"
+    expect_stdout: [
+        "3",
+        "4",
+    ]
 }

test/compress/issue-640.js

@@ -317,7 +317,35 @@ iife: {
         typeof function g() {}();
     }
     expect: {
-        x = 42, function a() {}(), function b() {}(), function c() {}(),
-        function d() {}(), function e() {}(), function f() {}(), typeof function g() {}();
+        x = 42,
+        function a() {}(),
+        !function b() {}(),
+        ~function c() {}(),
+        +function d() {}(),
+        -function e() {}(),
+        void function f() {}(),
+        typeof function g() {}();
+    }
+}
+
+iife_drop_side_effect_free: {
+    options = {
+        expression: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        x = 42;
+        (function a() {})();
+        !function b() {}();
+        ~function c() {}();
+        +function d() {}();
+        -function e() {}();
+        void function f() {}();
+        typeof function g() {}();
+    }
+    expect: {
+        x = 42,
+        typeof void 0;
     }
 }

test/compress/issue-979.js

@@ -1,4 +1,4 @@
-issue979_reported: {
+reported: {
     options = {
         booleans: true,
         comparisons: true,
@@ -17,29 +17,26 @@ issue979_reported: {
     }
     input: {
         function f1() {
-            if (a == 1 || b == 2) {
+            if (a == 1 || b == 2)
                 foo();
-            }
         }
         function f2() {
-            if (!(a == 1 || b == 2)) {
-            }
-            else {
+            if (!(a == 1 || b == 2));
+            else
                 foo();
-            }
         }
     }
     expect: {
         function f1() {
-            1!=a&&2!=b||foo();
+            1 != a && 2 != b || foo();
         }
         function f2() {
-            1!=a&&2!=b||foo();
+            1 != a && 2 != b || foo();
         }
     }
 }
 
-issue979_test_negated_is_best: {
+test_negated_is_best: {
     options = {
         booleans: true,
         comparisons: true,
@@ -58,53 +55,47 @@ issue979_test_negated_is_best: {
     }
     input: {
         function f3() {
-            if (a == 1 | b == 2) {
+            if (a == 1 | b == 2)
                 foo();
-            }
         }
         function f4() {
-            if (!(a == 1 | b == 2)) {
-            }
-            else {
+            if (!(a == 1 | b == 2));
+            else
                 foo();
-            }
         }
         function f5() {
-            if (a == 1 && b == 2) {
+            if (a == 1 && b == 2)
                 foo();
-            }
         }
         function f6() {
-            if (!(a == 1 && b == 2)) {
-            }
-            else {
+            if (!(a == 1 && b == 2));
+            else
                 foo();
-            }
         }
         function f7() {
-            if (a == 1 || b == 2) {
+            if (a == 1 || b == 2)
                 foo();
-            }
-            else {
+            else
                 return bar();
-            }
         }
     }
     expect: {
         function f3() {
-            1==a|2==b&&foo();
+            1 == a | 2 == b && foo();
         }
         function f4() {
-            1==a|2==b&&foo();
+            1 == a | 2 == b && foo();
         }
         function f5() {
-            1==a&&2==b&&foo();
+            1 == a && 2 == b && foo();
         }
         function f6() {
-            1!=a||2!=b||foo();
+            1 == a && 2 == b && foo();
         }
         function f7() {
-            if(1!=a&&2!=b)return bar();foo()
+            if (1 != a && 2 != b)
+                return bar();
+            foo();
         }
     }
 }

test/compress/join_vars.js

@@ -1144,7 +1144,7 @@ conditional_assignments_3: {
     expect_stdout: "PASS"
 }
 
-issue_3856: {
+issue_3856_1: {
     options = {
         booleans: true,
         conditionals: true,
@@ -1169,9 +1169,46 @@ issue_3856: {
         console.log(function() {
             (function() {
                 var a, b;
-                if (a) return a, 1;
-                for (a = 0; !console;);
-                return 0;
+                if (a) a;
+                else {
+                    a = 0;
+                    for (; !console;);
+                }
+            })();
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_3856_2: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        if_return: true,
+        join_vars: true,
+        passes: 2,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function() {
+            (function() {
+                var a;
+                if (!a) {
+                    a = 0;
+                    for (var b; !console;);
+                    return 0;
+                }
+                if (a) return 1;
+            })();
+        }());
+    }
+    expect: {
+        console.log(function() {
+            (function() {
+                var a, b;
+                if (!a)
+                    for (a = 0; !console;);
             })();
         }());
     }

test/compress/keep_fargs.js

@@ -1258,8 +1258,7 @@ issues_3267_1: {
     }
     expect: {
         !function() {
-            var i = Object();
-            if (i)
+            if (Object())
                 return console.log("PASS");
             throw "FAIL";
         }();

test/compress/let.js

@@ -912,8 +912,7 @@ do_if_continue_1: {
     expect: {
         "use strict";
         do {
-            if (!console);
-            else {
+            if (console) {
                 console.log("PASS");
                 {
                     let a = 0;
@@ -946,8 +945,7 @@ do_if_continue_2: {
     expect: {
         "use strict";
         do {
-            if (!console);
-            else {
+            if (console) {
                 console.log("FAIL");
                 {
                     let a = 0;
@@ -1606,48 +1604,6 @@ issue_4305_2: {
     node_version: ">=4"
 }
 
-issue_1753: {
-    mangle = {
-        toplevel: false,
-        webkit: true,
-    }
-    input: {
-        "use strict";
-        let l = null;
-        for (let i = 0; i < 1; i++)
-            console.log(i);
-    }
-    expect: {
-        "use strict";
-        let l = null;
-        for (let i = 0; i < 1; i++)
-            console.log(i);
-    }
-    expect_stdout: "0"
-    node_version: ">=4"
-}
-
-issue_1753_toplevel: {
-    mangle = {
-        toplevel: true,
-        webkit: true,
-    }
-    input: {
-        "use strict";
-        let l = null;
-        for (let i = 0; i < 1; i++)
-            console.log(i);
-    }
-    expect: {
-        "use strict";
-        let l = null;
-        for (let e = 0; e < 1; e++)
-            console.log(e);
-    }
-    expect_stdout: "0"
-    node_version: ">=4"
-}
-
 issue_4438: {
     options = {
         if_return: true,
@@ -1667,9 +1623,7 @@ issue_4438: {
     expect: {
         "use strict";
         function f() {
-            if (!console)
-                ;
-            else {
+            if (console) {
                 let a = console.log;
                 void a("PASS");
             }
@@ -1757,6 +1711,7 @@ issue_4689: {
 
 issue_4691: {
     options = {
+        conditionals: true,
         if_return: true,
         toplevel: true,
     }
@@ -2023,3 +1978,23 @@ issue_5338: {
     expect_stdout: ReferenceError("a is not defined")
     node_version: ">=4"
 }
+
+issue_5476: {
+    mangle = {
+        keep_fargs: true,
+    }
+    input: {
+        "use strict";
+        console.log(function(n) {
+            let a;
+        }());
+    }
+    expect: {
+        "use strict";
+        console.log(function(n) {
+            let o;
+        }());
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}

test/compress/merge_vars.js

@@ -169,6 +169,158 @@ conditional_branch: {
     expect_stdout: "PASS"
 }
 
+conditional_chain_1: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a, b) {
+            var c, d;
+            if (a && (c = a))
+                console.log(c);
+            else
+                b || (d = b) ? console.log("foo") : console.log(d);
+        }
+        f("", null);
+        f("", true);
+        f(42, null);
+        f(42, true);
+    }
+    expect: {
+        function f(a, b) {
+            var a, a;
+            if (a && (a = a))
+                console.log(a);
+            else
+                b || (a = b) ? console.log("foo") : console.log(a);
+        }
+        f("", null);
+        f("", true);
+        f(42, null);
+        f(42, true);
+    }
+    expect_stdout: [
+        "null",
+        "foo",
+        "42",
+        "42",
+    ]
+}
+
+conditional_chain_2: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a, b) {
+            var c, d;
+            if (a && (c = a))
+                console.log(c);
+            else
+                b || (d = b) ? console.log(c) : console.log(d);
+        }
+        f("", null);
+        f("", true);
+        f(42, null);
+        f(42, true);
+    }
+    expect: {
+        function f(a, b) {
+            var c, a;
+            if (a && (c = a))
+                console.log(c);
+            else
+                b || (a = b) ? console.log(c) : console.log(a);
+        }
+        f("", null);
+        f("", true);
+        f(42, null);
+        f(42, true);
+    }
+    expect_stdout: [
+        "null",
+        "undefined",
+        "42",
+        "42",
+    ]
+}
+
+conditional_chain_3: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a, b) {
+            var c, d;
+            if (a && (c = a) || b || (d = b))
+                console.log(c);
+            else
+                console.log(d);
+        }
+        f("", null);
+        f("", true);
+        f(42, null);
+        f(42, true);
+    }
+    expect: {
+        function f(a, b) {
+            var c, a;
+            if (a && (c = a) || b || (a = b))
+                console.log(c);
+            else
+                console.log(a);
+        }
+        f("", null);
+        f("", true);
+        f(42, null);
+        f(42, true);
+    }
+    expect_stdout: [
+        "null",
+        "undefined",
+        "42",
+        "42",
+    ]
+}
+
+conditional_chain_4: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a, b) {
+            var c, d;
+            if (a && b ? c = a : d = b)
+                console.log(c);
+            else
+                console.log(d);
+        }
+        f("", null);
+        f("", true);
+        f(42, null);
+        f(42, true);
+    }
+    expect: {
+        function f(a, b) {
+            var c, d;
+            if (a && b ? c = a : d = b)
+                console.log(c);
+            else
+                console.log(d);
+        }
+        f("", null);
+        f("", true);
+        f(42, null);
+        f(42, true);
+    }
+    expect_stdout: [
+        "null",
+        "undefined",
+        "null",
+        "42",
+    ]
+}
+
 if_branch: {
     options = {
         merge_vars: true,
@@ -253,6 +405,7 @@ read_before_assign_1: {
         inline: true,
         merge_vars: true,
         sequences: true,
+        side_effects: true,
         toplevel: true,
     }
     input: {
@@ -3549,3 +3702,146 @@ issue_5182: {
     ]
     node_version: ">=4"
 }
+
+issue_5420: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        do {
+            var a = "FAIL 1";
+            a && a.p;
+            a = "FAIL 2";
+            try {
+                continue;
+            } catch (e) {}
+            var b = "FAIL 3";
+        } while (console.log(b || "PASS"));
+    }
+    expect: {
+        do {
+            var a = "FAIL 1";
+            a && a.p;
+            a = "FAIL 2";
+            try {
+                continue;
+            } catch (e) {}
+            var b = "FAIL 3";
+        } while (console.log(b || "PASS"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5451: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        A = 1;
+        var a = 1, b;
+        console.log(function f() {
+            return a-- && f(b = A, b);
+        }());
+    }
+    expect: {
+        A = 1;
+        var a = 1, b;
+        console.log(function f() {
+            return a-- && f(b = A, b);
+        }());
+    }
+    expect_stdout: "0"
+}
+
+issue_5471_1: {
+    options = {
+        conditionals: true,
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL 1";
+        function f(b, c) {
+            function g() {
+                if (console)
+                    return 42;
+                else
+                    c = "FAIL 2";
+            }
+            var d = g();
+            console.log(c || "PASS");
+            var e = function h() {
+                while (b && e);
+            }();
+        }
+        f(a++) && a;
+    }
+    expect: {
+        var a = "FAIL 1";
+        var b, c, e;
+        b = +a,
+        function() {
+            if (console)
+                return;
+            c = "FAIL 2";
+        }(),
+        console.log(c || "PASS"),
+        e = function() {
+            while (b && e);
+        }();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5471_2: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        sequences: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL 1";
+        function f(b, c) {
+            function g() {
+                if (console)
+                    return 42;
+                else
+                    c = "FAIL 2";
+            }
+            var d = g();
+            console.log(c || "PASS");
+            var e = function h() {
+                while (b && e);
+            }();
+        }
+        f(a++) && a;
+    }
+    expect: {
+        var a = "FAIL 1";
+        var b, c, e;
+        b = +a,
+        function() {
+            if (console)
+                return;
+            c = "FAIL 2";
+        }(),
+        console.log(c || "PASS"),
+        e = function() {
+            while (b && e);
+        }(),
+        void 0;
+    }
+    expect_stdout: "PASS"
+}

test/compress/negate-iife.js

@@ -122,13 +122,41 @@ negate_iife_4: {
         sequences: true,
     }
     input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-        (function(){
+        (function() {
+            return t;
+        })() ? console.log(true) : console.log(false);
+        (function() {
             console.log("something");
         })();
     }
     expect: {
-        !function(){ return t }() ? console.log(false) : console.log(true), function(){
+        !function() {
+            return t;
+        }() ? console.log(false) : console.log(true), !function() {
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_4_drop_side_effect_free: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        (function() {
+            return t;
+        })() ? console.log(true) : console.log(false);
+        (function() {
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function() {
+            return t;
+        }() ? console.log(false) : console.log(true), function() {
             console.log("something");
         }();
     }
@@ -176,17 +204,49 @@ negate_iife_5: {
         sequences: true,
     }
     input: {
-        if ((function(){ return t })()) {
+        if (function() {
+            return t;
+        }()) {
             foo(true);
         } else {
             bar(false);
         }
-        (function(){
+        (function() {
             console.log("something");
         })();
     }
     expect: {
-        !function(){ return t }() ? bar(false) : foo(true), function(){
+        !function() {
+            return t;
+        }() ? bar(false) : foo(true), !function() {
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_5_drop_side_effect_free: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        if (function() {
+            return t;
+        }()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function() {
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function() {
+            return t;
+        }() ? bar(false) : foo(true), function() {
             console.log("something");
         }();
     }

test/compress/numbers.js

@@ -842,9 +842,9 @@ unary_binary_parentheses: {
         v.forEach(function(x) {
             v.forEach(function(y) {
                 console.log(
-                    +x*y,
-                    +x/y,
-                    +x%y,
+                    x*y,
+                    x/y,
+                    x%y,
                     -x*y,
                     -x/y,
                     -x%y
@@ -1397,7 +1397,7 @@ issue_3695: {
     }
     expect: {
         var a = [];
-        console.log(+(a * (a[0] = false)));
+        console.log(a * (a[0] = false));
     }
     expect_stdout: "NaN"
 }

test/compress/pure_funcs.js

@@ -147,7 +147,7 @@ relational: {
         "bar" >= "bar";
     }
     expect: {
-        bar();
+        0 instanceof bar();
         bar();
         bar(), bar();
         bar();

test/compress/pure_getters.js

@@ -1289,6 +1289,7 @@ issue_2878: {
         collapse_vars: true,
         pure_getters: true,
         sequences: true,
+        side_effects: true,
     }
     input: {
         var c = 0;

test/compress/reduce_vars.js

@@ -6,6 +6,7 @@ reduce_vars: {
             C: 0,
         },
         inline: true,
+        passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
@@ -6688,8 +6689,7 @@ issues_3267_1: {
     }
     expect: {
         !function(x) {
-            var i = Object();
-            if (i)
+            if (Object())
                 return console.log("PASS");
             throw "FAIL";
         }();
@@ -7861,3 +7861,38 @@ issue_5324: {
     }
     expect_stdout: "NaN"
 }
+
+issue_5434: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            for (var i = 0; i < 2; i++) {
+                var b = "FAIL";
+                f && f();
+                a = b;
+                var f = function() {
+                    b = "PASS";
+                };
+            }
+            return a;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            for (var i = 0; i < 2; i++) {
+                var b = "FAIL";
+                f && f();
+                a = b;
+                var f = function() {
+                    b = "PASS";
+                };
+            }
+            return a;
+        }());
+    }
+    expect_stdout: "PASS"
+}

test/compress/regexp.js

@@ -50,6 +50,22 @@ regexp_properties: {
     expect_stdout: "abc true false 0 false"
 }
 
+instanceof_1: {
+    input: {
+        console.log(/foo/ instanceof RegExp);
+    }
+    expect_exact: "console.log(/foo/ instanceof RegExp);"
+    expect_stdout: "true"
+}
+
+instanceof_2: {
+    input: {
+        console.log(42 + /foo/ instanceof Object);
+    }
+    expect_exact: "console.log(42+/foo/ instanceof Object);"
+    expect_stdout: "false"
+}
+
 issue_3434_1: {
     options = {
         evaluate: true,

test/compress/rests.js

@@ -1049,7 +1049,9 @@ issue_5100_1: {
             p: {},
             ...a
         } = [ {
-            p: [ a = 42["q"] ],
+            p: {
+                q: a,
+            } = 42,
             r: "PASS",
         } ][0]);
         console.log(a.r);
@@ -1082,7 +1084,9 @@ issue_5100_2: {
             p: {},
             ...a
         } = [ {
-            p: [ console.log("PASS"), a = 42["q"] ],
+            p: (console.log("PASS"), {
+                q: a,
+            } = 42),
         } ][0]);
     }
     expect_stdout: "PASS"
@@ -1267,3 +1271,95 @@ issue_5246_3: {
     expect_stdout: "PASS"
     node_version: ">=6"
 }
+
+issue_5360: {
+    options = {
+        keep_fargs: false,
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        var a;
+        console.log(function({ p: {}, ...b }) {
+            return b.q;
+        }({
+            p: ~a && ([ a ] = []),
+            q: "PASS",
+        }));
+    }
+    expect: {
+        var a;
+        console.log(function({ p: {}, ...b }) {
+            return b.q;
+        }({
+            p: ~a && ([ a ] = []),
+            q: "PASS",
+        }));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8.3.0"
+}
+
+issue_5370: {
+    options = {
+        dead_code: true,
+        ie: true,
+        unused: true,
+    }
+    input: {
+        console.log(function arguments(...a) {
+            return arguments;
+            try {} catch (e) {
+                var arguments;
+            }
+        }());
+    }
+    expect: {
+        console.log(function arguments(...a) {
+            return arguments;
+            var arguments;
+        }());
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_5391: {
+    options = {
+        evaluate: true,
+        keep_fargs: false,
+        objects: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, b = function f({
+            p: {},
+            ...c
+        }) {
+            while (c.q);
+        }({
+            p: {
+                r: a++,
+                r: 0,
+            }
+        });
+        console.log(a);
+    }
+    expect: {
+        (function({
+            p: {},
+            ...c
+        }) {
+            while (c.q);
+        })({
+            p: 0,
+        });
+        console.log(NaN);
+    }
+    expect_stdout: "NaN"
+    node_version: ">=8.3.0"
+}

test/compress/sequences.js

@@ -289,8 +289,34 @@ iife: {
         typeof function g() {}();
     }
     expect: {
-        x = 42, function a() {}(), function b() {}(), function c() {}(),
-        function d() {}(), function e() {}(), function f() {}(), function g() {}();
+        x = 42,
+        function a() {}(),
+        !function b() {}(),
+        ~function c() {}(),
+        +function d() {}(),
+        -function e() {}(),
+        void function f() {}(),
+        typeof function g() {}();
+    }
+}
+
+iife_drop_side_effect_free: {
+    options = {
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        x = 42;
+        (function a() {})();
+        !function b() {}();
+        ~function c() {}();
+        +function d() {}();
+        -function e() {}();
+        void function f() {}();
+        typeof function g() {}();
+    }
+    expect: {
+        x = 42;
     }
 }
 
@@ -1045,11 +1071,102 @@ call: {
         b.c = function() {
             console.log(this === b ? "bar" : "baz");
         },
+        a,
         b(),
+        a,
         b.c(),
         (a, b.c)(),
+        a,
         b["c"](),
         (a, b["c"])(),
+        a,
+        function() {
+            console.log(this === a);
+        }(),
+        a,
+        new b(),
+        a,
+        new b.c(),
+        a,
+        new b.c(),
+        a,
+        new b["c"](),
+        a,
+        new b["c"](),
+        a,
+        new function() {
+            console.log(this === a);
+        }(),
+        console.log((a, typeof b.c)),
+        console.log((a, typeof b["c"]));
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+        "bar",
+        "baz",
+        "true",
+        "foo",
+        "baz",
+        "baz",
+        "baz",
+        "baz",
+        "false",
+        "function",
+        "function",
+    ]
+}
+
+call_drop_side_effect_free: {
+    options = {
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = function() {
+            return this;
+        }();
+        function b() {
+            console.log("foo");
+        }
+        b.c = function() {
+            console.log(this === b ? "bar" : "baz");
+        };
+        (a, b)();
+        (a, b).c();
+        (a, b.c)();
+        (a, b)["c"]();
+        (a, b["c"])();
+        (a, function() {
+            console.log(this === a);
+        })();
+        new (a, b)();
+        new (a, b).c();
+        new (a, b.c)();
+        new (a, b)["c"]();
+        new (a, b["c"])();
+        new (a, function() {
+            console.log(this === a);
+        })();
+        console.log(typeof (a, b).c);
+        console.log(typeof (a, b)["c"]);
+    }
+    expect: {
+        var a = function() {
+            return this;
+        }();
+        function b() {
+            console.log("foo");
+        }
+        b.c = function() {
+            console.log(this === b ? "bar" : "baz");
+        },
+        b(),
+        b.c(),
+        (0, b.c)(),
+        b["c"](),
+        (0, b["c"])(),
         function() {
             console.log(this === a);
         }(),
@@ -1061,8 +1178,8 @@ call: {
         new function() {
             console.log(this === a);
         }(),
-        console.log((a, typeof b.c)),
-        console.log((a, typeof b["c"]));
+        console.log(typeof b.c),
+        console.log(typeof b["c"]);
     }
     expect_stdout: [
         "foo",
@@ -1097,6 +1214,26 @@ missing_link: {
     expect: {
         var a = 100;
         a,
+        a++ + (0, 1),
+        console.log(a);
+    }
+}
+
+missing_link_drop_side_effect_free: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 100;
+        a;
+        a++ + (0 ? 2 : 1);
+        console.log(a);
+    }
+    expect: {
+        var a = 100;
         a++,
         console.log(a);
     }
@@ -1192,7 +1329,7 @@ issue_3490_2: {
     expect: {
         var b = 42, c = "FAIL";
         var a;
-        for (c = "PASS", b; "" == typeof d;);
+        for (c = "PASS"; "" == typeof d;);
         console.log(c, b);
     }
     expect_stdout: "PASS 42"

test/compress/side_effects.js

@@ -617,7 +617,7 @@ issue_4730_2: {
     }
     expect: {
         var a;
-        !console.log("PASS") || a && a[a.p];
+        console.log("PASS") && a && a[a.p];
     }
     expect_stdout: "PASS"
 }
@@ -645,3 +645,56 @@ issue_4751: {
     }
     expect_stdout: "PASS"
 }
+
+drop_instanceof: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        42 instanceof function() {};
+        console.log("PASS");
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+drop_instanceof_reference: {
+    options = {
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        function f() {}
+        42 instanceof f;
+        console.log("PASS");
+    }
+    expect: {
+        function f() {}
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+retain_instanceof: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        try {
+            42 instanceof "foo";
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            0 instanceof "foo";
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/spreads.js

@@ -1166,3 +1166,31 @@ issue_5006: {
     expect_stdout: "PASS"
     node_version: ">=6"
 }
+
+issue_5382: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            f() {
+                ({ ...this });
+            },
+            get p() {
+                console.log("PASS");
+            },
+        }).f();
+    }
+    expect: {
+        ({
+            f() {
+                ({ ...this });
+            },
+            get p() {
+                console.log("PASS");
+            },
+        }).f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8.3.0"
+}

test/compress/typeof.js

@@ -307,7 +307,7 @@ typeof_defined_1: {
     }
     expect: {
         "undefined" == typeof A && A;
-        "undefined" != typeof A || A;
+        "undefined" == typeof A && A;
     }
 }
 
@@ -324,7 +324,7 @@ typeof_defined_2: {
     }
     expect: {
         "function" != typeof A && A;
-        "function" == typeof A || A;
+        "function" != typeof A && A;
     }
 }
 
@@ -355,16 +355,19 @@ typeof_defined_3: {
         "undefined" == typeof A && "undefined" == typeof B && (A, B);
         "undefined" == typeof A && "undefined" != typeof B && A;
         "undefined" != typeof A && "undefined" == typeof B && B;
+        // dropped
         "undefined" == typeof A && "undefined" == typeof B || (A, B);
         "undefined" == typeof A && "undefined" != typeof B || (A, B);
         "undefined" != typeof A && "undefined" == typeof B || (A, B);
         "undefined" != typeof A && "undefined" != typeof B || (A, B);
-        "undefined" == typeof A || "undefined" == typeof B && B;
-        "undefined" != typeof A || "undefined" == typeof B && (A, B);
-        "undefined" != typeof A || "undefined" != typeof B && A;
-        "undefined" == typeof A || "undefined" != typeof B || B;
-        "undefined" != typeof A || "undefined" == typeof B || A;
-        "undefined" != typeof A || "undefined" != typeof B || (A, B);
+        "undefined" != typeof A && "undefined" == typeof B && B;
+        // dropped
+        "undefined" == typeof A && "undefined" == typeof B && (A, B);
+        "undefined" == typeof A && "undefined" != typeof B && A;
+        // dropped
+        "undefined" != typeof A && "undefined" == typeof B && B;
+        "undefined" == typeof A && "undefined" != typeof B && A;
+        "undefined" == typeof A && "undefined" == typeof B && (A, B);
     }
 }
 
@@ -392,6 +395,7 @@ typeof_defined_4: {
         "object" != typeof A || "object" != typeof B || (A, B);
     }
     expect: {
+        // dropped
         "object" == typeof A && "object" != typeof B && B;
         "object" != typeof A && "object" == typeof B && A;
         "object" != typeof A && "object" != typeof B && (A, B);
@@ -399,12 +403,14 @@ typeof_defined_4: {
         "object" == typeof A && "object" != typeof B || (A, B);
         "object" != typeof A && "object" == typeof B || (A, B);
         "object" != typeof A && "object" != typeof B || (A, B);
-        "object" == typeof A || "object" == typeof B && A;
-        "object" == typeof A || "object" != typeof B && (A, B);
-        "object" != typeof A || "object" != typeof B && B;
-        "object" == typeof A || "object" == typeof B || (A, B);
-        "object" == typeof A || "object" != typeof B || A;
-        "object" != typeof A || "object" == typeof B || B;
+        "object" != typeof A && "object" == typeof B && A;
+        "object" != typeof A && "object" != typeof B && (A, B);
+        // dropped
+        "object" == typeof A && "object" != typeof B && B;
+        "object" != typeof A && "object" != typeof B && (A, B);
+        "object" != typeof A && "object" == typeof B && A;
+        "object" == typeof A && "object" != typeof B && B;
+        // dropped
     }
 }
 

test/compress/varify.js

@@ -111,7 +111,7 @@ hoist_props_const: {
         }
     }
     expect: {
-        var o = 0, o_p = "PASS";
+        var o, o_p = "PASS";
         console.log(o_p);
     }
     expect_stdout: "PASS"

test/compress/webkit.js

@@ -107,3 +107,209 @@ function_name_mangle_ie8: {
     expect_exact: "(function(){console.log(typeof function n(o){})})();"
     expect_stdout: "function"
 }
+
+issue_1753: {
+    mangle = {
+        toplevel: false,
+        webkit: true,
+    }
+    input: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect_stdout: "0"
+    node_version: ">=4"
+}
+
+issue_1753_toplevel: {
+    mangle = {
+        toplevel: true,
+        webkit: true,
+    }
+    input: {
+        "use strict";
+        let l = null;
+        for (let i = 0; i < 1; i++)
+            console.log(i);
+    }
+    expect: {
+        "use strict";
+        let l = null;
+        for (let e = 0; e < 1; e++)
+            console.log(e);
+    }
+    expect_stdout: "0"
+    node_version: ">=4"
+}
+
+issue_5032_await: {
+    options = {
+        merge_vars: true,
+        webkit: false,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var a = log(a), c = a;
+            log(a);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=8"
+}
+
+issue_5032_await_webkit: {
+    options = {
+        merge_vars: true,
+        webkit: true,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        async function f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=8"
+}
+
+issue_5032_yield: {
+    options = {
+        merge_vars: true,
+        webkit: false,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var a = log(a), c = a;
+            log(a);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=4"
+}
+
+issue_5032_yield_webkit: {
+    options = {
+        merge_vars: true,
+        webkit: true,
+    }
+    input: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect: {
+        function log(value) {
+            console.log(value);
+            return value;
+        }
+        function *f(a) {
+            var b = log(a), c = b;
+            log(b);
+            log(c);
+        }
+        f("PASS").next();
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=4"
+}
+
+issue_5480: {
+    mangle = {
+        webkit: true,
+    }
+    input: {
+        "use strict";
+        L: for (let a in console.log("PASS"));
+    }
+    expect: {
+        "use strict";
+        o: for (let o in console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/yields.js

@@ -934,6 +934,21 @@ drop_unused_call: {
     node_version: ">=4"
 }
 
+instanceof_lambda: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(42 instanceof function*() {});
+    }
+    expect: {
+        console.log(false);
+    }
+    expect_stdout: "false"
+    node_version: ">=4"
+}
+
 issue_4454_1: {
     rename = false
     options = {
@@ -978,8 +993,8 @@ issue_4454_2: {
     expect: {
         function f(a) {
             (function*(c = console.log(a)) {})();
-            var a = 42..toString();
-            console.log(a);
+            var b = 42..toString();
+            console.log(b);
         }
         f("PASS");
     }
@@ -1267,80 +1282,6 @@ issue_5019_2: {
     node_version: ">=4"
 }
 
-issue_5032_normal: {
-    options = {
-        merge_vars: true,
-        webkit: false,
-    }
-    input: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        function *f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS").next();
-    }
-    expect: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        function *f(a) {
-            var a = log(a), c = a;
-            log(a);
-            log(c);
-        }
-        f("PASS").next();
-    }
-    expect_stdout: [
-        "PASS",
-        "PASS",
-        "PASS",
-    ]
-    node_version: ">=4"
-}
-
-issue_5032_webkit: {
-    options = {
-        merge_vars: true,
-        webkit: true,
-    }
-    input: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        function *f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS").next();
-    }
-    expect: {
-        function log(value) {
-            console.log(value);
-            return value;
-        }
-        function *f(a) {
-            var b = log(a), c = b;
-            log(b);
-            log(c);
-        }
-        f("PASS").next();
-    }
-    expect_stdout: [
-        "PASS",
-        "PASS",
-        "PASS",
-    ]
-    node_version: ">=4"
-}
-
 issue_5034: {
     options = {
         functions: true,
@@ -1451,3 +1392,173 @@ issue_5177: {
     expect_stdout: "function"
     node_version: ">=4"
 }
+
+issue_5385_1: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function*() {
+            (function() {
+                try {
+                    return console.log("foo");
+                } finally {
+                    return console.log("bar");
+                }
+                console.log("baz");
+            })();
+        })().next();
+        console.log("moo");
+    }
+    expect: {
+        (async function*() {
+            (function() {
+                try {
+                    return console.log("foo");
+                } finally {
+                    return console.log("bar");
+                }
+                console.log("baz");
+            })();
+        })().next();
+        console.log("moo");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "moo",
+    ]
+    node_version: ">=10"
+}
+
+issue_5385_2: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function*() {
+            return function() {
+                try {
+                    return console.log("foo");
+                } finally {
+                    return console.log("bar");
+                }
+            }();
+        })().next();
+        console.log("moo");
+    }
+    expect: {
+        (async function*() {
+            return function() {
+                try {
+                    return console.log("foo");
+                } finally {
+                    return console.log("bar");
+                }
+            }();
+        })().next();
+        console.log("moo");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "moo",
+    ]
+    node_version: ">=10"
+}
+
+issue_5425: {
+    options = {
+        assignments: true,
+        ie: true,
+        toplevel: true,
+        unused: true,
+        yields: true,
+    }
+    input: {
+        var a = "FAIL";
+        var b = function* f() {}(a ? a = "PASS" : 42);
+        console.log(a, typeof f);
+    }
+    expect: {
+        var a = "FAIL";
+        (function* f() {})(a && (a = "PASS"));
+        console.log(a, typeof f);
+    }
+    expect_stdout: "PASS undefined"
+    node_version: ">=4"
+}
+
+issue_5456: {
+    options = {
+        inline: true,
+        merge_vars: true,
+    }
+    input: {
+        var a = true;
+        (function() {
+            (function(b, c) {
+                var d = function*() {
+                    c = null;
+                }();
+                var e = function() {
+                    if (c)
+                        console.log(typeof d);
+                    while (b);
+                }();
+            })(function(i) {
+                return console.log("foo") && i;
+            }(a));
+        })();
+    }
+    expect: {
+        var a = true;
+        (function() {
+            b = (i = a, console.log("foo") && i),
+            d = function*() {
+                c = null;
+            }(),
+            e = function() {
+                if (c) console.log(typeof d);
+                while (b);
+            }(),
+            void 0;
+            var b, c, d, e;
+            var i;
+        })();
+    }
+    expect_stdout: "foo"
+    node_version: ">=4"
+}
+
+issue_5506: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(function(a) {
+            var b = function*() {
+                a = null in (a = "PASS");
+            }();
+            try {
+                b.next();
+            } catch (e) {
+                return a;
+            }
+        }("FAIL"));
+    }
+    expect: {
+        console.log(function(a) {
+            var b = function*() {
+                a = null in (a = "PASS");
+            }();
+            try {
+                b.next();
+            } catch (e) {
+                return a;
+            }
+        }("FAIL"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/input/module/expect.js

@@ -0,0 +1 @@
+function n(){return this||arguments[0]+arguments[1]}function o(){return this||arguments[0]+arguments[1]}console.log(n(n(1,3),5)),console.log(o(o(2,4),6));

test/input/module/input.js

@@ -0,0 +1,13 @@
+console.log(function() {
+    function sum(...params) {
+        return this || arguments[0] + arguments[1];
+    }
+    return sum(sum(1, 3), 5);
+}());
+console.log(function() {
+    "use strict";
+    function sum(...params) {
+        return this || arguments[0] + arguments[1];
+    }
+    return sum(sum(2, 4), 6);
+}());

test/input/reduce/export_default.js

@@ -0,0 +1,17 @@
+var unused;
+export default class {
+    ____11111() {
+        a, b, c, d, e;
+        f, g, h, i, j;
+        k, l, m, n, o;
+        p, q, r, s, t;
+        u, v, w, x, y, z;
+        A, B, C, D, E;
+        F, G, H, I, J;
+        K, L, M, N, O;
+        P, Q, R, S, T;
+        U, V, W, X, Y, Z;
+        $, _;
+        unused;
+    }
+}

test/mocha/cli.js

@@ -928,6 +928,14 @@ describe("bin/uglifyjs", function() {
             done();
         });
     });
+    it("Should work with --module", function(done) {
+        var command = uglifyjscmd + " test/input/module/input.js --module -mc";
+        exec(command, function(err, stdout, stderr) {
+            if (err) throw err;
+            assert.strictEqual(stdout, read("test/input/module/expect.js"));
+            done();
+        });
+    });
     it("Should compress swarm of unused variables with reasonable performance", function(done) {
         var code = [
             "console.log(function() {",

test/mocha/minify.js

@@ -1,6 +1,7 @@
 var assert = require("assert");
 var readFileSync = require("fs").readFileSync;
 var run_code = require("../sandbox").run_code;
+var semver = require("semver");
 var UglifyJS = require("../..");
 
 function read(path) {
@@ -320,6 +321,24 @@ describe("minify", function() {
         });
     });
 
+    describe("module", function() {
+        it("Should not inline `await` variables", function() {
+            if (semver.satisfies(process.version, "<8")) return;
+            var code = [
+                "console.log(function() {",
+                "    return typeof await;",
+                "}());",
+            ].join("\n");
+            assert.strictEqual(run_code("(async function(){" + code + "})();"), "undefined\n");
+            var result = UglifyJS.minify(code, {
+                module: true,
+            });
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, "console.log(function(){return typeof await}());");
+            assert.strictEqual(run_code("(async function(){" + result.code + "})();"), "undefined\n");
+        });
+    });
+
     describe("rename", function() {
         it("Should be repeatable", function() {
             var code = "!function(x){return x(x)}(y);";

test/mocha/reduce.js

@@ -434,4 +434,55 @@ describe("test/reduce.js", function() {
             "// }",
         ].join("\n"));
     });
+    it("Should transform `export default class` correctly", function() {
+        var result = reduce_test(read("test/input/reduce/export_default.js"), {
+            compress: false,
+            toplevel: true,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "// Can't reproduce test failure",
+            "// minify options: {",
+            '//   "compress": false,',
+            '//   "toplevel": true',
+            "// }",
+        ].join("\n"));
+    });
+    it("Should transform `export default function` correctly", function() {
+        var code = [
+            "for (var k in this)",
+            "    console.log(k);",
+            "export default (function f() {});",
+            "console.log(k);",
+        ].join("\n");
+        var result = reduce_test(code, {
+            mangle: false,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "// Can't reproduce test failure",
+            "// minify options: {",
+            '//   "mangle": false',
+            "// }",
+        ].join("\n"));
+    });
+    it("Should transform `export default (42)` correctly", function() {
+        var code = [
+            "export default (42);",
+            "for (var k in this)",
+            "    console.log(k);",
+        ].join("\n");
+        var result = reduce_test(code, {
+            compress: false,
+            mangle: false,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "// Can't reproduce test failure",
+            "// minify options: {",
+            '//   "compress": false,',
+            '//   "mangle": false',
+            "// }",
+        ].join("\n"));
+    });
 });

test/release/web-tooling-benchmark.sh

@@ -54,7 +54,7 @@ ERR=$?; if [ "$ERR" != "0" ]; then echo "Error: $ERR"; exit $ERR; fi
 minify_in_situ "src" \
 && minify_in_situ "third_party" \
 && rm -rf node_modules \
-&& npm_install \
+&& npm_install --package-lock \
 && rm -rf build/* \
 && npm run build:terser-bundled \
 && npm run build:uglify-js-bundled \

test/sandbox.js

@@ -52,11 +52,19 @@ exports.same_stdout = semver.satisfies(process.version, "0.12") ? function(expec
     return typeof expected == typeof actual && strip_func_ids(expected) == strip_func_ids(actual);
 };
 exports.patch_module_statements = function(code) {
-    var count = 0, imports = [];
-    code = code.replace(/\bexport(?:\s*\{[^{}]*}\s*?(?:$|\n|;)|\s+default\b(?:\s*(\(|\{|class\s*\{|class\s+(?=extends\b)|(?:async\s+)?function\s*(?:\*\s*)?\())?|\b)/g, function(match, header) {
+    var count = 0, has_default = "", imports = [], strict_mode = "";
+    code = code.replace(/^\s*("|')use strict\1\s*;?/, function(match) {
+        strict_mode = match;
+        return "";
+    }).replace(/\bexport(?:\s*\{[^{}]*}\s*?(?:$|\n|;)|\s+default\b(?:\s*(\(|\{|class\s*\{|class\s+(?=extends\b)|(?:async\s+)?function\s*(?:\*\s*)?\())?|\b)/g, function(match, header) {
+        if (/^export\s+default/.test(match)) has_default = "var _uglify_export_default_;";
         if (!header) return "";
         if (header.length == 1) return "0, " + header;
-        return header.slice(0, -1) + " _" + ++count + header.slice(-1);
+        var name = "_uglify_export_default_";
+        if (/^class\b/.test(header)) do {
+            name = "_uglify_export_default_" + ++count;
+        } while (code.indexOf(name) >= 0);
+        return header.slice(0, -1) + " " + name + header.slice(-1);
     }).replace(/\bimport\.meta\b/g, function() {
         return '({ url: "https://example.com/path/index.html" })';
     }).replace(/\bimport\b(?:\s*([^\s('"][^('"]*)\bfrom\b)?\s*(['"]).*?\2(?:$|\n|;)/g, function(match, symbols) {
@@ -73,7 +81,7 @@ exports.patch_module_statements = function(code) {
         return "";
     });
     imports.push("");
-    return imports.join("\n") + code;
+    return strict_mode + has_default + imports.join("\n") + code;
 };
 
 function is_error(result) {

test/ufuzz/index.js

@@ -128,7 +128,7 @@ for (var i = 2; i < process.argv.length; ++i) {
 
 var SUPPORT = function(matrix) {
     for (var name in matrix) {
-        matrix[name] = typeof sandbox.run_code(matrix[name]) == "string";
+        matrix[name] = !sandbox.is_error(sandbox.run_code(matrix[name]));
     }
     return matrix;
 }({
@@ -140,6 +140,7 @@ var SUPPORT = function(matrix) {
     class: "class C { f() {} }",
     class_field: "class C { p = 0; }",
     class_private: "class C { #f() {} }",
+    class_static_init: "class C { static {} }",
     computed_key: "({[0]: 0});",
     const_block: "var a; { const a = 0; }",
     default_value: "[ a = 0 ] = [];",
@@ -252,7 +253,7 @@ BINARY_OPS = BINARY_OPS.concat(BINARY_OPS);
 if (SUPPORT.exponentiation) BINARY_OPS.push("**");
 BINARY_OPS = BINARY_OPS.concat(BINARY_OPS);
 BINARY_OPS = BINARY_OPS.concat(BINARY_OPS);
-BINARY_OPS.push(" in ");
+BINARY_OPS.push(" in ", " instanceof ");
 
 var ASSIGNMENTS = [ "=" ];
 ASSIGNMENTS = ASSIGNMENTS.concat(ASSIGNMENTS);
@@ -405,7 +406,7 @@ function createTopLevelCode() {
     unique_vars.length = 0;
     classes.length = 0;
     allow_this = true;
-    async = false;
+    async = SUPPORT.async && rng(200) == 0;
     has_await = false;
     export_default = false;
     generator = false;
@@ -413,7 +414,7 @@ function createTopLevelCode() {
     funcs = 0;
     clazz = 0;
     imports = 0;
-    in_class = 0;
+    in_class = async;
     called = Object.create(null);
     var s = [
         strictMode(),
@@ -1181,7 +1182,11 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
                 unique_vars.length = unique_len;
             });
         }
-        if (n !== 0) s += " finally { " + createStatements(3, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + " }";
+        if (n !== 0) s += [
+            " finally { ",
+            createStatements(rng(5) + 1, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth),
+            " }",
+        ].join("");
         return s;
       case STMT_C:
         return "c = c + 1;";
@@ -1805,7 +1810,7 @@ function createClassLiteral(recurmax, stmtDepth, canThrow, name) {
         if (canThrow && rng(20) == 0) {
             s += p;
         } else {
-            s += "(" + p + " && " + p + ".constructor === Function ? " + p + " : function() {})";
+            s += "(typeof " + p + ' == "function" && typeof ' + p + '.prototype == "object" && ' + p + ".constructor === Function ? " + p + " : function() {})";
         }
     }
     s += " {\n";
@@ -1824,15 +1829,31 @@ function createClassLiteral(recurmax, stmtDepth, canThrow, name) {
             declared.push(internal);
         }
         if (SUPPORT.class_field && rng(2)) {
-            s += internal || createObjectKey(recurmax, stmtDepth, canThrow);
+            if (internal) {
+                s += internal;
+            } else if (fixed && bug_class_static_nontrivial) {
+                s += getDotKey();
+            } else {
+                s += createObjectKey(recurmax, stmtDepth, canThrow);
+            }
             if (rng(5)) {
-                async = bug_async_class_await && fixed && 0;
+                async = false;
                 generator = false;
                 s += " = " + createExpression(recurmax, NO_COMMA, stmtDepth, fixed ? canThrow : CANNOT_THROW);
                 generator = save_generator;
                 async = save_async;
             }
             s += ";\n";
+        } else if (SUPPORT.class_static_init && fixed && !internal && rng(10) == 0) {
+            async = false;
+            generator = false;
+            s += [
+                "{ ",
+                createStatements(rng(5) + 1, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CANNOT_RETURN, stmtDepth),
+                " }\n",
+            ].join("");
+            generator = save_generator;
+            async = save_async;
         } else {
             if (!fixed && !internal && constructor && rng(10) == 0) {
                 internal = constructor;
@@ -1988,7 +2009,7 @@ function createBinaryOp(noComma, canThrow) {
     var op;
     do {
         op = BINARY_OPS[rng(BINARY_OPS.length)];
-    } while (noComma && op == "," || !canThrow && op == " in ");
+    } while (noComma && op == "," || !canThrow && /^ in/.test(op));
     return op;
 }
 
@@ -2031,7 +2052,7 @@ function isBannedKeyword(name) {
       case "let":
         return in_class;
       case "await":
-        return async !== false;
+        return async || in_class && bug_class_static_await;
       case "yield":
         return generator || in_class;
     }
@@ -2081,6 +2102,12 @@ if (require.main !== module) {
 }
 
 function run_code(code, toplevel, timeout) {
+    if (async && has_await) code = [
+        '"use strict";',
+        "(async function(){",
+        code,
+        "})();"
+    ].join("\n");
     return sandbox.run_code(sandbox.patch_module_statements(code), toplevel, timeout);
 }
 
@@ -2100,7 +2127,9 @@ function errorln(msg) {
 }
 
 function try_beautify(code, toplevel, result, printfn, options) {
-    var beautified = UglifyJS.minify(code, JSON.parse(beautify_options));
+    var o = JSON.parse(beautify_options);
+    if (async && has_await) o.module = true;
+    var beautified = UglifyJS.minify(code, o);
     if (beautified.error) {
         printfn("// !!! beautify failed !!!");
         printfn(beautified.error);
@@ -2110,7 +2139,7 @@ function try_beautify(code, toplevel, result, printfn, options) {
     } else if (options) {
         var uglified = UglifyJS.minify(beautified.code, JSON.parse(options));
         var expected, actual;
-        if (typeof uglify_code != "string" || uglified.error) {
+        if (sandbox.is_error(uglify_code) || uglified.error) {
             expected = uglify_code;
             actual = uglified.error;
         } else {
@@ -2147,7 +2176,7 @@ function log_suspects(minify_options, component) {
             m[component] = o;
             m.validate = true;
             var result = UglifyJS.minify(original_code, m);
-            if (typeof uglify_code != "string") {
+            if (sandbox.is_error(uglify_code)) {
                 return !sandbox.same_stdout(uglify_code, result.error);
             } else if (result.error) {
                 errorln("Error testing options." + component + "." + name);
@@ -2175,7 +2204,7 @@ function log_suspects_global(options, toplevel) {
         m[component] = false;
         m.validate = true;
         var result = UglifyJS.minify(original_code, m);
-        if (typeof uglify_code != "string") {
+        if (sandbox.is_error(uglify_code)) {
             return !sandbox.same_stdout(uglify_code, result.error);
         } else if (result.error) {
             errorln("Error testing options." + component);
@@ -2204,7 +2233,16 @@ function log(options) {
     errorln();
     errorln();
     errorln("//-------------------------------------------------------------");
-    if (typeof uglify_code == "string") {
+    if (sandbox.is_error(uglify_code)) {
+        errorln("// !!! uglify failed !!!");
+        errorln(uglify_code);
+        if (original_erred) {
+            errorln();
+            errorln();
+            errorln("original stacktrace:");
+            errorln(original_result);
+        }
+    } else {
         errorln("// uglified code");
         try_beautify(uglify_code, toplevel, uglify_result, errorln);
         errorln();
@@ -2213,15 +2251,6 @@ function log(options) {
         errorln(original_result);
         errorln("uglified result:");
         errorln(uglify_result);
-    } else {
-        errorln("// !!! uglify failed !!!");
-        errorln(uglify_code);
-        if (errored) {
-            errorln();
-            errorln();
-            errorln("original stacktrace:");
-            errorln(original_result);
-        }
     }
     errorln("//-------------------------------------------------------------");
     if (!ok) {
@@ -2253,12 +2282,27 @@ function log(options) {
 }
 
 function sort_globals(code) {
-    var globals = run_code("throw Object.keys(this).sort(" + function(global) {
+    var injected = "throw Object.keys(this).sort(" + function(global) {
         return function(m, n) {
             return (typeof global[n] == "function") - (typeof global[m] == "function")
                 || (m < n ? -1 : m > n ? 1 : 0);
         };
-    } + "(this));\n" + code);
+    } + "(this));";
+    var save_async = async;
+    if (async && has_await) {
+        async = false;
+        injected = [
+            '"use strict";',
+            injected,
+            "(async function(){",
+            code,
+            "})();"
+        ].join("\n");
+    } else {
+        injected += "\n" + code;
+    }
+    var globals = run_code(injected);
+    async = save_async;
     if (!Array.isArray(globals)) {
         errorln();
         errorln();
@@ -2318,20 +2362,28 @@ function is_error_in(ex) {
     return ex.name == "TypeError" && /'in'/.test(ex.message);
 }
 
+function is_error_tdz(ex) {
+    return ex.name == "ReferenceError";
+}
+
 function is_error_spread(ex) {
-    return ex.name == "TypeError" && /Found non-callable @@iterator| is not iterable| not a function/.test(ex.message);
+    return ex.name == "TypeError" && /Found non-callable @@iterator| is not iterable| not a function|Symbol\(Symbol\.iterator\)/.test(ex.message);
 }
 
 function is_error_recursion(ex) {
     return ex.name == "RangeError" && /Invalid string length|Maximum call stack size exceeded/.test(ex.message);
 }
 
+function is_error_set_property(ex) {
+    return ex.name == "TypeError" && /^Cannot set propert[\s\S]+? of (null|undefined)/.test(ex.message);
+}
+
 function is_error_redeclaration(ex) {
     return ex.name == "SyntaxError" && /already been declared|redeclaration/.test(ex.message);
 }
 
 function is_error_destructuring(ex) {
-    return ex.name == "TypeError" && /^Cannot destructure /.test(ex.message);
+    return ex.name == "TypeError" && /^Cannot (destructure|read propert)/.test(ex.message);
 }
 
 function is_error_class_constructor(ex) {
@@ -2345,6 +2397,8 @@ function is_error_getter_only_property(ex) {
 }
 
 function patch_try_catch(orig, toplevel) {
+    var patched = Object.create(null);
+    var patches = [];
     var stack = [ {
         code: orig,
         index: 0,
@@ -2382,7 +2436,7 @@ function patch_try_catch(orig, toplevel) {
                     "throw " + match[1] + ";",
                 ].join("\n");
             }
-            var new_code = code.slice(0, index) + insert + code.slice(index) + tail_throw;
+            var new_code = code.slice(0, index) + insert + code.slice(index) + tail_throw + "var UFUZZ_ERROR;";
             var result = run_code(new_code, toplevel);
             if (!sandbox.is_error(result)) {
                 if (!stack.filled && match[1]) stack.push({
@@ -2394,27 +2448,35 @@ function patch_try_catch(orig, toplevel) {
                 offset += insert.length;
                 code = new_code;
             } else if (is_error_in(result)) {
-                index = result.ufuzz_catch;
-                return orig.slice(0, index) + result.ufuzz_var + ' = new Error("invalid `in`");' + orig.slice(index);
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("invalid `in`");');
+            } else if (is_error_tdz(result)) {
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("TDZ");');
             } else if (is_error_spread(result)) {
-                index = result.ufuzz_catch;
-                return orig.slice(0, index) + result.ufuzz_var + ' = new Error("spread not iterable");' + orig.slice(index);
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("spread not iterable");');
             } else if (is_error_recursion(result)) {
-                index = result.ufuzz_try;
-                return orig.slice(0, index) + 'throw new Error("skipping infinite recursion");' + orig.slice(index);
+                patch(result.ufuzz_try, 'throw new Error("skipping infinite recursion");');
+            } else if (is_error_set_property(result)) {
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("cannot set property");');
             } else if (is_error_destructuring(result)) {
-                index = result.ufuzz_catch;
-                return orig.slice(0, index) + result.ufuzz_var + ' = new Error("cannot destructure");' + orig.slice(index);
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("cannot destructure");');
             } else if (is_error_class_constructor(result)) {
-                index = result.ufuzz_catch;
-                return orig.slice(0, index) + result.ufuzz_var + ' = new Error("missing new for class");' + orig.slice(index);
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("missing new for class");');
             } else if (is_error_getter_only_property(result)) {
-                index = result.ufuzz_catch;
-                return orig.slice(0, index) + result.ufuzz_var + ' = new Error("setting getter-only property");' + orig.slice(index);
+                patch(result.ufuzz_catch, result.ufuzz_var + ' = new Error("setting getter-only property");');
             }
         }
         stack.filled = true;
     }
+    if (patches.length) return patches.reduce(function(code, patch) {
+        var index = patch[0];
+        return code.slice(0, index) + patch[1] + code.slice(index);
+    }, orig);
+
+    function patch(index, code) {
+        if (patched[index]) return;
+        patched[index] = true;
+        patches.unshift([ index, code ]);
+    }
 }
 
 var beautify_options = {
@@ -2426,22 +2488,26 @@ var beautify_options = {
     },
 };
 var minify_options = require("./options.json");
-if (typeof sandbox.run_code("A:if (0) B:; else B:;") != "string") {
+if (sandbox.is_error(sandbox.run_code("A:if (0) B:; else B:;"))) {
     minify_options.forEach(function(o) {
         if (!("mangle" in o)) o.mangle = {};
         if (o.mangle) o.mangle.v8 = true;
     });
 }
 var bug_async_arrow_rest = function() {};
-if (SUPPORT.arrow && SUPPORT.async && SUPPORT.rest && typeof sandbox.run_code("async (a = f(...[], b)) => 0;") != "string") {
+if (SUPPORT.arrow && SUPPORT.async && SUPPORT.rest && sandbox.is_error(sandbox.run_code("async (a = f(...[], b)) => 0;"))) {
     bug_async_arrow_rest = function(ex) {
         return ex.name == "SyntaxError" && ex.message == "Rest parameter must be last formal parameter";
     };
 }
-var bug_async_class_await = SUPPORT.async && SUPPORT.class_field && typeof sandbox.run_code("var await; async function f() { class A { static p = await; } }") != "string";
-var bug_for_of_async = SUPPORT.for_await_of && typeof sandbox.run_code("var async; for (async of []);") != "string";
-var bug_for_of_var = SUPPORT.for_of && SUPPORT.let && typeof sandbox.run_code("try {} catch (e) { for (var e of []); }") != "string";
-if (SUPPORT.destructuring && typeof sandbox.run_code("console.log([ 1 ], {} = 2);") != "string") {
+var bug_class_static_await = SUPPORT.async && SUPPORT.class_field && sandbox.is_error(sandbox.run_code("var await; class A { static p = await; }"));
+var bug_class_static_nontrivial = SUPPORT.class_field && sandbox.is_error(sandbox.run_code("class A { static 42; static get 42() {} }"));
+var bug_for_of_async = SUPPORT.for_await_of && sandbox.is_error(sandbox.run_code("var async; for (async of []);"));
+var bug_for_of_var = SUPPORT.for_of && SUPPORT.let && sandbox.is_error(sandbox.run_code("try {} catch (e) { for (var e of []); }"));
+var bug_proto_stream = function(ex) {
+    return ex.name == "TypeError" && ex.message == "callback is not a function";
+}
+if (SUPPORT.destructuring && sandbox.is_error(sandbox.run_code("console.log([ 1 ], {} = 2);"))) {
     beautify_options.output.v8 = true;
     minify_options.forEach(function(o) {
         if (!("output" in o)) o.output = {};
@@ -2450,7 +2516,7 @@ if (SUPPORT.destructuring && typeof sandbox.run_code("console.log([ 1 ], {} = 2)
 }
 beautify_options = JSON.stringify(beautify_options);
 minify_options = minify_options.map(JSON.stringify);
-var original_code, original_result, errored;
+var original_code, original_result, original_erred;
 var uglify_code, uglify_result, ok;
 for (var round = 1; round <= num_iterations; round++) {
     process.stdout.write(round + " of " + num_iterations + "\r");
@@ -2458,7 +2524,7 @@ for (var round = 1; round <= num_iterations; round++) {
     original_code = createTopLevelCode();
     var orig_result = [ run_code(original_code), run_code(original_code, true) ];
     if (orig_result.some(function(result, toplevel) {
-        if (typeof result == "string") return;
+        if (!sandbox.is_error(result)) return;
         println();
         println();
         println("//=============================================================");
@@ -2471,28 +2537,37 @@ for (var round = 1; round <= num_iterations; round++) {
         println();
             // ignore v8 parser bug
         return bug_async_arrow_rest(result)
+            // ignore Node.js `__proto__` quirks
+            || bug_proto_stream(result)
             // ignore runtime platform bugs
             || result.message == "Script execution aborted.";
     })) continue;
     minify_options.forEach(function(options) {
         var o = JSON.parse(options);
+        if (async && has_await) {
+            o.module = true;
+            options = JSON.stringify(o);
+        }
         var toplevel = sandbox.has_toplevel(o);
         o.validate = true;
         uglify_code = UglifyJS.minify(original_code, o);
         original_result = orig_result[toplevel ? 1 : 0];
-        errored = typeof original_result != "string";
+        original_erred = sandbox.is_error(original_result);
         if (!uglify_code.error) {
             uglify_code = uglify_code.code;
             uglify_result = run_code(uglify_code, toplevel);
             ok = sandbox.same_stdout(original_result, uglify_result);
+            var uglify_erred = sandbox.is_error(uglify_result);
             // ignore v8 parser bug
-            if (!ok && bug_async_arrow_rest(uglify_result)) ok = true;
+            if (!ok && uglify_erred && bug_async_arrow_rest(uglify_result)) ok = true;
+            // ignore Node.js `__proto__` quirks
+            if (!ok && uglify_erred && bug_proto_stream(uglify_result)) ok = true;
             // ignore runtime platform bugs
-            if (!ok && uglify_result.message == "Script execution aborted.") ok = true;
+            if (!ok && uglify_erred && uglify_result.message == "Script execution aborted.") ok = true;
             // handle difference caused by time-outs
             if (!ok) {
-                if (errored && is_error_timeout(original_result)) {
-                    if (is_error_timeout(uglify_result)) {
+                if (original_erred && is_error_timeout(original_result)) {
+                    if (uglify_erred && is_error_timeout(uglify_result)) {
                         // ignore difference in error message
                         ok = true;
                     } else {
@@ -2500,21 +2575,23 @@ for (var round = 1; round <= num_iterations; round++) {
                         if (!orig_result[toplevel ? 3 : 2]) orig_result[toplevel ? 3 : 2] = run_code(original_code, toplevel, 10000);
                         ok = sandbox.same_stdout(orig_result[toplevel ? 3 : 2], uglify_result);
                     }
-                } else if (is_error_timeout(uglify_result)) {
+                } else if (uglify_erred && is_error_timeout(uglify_result)) {
                     // ignore spurious time-outs
                     var waited_result = run_code(uglify_code, toplevel, 10000);
                     ok = sandbox.same_stdout(original_result, waited_result);
                 }
             }
             // ignore declaration order of global variables
-            if (!ok && !toplevel && uglify_result.name != "SyntaxError" && original_result.name != "SyntaxError") {
-                ok = sandbox.same_stdout(run_code(sort_globals(original_code)), run_code(sort_globals(uglify_code)));
+            if (!ok && !toplevel) {
+                if (!(original_erred && original_result.name == "SyntaxError") && !(uglify_erred && uglify_result.name == "SyntaxError")) {
+                    ok = sandbox.same_stdout(run_code(sort_globals(original_code)), run_code(sort_globals(uglify_code)));
+                }
             }
             // ignore numerical imprecision caused by `unsafe_math`
-            if (!ok && o.compress && o.compress.unsafe_math && typeof original_result == typeof uglify_result) {
-                if (typeof original_result == "string") {
+            if (!ok && o.compress && o.compress.unsafe_math) {
+                if (typeof original_result == "string" && typeof uglify_result == "string") {
                     ok = fuzzy_match(original_result, uglify_result);
-                } else if (sandbox.is_error(original_result)) {
+                } else if (original_erred && uglify_erred) {
                     ok = original_result.name == uglify_result.name && fuzzy_match(original_result.message, uglify_result.message);
                 }
                 if (!ok) {
@@ -2522,46 +2599,33 @@ for (var round = 1; round <= num_iterations; round++) {
                     ok = sandbox.same_stdout(fuzzy_result, uglify_result);
                 }
             }
-            // ignore difference in error message caused by Temporal Dead Zone
-            if (!ok && errored && uglify_result.name == "ReferenceError" && original_result.name == "ReferenceError") ok = true;
-            // ignore difference due to implicit strict-mode in `class`
-            if (!ok && /\bclass\b/.test(original_code)) {
-                var original_strict = run_code('"use strict";\n' + original_code, toplevel);
-                if (/^(Syntax|Type)Error$/.test(uglify_result.name)) {
-                    ok = typeof original_strict != "string";
-                } else {
-                    ok = sandbox.same_stdout(original_strict, uglify_result);
-                }
-            }
-            // ignore difference in error message caused by `import` symbol redeclaration
-            if (!ok && errored && /\bimport\b/.test(original_code)) {
-                if (is_error_redeclaration(uglify_result) && is_error_redeclaration(original_result)) ok = true;
-            }
+            if (!ok && original_erred && uglify_erred && (
+                // ignore difference in error message caused by `in`
+                is_error_in(original_result) && is_error_in(uglify_result)
+                // ignore difference in error message caused by Temporal Dead Zone
+                || is_error_tdz(original_result) && is_error_tdz(uglify_result)
+                // ignore difference in error message caused by spread syntax
+                || is_error_spread(original_result) && is_error_spread(uglify_result)
+                // ignore difference in error message caused by destructuring assignment
+                || is_error_set_property(original_result) && is_error_set_property(uglify_result)
+                // ignore difference in error message caused by `import` symbol redeclaration
+                || /\bimport\b/.test(original_code) && is_error_redeclaration(original_result) && is_error_redeclaration(uglify_result)
+                // ignore difference in error message caused by destructuring
+                || is_error_destructuring(original_result) && is_error_destructuring(uglify_result)
+                // ignore difference in error message caused by call on class
+                || is_error_class_constructor(original_result) && is_error_class_constructor(uglify_result)
+                // ignore difference in error message caused by setting getter-only property
+                || is_error_getter_only_property(original_result) && is_error_getter_only_property(uglify_result)
+            )) ok = true;
             // ignore difference due to `__proto__` assignment
             if (!ok && /\b__proto__\b/.test(original_code)) {
                 var original_proto = run_code("(" + patch_proto + ")();\n" + original_code, toplevel);
                 var uglify_proto = run_code("(" + patch_proto + ")();\n" + uglify_code, toplevel);
                 ok = sandbox.same_stdout(original_proto, uglify_proto);
             }
-            // ignore difference in error message caused by `in`
-            if (!ok && errored && is_error_in(uglify_result) && is_error_in(original_result)) ok = true;
-            // ignore difference in error message caused by spread syntax
-            if (!ok && errored && is_error_spread(uglify_result) && is_error_spread(original_result)) ok = true;
             // ignore difference in depth of termination caused by infinite recursion
-            if (!ok && errored && is_error_recursion(original_result)) {
-                if (is_error_recursion(uglify_result) || typeof uglify_result == "string") ok = true;
-            }
-            // ignore difference in error message caused by destructuring
-            if (!ok && errored && is_error_destructuring(uglify_result) && is_error_destructuring(original_result)) {
-                ok = true;
-            }
-            // ignore difference in error message caused by call on class
-            if (!ok && errored && is_error_class_constructor(uglify_result) && is_error_class_constructor(original_result)) {
-                ok = true;
-            }
-            // ignore difference in error message caused by setting getter-only property
-            if (!ok && errored && is_error_getter_only_property(uglify_result) && is_error_getter_only_property(original_result)) {
-                ok = true;
+            if (!ok && original_erred && is_error_recursion(original_result)) {
+                if (!uglify_erred || is_error_recursion(uglify_result)) ok = true;
             }
             // ignore errors above when caught by try-catch
             if (!ok) {
@@ -2573,7 +2637,7 @@ for (var round = 1; round <= num_iterations; round++) {
             }
         } else {
             uglify_code = uglify_code.error;
-            ok = errored && uglify_code.name == original_result.name;
+            ok = original_erred && uglify_code.name == original_result.name;
         }
         if (verbose || (verbose_interval && !(round % INTERVAL_COUNT)) || !ok) log(options);
         if (!ok && isFinite(num_iterations)) {