v3.16.0

fix corner case in comparisons (#5486 )
fixes #5485
2022-06-06 11:29:26 +08:00 · 2022-06-05 00:47:38 +08:00 · 2022-06-02 02:45:02 +08:00 · 2022-06-02 02:44:06 +08:00 · 2022-06-02 02:42:39 +08:00 · 2022-05-31 00:27:40 +08:00
40 changed files with 2836 additions and 656 deletions
--- a/.github/workflows/ufuzz.yml
+++ b/.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
--- a/README.md
+++ b/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,9 @@ 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";` 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
@@ -728,6 +732,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.
@@ -1331,10 +1338,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 +1378,46 @@ 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);
+  // Expected: "function"
+  // Actual:   "undefined"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
--- a/bin/uglifyjs
+++ b/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":
--- a/lib/ast.js
+++ b/lib/ast.js
@@ -827,6 +827,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() {
@@ -1834,7 +1837,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 +2039,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);
        }
    },
--- a/lib/compress.js
+++ b/lib/compress.js
--- a/lib/minify.js
+++ b/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) {
--- a/lib/parse.js
+++ b/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,
@@ -1194,10 +1189,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 +1201,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,8 +1335,6 @@ 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", "{")) {
@@ -1352,8 +1345,6 @@ function parse($TEXT, options) {
            handle_regexp();
            value = maybe_assign();
        }
-        var is_strict = S.input.has_directive("use strict");
-        S.input.pop_directives_stack();
        --S.in_function;
        S.in_loop = loop;
        S.labels = labels;
@@ -1367,7 +1358,7 @@ function parse($TEXT, options) {
            value: value,
            end: prev(),
        });
-        if (is_strict) node.each_argname(strict_verify_symbol);
+        if (S.input.has_directive("use strict")) node.each_argname(strict_verify_symbol);
        return node;
    }

@@ -1412,7 +1403,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 +2541,7 @@ function parse($TEXT, options) {
    return function() {
        var start = S.token;
        var body = [];
+        if (options.module) S.input.add_directive("use strict");
        S.input.push_directives_stack();
        while (!is("eof"))
            body.push(statement());
--- a/lib/scope.js
+++ b/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() {
@@ -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,
    }));
@@ -620,14 +622,10 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
    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) {
--- a/package.json
+++ b/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.3",
+  "version": "3.16.0",
  "engines": {
    "node": ">=0.8.0"
  },
--- a/test/compress.js
+++ b/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;
--- a/test/compress/arrows.js
+++ b/test/compress/arrows.js
@@ -1018,3 +1018,91 @@ issue_5356: {
    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"
+}
--- a/test/compress/awaits.js
+++ b/test/compress/awaits.js
@@ -1748,8 +1748,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 +2427,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 +2885,79 @@ 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"
+}
--- a/test/compress/booleans.js
+++ b/test/compress/booleans.js
@@ -762,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"
+}
--- a/test/compress/classes.js
+++ b/test/compress/classes.js
@@ -341,7 +341,7 @@ drop_extends: {
    node_version: ">=4"
 }

-keep_extends: {
+keep_extends_1: {
    options = {
        toplevel: true,
        unused: true,
@@ -366,6 +366,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 +707,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 +831,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 +1060,8 @@ keep_fnames: {
        class Foo {}
        console.log(Foo.name, class Bar {}.name);
    }
+    expect_stdout: "Foo Bar"
+    node_version: ">=4"
 }

 issue_805_1: {
@@ -1756,12 +1879,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 +1919,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 +1969,11 @@ issue_4962_2: {
    }
    expect: {
        console.log(function f() {}(function g() {
+            function h() {
+                f;
+            }
            (class {
-                static c = f;
+                static c = h();
            });
        }));
    }
@@ -1850,6 +2009,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,
@@ -2502,3 +2724,161 @@ issue_5352: {
    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"
+}
--- a/test/compress/collapse_vars.js
+++ b/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"
+}
--- a/test/compress/const.js
+++ b/test/compress/const.js
@@ -1855,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"
+}
--- a/test/compress/default-values.js
+++ b/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"
+}
--- a/test/compress/destructured.js
+++ b/test/compress/destructured.js
@@ -1848,8 +1848,8 @@ issue_4294: {
            }) {}({
                [a]: 0,
            });
-            var a = A;
-            console.log(a);
+            var b = A;
+            console.log(b);
        })();
    }
    expect_stdout: "PASS"
@@ -3020,6 +3020,7 @@ issue_5074_method_pure_getters: {
 issue_5085_1: {
    options = {
        evaluate: true,
+        passes: 2,
        reduce_vars: true,
        toplevel: true,
        unsafe: true,
@@ -3032,8 +3033,7 @@ issue_5085_1: {
    }
    expect: {
        var a = "PASS";
-        var b = [ 42 ][0];
-        b;
+        42;
        console.log(a);
    }
    expect_stdout: "PASS"
@@ -3043,6 +3043,7 @@ issue_5085_1: {
 issue_5085_2: {
    options = {
        evaluate: true,
+        passes: 2,
        reduce_vars: true,
        side_effects: true,
        unsafe: true,
@@ -3059,7 +3060,7 @@ issue_5085_2: {
    expect: {
        var a = "PASS";
        (function(b) {
-            b = [ 42 ][0];
+            0;
        })();
        console.log(a);
    }
@@ -3400,7 +3401,7 @@ issue_5222: {
    node_version: ">=6"
 }

-issue_5288: {
+issue_5288_1: {
    options = {
        conditionals: true,
        inline: true,
@@ -3420,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"
@@ -3497,3 +3528,121 @@ issue_5370: {
    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"
+}
--- a/test/compress/evaluate.js
+++ b/test/compress/evaluate.js
@@ -3349,3 +3349,30 @@ issue_5362_2: {
    }
    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"
+}
--- a/test/compress/exports.js
+++ b/test/compress/exports.js
@@ -496,3 +496,16 @@ issue_4766: {
        export var a = "bar";
    }
 }
+
+issue_5444: {
+    options = {
+        unused: true,
+    }
+    input: {
+        export var a = (console, console);
+    }
+    expect: {
+        console;
+        export var a = console;
+    }
+}
--- a/test/compress/functions.js
+++ b/test/compress/functions.js
@@ -3557,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,
@@ -8329,3 +8350,299 @@ issue_5376_2: {
    }
    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"
+}
--- a/test/compress/hoist_props.js
+++ b/test/compress/hoist_props.js
@@ -1176,3 +1176,30 @@ 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"
+}
--- a/test/compress/hoist_vars.js
+++ b/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");
@@ -530,3 +529,77 @@ issue_5378: {
        "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"
+}
--- a/test/compress/keep_fargs.js
+++ b/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";
        }();
--- a/test/compress/let.js
+++ b/test/compress/let.js
@@ -1604,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,
@@ -2020,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"
+}
--- a/test/compress/merge_vars.js
+++ b/test/compress/merge_vars.js
@@ -3702,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"
+}
--- a/test/compress/reduce_vars.js
+++ b/test/compress/reduce_vars.js
@@ -6689,8 +6689,7 @@ issues_3267_1: {
    }
    expect: {
        !function(x) {
-            var i = Object();
-            if (i)
+            if (Object())
                return console.log("PASS");
            throw "FAIL";
        }();
@@ -7862,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"
+}
--- a/test/compress/rests.js
+++ b/test/compress/rests.js
@@ -1323,3 +1323,43 @@ issue_5370: {
    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"
+}
--- a/test/compress/spreads.js
+++ b/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"
+}
--- a/test/compress/varify.js
+++ b/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"
--- a/test/compress/webkit.js
+++ b/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"
+}
--- a/test/compress/yields.js
+++ b/test/compress/yields.js
@@ -978,8 +978,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 +1267,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 +1377,141 @@ 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"
+}
--- a/test/input/module/expect.js
+++ b/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));
--- a/test/input/module/input.js
+++ b/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);
+}());
--- a/test/mocha/cli.js
+++ b/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() {",
--- a/test/mocha/reduce.js
+++ b/test/mocha/reduce.js
@@ -434,7 +434,7 @@ describe("test/reduce.js", function() {
            "// }",
        ].join("\n"));
    });
-    it("Should transform `export default` correctly", function() {
+    it("Should transform `export default class` correctly", function() {
        var result = reduce_test(read("test/input/reduce/export_default.js"), {
            compress: false,
            toplevel: true,
@@ -448,4 +448,41 @@ describe("test/reduce.js", function() {
            "// }",
        ].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"));
+    });
 });
--- a/test/reduce.js
+++ b/test/reduce.js
@@ -210,10 +210,10 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
            }
            if (node.expression instanceof U.AST_Function) {
                // hoist and return expressions from the IIFE function expression
-                var seq = [];
+                var scope = tt.find_parent(U.AST_Scope), seq = [];
                node.expression.body.forEach(function(node) {
                    var expr = node instanceof U.AST_Exit ? node.value : node.body;
-                    if (expr instanceof U.AST_Node && !U.is_statement(expr) && can_hoist(expr)) {
+                    if (expr instanceof U.AST_Node && !U.is_statement(expr) && can_hoist(expr, scope)) {
                        // collect expressions from each statement's body
                        seq.push(expr);
                    }
@@ -264,11 +264,12 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                CHANGED = true;
                return List.skip;
              default:
-                if (!has_exit(node) && can_hoist(node)) {
+                if (can_hoist(node, tt.find_parent(U.AST_Scope))) {
                    // hoist function declaration body
                    var body = node.body;
                    node.body = [];
-                    body.push(node); // retain function with empty body to be dropped later
+                    // retain function with empty body to be dropped later
+                    body.push(node);
                    CHANGED = true;
                    return List.splice(body);
                }
@@ -382,7 +383,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
            if (node.body instanceof U.AST_Call && node.body.expression instanceof U.AST_Function) {
                // hoist simple statement IIFE function expression body
                node.start._permute++;
-                if (!has_exit(node.body.expression) && can_hoist(node.body.expression)) {
+                if (can_hoist(node.body.expression, tt.find_parent(U.AST_Scope))) {
                    CHANGED = true;
                    return List.splice(node.body.expression.body);
                }
@@ -647,21 +648,6 @@ function trim_trailing_whitespace(value) {
    return ("" + value).replace(/\s+$/, "");
 }

-function has_exit(fn) {
-    var found = false;
-    var tw = new U.TreeWalker(function(node) {
-        if (found) return found;
-        if (node instanceof U.AST_Exit) {
-            return found = true;
-        }
-        if (node instanceof U.AST_Scope && node !== fn) {
-            return true; // don't descend into nested functions
-        }
-    });
-    fn.walk(tw);
-    return found;
-}
-
 function has_loopcontrol(body, loop, label) {
    var found = false;
    var tw = new U.TreeWalker(function(node) {
@@ -676,17 +662,31 @@ function has_loopcontrol(body, loop, label) {
    return found;
 }

-function can_hoist(body) {
+function can_hoist(body, scope) {
    var found = false;
-    body.walk(new U.TreeWalker(function(node) {
+    var tw = new U.TreeWalker(function(node) {
        if (found) return true;
+        if (node instanceof U.AST_Exit) return found = true;
        if (node instanceof U.AST_NewTarget) return found = true;
        if (node instanceof U.AST_Scope) {
            if (node === body) return;
+            if (node instanceof U.AST_Arrow || node instanceof U.AST_AsyncArrow) node.argnames.forEach(function(sym) {
+                sym.walk(tw);
+            });
+            // don't descend into nested functions
            return true;
        }
        if (node instanceof U.AST_Super) return found = true;
-    }));
+        if (node instanceof U.AST_SymbolDeclaration || node instanceof U.AST_SymbolRef) switch (node.name) {
+          case "await":
+            if (/^Async/.test(scope.TYPE)) return found = true;
+            return;
+          case "yield":
+            if (/Generator/.test(scope.TYPE)) return found = true;
+            return;
+        }
+    });
+    body.walk(tw);
    return !found;
 }

--- a/test/release/web-tooling-benchmark.sh
+++ b/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 \
--- a/test/sandbox.js
+++ b/test/sandbox.js
@@ -52,12 +52,17 @@ 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;
-        do {
-            var name = "_export_default_" + ++count;
+        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() {
@@ -76,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) {
--- a/test/ufuzz/index.js
+++ b/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;
 }({
@@ -1805,7 +1805,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,9 +1824,15 @@ 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;
@@ -2031,7 +2037,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;
    }
@@ -2110,7 +2116,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 +2153,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 +2181,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 +2210,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 +2228,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) {
@@ -2318,20 +2324,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 +2359,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 +2398,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 +2410,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 +2450,23 @@ 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 []); }"));
+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 +2475,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 +2483,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("//=============================================================");
@@ -2480,19 +2505,20 @@ for (var round = 1; round <= num_iterations; round++) {
        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 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 +2526,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 +2550,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 +2588,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)) {
Author	SHA1	Message	Date
Alex Lam S.L	25441d44f6	v3.16.0	2022-06-06 11:29:26 +08:00
Alex Lam S.L	a025392a30	fix corner case in `comparisons` (#5486 ) fixes #5485	2022-06-05 00:47:38 +08:00
Alex Lam S.L	ad5f5ef2a3	fix corner case in `webkit` (#5483 ) fixes #5480	2022-06-02 02:45:02 +08:00
Chen Yangjian	40e669eacb	docs: toplevel `webkit` option sets `compress.webkit` as well (#5480 )	2022-06-02 02:44:06 +08:00
Alex Lam S.L	ad3a331ca3	fix corner case in `collapse_vars` (#5482 ) fixes #5481	2022-06-02 02:42:39 +08:00
Alex Lam S.L	3c9e1693d5	fix corner case in `side_effects` (#5479 ) fixes #5478	2022-05-31 00:27:40 +08:00
Alex Lam S.L	8bc03dc6c4	fix corner case in `keep_fargs` (#5477 ) fixes #5476	2022-05-29 12:10:19 +08:00
Alex Lam S.L	2152f00de2	enhance `inline` & `module` (#5475 )	2022-05-27 11:57:05 +08:00
Alex Lam S.L	94aae05d45	fix corner case in `merge_vars` (#5472 ) fixes #5471	2022-05-27 03:13:24 +08:00
Alex Lam S.L	0dbf2b1d3c	suppress false positives in `ufuzz` (#5473 )	2022-05-26 23:17:47 +08:00
Alex Lam S.L	59b23b8c13	fix corner case in `booleans` (#5470 ) fixes #5469	2022-05-26 05:33:50 +08:00
Alex Lam S.L	5979b195fe	suppress false positives in `ufuzz` (#5468 )	2022-05-25 23:50:47 +08:00
Alex Lam S.L	a1cff23377	suppress false positives in `ufuzz` (#5467 )	2022-05-25 06:35:59 +08:00
Alex Lam S.L	c82fc1ef71	implement `--module` (#5462 )	2022-05-24 05:45:47 +08:00
Alex Lam S.L	740f93f5a9	fix corner case in `merge_vars` (#5466 ) fixes #5465	2022-05-24 05:45:07 +08:00
Alex Lam S.L	d4caa97b88	fix corner case in `reduce_vars` (#5464 ) fixes #5463	2022-05-23 11:08:12 +08:00
Alex Lam S.L	c2ca7b7659	drop unused `extends` properly (#5461 )	2022-05-23 03:53:32 +08:00
Alex Lam S.L	59edda6ca5	suppress false positives in `ufuzz` (#5460 )	2022-05-22 01:36:45 +08:00
Alex Lam S.L	1668bc33c3	improve `ufuzz` coverage (#5459 )	2022-05-21 02:57:13 +08:00
Alex Lam S.L	01f1e3fef8	avoid v8 quirks in `ufuzz` (#5458 )	2022-05-20 00:00:24 +08:00
Alex Lam S.L	27aa85f84b	fix corner cases in `merge_vars` (#5457 ) fixes #5456	2022-05-19 06:39:20 +08:00
Alex Lam S.L	33c9c48318	fix corner case in `hoist_props` & `unused` (#5455 ) fixes #5454	2022-05-19 04:45:38 +08:00
Alex Lam S.L	63f16e4616	fix corner case in `merge_vars` (#5452 ) fixes #5451	2022-05-18 02:41:05 +08:00
Alex Lam S.L	cb6dd34b98	avoid broken versions of Node.js (#5453 )	2022-05-18 02:40:31 +08:00
Alex Lam S.L	27727e6926	fix corner cases in `unused` (#5449 ) fixes #5448	2022-05-17 17:03:06 +08:00
Alex Lam S.L	a968ddc78c	avoid webpack bug in web-tooling-benchmark (#5450 )	2022-05-17 14:08:11 +08:00
Alex Lam S.L	f70462aeb2	fix corner case in `merge_vars` (#5445 ) fixes #5444	2022-05-16 16:30:14 +08:00
Alex Lam S.L	3aa92c76cc	avoid `extends` error in `ufuzz` (#5447 )	2022-05-16 11:11:10 +08:00
Alex Lam S.L	fc6a66836a	fix corner case in `unused` (#5446 ) fixes #5444	2022-05-16 09:13:30 +08:00
Alex Lam S.L	31167da1a9	avoid `extends` error in test cases (#5443 )	2022-05-16 06:50:22 +08:00
Alex Lam S.L	7db2ada880	fix corner case in `hoist_props` (#5442 ) fixes #5441	2022-05-16 06:49:09 +08:00
Alex Lam S.L	e31bbe329a	improve compatibility with `use strict` (#5440 )	2022-05-14 12:15:54 +08:00
Alex Lam S.L	8946c87011	suppress invalid test case generation (#5439 ) - document v8 quirks closes #5438	2022-05-12 04:38:11 +08:00
Alex Lam S.L	a9ef659bcb	v3.15.5	2022-05-11 05:26:10 +08:00
Alex Lam S.L	35c2149dbd	fix corner case in `merge_vars` (#5437 ) fixes #5436	2022-05-08 04:16:28 +08:00
Alex Lam S.L	89a35f9fcd	fix corner case in `reduce_vars` (#5435 ) fixes #5434	2022-05-06 09:32:47 +08:00
Alex Lam S.L	1a4e99dc2d	avoid v8 quirks in `ufuzz` (#5431 ) closes #5428 closes #5429	2022-04-25 21:33:31 +08:00
Alex Lam S.L	cb870f6fd6	document v8 quirks (#5430 ) closes #5428 closes #5429	2022-04-21 02:51:53 +08:00
Alex Lam S.L	a0c0c294c5	fix corner case in `assignments` (#5426 ) fixes #5425	2022-04-19 13:19:30 +08:00
Alex Lam S.L	fbdb7eeda3	fix corner case in `merge_vars` (#5424 ) fixes #5423	2022-04-19 09:04:06 +08:00
Alex Lam S.L	1bc0fccc8c	improve `ufuzz` resilience (#5422 )	2022-04-18 13:03:01 +08:00
Alex Lam S.L	20252c6483	fix corner case in `merge_vars` (#5421 ) fixes #5420	2022-04-18 06:38:08 +08:00
Alex Lam S.L	e396912ea2	suppress false positives with `export` & `import` (#5418 )	2022-04-16 04:27:50 +08:00
Alex Lam S.L	5ebfa78f56	fix corner case with `arguments` (#5417 ) fixes #5416	2022-04-15 06:52:10 +08:00
Alex Lam S.L	950609f578	fix corner case in `inline` (#5415 ) fixes #5414	2022-04-13 06:19:37 +08:00
Alex Lam S.L	4a44d95f09	v3.15.4	2022-04-10 01:16:11 +08:00
David Luhmer	36718948be	rename reserved keyword `await` (#5413 )	2022-04-08 00:31:29 +08:00
Alex Lam S.L	21bd4c4a9d	fix corner cases in `collapse_vars` & `hoist_vars` (#5412 ) fixes #5411	2022-04-07 04:12:03 +08:00
Alex Lam S.L	998c9792da	fix corner case in `inline` (#5410 ) fixes #5409	2022-04-06 12:23:47 +08:00
Alex Lam S.L	ccd77d70db	fix corner case in `reduce_vars` (#5408 ) fixes #5407	2022-04-05 10:09:25 +08:00
Alex Lam S.L	d75a946707	fix corner case in `reduce_vars` (#5406 ) fixes #5405	2022-04-03 21:57:37 +08:00
Alex Lam S.L	696a20f10d	patch `export default` within sandbox correctly (#5404 ) fixes #5403	2022-04-03 19:56:19 +08:00
Alex Lam S.L	224c91b6c1	fix corner case in `inline` (#5402 ) fixes #5401	2022-04-03 01:12:53 +08:00
Alex Lam S.L	8065e27a7d	patch `export default` within sandbox correctly (#5400 ) fixes #5399	2022-04-02 21:59:28 +08:00
Alex Lam S.L	584e253f33	enahnce `collapse_vars` (#5398 )	2022-04-01 20:26:27 +08:00
Alex Lam S.L	fb5e08e4ec	fix corner case in `collapse_vars` (#5397 ) fixes #5396	2022-03-31 20:02:56 +08:00
Alex Lam S.L	e3d328f741	fix corner case in `collapse_vars` (#5395 ) fixes #5394	2022-03-30 01:22:57 +08:00
Alex Lam S.L	8922f08fbf	fix corner cases in `keep_fnames` (#5393 )	2022-03-29 03:01:01 +08:00
Alex Lam S.L	15a4074d1a	fix corner case in `unused` (#5392 ) fixes #5391	2022-03-28 05:46:43 +08:00
Alex Lam S.L	c624b43739	fix corner case in `collapse_vars` (#5390 ) fixes #5389	2022-03-22 13:05:57 +08:00
Alex Lam S.L	a8e040b133	fix corner case in `properties` (#5388 ) fixes #5387	2022-03-21 00:01:42 +08:00
Alex Lam S.L	5e30f3a48b	fix corner case in `inline` (#5386 ) fixes #5385	2022-03-20 22:50:28 +08:00
Alex Lam S.L	46570a4eb6	fix corner case in `side_effects` (#5383 ) fixes #5382	2022-03-12 14:14:30 +08:00
Alex Lam S.L	01b84074d7	fix corner case in `evaluate` (#5381 ) fixes #5380	2022-03-12 13:08:29 +08:00
				`@@ -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));`