v3.17.0

fixes #5602

.github/workflows/build.yml

@@ -8,7 +8,12 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        options: [ '-mb braces', '--ie8 -c', '-mc', '--toplevel -mc passes=3,pure_getters,unsafe' ]
+        options:
+          - '-mb braces'
+          - '--ie -c'
+          - '-mc'
+          - '-p acorn --toplevel -mco spidermonkey'
+          - '--toplevel -mc passes=3,pure_getters,unsafe'
         script:
           - acorn.sh
           - bootstrap.sh
@@ -45,7 +50,7 @@ jobs:
       OPTIONS: ${{ matrix.options }}
       SCRIPT: ${{ matrix.script }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Perform uglify, build & test
         shell: bash
         run: |

.github/workflows/ci.yml

@@ -7,22 +7,18 @@ jobs:
   test:
     strategy:
       matrix:
-        node: [ '0.8', '0.10', '0.12', '4', '6', '8', '10', '12', '14', latest ]
+        node: [ '0.10', '0.12', '4', '6', '8', '10', '12', '14', '16', latest ]
         os: [ ubuntu-latest, windows-latest ]
         script: [ compress, mocha, release/benchmark, release/jetstream ]
-        exclude:
-          - node: '0.8'
-            script: release/benchmark
-          - node: '0.8'
-            script: release/jetstream
     name: ${{ matrix.node }} ${{ matrix.os }} ${{ matrix.script }}
     runs-on: ${{ matrix.os }}
     env:
       NODE: ${{ matrix.node }}
       TYPE: ${{ matrix.script }}
+      UGLIFY_GITHUB_LAG: 10000
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/cache@v2
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
         with:
           path: tmp
           key: tmp ${{ matrix.script }}

.github/workflows/ufuzz.yml

@@ -2,11 +2,14 @@ name: Fuzzing
 on:
   pull_request:
   schedule:
-    - cron: '*/5 * * * *'
+    - cron: '*/15 * * * *'
+  workflow_dispatch:
+  workflow_run:
+    branches: [ master ]
+    types: [ completed ]
+    workflows: [ 'Build testing', CI ]
 env:
   BASE_URL: https://api.github.com/repos/${{ github.repository }}
-  CAUSE: ${{ github.event_name }}
-  RUN_NUM: ${{ github.run_number }}
   TOKEN: ${{ github.token }}
 jobs:
   ufuzz:
@@ -14,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
@@ -29,13 +32,13 @@ jobs:
     env:
       NODE: ${{ matrix.node }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Perform fuzzing
         shell: bash
         run: |
           . ./test/release/install.sh
-          if [[ $CAUSE == "schedule" ]]; then
-            node test/ufuzz/job $BASE_URL $TOKEN $RUN_NUM
-          else
+          if [[ $GITHUB_EVENT_NAME == "pull_request" ]]; then
             node test/ufuzz/job 5000
+          else
+            node test/ufuzz/job $BASE_URL $TOKEN $GITHUB_RUN_NUMBER
           fi

README.md

@@ -54,8 +54,6 @@ a double dash to prevent input files being used as option arguments:
                                                 modules and Userscripts that may
                                                 be anonymous function wrapped (IIFE)
                                                 by the .user.js engine `caller`.
-                                `expression`  Parse a single expression, rather than
-                                              a program (for parsing JSON).
                                 `spidermonkey`  Assume input files are SpiderMonkey
                                                 AST format (as JSON).
     -c, --compress [options]    Enable compressor/specify compressor options:
@@ -111,12 +109,16 @@ a double dash to prevent input files being used as option arguments:
     -d, --define <expr>[=value] Global definitions.
     -e, --enclose [arg[:value]] Embed everything in a big function, with configurable
                                 argument(s) & value(s).
-    --ie8                       Support non-standard Internet Explorer 8.
-                                Equivalent to setting `ie8: true` in `minify()`
+    --expression                Parse a single expression, rather than a program
+                                (for parsing JSON).
+    --ie                        Support non-standard Internet Explorer.
+                                Equivalent to setting `ie: true` in `minify()`
                                 for `compress`, `mangle` and `output` options.
                                 By default UglifyJS will not try to be IE-proof.
+    --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:
@@ -145,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
@@ -502,7 +504,12 @@ if (result.error) throw result.error;
 - `compress` (default: `{}`) — pass `false` to skip compressing entirely.
   Pass an object to specify custom [compress options](#compress-options).
 
-- `ie8` (default: `false`) — set to `true` to support IE8.
+- `expression` (default: `false`) — parse as a single expression, e.g. JSON.
+
+- `ie` (default: `false`) — enable workarounds for Internet Explorer bugs.
+
+- `keep_fargs` (default: `false`) — pass `true` to prevent discarding or mangling
+  of function arguments.
 
 - `keep_fnames` (default: `false`) — pass `true` to prevent discarding or mangling
   of function names.  Useful for code relying on `Function.prototype.name`.
@@ -513,6 +520,10 @@ if (result.error) throw result.error;
   - `mangle.properties` (default: `false`) — a subcategory of the mangle option.
     Pass an object to specify custom [mangle property options](#mangle-properties-options).
 
+- `module` (default: `false`) — set to `true` if you wish to process input as
+  ES module, i.e. implicit `"use strict";` and support for top-level `await`,
+  alongside with `toplevel` enabled.
+
 - `nameCache` (default: `null`) — pass an empty object `{}` or a previously
   used `nameCache` object if you wish to cache mangled variable and
   property names across multiple invocations of `minify()`. Note: this is
@@ -566,7 +577,6 @@ if (result.error) throw result.error;
     },
     nameCache: null, // or specify a name cache object
     toplevel: false,
-    ie8: false,
     warnings: false,
 }
 ```
@@ -625,7 +635,11 @@ to be `false` and all symbol names will be omitted.
 
 - `bare_returns` (default: `false`) — support top level `return` statements
 
-- `html5_comments` (default: `true`)
+- `html5_comments` (default: `true`) — process HTML comment as workaround for
+  browsers which do not recognise `<script>` tags
+
+- `module` (default: `false`) — set to `true` if you wish to process input as
+  ES module, i.e. implicit `"use strict";` and support for top-level `await`.
 
 - `shebang` (default: `true`) — support `#!command` as the first line
 
@@ -708,7 +722,8 @@ to be `false` and all symbol names will be omitted.
   - `1` — inline simple functions
   - `2` — inline functions with arguments
   - `3` — inline functions with arguments and variables
-  - `true` — same as `3`
+  - `4` — inline functions with arguments, variables and statements
+  - `true` — same as `4`
 
 - `join_vars` (default: `true`) — join consecutive `var` statements
 
@@ -724,6 +739,9 @@ to be `false` and all symbol names will be omitted.
 
 - `merge_vars` (default: `true`) — combine and reuse variables.
 
+- `module` (default: `false`) — set to `true` if you wish to process input as
+  ES module, i.e. implicit `"use strict";` alongside with `toplevel` enabled.
+
 - `negate_iife` (default: `true`) — negate "Immediately-Called Function Expressions"
   where the return value is discarded, to avoid the parens that the
   code generator would insert.
@@ -795,14 +813,14 @@ to be `false` and all symbol names will be omitted.
   variables (`"vars"`) in the top level scope (`false` by default, `true` to drop
   both unreferenced functions and variables)
 
-- `typeofs` (default: `true`) — Transforms `typeof foo == "undefined"` into
-  `foo === void 0`.  Note: recommend to set this value to `false` for IE10 and
-  earlier versions due to known issues.
+- `typeofs` (default: `true`) — compress `typeof` expressions, e.g.
+  `typeof foo == "undefined" → void 0 === foo`
 
 - `unsafe` (default: `false`) — apply "unsafe" transformations (discussion below)
 
-- `unsafe_comps` (default: `false`) — compress expressions like `a <= b` assuming
-  none of the operands can be (coerced to) `NaN`.
+- `unsafe_comps` (default: `false`) — assume operands cannot be (coerced to) `NaN`
+  in numeric comparisons, e.g. `a <= b`. In addition, expressions involving `in`
+  or `instanceof` would never throw.
 
 - `unsafe_Function` (default: `false`) — compress and mangle `Function(args, code)`
   when both `args` and `code` are string literals.
@@ -869,6 +887,9 @@ UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
 - `debug` (default: `false`) — Mangle names with the original name still present.
   Pass an empty string `""` to enable, or a non-empty string to set the debug suffix.
 
+- `keep_fargs` (default: `false`) — Use `true` to prevent mangling of function
+  arguments.
+
 - `keep_quoted` (default: `false`) — Only mangle unquoted property names.
 
 - `regex` (default: `null`) — Pass a RegExp literal to only mangle property
@@ -911,9 +932,11 @@ can pass additional arguments that control the code output:
 
 - `galio` (default: `false`) — enable workarounds for ANT Galio bugs
 
-- `indent_level` (default: `4`)
+- `indent_level` (default: `4`) — indent by specified number of spaces or the
+  exact whitespace sequence supplied, e.g. `"\t"`.
 
-- `indent_start` (default: `0`) — prefix all lines by that many spaces
+- `indent_start` (default: `0`) — prefix all lines by whitespace sequence
+  specified in the same format as `indent_level`.
 
 - `inline_script` (default: `true`) — escape HTML comments and the slash in
   occurrences of `</script>` in strings
@@ -1201,6 +1224,17 @@ To allow for better optimizations, the compiler makes various assumptions:
 - Object properties can be added, removed and modified (not prevented with
   `Object.defineProperty()`, `Object.defineProperties()`, `Object.freeze()`,
   `Object.preventExtensions()` or `Object.seal()`).
+- If array destructuring is present, index-like properties in `Array.prototype`
+  have not been overridden:
+  ```javascript
+  Object.prototype[0] = 42;
+  var [ a ] = [];
+  var { 0: b } = {};
+  // 42 undefined
+  console.log([][0], a);
+  // 42 42
+  console.log({}[0], b);
+  ```
 - Earlier versions of JavaScript will throw `SyntaxError` with the following:
   ```javascript
   ({
@@ -1309,3 +1343,106 @@ To allow for better optimizations, the compiler makes various assumptions:
   // Actual:   { '42': undefined }
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  var await;
+  class A {
+      static p = await;
+  }
+  // SyntaxError: Unexpected reserved word
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  var async;
+  for (async of []);
+  // SyntaxError: The left-hand side of a for-of loop may not be 'async'.
+  ```
+  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
+  console.log({
+      ...console,
+      get 42() {
+          return "FAIL";
+      },
+      [42]: "PASS",
+  }[42], {
+      ...console,
+      get 42() {
+          return "FAIL";
+      },
+      42: "PASS",
+  }[42]);
+  // Expected: "PASS PASS"
+  // Actual:   "PASS FAIL"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Earlier versions of JavaScript will throw `TypeError` with the following:
+  ```javascript
+  (function() {
+      {
+          const a = "foo";
+      }
+      {
+          const a = "bar";
+      }
+  })();
+  // TypeError: const 'a' has already been declared
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  try {
+      class A {
+          static 42;
+          static get 42() {}
+      }
+      console.log("PASS");
+  } catch (e) {
+      console.log("FAIL");
+  }
+  // Expected: "PASS"
+  // Actual:   "FAIL"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  (async function(a) {
+      (function() {
+          var b = await => console.log("PASS");
+          b();
+      })();
+  })().catch(console.error);
+  // Expected: "PASS"
+  // Actual:   SyntaxError: Unexpected reserved word
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of Chrome and Node.js will give incorrect results with the
+  following:
+  ```javascript
+  try {
+      f();
+      function f() {
+          throw 42;
+      }
+  } catch (e) {
+      console.log(typeof f, e);
+  }
+  // Expected: "function 42"
+  // Actual:   "undefined 42"
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Later versions of JavaScript will throw `SyntaxError` with the following:
+  ```javascript
+  "use strict";
+  console.log(function f() {
+      return f = "PASS";
+  }());
+  // Expected: "PASS"
+  // Actual:   TypeError: invalid assignment to const 'f'
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.

bin/uglifyjs

@@ -10,7 +10,9 @@ var info = require("../package.json");
 var path = require("path");
 var UglifyJS = require("../tools/node");
 
-var skip_keys = [ "cname", "fixed", "inlined", "parent_scope", "scope", "uses_eval", "uses_with" ];
+var skip_keys = [ "cname", "fixed", "in_arg", "inlined", "length_read", "parent_scope", "redef", "scope", "unused" ];
+var truthy_keys = [ "optional", "pure", "terminal", "uses_arguments", "uses_eval", "uses_with" ];
+
 var files = {};
 var options = {};
 var short_forms = {
@@ -70,6 +72,7 @@ function process_option(name, no_value) {
                 } else {
                     if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
                     toplevels.push([ {
+                        keep_fargs: "keep-fargs",
                         keep_fnames: "keep-fnames",
                         nameCache: "name-cache",
                     }[name] || name, option ]);
@@ -101,8 +104,11 @@ function process_option(name, no_value) {
                 "  --config-file <file>                     Read minify() options from JSON file.",
                 "  -d, --define <expr>[=value]              Global definitions.",
                 "  -e, --enclose [arg[,...][:value[,...]]]  Embed everything in a big function, with configurable argument(s) & value(s).",
-                "  --ie8                                    Support non-standard Internet Explorer 8.",
+                "  --expression                             Parse a single expression, rather than a program.",
+                "  --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.",
@@ -110,6 +116,7 @@ function process_option(name, no_value) {
                 "  --source-map [options]                   Enable source map/specify source map options.",
                 "  --timings                                Display operations run time on STDERR.",
                 "  --toplevel                               Compress and/or mangle variables in toplevel scope.",
+                "  --v8                                     Support non-standard Chrome & Node.js.",
                 "  --validate                               Perform validation during AST manipulations.",
                 "  --verbose                                Print diagnostic messages.",
                 "  --warn                                   Print warning messages.",
@@ -145,9 +152,13 @@ function process_option(name, no_value) {
         options[name] = read_value();
         break;
       case "annotations":
+      case "expression":
+      case "ie":
       case "ie8":
+      case "module":
       case "timings":
       case "toplevel":
+      case "v8":
       case "validate":
       case "webkit":
         options[name] = true;
@@ -155,6 +166,9 @@ function process_option(name, no_value) {
       case "no-annotations":
         options.annotations = false;
         break;
+      case "keep-fargs":
+        options.keep_fargs = true;
+        break;
       case "keep-fnames":
         options.keep_fnames = true;
         break;
@@ -235,10 +249,11 @@ if (options.mangle && options.mangle.properties) {
         });
     }
 }
-if (output == "ast") options.output = {
-    ast: true,
-    code: false,
-};
+if (/^ast|spidermonkey$/.test(output)) {
+    if (typeof options.output != "object") options.output = {};
+    options.output.ast = true;
+    options.output.code = false;
+}
 if (options.parse && (options.parse.acorn || options.parse.spidermonkey)
     && options.sourceMap && options.sourceMap.content == "inline") {
     fatal("inline source map only works with built-in parser");
@@ -265,7 +280,9 @@ if (specified["self"]) {
     paths = UglifyJS.FILES;
 }
 if (specified["in-situ"]) {
-    if (output || specified["reduce-test"] || specified["self"]) fatal("incompatible options specified");
+    if (output && output != "spidermonkey" || specified["reduce-test"] || specified["self"]) {
+        fatal("incompatible options specified");
+    }
     paths.forEach(function(name) {
         print(name);
         if (/^ast|spidermonkey$/.test(name)) fatal("invalid file name specified");
@@ -311,13 +328,43 @@ function run() {
     try {
         if (options.parse) {
             if (options.parse.acorn) {
+                var annotations = Object.create(null);
                 files = convert_ast(function(toplevel, name) {
-                    return require("acorn").parse(files[name], {
+                    var content = files[name];
+                    var list = annotations[name] = [];
+                    var prev = -1;
+                    return require("acorn").parse(content, {
+                        allowHashBang: true,
+                        ecmaVersion: "latest",
                         locations: true,
+                        onComment: function(block, text, start, end) {
+                            var match = /[@#]__PURE__/.exec(text);
+                            if (!match) {
+                                if (start != prev) return;
+                                match = [ list[prev] ];
+                            }
+                            while (/\s/.test(content[end])) end++;
+                            list[end] = match[0];
+                            prev = end;
+                        },
+                        preserveParens: true,
                         program: toplevel,
-                        sourceFile: name
+                        sourceFile: name,
+                        sourceType: "module",
                     });
                 });
+                files.walk(new UglifyJS.TreeWalker(function(node) {
+                    if (!(node instanceof UglifyJS.AST_Call)) return;
+                    var list = annotations[node.start.file];
+                    var pure = list[node.start.pos];
+                    if (!pure) {
+                        var tokens = node.start.parens;
+                        if (tokens) for (var i = 0; !pure && i < tokens.length; i++) {
+                            pure = list[tokens[i].pos];
+                        }
+                    }
+                    if (pure) node.pure = pure;
+                }));
             } else if (options.parse.spidermonkey) {
                 files = convert_ast(function(toplevel, name) {
                     var obj = JSON.parse(files[name]);
@@ -394,7 +441,7 @@ function run() {
               case "thedef":
                 return symdef(value);
             }
-            if (skip_key(key)) return;
+            if (skip_property(key, value)) return;
             if (value instanceof UglifyJS.AST_Token) return;
             if (value instanceof UglifyJS.Dictionary) return;
             if (value instanceof UglifyJS.AST_Node) {
@@ -409,16 +456,19 @@ function run() {
             return value;
         }, 2));
     } else if (output == "spidermonkey") {
-        print(JSON.stringify(UglifyJS.minify(result.code, {
-            compress: false,
-            mangle: false,
-            output: {
-                ast: true,
-                code: false
-            },
-        }).ast.to_mozilla_ast(), null, 2));
+        print(JSON.stringify(result.ast.to_mozilla_ast(), null, 2));
     } else if (output) {
-        fs.writeFileSync(output, result.code);
+        var code;
+        if (result.ast) {
+            var opts = {};
+            for (var name in options.output) {
+                if (!/^ast|code$/.test(name)) opts[name] = options.output[name];
+            }
+            code = UglifyJS.AST_Node.from_mozilla_ast(result.ast.to_mozilla_ast()).print_to_string(opts);
+        } else {
+            code = result.code;
+        }
+        fs.writeFileSync(output, code);
         if (result.map) fs.writeFileSync(output + ".map", result.map);
     } else {
         print(result.code);
@@ -480,7 +530,7 @@ function read_file(path, default_value) {
 }
 
 function parse_js(value, options, flag) {
-    if (!options || typeof options != "object") options = {};
+    if (!options || typeof options != "object") options = Object.create(null);
     if (typeof value == "string") try {
         UglifyJS.parse(value, {
             expression: true
@@ -520,8 +570,10 @@ function parse_js(value, options, flag) {
     return options;
 }
 
-function skip_key(key) {
-    return skip_keys.indexOf(key) >= 0;
+function skip_property(key, value) {
+    return skip_keys.indexOf(key) >= 0
+        // only skip truthy_keys if their value is falsy
+        || truthy_keys.indexOf(key) >= 0 && !value;
 }
 
 function symdef(def) {

lib/minify.js

@@ -28,7 +28,7 @@ function read_source_map(name, toplevel) {
         var match = /^# ([^\s=]+)=(\S+)\s*$/.exec(comment.value);
         if (!match) break;
         if (match[1] == "sourceMappingURL") {
-            match = /^data:application\/json(;.*?)?;base64,(\S+)$/.exec(match[2]);
+            match = /^data:application\/json(;.*?)?;base64,([^,]+)$/.exec(match[2]);
             if (!match) break;
             return to_ascii(match[2]);
         }
@@ -76,16 +76,20 @@ function minify(files, options) {
             annotations: undefined,
             compress: {},
             enclose: false,
+            expression: false,
+            ie: false,
             ie8: false,
+            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,
@@ -94,19 +98,23 @@ 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) set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
-        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, [ "mangle", "output" ]);
+        if (options.expression) set_shorthand("expression", options, [ "compress", "parse" ]);
+        if (options.ie8) options.ie = options.ie || options.ie8;
+        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, {
                 cache: options.nameCache && (options.nameCache.vars || {}),
                 eval: false,
-                ie8: false,
+                ie: false,
+                keep_fargs: false,
                 keep_fnames: false,
                 properties: false,
                 reserved: [],
@@ -130,6 +138,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,
@@ -146,13 +155,11 @@ function minify(files, options) {
         }, options.warnings == "verbose");
         if (timings) timings.parse = Date.now();
         var toplevel;
-        if (files instanceof AST_Toplevel) {
+        options.parse = options.parse || {};
+        if (files instanceof AST_Node) {
             toplevel = files;
         } else {
-            if (typeof files == "string") {
-                files = [ files ];
-            }
-            options.parse = options.parse || {};
+            if (typeof files == "string") files = [ files ];
             options.parse.toplevel = null;
             var source_map_content = options.sourceMap && options.sourceMap.content;
             if (typeof source_map_content == "string" && source_map_content != "inline") {
@@ -164,17 +171,14 @@ function minify(files, options) {
                 options.parse.toplevel = toplevel = parse(files[name], options.parse);
                 if (source_map_content == "inline") {
                     var inlined_content = read_source_map(name, toplevel);
-                    if (inlined_content) {
-                        options.sourceMap.orig[name] = parse_source_map(inlined_content);
-                    }
+                    if (inlined_content) options.sourceMap.orig[name] = parse_source_map(inlined_content);
                 } else if (source_map_content) {
                     options.sourceMap.orig[name] = source_map_content;
                 }
             }
         }
-        if (quoted_props) {
-            reserve_quoted_keys(toplevel, quoted_props);
-        }
+        if (options.parse.expression) toplevel = toplevel.wrap_expression();
+        if (quoted_props) reserve_quoted_keys(toplevel, quoted_props);
         [ "enclose", "wrap" ].forEach(function(action) {
             var option = options[action];
             if (!option) return;
@@ -185,8 +189,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) {
@@ -202,29 +206,32 @@ function minify(files, options) {
         }
         if (timings) timings.properties = Date.now();
         if (options.mangle && options.mangle.properties) mangle_properties(toplevel, options.mangle.properties);
+        if (options.parse.expression) toplevel = toplevel.unwrap_expression();
         if (timings) timings.output = Date.now();
         var result = {};
-        if (options.output.ast) {
-            result.ast = toplevel;
-        }
-        if (!HOP(options.output, "code") || options.output.code) {
+        var output = defaults(options.output, {
+            ast: false,
+            code: true,
+        });
+        if (output.ast) result.ast = toplevel;
+        if (output.code) {
             if (options.sourceMap) {
-                options.output.source_map = SourceMap(options.sourceMap);
+                output.source_map = SourceMap(options.sourceMap);
                 if (options.sourceMap.includeSources) {
                     if (files instanceof AST_Toplevel) {
                         throw new Error("original source content unavailable");
                     } else for (var name in files) if (HOP(files, name)) {
-                        options.output.source_map.setSourceContent(name, files[name]);
+                        output.source_map.setSourceContent(name, files[name]);
                     }
                 }
             }
-            delete options.output.ast;
-            delete options.output.code;
-            var stream = OutputStream(options.output);
+            delete output.ast;
+            delete output.code;
+            var stream = OutputStream(output);
             toplevel.print(stream);
             result.code = stream.get();
             if (options.sourceMap) {
-                result.map = options.output.source_map.toString();
+                result.map = output.source_map.toString();
                 var url = options.sourceMap.url;
                 if (url) {
                     result.code = result.code.replace(/\n\/\/# sourceMappingURL=\S+\s*$/, "");

lib/parse.js

@@ -44,10 +44,10 @@
 
 "use strict";
 
-var KEYWORDS = "break case catch class const continue debugger default delete do else extends finally for function if in instanceof let new return switch throw try typeof var void while with";
+var KEYWORDS = "break case catch class const continue debugger default delete do else extends finally for function if in instanceof new return switch throw try typeof var void while with";
 var KEYWORDS_ATOM = "false null true";
 var RESERVED_WORDS = [
-    "abstract async await boolean byte char double enum export final float goto implements import int interface long native package private protected public short static super synchronized this throws transient volatile yield",
+    "abstract async await boolean byte char double enum export final float goto implements import int interface let long native package private protected public short static super synchronized this throws transient volatile yield",
     KEYWORDS_ATOM,
     KEYWORDS,
 ].join(" ");
@@ -124,7 +124,7 @@ var PUNC_AFTER_EXPRESSION = PUNC_SEPARATORS + PUNC_CLOSERS;
 var PUNC_BEFORE_EXPRESSION = PUNC_OPENERS + PUNC_SEPARATORS;
 var PUNC_CHARS = PUNC_BEFORE_EXPRESSION + "`" + PUNC_CLOSERS;
 var WHITESPACE_CHARS = NEWLINE_CHARS + " \u00a0\t\f\u000b\u200b\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\uFEFF";
-var NON_IDENTIFIER_CHARS = makePredicate(characters("./'\"" + OPERATOR_CHARS + PUNC_CHARS + WHITESPACE_CHARS));
+var NON_IDENTIFIER_CHARS = makePredicate(characters("./'\"#" + OPERATOR_CHARS + PUNC_CHARS + WHITESPACE_CHARS));
 
 NEWLINE_CHARS = makePredicate(characters(NEWLINE_CHARS));
 OPERATOR_CHARS = makePredicate(characters(OPERATOR_CHARS));
@@ -237,15 +237,14 @@ 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 (;;) {
-                var ch = next(true, true);
+                var ch = read();
                 switch (ch) {
                   case "\\":
-                    ch += next(true, true);
+                    ch += read();
                     break;
                   case "`":
                     strings.push(s);
@@ -260,6 +259,11 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
                 }
                 s += ch;
             }
+
+            function read() {
+                var ch = next(true, true);
+                return ch == "\r" ? "\n" : ch;
+            }
         }),
     };
     var prev_was_dot = false;
@@ -351,7 +355,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     function read_while(pred) {
         var ret = "", ch;
-        while ((ch = peek()) && pred(ch)) ret += next();
+        while ((ch = peek()) && pred(ch, ret)) ret += next();
         return ret;
     }
 
@@ -359,24 +363,27 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         js_error(err, filename, S.tokline, S.tokcol, S.tokpos);
     }
 
+    function is_octal(num) {
+        return /^0[0-7_]+$/.test(num);
+    }
+
     function read_num(prefix) {
         var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".";
-        var num = read_while(function(ch) {
-            var code = ch.charCodeAt(0);
-            switch (code) {
-              case 120: case 88: // xX
+        var num = read_while(function(ch, str) {
+            switch (ch) {
+              case "x": case "X":
                 return has_x ? false : (has_x = true);
-              case 101: case 69: // eE
+              case "e": case "E":
                 return has_x ? true : has_e ? false : (has_e = after_e = true);
-              case 43: case 45: // +-
+              case "+": case "-":
                 return after_e;
-              case (after_e = false, 46): // .
-                return (!has_dot && !has_x && !has_e) ? (has_dot = true) : false;
+              case (after_e = false, "."):
+                return has_dot || has_e || has_x || is_octal(str) ? false : (has_dot = true);
             }
-            return is_digit(code) || /[_0-9a-fo]/i.test(ch);
+            return /[_0-9a-dfo]/i.test(ch);
         });
         if (prefix) num = prefix + num;
-        if (/^0[0-7_]+$/.test(num)) {
+        if (is_octal(num)) {
             if (next_token.has_directive("use strict")) parse_error("Legacy octal literals are not allowed in strict mode");
         } else {
             num = num.replace(has_x ? /([1-9a-f]|.0)_(?=[0-9a-f])/gi : /([1-9]|.0)_(?=[0-9])/gi, "$1");
@@ -465,7 +472,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     });
 
     function read_name() {
-        var backslash = false, name = "", ch, escaped = false, hex;
+        var backslash = false, ch, escaped = false, name = peek() == "#" ? next() : "";
         while (ch = peek()) {
             if (!backslash) {
                 if (ch == "\\") escaped = backslash = true, next();
@@ -480,7 +487,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             }
         }
         if (KEYWORDS[name] && escaped) {
-            hex = name.charCodeAt(0).toString(16).toUpperCase();
+            var hex = name.charCodeAt(0).toString(16).toUpperCase();
             name = "\\u" + "0000".substr(hex.length) + hex + name.slice(1);
         }
         return name;
@@ -545,16 +552,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     function handle_dot() {
         next();
-        var ch = peek();
-        if (ch == ".") {
-            var op = ".";
-            do {
-                op += ".";
-                next();
-            } while (peek() == ".");
-            return token("operator", op);
-        }
-        return is_digit(ch.charCodeAt(0)) ? read_num(".") : token("punc", ".");
+        if (looking_at("..")) return token("operator", "." + next() + next());
+        return is_digit(peek().charCodeAt(0)) ? read_num(".") : token("punc", ".");
     }
 
     function read_word() {
@@ -615,7 +614,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             if (PUNC_CHARS[ch]) return token("punc", next());
             if (looking_at("=>")) return token("punc", next() + next());
             if (OPERATOR_CHARS[ch]) return read_operator();
-            if (code == 92 || !NON_IDENTIFIER_CHARS[ch]) return read_word();
+            if (code == 35 || code == 92 || !NON_IDENTIFIER_CHARS[ch]) return read_word();
             break;
         }
         parse_error("Unexpected character '" + ch + "'");
@@ -627,24 +626,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;
@@ -691,6 +685,7 @@ function parse($TEXT, options) {
         expression     : false,
         filename       : null,
         html5_comments : true,
+        module         : false,
         shebang        : true,
         strict         : false,
         toplevel       : null,
@@ -812,7 +807,7 @@ function parse($TEXT, options) {
         }
     }
 
-    var statement = embed_tokens(function() {
+    var statement = embed_tokens(function(toplevel) {
         handle_regexp();
         switch (S.token.type) {
           case "string":
@@ -851,13 +846,23 @@ function parse($TEXT, options) {
                 if (S.in_async) return simple_statement();
                 break;
               case "export":
+                if (!toplevel && options.module !== "") unexpected();
                 next();
                 return export_();
               case "import":
-                if (!is_token(peek(), "punc", "(")) {
+                var token = peek();
+                if (token.type == "punc" && /^[(.]$/.test(token.value)) break;
+                if (!toplevel && options.module !== "") unexpected();
+                next();
+                return import_();
+              case "let":
+                if (is_vardefs()) {
                     next();
-                    return import_();
+                    var node = let_();
+                    semicolon();
+                    return node;
                 }
+                break;
               case "yield":
                 if (S.in_generator) return simple_statement();
                 break;
@@ -943,12 +948,6 @@ function parse($TEXT, options) {
                 next();
                 return if_();
 
-              case "let":
-                next();
-                var node = let_();
-                semicolon();
-                return node;
-
               case "return":
                 if (S.in_function == 0 && !options.bare_returns)
                     croak("'return' outside of function");
@@ -1057,13 +1056,13 @@ function parse($TEXT, options) {
         return stat;
     }
 
-    function has_modifier(name) {
+    function has_modifier(name, no_nlb) {
         if (!is("name", name)) return;
         var token = peek();
         if (!token) return;
         if (is_token(token, "operator", "=")) return;
         if (token.type == "punc" && /^[(;}]$/.test(token.value)) return;
-        if (has_newline_before(token)) return;
+        if (no_nlb && has_newline_before(token)) return;
         return next();
     }
 
@@ -1093,7 +1092,7 @@ function parse($TEXT, options) {
             }
             var start = S.token;
             var fixed = !!has_modifier("static");
-            var async = has_modifier("async");
+            var async = has_modifier("async", true);
             if (is("operator", "*")) {
                 next();
                 var internal = is("name") && /^#/.test(S.token.value);
@@ -1112,6 +1111,18 @@ function parse($TEXT, options) {
                 }));
                 continue;
             }
+            if (fixed && is("punc", "{")) {
+                props.push(new AST_ClassInit({
+                    start: start,
+                    value: new AST_ClassInitBlock({
+                        start: start,
+                        body: block_(),
+                        end: prev(),
+                    }),
+                    end: prev(),
+                }));
+                continue;
+            }
             var internal = is("name") && /^#/.test(S.token.value);
             var key = as_property_key();
             if (is("punc", "(")) {
@@ -1182,19 +1193,19 @@ function parse($TEXT, options) {
     }
 
     function for_() {
-        var await = is("name", "await") && next();
+        var await_token = is("name", "await") && next();
         expect("(");
         var init = null;
-        if (!is("punc", ";")) {
+        if (await_token || !is("punc", ";")) {
             init = is("keyword", "const")
                 ? (next(), const_(true))
-                : is("keyword", "let")
+                : is("name", "let") && is_vardefs()
                 ? (next(), let_(true))
                 : is("keyword", "var")
                 ? (next(), var_(true))
                 : expression(true);
             var ctor;
-            if (await) {
+            if (await_token) {
                 expect_token("name", "of");
                 ctor = AST_ForAwaitOf;
             } else if (is("operator", "in")) {
@@ -1236,6 +1247,7 @@ function parse($TEXT, options) {
     }
 
     function for_enum(ctor, init) {
+        handle_regexp();
         var obj = expression();
         expect(")");
         return new ctor({
@@ -1303,6 +1315,11 @@ function parse($TEXT, options) {
         }
         if (node instanceof AST_SymbolFunarg) return node;
         if (node instanceof AST_SymbolRef) return new AST_SymbolFunarg(node);
+        if (node instanceof AST_Yield) return new AST_SymbolFunarg({
+            start: node.start,
+            name: "yield",
+            end: node.end,
+        });
         token_error(node.start, "Invalid arrow parameter");
     }
 
@@ -1322,28 +1339,26 @@ function parse($TEXT, options) {
         var loop = S.in_loop;
         var labels = S.labels;
         ++S.in_function;
-        S.in_directives = true;
         S.input.push_directives_stack();
         S.in_loop = 0;
         S.labels = [];
         if (is("punc", "{")) {
+            S.in_directives = true;
             body = block_();
             value = null;
-            if (S.input.has_directive("use strict")) {
-                argnames.forEach(strict_verify_symbol);
-            }
         } else {
             body = [];
             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;
         S.in_generator = was_gen;
         S.in_async = was_async;
-        return new (async ? AST_AsyncArrow : AST_Arrow)({
+        var node = new (async ? AST_AsyncArrow : AST_Arrow)({
             start: start,
             argnames: argnames,
             rest: rest,
@@ -1351,6 +1366,8 @@ function parse($TEXT, options) {
             value: value,
             end: prev(),
         });
+        if (is_strict) node.each_argname(strict_verify_symbol);
+        return node;
     }
 
     var function_ = function(ctor) {
@@ -1383,23 +1400,24 @@ function parse($TEXT, options) {
         S.in_loop = 0;
         S.labels = [];
         var body = block_();
-        if (S.input.has_directive("use strict")) {
-            if (name) strict_verify_symbol(name);
-            argnames.forEach(strict_verify_symbol);
-            if (argnames.rest) strict_verify_symbol(argnames.rest);
-        }
+        var is_strict = S.input.has_directive("use strict");
         S.input.pop_directives_stack();
         --S.in_function;
         S.in_loop = loop;
         S.labels = labels;
         S.in_generator = was_gen;
         S.in_async = was_async;
-        return new ctor({
+        var node = new ctor({
             name: name,
             argnames: argnames,
             rest: argnames.rest || null,
-            body: body
+            body: body,
         });
+        if (is_strict) {
+            if (name) strict_verify_symbol(name);
+            node.each_argname(strict_verify_symbol);
+        }
+        return node;
     };
 
     function if_() {
@@ -1416,28 +1434,41 @@ function parse($TEXT, options) {
     }
 
     function is_alias() {
-        return is("name") || is_identifier_string(S.token.value);
+        return is("name") || is("string") || is_identifier_string(S.token.value);
+    }
+
+    function make_string(token) {
+        return new AST_String({
+            start: token,
+            quote: token.quote,
+            value: token.value,
+            end: token,
+        });
+    }
+
+    function as_path() {
+        var path = S.token;
+        expect_token("string");
+        semicolon();
+        return make_string(path);
     }
 
     function export_() {
         if (is("operator", "*")) {
+            var key = S.token;
+            var alias = key;
             next();
-            var alias = "*";
             if (is("name", "as")) {
                 next();
                 if (!is_alias()) expect_token("name");
-                alias = S.token.value;
+                alias = S.token;
                 next();
             }
             expect_token("name", "from");
-            var path = S.token;
-            expect_token("string");
-            semicolon();
             return new AST_ExportForeign({
-                aliases: [ alias ],
-                keys: [ "*" ],
-                path: path.value,
-                quote: path.quote,
+                aliases: [ make_string(alias) ],
+                keys: [ make_string(key) ],
+                path: as_path(),
             });
         }
         if (is("punc", "{")) {
@@ -1451,26 +1482,20 @@ function parse($TEXT, options) {
                 if (is("name", "as")) {
                     next();
                     if (!is_alias()) expect_token("name");
-                    aliases.push(S.token.value);
+                    aliases.push(S.token);
                     next();
                 } else {
-                    aliases.push(key.value);
+                    aliases.push(key);
                 }
                 if (!is("punc", "}")) expect(",");
             }
             expect("}");
             if (is("name", "from")) {
                 next();
-                var path = S.token;
-                expect_token("string");
-                semicolon();
                 return new AST_ExportForeign({
-                    aliases: aliases,
-                    keys: keys.map(function(token) {
-                        return token.value;
-                    }),
-                    path: path.value,
-                    quote: path.quote,
+                    aliases: aliases.map(make_string),
+                    keys: keys.map(make_string),
+                    path: as_path(),
                 });
             }
             semicolon();
@@ -1478,7 +1503,7 @@ function parse($TEXT, options) {
                 properties: keys.map(function(token, index) {
                     if (!is_token(token, "name")) token_error(token, "Name expected");
                     var sym = _make_symbol(AST_SymbolExport, token);
-                    sym.alias = aliases[index];
+                    sym.alias = make_string(aliases[index]);
                     return sym;
                 }),
             });
@@ -1491,6 +1516,7 @@ function parse($TEXT, options) {
                 body.start = start;
                 body.end = prev();
             } else {
+                handle_regexp();
                 body = expression();
                 semicolon();
             }
@@ -1528,12 +1554,18 @@ function parse($TEXT, options) {
     }
 
     var export_decl = embed_tokens(function() {
-        if (is("name", "async")) {
+        if (is("name")) switch (S.token.value) {
+          case "async":
             next();
             expect_token("keyword", "function");
             if (!is("operator", "*")) return function_(AST_AsyncDefun);
             next();
             return function_(AST_AsyncGeneratorDefun);
+          case "let":
+            next();
+            var node = let_();
+            semicolon();
+            return node;
         } else if (is("keyword")) switch (S.token.value) {
           case "class":
             next();
@@ -1548,11 +1580,6 @@ function parse($TEXT, options) {
             if (!is("operator", "*")) return function_(AST_Defun);
             next();
             return function_(AST_GeneratorDefun);
-          case "let":
-            next();
-            var node = let_();
-            semicolon();
-            return node;
           case "var":
             next();
             var node = var_();
@@ -1566,26 +1593,42 @@ function parse($TEXT, options) {
         var all = null;
         var def = as_symbol(AST_SymbolImport, true);
         var props = null;
-        if (def ? (def.key = "", is("punc", ",") && next()) : !is("string")) {
+        var cont;
+        if (def) {
+            def.key = new AST_String({
+                start: def.start,
+                value: "",
+                end: def.end,
+            });
+            if (cont = is("punc", ",")) next();
+        } else {
+            cont = !is("string");
+        }
+        if (cont) {
             if (is("operator", "*")) {
+                var key = S.token;
                 next();
                 expect_token("name", "as");
                 all = as_symbol(AST_SymbolImport);
-                all.key = "*";
+                all.key = make_string(key);
             } else {
                 expect("{");
                 props = [];
                 while (is_alias()) {
                     var alias;
                     if (is_token(peek(), "name", "as")) {
-                        var key = S.token.value;
+                        var key = S.token;
                         next();
                         next();
                         alias = as_symbol(AST_SymbolImport);
-                        alias.key = key;
+                        alias.key = make_string(key);
                     } else {
                         alias = as_symbol(AST_SymbolImport);
-                        alias.key = alias.name;
+                        alias.key = new AST_String({
+                            start: alias.start,
+                            value: alias.name,
+                            end: alias.end,
+                        });
                     }
                     props.push(alias);
                     if (!is("punc", "}")) expect(",");
@@ -1594,15 +1637,11 @@ function parse($TEXT, options) {
             }
         }
         if (all || def || props) expect_token("name", "from");
-        var path = S.token;
-        expect_token("string");
-        semicolon();
         return new AST_Import({
             all: all,
             default: def,
-            path: path.value,
+            path: as_path(),
             properties: props,
-            quote: path.quote,
         });
     }
 
@@ -1713,6 +1752,11 @@ function parse($TEXT, options) {
         return a;
     }
 
+    function is_vardefs() {
+        var token = peek();
+        return is_token(token, "name") || is_token(token, "punc", "[") || is_token(token, "punc", "{");
+    }
+
     var const_ = function(no_in) {
         return new AST_Const({
             start       : prev(),
@@ -1775,7 +1819,7 @@ function parse($TEXT, options) {
             ret = new AST_BigInt({ value: value });
             break;
           case "string":
-            ret = new AST_String({ value : value, quote : tok.quote });
+            ret = new AST_String({ value: value, quote: tok.quote });
             break;
           case "regexp":
             ret = new AST_RegExp({ value: value });
@@ -1811,10 +1855,7 @@ function parse($TEXT, options) {
         if (is("punc")) {
             switch (start.value) {
               case "`":
-                var tmpl = template(null);
-                tmpl.start = start;
-                tmpl.end = prev();
-                return subscripts(tmpl, allow_calls);
+                return subscripts(template(null), allow_calls);
               case "(":
                 next();
                 if (is("punc", ")")) {
@@ -2126,7 +2167,7 @@ function parse($TEXT, options) {
     }
 
     function strict_verify_symbol(sym) {
-        if (sym.name == "arguments" || sym.name == "eval")
+        if (sym.name == "arguments" || sym.name == "eval" || sym.name == "let")
             token_error(sym.start, "Unexpected " + sym.name + " in strict mode");
     }
 
@@ -2223,6 +2264,7 @@ function parse($TEXT, options) {
     }
 
     function template(tag) {
+        var start = tag ? tag.start : S.token;
         var read = S.input.context().read_template;
         var strings = [];
         var expressions = [];
@@ -2233,64 +2275,73 @@ function parse($TEXT, options) {
         }
         next();
         return new AST_Template({
+            start: start,
             expressions: expressions,
             strings: strings,
             tag: tag,
+            end: prev(),
         });
     }
 
-    var subscripts = function(expr, allow_calls) {
+    function subscripts(expr, allow_calls) {
         var start = expr.start;
-        if (is("punc", ".")) {
-            next();
-            return subscripts(new AST_Dot({
-                start      : start,
-                expression : expr,
-                property   : as_name(),
-                end        : prev()
-            }), allow_calls);
-        }
-        if (is("punc", "[")) {
-            next();
-            var prop = expression();
-            expect("]");
-            return subscripts(new AST_Sub({
-                start      : start,
-                expression : expr,
-                property   : prop,
-                end        : prev()
-            }), allow_calls);
-        }
-        if (allow_calls && is("punc", "(")) {
-            next();
-            var call = new AST_Call({
-                start      : start,
-                expression : expr,
-                args       : expr_list(")", !options.strict),
-                end        : prev()
-            });
-            return subscripts(call, true);
-        }
-        if (is("punc", "`")) {
-            var tmpl = template(expr);
-            tmpl.start = expr.start;
-            tmpl.end = prev();
-            return subscripts(tmpl, allow_calls);
+        var optional = null;
+        while (true) {
+            if (is("operator", "?") && is_token(peek(), "punc", ".")) {
+                next();
+                next();
+                optional = expr;
+            }
+            if (is("punc", "[")) {
+                next();
+                var prop = expression();
+                expect("]");
+                expr = new AST_Sub({
+                    start: start,
+                    optional: optional === expr,
+                    expression: expr,
+                    property: prop,
+                    end: prev(),
+                });
+            } else if (allow_calls && is("punc", "(")) {
+                next();
+                expr = new AST_Call({
+                    start: start,
+                    optional: optional === expr,
+                    expression: expr,
+                    args: expr_list(")", !options.strict),
+                    end: prev(),
+                });
+            } else if (optional === expr || is("punc", ".")) {
+                if (optional !== expr) next();
+                expr = new AST_Dot({
+                    start: start,
+                    optional: optional === expr,
+                    expression: expr,
+                    property: as_name(),
+                    end: prev(),
+                });
+            } else if (is("punc", "`")) {
+                if (optional) croak("Invalid template on optional chain");
+                expr = template(expr);
+            } else {
+                break;
+            }
         }
+        if (optional) expr.terminal = true;
         if (expr instanceof AST_Call && !expr.pure) {
             var start = expr.start;
             var comments = start.comments_before;
             var i = HOP(start, "comments_before_length") ? start.comments_before_length : comments.length;
             while (--i >= 0) {
-                var match = /[@#]__PURE__/.exec(comments[i].value);
-                if (match) {
-                    expr.pure = match[0];
+                if (/[@#]__PURE__/.test(comments[i].value)) {
+                    expr.pure = true;
                     break;
                 }
             }
         }
         return expr;
-    };
+    }
 
     function maybe_unary(no_in) {
         var start = S.token;
@@ -2399,7 +2450,7 @@ function parse($TEXT, options) {
     };
 
     function is_assignable(expr) {
-        return expr instanceof AST_PropAccess || expr instanceof AST_SymbolRef;
+        return expr instanceof AST_PropAccess && !expr.optional || expr instanceof AST_SymbolRef;
     }
 
     function to_destructured(node) {
@@ -2517,11 +2568,15 @@ function parse($TEXT, options) {
     return function() {
         var start = S.token;
         var body = [];
+        if (options.module) {
+            S.in_async = true;
+            S.input.add_directive("use strict");
+        }
         S.input.push_directives_stack();
         while (!is("eof"))
-            body.push(statement());
+            body.push(statement(true));
         S.input.pop_directives_stack();
-        var end = prev();
+        var end = prev() || start;
         var toplevel = options.toplevel;
         if (toplevel) {
             toplevel.body = toplevel.body.concat(body);

lib/propmangle.js

@@ -43,10 +43,11 @@
 
 "use strict";
 
-var builtins = function() {
-    var names = [];
-    // NaN will be included due to Number.NaN
+function get_builtins() {
+    var names = new Dictionary();
+    // constants
     [
+        "NaN",
         "null",
         "true",
         "false",
@@ -54,34 +55,78 @@ var builtins = function() {
         "-Infinity",
         "undefined",
     ].forEach(add);
+    // global functions
     [
-        Array,
-        Boolean,
-        Date,
-        Error,
-        Function,
-        Math,
-        Number,
-        Object,
-        RegExp,
-        String,
-    ].forEach(function(ctor) {
+        "encodeURI",
+        "encodeURIComponent",
+        "escape",
+        "eval",
+        "decodeURI",
+        "decodeURIComponent",
+        "isFinite",
+        "isNaN",
+        "parseFloat",
+        "parseInt",
+        "unescape",
+    ].forEach(add);
+    // global constructors & objects
+    var global = Function("return this")();
+    [
+        "Array",
+        "ArrayBuffer",
+        "Atomics",
+        "BigInt",
+        "Boolean",
+        "console",
+        "DataView",
+        "Date",
+        "Error",
+        "Function",
+        "Int8Array",
+        "Intl",
+        "JSON",
+        "Map",
+        "Math",
+        "Number",
+        "Object",
+        "Promise",
+        "Proxy",
+        "Reflect",
+        "RegExp",
+        "Set",
+        "String",
+        "Symbol",
+        "WebAssembly",
+    ].forEach(function(name) {
+        add(name);
+        var ctor = global[name];
+        if (!ctor) return;
         Object.getOwnPropertyNames(ctor).map(add);
-        if (ctor.prototype) {
+        if (typeof ctor != "function") return;
+        if (ctor.__proto__) Object.getOwnPropertyNames(ctor.__proto__).map(add);
+        if (ctor.prototype) Object.getOwnPropertyNames(ctor.prototype).map(add);
+        try {
             Object.getOwnPropertyNames(new ctor()).map(add);
-            Object.getOwnPropertyNames(ctor.prototype).map(add);
+        } catch (e) {
+            try {
+                Object.getOwnPropertyNames(ctor()).map(add);
+            } catch (e) {}
         }
     });
-    return makePredicate(names);
+    return (get_builtins = function() {
+        return names.clone();
+    })();
 
     function add(name) {
-        names.push(name);
+        names.set(name, true);
     }
-}();
+}
 
 function reserve_quoted_keys(ast, reserved) {
     ast.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_ObjectProperty) {
+        if (node instanceof AST_ClassProperty) {
+            if (node.start && node.start.quote) add(node.key);
+        } else if (node instanceof AST_ObjectProperty) {
             if (node.start && node.start.quote) add(node.key);
         } else if (node instanceof AST_Sub) {
             addStrings(node.property, add);
@@ -114,9 +159,9 @@ function mangle_properties(ast, options) {
         reserved: null,
     }, true);
 
-    var reserved = Object.create(options.builtins ? null : builtins);
+    var reserved = options.builtins ? new Dictionary() : get_builtins();
     if (Array.isArray(options.reserved)) options.reserved.forEach(function(name) {
-        reserved[name] = true;
+        reserved.set(name, true);
     });
 
     var cname = -1;
@@ -124,7 +169,7 @@ function mangle_properties(ast, options) {
     if (options.cache) {
         cache = options.cache.props;
         cache.each(function(name) {
-            reserved[name] = true;
+            reserved.set(name, true);
         });
     } else {
         cache = new Dictionary();
@@ -139,8 +184,8 @@ function mangle_properties(ast, options) {
     var debug_suffix;
     if (debug) debug_suffix = options.debug === true ? "" : options.debug;
 
-    var names_to_mangle = Object.create(null);
-    var unmangleable = Object.create(reserved);
+    var names_to_mangle = new Dictionary();
+    var unmangleable = reserved.clone();
 
     // step 1: find candidates to mangle
     ast.walk(new TreeWalker(function(node) {
@@ -163,6 +208,8 @@ function mangle_properties(ast, options) {
                 addStrings(node.args[0], add);
                 break;
             }
+        } else if (node instanceof AST_ClassProperty) {
+            if (typeof node.key == "string") add(node.key);
         } else if (node instanceof AST_Dot) {
             add(node.property);
         } else if (node instanceof AST_ObjectProperty) {
@@ -193,6 +240,8 @@ function mangle_properties(ast, options) {
                 mangleStrings(node.args[0]);
                 break;
             }
+        } else if (node instanceof AST_ClassProperty) {
+            if (typeof node.key == "string") node.key = mangle(node.key);
         } else if (node instanceof AST_Dot) {
             node.property = mangle(node.property);
         } else if (node instanceof AST_ObjectProperty) {
@@ -205,26 +254,24 @@ function mangle_properties(ast, options) {
     // only function declarations after this line
 
     function can_mangle(name) {
-        if (unmangleable[name]) return false;
+        if (unmangleable.has(name)) return false;
         if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false;
         return true;
     }
 
     function should_mangle(name) {
-        if (reserved[name]) return false;
+        if (reserved.has(name)) return false;
         if (regex && !regex.test(name)) return false;
-        return cache.has(name) || names_to_mangle[name];
+        return cache.has(name) || names_to_mangle.has(name);
     }
 
     function add(name) {
-        if (can_mangle(name)) names_to_mangle[name] = true;
-        if (!should_mangle(name)) unmangleable[name] = true;
+        if (can_mangle(name)) names_to_mangle.set(name, true);
+        if (!should_mangle(name)) unmangleable.set(name, true);
     }
 
     function mangle(name) {
-        if (!should_mangle(name)) {
-            return name;
-        }
+        if (!should_mangle(name)) return name;
         var mangled = cache.get(name);
         if (!mangled) {
             if (debug) {
@@ -236,6 +283,7 @@ function mangle_properties(ast, options) {
             if (!mangled) do {
                 mangled = base54(++cname);
             } while (!can_mangle(mangled));
+            if (/^#/.test(name)) mangled = "#" + mangled;
             cache.set(name, mangled);
         }
         return mangled;

lib/scope.js

@@ -44,9 +44,9 @@
 "use strict";
 
 function SymbolDef(id, scope, orig, init) {
+    this._bits = 0;
+    this.defun = undefined;
     this.eliminated = 0;
-    this.exported = false;
-    this.global = false;
     this.id = id;
     this.init = init;
     this.mangled_name = null;
@@ -54,8 +54,8 @@ function SymbolDef(id, scope, orig, init) {
     this.orig = [ orig ];
     this.references = [];
     this.replaced = 0;
+    this.safe_ids = undefined;
     this.scope = scope;
-    this.undeclared = false;
 }
 
 SymbolDef.prototype = {
@@ -64,45 +64,64 @@ 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() {
-        var scope = this.defun;
+        var self = this;
+        var scope = self.defun;
         if (!scope) return;
-        var name = this.name;
+        var name = self.name;
         var def = scope.variables.get(name)
             || scope instanceof AST_Toplevel && scope.globals.get(name)
-            || this.orig[0] instanceof AST_SymbolConst && find_if(function(def) {
+            || self.orig[0] instanceof AST_SymbolConst && find_if(function(def) {
                 return def.name == name;
             }, scope.enclosed);
-        if (def && def !== this) return def.redefined() || def;
+        if (def && def !== self) return def.redefined() || def;
     },
     unmangleable: function(options) {
-        return this.global && !options.toplevel
-            || this.exported
-            || this.undeclared
-            || !options.eval && this.scope.pinned()
-            || options.keep_fnames
-                && (this.orig[0] instanceof AST_SymbolClass
-                    || this.orig[0] instanceof AST_SymbolDefClass
-                    || this.orig[0] instanceof AST_SymbolDefun
-                    || this.orig[0] instanceof AST_SymbolLambda);
+        if (this.exported) return true;
+        if (this.undeclared) return true;
+        if (!options.eval && this.scope.pinned()) return true;
+        if (options.keep_fargs && is_funarg(this)) return true;
+        if (options.keep_fnames) {
+            var sym = this.orig[0];
+            if (sym instanceof AST_SymbolClass) return true;
+            if (sym instanceof AST_SymbolDefClass) return true;
+            if (sym instanceof AST_SymbolDefun) return true;
+            if (sym instanceof AST_SymbolLambda) return true;
+        }
+        if (!options.toplevel && this.global) return true;
+        return false;
     },
 };
 
+DEF_BITPROPS(SymbolDef, [
+    "const_redefs",
+    "cross_loop",
+    "direct_access",
+    "exported",
+    "global",
+    "undeclared",
+]);
+
+function is_funarg(def) {
+    return def.orig[0] instanceof AST_SymbolFunarg || def.orig[1] instanceof AST_SymbolFunarg;
+}
+
 var unary_side_effects = makePredicate("delete ++ --");
 
 function is_lhs(node, parent) {
@@ -117,7 +136,7 @@ function is_lhs(node, parent) {
 AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     options = defaults(options, {
         cache: null,
-        ie8: false,
+        ie: false,
     });
 
     // pass 1: setup scope chaining and handle definitions
@@ -204,20 +223,17 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         } else if (node instanceof AST_SymbolDefun) {
             var def = defun.def_function(node, tw.parent());
             if (exported) def.exported = true;
-            entangle(defun, scope);
         } else if (node instanceof AST_SymbolFunarg) {
             defun.def_variable(node);
-            entangle(defun, scope);
         } else if (node instanceof AST_SymbolLambda) {
             var def = defun.def_function(node, node.name == "arguments" ? undefined : defun);
-            if (options.ie8) def.defun = defun.parent_scope.resolve();
+            if (options.ie && node.name != "arguments") def.defun = defun.parent_scope.resolve();
         } else if (node instanceof AST_SymbolLet) {
             var def = scope.def_variable(node);
             if (exported) def.exported = true;
         } else if (node instanceof AST_SymbolVar) {
             var def = defun.def_variable(node, node instanceof AST_SymbolImport ? undefined : null);
             if (exported) def.exported = true;
-            entangle(defun, scope);
         }
 
         function walk_scope(descend) {
@@ -230,16 +246,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             scope = save_scope;
             defun = save_defun;
         }
-
-        function entangle(defun, scope) {
-            if (defun === scope) return;
-            node.mark_enclosed(options);
-            var def = scope.find_variable(node.name);
-            if (node.thedef === def) return;
-            node.thedef = def;
-            def.orig.push(node);
-            node.mark_enclosed(options);
-        }
     });
     self.make_def = function(orig, init) {
         return new SymbolDef(++next_def_id, this, orig, init);
@@ -260,6 +266,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         }
         if (node instanceof AST_Lambda) {
             in_arg.push(node);
+            if (node.name) node.name.walk(tw);
             node.argnames.forEach(function(argname) {
                 argname.walk(tw);
             });
@@ -273,17 +280,29 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             return true;
         }
         if (node instanceof AST_SymbolDeclaration) {
+            var def = node.definition();
+            def.preinit = def.references.length;
             if (node instanceof AST_SymbolCatch) {
                 // ensure mangling works if `catch` reuses a scope variable
-                var def = node.definition().redefined();
-                if (def) for (var s = node.scope; s; s = s.parent_scope) {
-                    push_uniq(s.enclosed, def);
-                    if (s === def.scope) break;
+                var redef = def.redefined();
+                if (redef) for (var s = node.scope; s; s = s.parent_scope) {
+                    if (!push_uniq(s.enclosed, redef)) break;
+                    if (s === redef.scope) break;
                 }
             } else if (node instanceof AST_SymbolConst) {
                 // ensure compression works if `const` reuses a scope variable
-                var redef = node.definition().redefined();
+                var redef = def.redefined();
                 if (redef) redef.const_redefs = true;
+            } else if (def.scope !== node.scope && (node instanceof AST_SymbolDefun
+                || node instanceof AST_SymbolFunarg
+                || node instanceof AST_SymbolVar)) {
+                node.mark_enclosed(options);
+                var redef = node.scope.find_variable(node.name);
+                if (node.thedef !== redef) {
+                    node.thedef = redef;
+                    redef.orig.push(node);
+                    node.mark_enclosed(options);
+                }
             }
             if (node.name != "arguments") return true;
             var parent = node instanceof AST_SymbolVar && tw.parent();
@@ -348,7 +367,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     self.walk(tw);
 
     // pass 3: fix up any scoping issue with IE8
-    if (options.ie8) self.walk(new TreeWalker(function(node) {
+    if (options.ie) self.walk(new TreeWalker(function(node) {
         if (node instanceof AST_SymbolCatch) {
             var scope = node.thedef.defun;
             if (scope.name instanceof AST_SymbolLambda && scope.name.name == node.name) {
@@ -360,7 +379,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         if (node instanceof AST_SymbolLambda) {
             var def = node.thedef;
             if (!redefine(node, node.scope.parent_scope.resolve())) {
-                delete def.defun;
+                def.defun = undefined;
             } else if (typeof node.thedef.init !== "undefined") {
                 node.thedef.init = false;
             } else if (def.init) {
@@ -394,13 +413,14 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         } else {
             new_def = scope.def_variable(node);
         }
+        if (new_def.undeclared) self.variables.set(name, new_def);
+        if (name == "arguments" && is_arguments(old_def) && node instanceof AST_SymbolLambda) return true;
         old_def.defun = new_def.scope;
         old_def.forEach(function(node) {
             node.redef = old_def;
             node.thedef = new_def;
             node.reference(options);
         });
-        if (new_def.undeclared) self.variables.set(name, new_def);
         return true;
     }
 });
@@ -450,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,
     }));
@@ -459,11 +480,14 @@ AST_Lambda.DEFMETHOD("init_vars", function(parent_scope) {
 AST_Symbol.DEFMETHOD("mark_enclosed", function(options) {
     var def = this.definition();
     for (var s = this.scope; s; s = s.parent_scope) {
-        push_uniq(s.enclosed, def);
+        if (!push_uniq(s.enclosed, def)) break;
         if (!options) {
-            delete s._var_names;
-        } else if (options.keep_fnames) {
-            s.functions.each(function(d) {
+            s._var_names = undefined;
+        } else {
+            if (options.keep_fargs && s instanceof AST_Lambda) s.each_argname(function(arg) {
+                push_uniq(def.scope.enclosed, arg.definition());
+            });
+            if (options.keep_fnames) s.functions.each(function(d) {
                 push_uniq(def.scope.enclosed, d);
             });
         }
@@ -506,12 +530,12 @@ function names_in_use(scope, options) {
     if (!names) {
         scope.cname = -1;
         scope.cname_holes = [];
-        scope.names_in_use = names = Object.create(null);
+        scope.names_in_use = names = new Dictionary();
         var cache = options.cache && options.cache.props;
         scope.enclosed.forEach(function(def) {
-            if (def.unmangleable(options)) names[def.name] = true;
+            if (def.unmangleable(options)) names.set(def.name, true);
             if (def.global && cache && cache.has(def.name)) {
-                names[cache.get(def.name)] = true;
+                names.set(cache.get(def.name), true);
             }
         });
     }
@@ -522,34 +546,33 @@ function next_mangled_name(def, options) {
     var scope = def.scope;
     var in_use = names_in_use(scope, options);
     var holes = scope.cname_holes;
-    var names = Object.create(null);
+    var names = new Dictionary();
     var scopes = [ scope ];
     def.forEach(function(sym) {
         var scope = sym.scope;
         do {
-            if (scopes.indexOf(scope) < 0) {
-                for (var name in names_in_use(scope, options)) {
-                    names[name] = true;
-                }
-                scopes.push(scope);
-            } else break;
+            if (member(scope, scopes)) break;
+            names_in_use(scope, options).each(function(marker, name) {
+                names.set(name, marker);
+            });
+            scopes.push(scope);
         } while (scope = scope.parent_scope);
     });
     var name;
     for (var i = 0; i < holes.length; i++) {
         name = base54(holes[i]);
-        if (names[name]) continue;
+        if (names.has(name)) continue;
         holes.splice(i, 1);
-        in_use[name] = true;
+        in_use.set(name, true);
         return name;
     }
     while (true) {
         name = base54(++scope.cname);
-        if (in_use[name] || RESERVED_WORDS[name] || options.reserved.has[name]) continue;
-        if (!names[name]) break;
+        if (in_use.has(name) || RESERVED_WORDS[name] || options.reserved.has[name]) continue;
+        if (!names.has(name)) break;
         holes.push(scope.cname);
     }
-    in_use[name] = true;
+    in_use.set(name, true);
     return name;
 }
 
@@ -568,7 +591,8 @@ AST_Symbol.DEFMETHOD("definition", function() {
 function _default_mangler_options(options) {
     options = defaults(options, {
         eval        : false,
-        ie8         : false,
+        ie          : false,
+        keep_fargs  : false,
         keep_fnames : false,
         reserved    : [],
         toplevel    : false,
@@ -576,38 +600,32 @@ function _default_mangler_options(options) {
         webkit      : false,
     });
     if (!Array.isArray(options.reserved)) options.reserved = [];
-    // Never mangle arguments
+    // Never mangle `arguments`
     push_uniq(options.reserved, "arguments");
     options.reserved.has = makePredicate(options.reserved);
     return options;
 }
 
+// We only need to mangle declaration nodes. Special logic wired into the code
+// generator will display the mangled name if it is present (and for
+// `AST_SymbolRef`s it will use the mangled name of the `AST_SymbolDeclaration`
+// that it points to).
 AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
     options = _default_mangler_options(options);
-
-    // We only need to mangle declaration nodes.  Special logic wired
-    // into the code generator will display the mangled name if it's
-    // present (and for AST_SymbolRef-s it'll use the mangled name of
-    // the AST_SymbolDeclaration that it points to).
-    var lname = -1;
-
     if (options.cache && options.cache.props) {
         var mangled_names = names_in_use(this, options);
         options.cache.props.each(function(mangled_name) {
-            mangled_names[mangled_name] = true;
+            mangled_names.set(mangled_name, true);
         });
     }
-
+    var cutoff = 36;
+    var lname = -1;
     var redefined = [];
     var tw = new TreeWalker(function(node, descend) {
-        if (node instanceof AST_LabeledStatement) {
-            // lname is incremented when we get to the AST_Label
-            var save_nesting = lname;
-            descend();
-            if (!options.v8 || !in_label(tw)) lname = save_nesting;
-            return true;
-        }
+        var save_nesting;
         if (node instanceof AST_BlockScope) {
+            // `lname` is incremented when we get to the `AST_Label`
+            if (node instanceof AST_LabeledStatement) save_nesting = lname;
             if (options.webkit && node instanceof AST_IterationStatement && node.init instanceof AST_Let) {
                 node.init.definitions.forEach(function(defn) {
                     defn.name.match_symbol(function(sym) {
@@ -623,9 +641,9 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
                     });
                 }, true);
             }
-            node.to_mangle = [];
+            var to_mangle = node.to_mangle = [];
             node.variables.each(function(def) {
-                if (!defer_redef(def)) node.to_mangle.push(def);
+                if (!defer_redef(def)) to_mangle.push(def);
             });
             descend();
             if (options.cache && node instanceof AST_Toplevel) {
@@ -636,7 +654,24 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
                 sym.scope = node;
                 sym.reference(options);
             }
-            node.to_mangle.forEach(mangle);
+            if (to_mangle.length > cutoff) {
+                var indices = to_mangle.map(function(def, index) {
+                    return index;
+                }).sort(function(i, j) {
+                    return to_mangle[j].references.length - to_mangle[i].references.length || i - j;
+                });
+                to_mangle = indices.slice(0, cutoff).sort(function(i, j) {
+                    return i - j;
+                }).map(function(index) {
+                    return to_mangle[index];
+                }).concat(indices.slice(cutoff).sort(function(i, j) {
+                    return i - j;
+                }).map(function(index) {
+                    return to_mangle[index];
+                }));
+            }
+            to_mangle.forEach(mangle);
+            if (node instanceof AST_LabeledStatement && !(options.v8 && in_label(tw))) lname = save_nesting;
             return true;
         }
         if (node instanceof AST_Label) {
@@ -669,7 +704,12 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
         }
         redefined.push(def);
         def.references.forEach(reference);
-        if (sym instanceof AST_SymbolCatch || sym instanceof AST_SymbolConst) reference(sym);
+        if (sym instanceof AST_SymbolCatch || sym instanceof AST_SymbolConst) {
+            reference(sym);
+            def.redefined = function() {
+                return redef;
+            };
+        }
         return true;
 
         function reference(sym) {
@@ -798,6 +838,7 @@ var base54 = (function() {
     var leading = init("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_");
     var chars, frequency;
     function reset() {
+        chars = null;
         frequency = Object.create(freq);
     }
     base54.consider = function(str, delta) {
@@ -809,19 +850,15 @@ var base54 = (function() {
         return frequency[b] - frequency[a];
     }
     base54.sort = function() {
-        chars = leading.sort(compare).concat(digits.sort(compare));
+        chars = leading.sort(compare).concat(digits).sort(compare);
     };
     base54.reset = reset;
     reset();
     function base54(num) {
-        var ret = "", base = 54;
-        num++;
-        do {
-            num--;
-            ret += chars[num % base];
-            num = Math.floor(num / base);
-            base = 64;
-        } while (num > 0);
+        var ret = leading[num % 54];
+        for (num = Math.floor(num / 54); --num >= 0; num >>= 6) {
+            ret += chars[num & 0x3F];
+        }
         return ret;
     }
     return base54;

lib/sourcemap.js

@@ -77,21 +77,23 @@ function vlq_encode(num) {
 }
 
 function create_array_map() {
-    var map = Object.create(null);
+    var map = new Dictionary();
     var array = [];
     array.index = function(name) {
-        if (!HOP(map, name)) {
-            map[name] = array.length;
+        var index = map.get(name);
+        if (!(index >= 0)) {
+            index = array.length;
             array.push(name);
+            map.set(name, index);
         }
-        return map[name];
+        return index;
     };
     return array;
 }
 
 function SourceMap(options) {
     var sources = create_array_map();
-    var sources_content = options.includeSources && Object.create(null);
+    var sources_content = options.includeSources && new Dictionary();
     var names = create_array_map();
     var mappings = "";
     if (options.orig) Object.keys(options.orig).forEach(function(name) {
@@ -110,7 +112,7 @@ function SourceMap(options) {
         if (!sources_content || !map.sourcesContent) return;
         for (var i = 0; i < map.sources.length; i++) {
             var content = map.sourcesContent[i];
-            if (content) sources_content[map.sources[i]] = content;
+            if (content) sources_content.set(map.sources[i], content);
         }
     });
     var prev_source;
@@ -144,8 +146,8 @@ function SourceMap(options) {
             add(source, gen_line, gen_col, orig_line, orig_col, name);
         } : add,
         setSourceContent: sources_content ? function(source, content) {
-            if (!(source in sources_content)) {
-                sources_content[source] = content;
+            if (!sources_content.has(source)) {
+                sources_content.set(source, content);
             }
         } : noop,
         toString: function() {
@@ -155,7 +157,7 @@ function SourceMap(options) {
                 sourceRoot: options.root || undefined,
                 sources: sources,
                 sourcesContent: sources_content ? sources.map(function(source) {
-                    return sources_content[source] || null;
+                    return sources_content.get(source) || null;
                 }) : undefined,
                 names: names,
                 mappings: mappings,

lib/utils.js

@@ -55,14 +55,6 @@ function find_if(func, array) {
     for (var i = array.length; --i >= 0;) if (func(array[i])) return array[i];
 }
 
-function repeat_string(str, i) {
-    if (i <= 0) return "";
-    if (i == 1) return str;
-    var d = repeat_string(str, i >> 1);
-    d += d;
-    return i & 1 ? d + str : d;
-}
-
 function configure_error_stack(fn) {
     Object.defineProperty(fn.prototype, "stack", {
         get: function() {
@@ -96,15 +88,6 @@ function defaults(args, defs, croak) {
     return defs;
 }
 
-function merge(obj, ext) {
-    var count = 0;
-    for (var i in ext) if (HOP(ext, i)) {
-        obj[i] = ext[i];
-        count++;
-    }
-    return count;
-}
-
 function noop() {}
 function return_false() { return false; }
 function return_true() { return true; }
@@ -143,9 +126,11 @@ function push_uniq(array, el) {
 }
 
 function string_template(text, props) {
-    return text.replace(/\{([^}]+)\}/g, function(str, p) {
-        var value = props[p];
-        return value instanceof AST_Node ? value.print_to_string() : value;
+    return text.replace(/\{([^{}]+)\}/g, function(str, p) {
+        var value = p == "this" ? props : props[p];
+        if (value instanceof AST_Node) return value.print_to_string();
+        if (value instanceof AST_Token) return value.file + ":" + value.line + "," + value.col;
+        return value;
     });
 }
 
@@ -171,63 +156,80 @@ function all(array, predicate) {
 }
 
 function Dictionary() {
-    this._values = Object.create(null);
-    this._size = 0;
+    this.values = Object.create(null);
 }
 Dictionary.prototype = {
     set: function(key, val) {
-        if (!this.has(key)) ++this._size;
-        this._values["$" + key] = val;
+        if (key == "__proto__") {
+            this.proto_value = val;
+        } else {
+            this.values[key] = val;
+        }
         return this;
     },
     add: function(key, val) {
-        if (this.has(key)) {
-            this.get(key).push(val);
+        var list = this.get(key);
+        if (list) {
+            list.push(val);
         } else {
             this.set(key, [ val ]);
         }
         return this;
     },
-    get: function(key) { return this._values["$" + key] },
+    get: function(key) {
+        return key == "__proto__" ? this.proto_value : this.values[key];
+    },
     del: function(key) {
-        if (this.has(key)) {
-            --this._size;
-            delete this._values["$" + key];
+        if (key == "__proto__") {
+            delete this.proto_value;
+        } else {
+            delete this.values[key];
         }
         return this;
     },
-    has: function(key) { return ("$" + key) in this._values },
+    has: function(key) {
+        return key == "__proto__" ? "proto_value" in this : key in this.values;
+    },
     all: function(predicate) {
-        for (var i in this._values)
-            if (!predicate(this._values[i], i.substr(1)))
-                return false;
+        for (var i in this.values)
+            if (!predicate(this.values[i], i)) return false;
+        if ("proto_value" in this && !predicate(this.proto_value, "__proto__")) return false;
         return true;
     },
     each: function(f) {
-        for (var i in this._values)
-            f(this._values[i], i.substr(1));
+        for (var i in this.values)
+            f(this.values[i], i);
+        if ("proto_value" in this) f(this.proto_value, "__proto__");
     },
     size: function() {
-        return this._size;
+        return Object.keys(this.values).length + ("proto_value" in this);
     },
     map: function(f) {
         var ret = [];
-        for (var i in this._values)
-            ret.push(f(this._values[i], i.substr(1)));
+        for (var i in this.values)
+            ret.push(f(this.values[i], i));
+        if ("proto_value" in this) ret.push(f(this.proto_value, "__proto__"));
         return ret;
     },
     clone: function() {
         var ret = new Dictionary();
-        for (var i in this._values)
-            ret._values[i] = this._values[i];
-        ret._size = this._size;
+        this.each(function(value, i) {
+            ret.set(i, value);
+        });
         return ret;
     },
-    toObject: function() { return this._values }
+    toObject: function() {
+        var obj = {};
+        this.each(function(value, i) {
+            obj["$" + i] = value;
+        });
+        return obj;
+    },
 };
 Dictionary.fromObject = function(obj) {
     var dict = new Dictionary();
-    dict._size = merge(dict._values, obj);
+    for (var i in obj)
+        if (HOP(obj, i)) dict.set(i.slice(1), obj[i]);
     return dict;
 };
 
@@ -265,3 +267,21 @@ function first_in_statement(stack, arrow, export_default) {
         return false;
     }
 }
+
+function DEF_BITPROPS(ctor, props) {
+    if (props.length > 31) throw new Error("Too many properties: " + props.length + "\n" + props.join(", "));
+    props.forEach(function(name, pos) {
+        var mask = 1 << pos;
+        Object.defineProperty(ctor.prototype, name, {
+            get: function() {
+                return !!(this._bits & mask);
+            },
+            set: function(val) {
+                if (val)
+                    this._bits |= mask;
+                else
+                    this._bits &= ~mask;
+            },
+        });
+    });
+}

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.13.3",
+  "version": "3.17.0",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -23,7 +23,7 @@
     "LICENSE"
   ],
   "devDependencies": {
-    "acorn": "~7.1.0",
+    "acorn": "~8.7.1",
     "semver": "~6.3.0"
   },
   "scripts": {

test/benchmark.js

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

test/compress.js

@@ -60,8 +60,9 @@ function log() {
     console.log("%s", tmpl.apply(null, arguments));
 }
 
-function make_code(ast, options) {
+function make_code(ast, options, expression) {
     var stream = U.OutputStream(options);
+    if (expression) ast = ast.clone(true).unwrap_expression();
     ast.print(stream);
     return stream.get();
 }
@@ -69,9 +70,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, module: "" });
     } catch (e) {
         console.error("Caught error while parsing tests in " + file);
         console.error(e);
@@ -98,14 +97,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 +141,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 +154,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;
                         }));
@@ -180,16 +179,23 @@ function parse_test(file) {
 
 // Try to reminify original input with standard options
 // to see if it matches expect_stdout.
-function reminify(orig_options, input_code, input_formatted, stdout) {
+function reminify(expression, 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) [
+        if (expression) {
+            if (!options.parse || typeof options.parse != "object") options.parse = {};
+            options.parse.expression = true;
+            if (options.compress == null) options.compress = {};
+            if (options.compress) {
+                if (typeof options.compress != "object") options.compress = {};
+                options.compress.expression = true;
+            }
+        }
+        [
             "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;
@@ -214,7 +220,7 @@ function reminify(orig_options, input_code, input_formatted, stdout) {
         } else {
             var toplevel = sandbox.has_toplevel(options);
             var expected = stdout[toplevel ? 1 : 0];
-            var actual = sandbox.run_code(result.code, toplevel);
+            var actual = run_code(expression, result.code, toplevel);
             if (typeof expected != "string" && typeof actual != "string" && expected.name == actual.name) {
                 actual = expected;
             }
@@ -249,18 +255,23 @@ function reminify(orig_options, input_code, input_formatted, stdout) {
     return true;
 }
 
+function run_code(expression, code, toplevel) {
+    return sandbox.run_code(expression ? "console.log(" + code + ");" : code, toplevel);
+}
+
 function test_case(test) {
     log("    Running test [{name}]", { name: test.name });
     U.AST_Node.enable_validation();
     var output_options = test.beautify || {};
     var expect;
     if (test.expect) {
-        expect = make_code(to_toplevel(test.expect, test.mangle), output_options);
+        expect = to_toplevel(test.expect, test.mangle, test.expression);
+        expect = make_code(expect, output_options, test.expression);
     } else {
         expect = test.expect_exact;
     }
-    var input = to_toplevel(test.input, test.mangle);
-    var input_code = make_code(input);
+    var input = to_toplevel(test.input, test.mangle, test.expression);
+    var input_code = make_code(input, {}, test.expression);
     var input_formatted = make_code(test.input, {
         annotations: true,
         beautify: true,
@@ -270,7 +281,7 @@ function test_case(test) {
     });
     try {
         input.validate_ast();
-        U.parse(input_code);
+        U.parse(input_code, { expression: test.expression });
     } catch (ex) {
         log([
             "!!! Cannot parse input",
@@ -314,7 +325,7 @@ function test_case(test) {
         output.mangle_names(test.mangle);
         if (test.mangle.properties) U.mangle_properties(output, test.mangle.properties);
     }
-    var output_code = make_code(output, output_options);
+    var output_code = make_code(output, output_options, test.expression);
     U.AST_Node.log_function();
     if (expect != output_code) {
         log([
@@ -337,7 +348,7 @@ function test_case(test) {
     // expect == output
     try {
         output.validate_ast();
-        U.parse(output_code);
+        U.parse(output_code, { expression: test.expression });
     } catch (ex) {
         log([
             "!!! Test matched expected result but cannot parse output",
@@ -381,7 +392,7 @@ function test_case(test) {
         }
     }
     if (test.expect_stdout && (!test.node_version || semver.satisfies(process.version, test.node_version))) {
-        var stdout = [ sandbox.run_code(input_code), sandbox.run_code(input_code, true) ];
+        var stdout = [ run_code(test.expression, input_code), run_code(test.expression, input_code, true) ];
         var toplevel = sandbox.has_toplevel({
             compress: test.options,
             mangle: test.mangle
@@ -410,7 +421,7 @@ function test_case(test) {
             });
             return false;
         }
-        actual = sandbox.run_code(output_code, toplevel);
+        actual = run_code(test.expression, output_code, toplevel);
         if (!sandbox.same_stdout(test.expect_stdout, actual)) {
             log([
                 "!!! failed",
@@ -431,7 +442,7 @@ function test_case(test) {
             });
             return false;
         }
-        if (!reminify(test.options, input_code, input_formatted, stdout)) {
+        if (!reminify(test.expression, test.options, input_code, input_formatted, stdout)) {
             return false;
         }
     }
@@ -442,20 +453,29 @@ function tmpl() {
     return U.string_template.apply(null, arguments);
 }
 
-function to_toplevel(input, mangle_options) {
+function to_toplevel(input, mangle_options, expression) {
     if (!(input instanceof U.AST_BlockStatement)) throw new Error("Unsupported input syntax");
-    var directive = true;
     var offset = input.start.line;
     var tokens = [];
-    var toplevel = new U.AST_Toplevel(input.transform(new U.TreeTransformer(function(node) {
+    input.walk(new U.TreeWalker(function(node) {
         if (U.push_uniq(tokens, node.start)) node.start.line -= offset;
-        if (!directive || node === input) return;
-        if (node instanceof U.AST_SimpleStatement && node.body instanceof U.AST_String) {
-            return new U.AST_Directive(node.body);
-        } else {
+    }));
+    var toplevel;
+    if (!expression) {
+        var directive = true;
+        toplevel = new U.AST_Toplevel(input.transform(new U.TreeTransformer(function(node) {
+            if (!directive) return node;
+            if (node === input) return;
+            if (node instanceof U.AST_SimpleStatement && node.body instanceof U.AST_String) {
+                return new U.AST_Directive(node.body);
+            }
             directive = false;
-        }
-    })));
+        })));
+    } else if (input.body.length == 1) {
+        toplevel = input.body[0].wrap_expression();
+    } else {
+        throw new Error("Invalid expression");
+    }
     toplevel.figure_out_scope(mangle_options);
     return toplevel;
 }

test/compress/annotations.js

@@ -256,6 +256,7 @@ issue_3858: {
         collapse_vars: true,
         inline: true,
         keep_fargs: false,
+        unsafe: true,
         unused: true,
     }
     input: {
@@ -441,9 +442,9 @@ compress_annotations_disabled_output_annotations_enabled: {
     }
     expect_exact: [
         "/*@__PURE__*/a(3),",
-        "/*#__PURE__*/b(5),",
+        "/*@__PURE__*/b(5),",
         "c(side_effect),",
-        "/*#__PURE__*/d(effect());",
+        "/*@__PURE__*/d(effect());",
     ]
 }
 

test/compress/arguments.js

@@ -254,6 +254,25 @@ duplicate_argname: {
     expect_stdout: "bar 42 foo 42 bar"
 }
 
+fraction: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            return arguments[0.3];
+        }("FAIL") || "PASS");
+    }
+    expect: {
+        console.log(function() {
+            return arguments[0.3];
+        }("FAIL") || "PASS");
+    }
+    expect_stdout: "PASS"
+}
+
 issue_3273: {
     options = {
         arguments: true,

test/compress/arrows.js

@@ -363,6 +363,28 @@ negate: {
 }
 
 inline_this: {
+    options = {
+        inline: true,
+    }
+    input: {
+        var p = "PASS";
+        console.log({
+            p: "FAIL",
+            q: (() => this.p)(),
+        }.q);
+    }
+    expect: {
+        var p = "PASS";
+        console.log({
+            p: "FAIL",
+            q: this.p,
+        }.q);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+dont_inline_this: {
     options = {
         inline: true,
     }
@@ -421,6 +443,7 @@ collapse_value: {
         arrows: true,
         collapse_vars: true,
         keep_fargs: false,
+        unsafe: true,
         unused: true,
     }
     input: {
@@ -485,7 +508,7 @@ drop_value: {
         ((a, b) => a + b)(console.log(42));
     }
     expect: {
-        ((a, b) => {})(console.log(42));
+        void console.log(42);
     }
     expect_stdout: "42"
     node_version: ">=4"
@@ -555,6 +578,75 @@ reduce_iife_3: {
     node_version: ">=4"
 }
 
+reduce_lambda_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            console.log(a, b);
+        };
+        var a = "foo", b = 42;
+        f();
+        b = "bar";
+        f();
+    }
+    expect: {
+        var f = () => {
+            console.log("foo", b);
+        };
+        var b = 42;
+        f();
+        b = "bar";
+        f();
+    }
+    expect_stdout: [
+        "foo 42",
+        "foo bar",
+    ]
+    node_version: ">=4"
+}
+
+reduce_lambda_2: {
+    options = {
+        evaluate: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function(f, a, b) {
+            f = () => {
+                console.log(a, b);
+            };
+            a = "foo", b = 42;
+            f();
+            b = "bar";
+            f();
+        })();
+    }
+    expect: {
+        (function(f, a, b) {
+            f = () => {
+                console.log("foo", b);
+            };
+            b = 42;
+            f();
+            b = "bar";
+            f();
+        })();
+    }
+    expect_stdout: [
+        "foo 42",
+        "foo bar",
+    ]
+    node_version: ">=4"
+}
+
 single_use_recursive: {
     options = {
         reduce_vars: true,
@@ -814,3 +906,309 @@ issue_4772: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_5251: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        (() => {
+            while (console.log(arguments))
+                var arguments = "FAIL";
+        })();
+    }
+    expect: {
+        (() => {
+            while (console.log(arguments))
+                var arguments = "FAIL";
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_5342_1: {
+    options = {
+        dead_code: true,
+        inline: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var a in 0) {
+            (() => {
+                while (1);
+            })(new function(NaN) {
+                a.p;
+            }());
+        }
+        console.log(function() {
+            return b;
+            try {
+                b;
+            } catch (e) {
+                var b;
+            }
+        }());
+    }
+    expect: {
+        for (var a in 0) {
+            (function(NaN) {
+                a.p;
+            })();
+            while (1);
+        }
+        console.log(b);
+        var b;
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5342_2: {
+    rename = true
+    options = {
+        dead_code: true,
+        inline: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var a in 0) {
+            (() => {
+                while (1);
+            })(new function(NaN) {
+                a.p;
+            }());
+        }
+        console.log(function() {
+            return b;
+            try {
+                b;
+            } catch (e) {
+                var b;
+            }
+        }());
+    }
+    expect: {
+        for (var a in 0) {
+            a.p;
+            while (1);
+        }
+        console.log(c);
+        var c;
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5356: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log((a => a++)(console));
+    }
+    expect: {
+        console.log((a => +a)(console));
+    }
+    expect_stdout: "NaN"
+    node_version: ">=4"
+}
+
+issue_5414_1: {
+    options = {
+        arrows: true,
+        if_return: true,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        (() => {
+            (() => {
+                if (!console)
+                    var arguments = 42;
+                while (console.log(arguments));
+            })();
+        })();
+    }
+    expect: {
+        (() => {
+            if (!console)
+                var arguments = 42;
+            while (console.log(arguments));
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_5414_2: {
+    options = {
+        arrows: true,
+        inline: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        (() => {
+            (() => {
+                if (!console)
+                    var arguments = 42;
+                while (console.log(arguments));
+            })();
+        })();
+    }
+    expect: {
+        (() => {
+            if (!console)
+                var arguments = 42;
+            while (console.log(arguments));
+        })();
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_5416_1: {
+    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 = () => {
+            {
+                console;
+                arguments = void 0,
+                console.log(arguments);
+                var arguments;
+                return;
+            }
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5416_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        inline: true,
+        loops: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            while ((() => {
+                console;
+                var a = function g(arguments) {
+                    while (console.log(arguments));
+                }();
+            })());
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            {
+                console;
+                var arguments = void 0;
+                for (; console.log(arguments););
+                return;
+            }
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5416_3: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            (() => {
+                var a = function g(arguments) {
+                    console.log(arguments);
+                }();
+            })();
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            arguments = void 0,
+            console.log(arguments);
+            var arguments;
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5416_4: {
+    options = {
+        arrows: true,
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var f = () => {
+            (() => {
+                var a = function g(arguments) {
+                    while (console.log(arguments));
+                }();
+            })();
+        };
+        f();
+    }
+    expect: {
+        var f = () => {
+            var arguments = void 0;
+            while (console.log(arguments));
+            return;
+        };
+        f();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5495: {
+    input: {
+        console.log((() => {
+            "use strict";
+            return function() {
+                return this;
+            }();
+        })());
+    }
+    expect_exact: 'console.log((()=>{"use strict";return function(){return this}()})());'
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}

test/compress/assignments.js

@@ -489,7 +489,7 @@ logical_assignments: {
     node_version: ">=15"
 }
 
-logical_collapse_vars: {
+logical_collapse_vars_1: {
     options = {
         collapse_vars: true,
     }
@@ -509,6 +509,46 @@ logical_collapse_vars: {
     node_version: ">=15"
 }
 
+logical_collapse_vars_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "PASS";
+        (function(b) {
+            b ||= (a = "FAIL", {});
+            return b;
+        })(console).log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (function(b) {
+            return b ||= (a = "FAIL", {});
+        })(console).log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+logical_collapse_vars_3: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 6;
+        a *= 7;
+        a ??= "FAIL";
+        console.log(a);
+    }
+    expect: {
+        var a = 6;
+        a = a * 7 ?? "FAIL";
+        console.log(a);
+    }
+    expect_stdout: "42"
+    node_version: ">=15"
+}
+
 logical_reduce_vars: {
     options = {
         evaluate: true,
@@ -550,6 +590,24 @@ logical_side_effects: {
     node_version: ">=15"
 }
 
+evaluate_lazy_assignment: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 42;
+        console.log(a &&= "PASS");
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
 issue_4815_1: {
     options = {
         evaluate: true,
@@ -615,8 +673,7 @@ issue_4827_1: {
         c &&= b = a, console.log(b);
     }
     expect: {
-        A = "FAIL";
-        var a = A, b = "PASS", c;
+        var a = A = "FAIL", b = "PASS", c;
         c &&= b = a, console.log(b);
     }
     expect_stdout: "PASS"
@@ -672,3 +729,77 @@ issue_4827_3: {
     expect_stdout: "undefined"
     node_version: ">=15"
 }
+
+issue_4876: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        try {
+            var a = null;
+            var b = a &&= 42;
+            b.p;
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            var a = null;
+            var b = a &&= 42;
+            b.p;
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+issue_4924_1: {
+    options = {
+        collapse_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, b;
+        console.log("PASS");
+        a = function() {};
+        b = function() {}(b ||= a);
+    }
+    expect: {
+        var b;
+        console.log("PASS");
+        b = void (b ||= function() {});
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+issue_4924_2: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        passes: 2,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, b;
+        console.log("PASS");
+        a = function() {};
+        b = function() {}(b ||= a);
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}

test/compress/bigint.js

@@ -4,7 +4,7 @@ arithmetic: {
     }
     expect_exact: "console.log((1n+0x2n)*(0o3n- -4n)>>5n-6n);"
     expect_stdout: "42n"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 minus_dot: {
@@ -13,7 +13,7 @@ minus_dot: {
     }
     expect_exact: "console.log(typeof-42n.toString(),typeof(-42n).toString());"
     expect_stdout: "number string"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 evaluate: {
@@ -28,7 +28,7 @@ evaluate: {
         console.log(0xdeadbeefn.toString(16));
     }
     expect_stdout: "deadbeef"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 Number: {
@@ -42,7 +42,7 @@ Number: {
         console.log(+("" + -0xfeed_dead_beef_badn));
     }
     expect_stdout: "-1148098955808013200"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 issue_4590: {
@@ -58,7 +58,7 @@ issue_4590: {
         0n || console.log("PASS");
     }
     expect_stdout: "PASS"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 issue_4801: {
@@ -88,5 +88,5 @@ issue_4801: {
         }
     }
     expect_stdout: "PASS"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }

test/compress/booleans.js

@@ -29,6 +29,442 @@ iife_boolean_context: {
     ]
 }
 
+de_morgan_1a: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        function f(a) {
+            return a || a;
+        }
+        console.log(f(null), f(42));
+    }
+    expect: {
+        function f(a) {
+            return a;
+        }
+        console.log(f(null), f(42));
+    }
+    expect_stdout: "null 42"
+}
+
+de_morgan_1b: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        function f(a) {
+            return a && a;
+        }
+        console.log(f(null), f(42));
+    }
+    expect: {
+        function f(a) {
+            return a;
+        }
+        console.log(f(null), f(42));
+    }
+    expect_stdout: "null 42"
+}
+
+de_morgan_1c: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        console.log(delete (NaN && NaN));
+    }
+    expect: {
+        console.log(delete (0, NaN));
+    }
+    expect_stdout: "true"
+}
+
+de_morgan_2a: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        function f(a, b) {
+            return a || (a || b);
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect: {
+        function f(a, b) {
+            return a || b;
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect_stdout: [
+        "undefined {}",
+        "42 42",
+    ]
+}
+
+de_morgan_2b: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        function f(a, b) {
+            return a || (a && b);
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect: {
+        function f(a, b) {
+            return a;
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect_stdout: [
+        "null null",
+        "42 42",
+    ]
+}
+
+de_morgan_2c: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        function f(a, b) {
+            return a && (a || b);
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect: {
+        function f(a, b) {
+            return a;
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect_stdout: [
+        "null null",
+        "42 42",
+    ]
+}
+
+de_morgan_2d: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a, b) {
+            return a && (a && b);
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect: {
+        function f(a, b) {
+            return a && b;
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect_stdout: [
+        "null null",
+        "undefined {}",
+    ]
+}
+
+de_morgan_3a: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        function f(a, b, c) {
+            return a || ((a || b) || c);
+        }
+        console.log(f(null, false), f(null, false, {}), f(null, true), f(null, true, {}));
+        console.log(f(42, false), f(42, false, {}), f(42, true), f(42, true, {}));
+    }
+    expect: {
+        function f(a, b, c) {
+            return a || b || c;
+        }
+        console.log(f(null, !1), f(null, !1, {}), f(null, !0), f(null, !0, {}));
+        console.log(f(42, !1), f(42, !1, {}), f(42, !0), f(42, !0, {}));
+    }
+    expect_stdout: [
+        "undefined {} true true",
+        "42 42 42 42",
+    ]
+}
+
+de_morgan_3b: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a, b, c) {
+            return a || ((a || b) && c);
+        }
+        console.log(f(null, false), f(null, false, {}), f(null, true), f(null, true, {}));
+        console.log(f(42, false), f(42, false, {}), f(42, true), f(42, true, {}));
+    }
+    expect: {
+        function f(a, b, c) {
+            return a || b && c;
+        }
+        console.log(f(null, !1), f(null, !1, {}), f(null, !0), f(null, !0, {}));
+        console.log(f(42, !1), f(42, !1, {}), f(42, !0), f(42, !0, {}));
+    }
+    expect_stdout: [
+        "false false undefined {}",
+        "42 42 42 42",
+    ]
+}
+
+de_morgan_3c: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a, b, c) {
+            return a || ((a && b) || c);
+        }
+        console.log(f(null, false), f(null, false, {}), f(null, true), f(null, true, {}));
+        console.log(f(42, false), f(42, false, {}), f(42, true), f(42, true, {}));
+    }
+    expect: {
+        function f(a, b, c) {
+            return a || c;
+        }
+        console.log(f(null, !1), f(null, !1, {}), f(null, !0), f(null, !0, {}));
+        console.log(f(42, !1), f(42, !1, {}), f(42, !0), f(42, !0, {}));
+    }
+    expect_stdout: [
+        "undefined {} undefined {}",
+        "42 42 42 42",
+    ]
+}
+
+de_morgan_3d: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        function f(a, b, c) {
+            return a || ((a && b) && c);
+        }
+        console.log(f(null, false), f(null, false, {}), f(null, true), f(null, true, {}));
+        console.log(f(42, false), f(42, false, {}), f(42, true), f(42, true, {}));
+    }
+    expect: {
+        function f(a, b, c) {
+            return a;
+        }
+        console.log(f(null, !1), f(null, !1, {}), f(null, !0), f(null, !0, {}));
+        console.log(f(42, !1), f(42, !1, {}), f(42, !0), f(42, !0, {}));
+    }
+    expect_stdout: [
+        "null null null null",
+        "42 42 42 42",
+    ]
+}
+
+de_morgan_3e: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        function f(a, b, c) {
+            return a && ((a || b) || c);
+        }
+        console.log(f(null, false), f(null, false, {}), f(null, true), f(null, true, {}));
+        console.log(f(42, false), f(42, false, {}), f(42, true), f(42, true, {}));
+    }
+    expect: {
+        function f(a, b, c) {
+            return a;
+        }
+        console.log(f(null, !1), f(null, !1, {}), f(null, !0), f(null, !0, {}));
+        console.log(f(42, !1), f(42, !1, {}), f(42, !0), f(42, !0, {}));
+    }
+    expect_stdout: [
+        "null null null null",
+        "42 42 42 42",
+    ]
+}
+
+de_morgan_3f: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a, b, c) {
+            return a && ((a || b) && c);
+        }
+        console.log(f(null, false), f(null, false, {}), f(null, true), f(null, true, {}));
+        console.log(f(42, false), f(42, false, {}), f(42, true), f(42, true, {}));
+    }
+    expect: {
+        function f(a, b, c) {
+            return a && c;
+        }
+        console.log(f(null, !1), f(null, !1, {}), f(null, !0), f(null, !0, {}));
+        console.log(f(42, !1), f(42, !1, {}), f(42, !0), f(42, !0, {}));
+    }
+    expect_stdout: [
+        "null null null null",
+        "undefined {} undefined {}",
+    ]
+}
+
+de_morgan_3g: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a, b, c) {
+            return a && ((a && b) || c);
+        }
+        console.log(f(null, false), f(null, false, {}), f(null, true), f(null, true, {}));
+        console.log(f(42, false), f(42, false, {}), f(42, true), f(42, true, {}));
+    }
+    expect: {
+        function f(a, b, c) {
+            return a && (b || c);
+        }
+        console.log(f(null, !1), f(null, !1, {}), f(null, !0), f(null, !0, {}));
+        console.log(f(42, !1), f(42, !1, {}), f(42, !0), f(42, !0, {}));
+    }
+    expect_stdout: [
+        "null null null null",
+        "undefined {} true true",
+    ]
+}
+
+de_morgan_3h: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        function f(a, b, c) {
+            return a && ((a && b) && c);
+        }
+        console.log(f(null, false), f(null, false, {}), f(null, true), f(null, true, {}));
+        console.log(f(42, false), f(42, false, {}), f(42, true), f(42, true, {}));
+    }
+    expect: {
+        function f(a, b, c) {
+            return a && b && c;
+        }
+        console.log(f(null, !1), f(null, !1, {}), f(null, !0), f(null, !0, {}));
+        console.log(f(42, !1), f(42, !1, {}), f(42, !0), f(42, !0, {}));
+    }
+    expect_stdout: [
+        "null null null null",
+        "false false undefined {}",
+    ]
+}
+
+conditional_chain: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+    }
+    input: {
+        function f(a, b) {
+            return a ? a : b ? b : 42;
+        }
+        console.log(f("PASS", "FAIL"));
+    }
+    expect: {
+        function f(a, b) {
+            return a || b || 42;
+        }
+        console.log(f("PASS", "FAIL"));
+    }
+    expect_stdout: "PASS"
+}
+
+negated_if: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(a) {
+            if (!a)
+                return a ? "FAIL" : "PASS";
+        }(!console));
+    }
+    expect: {
+        console.log(function(a) {
+            if (!a)
+                return "PASS";
+        }(!console));
+    }
+    expect_stdout: "PASS"
+}
+
+concat_truthy: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        console.log("foo") + (console.log("bar"), "baz") || console.log("moo");
+    }
+    expect: {
+        console.log("foo") + (console.log("bar"), "baz");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    expect_warnings: [
+        "WARN: + in boolean context always true [test/compress/booleans.js:1,8]",
+        "WARN: Condition left of || always true [test/compress/booleans.js:1,8]",
+    ]
+}
+
+process_returns: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        (function() {
+            return 42;
+        })() && console.log("PASS");
+    }
+    expect: {
+        (function() {
+            return 42;
+        })() && console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
 issue_3465_1: {
     options = {
         booleans: true,
@@ -181,3 +617,172 @@ issue_4374: {
     }
     expect_stdout: "0"
 }
+
+issue_5028_1: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        var a = 1;
+        console.log(function() {
+            return a-- ? a-- ? "FAIL 1" : "PASS" : "FAIL 2";
+        }());
+    }
+    expect: {
+        var a = 1;
+        console.log(function() {
+            return a-- ? a-- ? "FAIL 1" : "PASS" : "FAIL 2";
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5028_2: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
+    input: {
+        var a = 1;
+        (function() {
+            if (a--)
+                if (a--)
+                    a = "FAIL";
+                else
+                    return;
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        (function() {
+            a-- && a-- && (a = "FAIL");
+        })();
+        console.log(a);
+    }
+    expect_stdout: "-1"
+}
+
+issue_5028_3: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+        if_return: true,
+    }
+    input: {
+        var a = 1;
+        (function() {
+            if (a--)
+                if (a--)
+                    a = "FAIL";
+                else
+                    return;
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        (function() {
+            a-- && a-- && (a = "FAIL");
+        })();
+        console.log(a);
+    }
+    expect_stdout: "-1"
+}
+
+issue_5041_1: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        var a = 42;
+        if (a)
+            if ([ a = null ])
+                if (a)
+                    console.log("FAIL");
+                else
+                    console.log("PASS");
+    }
+    expect: {
+        var a = 42;
+        a && [ a = null ] && (a ? console.log("FAIL") : console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5041_2: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (!a)
+            if (a = 42)
+                if (a)
+                    console.log("PASS");
+                else
+                    console.log("FAIL");
+    }
+    expect: {
+        var a;
+        a || (a = 42) && (a ? console.log("PASS") : console.log("FAIL"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5228: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+    }
+    input: {
+        console.log(function() {
+            return !function() {
+                do {
+                    return null;
+                } while (console);
+            }();
+        }());
+    }
+    expect: {
+        console.log(function() {
+            do {
+                return !0;
+            } while (console);
+            return !0;
+        }());
+    }
+    expect_stdout: "true"
+}
+
+issue_5469: {
+    options = {
+        assignments: true,
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        console.log(function f(a) {
+            a && 42[a = A && null];
+        }());
+    }
+    expect: {
+        console.log(function f(a) {
+            a && A,
+            0;
+        }());
+    }
+    expect_stdout: "undefined"
+}

test/compress/comparisons.js

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

test/compress/concat-strings.js

@@ -289,3 +289,18 @@ issue_3689: {
     }
     expect_stdout: "00"
 }
+
+issue_5145: {
+    options = {
+        strings: true,
+    }
+    input: {
+        var a = [];
+        console.log("" + a + ((a[0] = 4) + "2"));
+    }
+    expect: {
+        var a = [];
+        console.log("" + a + (a[0] = 4) + "2");
+    }
+    expect_stdout: "42"
+}

test/compress/conditionals.js

@@ -82,14 +82,14 @@ ifs_3_should_warn: {
         "WARN: Boolean && always false [test/compress/conditionals.js:3,12]",
         "WARN: Condition left of && always false [test/compress/conditionals.js:3,12]",
         "WARN: Condition always false [test/compress/conditionals.js:3,12]",
+        "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:3,12]",
         "WARN: Dropping unreachable code [test/compress/conditionals.js:3,34]",
         "WARN: + in boolean context always true [test/compress/conditionals.js:10,19]",
         "WARN: Boolean || always true [test/compress/conditionals.js:10,12]",
         "WARN: Condition left of || always true [test/compress/conditionals.js:10,12]",
         "WARN: Condition always true [test/compress/conditionals.js:10,12]",
-        "WARN: Dropping unreachable code [test/compress/conditionals.js:12,15]",
-        "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:3,12]",
         "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:10,12]",
+        "WARN: Dropping unreachable code [test/compress/conditionals.js:12,15]",
     ]
 }
 
@@ -196,6 +196,178 @@ ifs_7: {
     }
 }
 
+merge_tail_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                while (console.log("baz"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (a)
+                while (console.log("bar"));
+            else
+                while (console.log("baz"));
+            console.log(b);
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "baz",
+        "foo",
+        "bar",
+        "foo",
+    ]
+}
+
+merge_tail_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                c = "baz";
+                while (console.log(c));
+                while (console.log("bar"));
+                console.log(b);
+                var c;
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (!a) {
+                c = "baz";
+                while (console.log(c));
+                var c;
+            }
+            while (console.log("bar"));
+            console.log(b);
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "baz",
+        "bar",
+        "foo",
+        "bar",
+        "foo",
+    ]
+}
+
+merge_tail_sequence_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                c = "baz";
+                while (console.log(c));
+                console.log("bar"),
+                console.log(b);
+                var c;
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (a)
+                while (console.log("bar"));
+            else {
+                c = "baz";
+                while (console.log(c));
+                console.log("bar");
+                var c;
+            }
+            console.log(b);
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "baz",
+        "bar",
+        "foo",
+        "bar",
+        "foo",
+    ]
+}
+
+merge_tail_sequence_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                console.log("bar");
+                console.log(b);
+            } else {
+                c = "baz";
+                while (console.log(c));
+                console.log("bar"),
+                console.log(b);
+                var c;
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (!a) {
+                c = "baz";
+                while (console.log(c));
+                var c;
+            }
+            console.log("bar");
+            console.log(b);
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "baz",
+        "bar",
+        "foo",
+        "bar",
+        "foo",
+    ]
+}
+
 cond_1: {
     options = {
         conditionals: true,
@@ -822,6 +994,33 @@ cond_13: {
     }
 }
 
+cond_14: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a) {
+            if (a)
+                if (a)
+                    console.log("PASS");
+                else
+                    console.log("FAIL");
+        }
+        f(null);
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            a && console.log("PASS");
+        }
+        f(null);
+        f(42);
+    }
+    expect_stdout: "PASS"
+}
+
 ternary_boolean_consequent: {
     options = {
         booleans: true,
@@ -1234,6 +1433,398 @@ condition_matches_alternative: {
     expect_stdout: "null 0 false 5"
 }
 
+condition_sequence_1: {
+    options = {
+        conditionals: true,
+        sequences: true,
+    }
+    input: {
+        function f(x, y) {
+            return (console.log(x), x) ? x : y;
+        }
+        console.log(f("foo", "bar"));
+        console.log(f(null, "baz"));
+        console.log(f(42));
+        console.log(f());
+    }
+    expect: {
+        function f(x, y) {
+            return console.log(x), x || y;
+        }
+        console.log(f("foo", "bar")),
+        console.log(f(null, "baz")),
+        console.log(f(42)),
+        console.log(f());
+    }
+    expect_stdout: [
+        "foo",
+        "foo",
+        "null",
+        "baz",
+        "42",
+        "42",
+        "undefined",
+        "undefined",
+    ]
+}
+
+condition_sequence_2: {
+    options = {
+        conditionals: true,
+        sequences: true,
+    }
+    input: {
+        function f(x, y) {
+            return (console.log(y), y) ? x : y;
+        }
+        console.log(f("foo", "bar"));
+        console.log(f(null, "baz"));
+        console.log(f(42));
+        console.log(f());
+    }
+    expect: {
+        function f(x, y) {
+            return console.log(y), y && x;
+        }
+        console.log(f("foo", "bar")),
+        console.log(f(null, "baz")),
+        console.log(f(42)),
+        console.log(f());
+    }
+    expect_stdout: [
+        "bar",
+        "foo",
+        "baz",
+        "null",
+        "undefined",
+        "undefined",
+        "undefined",
+        "undefined",
+    ]
+}
+
+combine_tail_sequence: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var n = {
+            f: function() {
+                console.log("foo");
+                return this.p;
+            },
+            p: "FAIL 1",
+        };
+        var o = {
+            f: function() {
+                console.log("foz");
+                return this.p;
+            },
+            p: "FAIL 2",
+        };
+        var p = "PASS";
+        function g(a) {
+            return a
+                ? (console.log("baa"), (console.log("bar"), (console.log("baz"), n).f)())
+                : (console.log("moo"), (console.log("mor"), (console.log("moz"), o).f)());
+        }
+        console.log(g());
+        console.log(g(42));
+    }
+    expect: {
+        var n = {
+            f: function() {
+                console.log("foo");
+                return this.p;
+            },
+            p: "FAIL 1",
+        };
+        var o = {
+            f: function() {
+                console.log("foz");
+                return this.p;
+            },
+            p: "FAIL 2",
+        };
+        var p = "PASS";
+        function g(a) {
+            return (0, (a
+                ? (console.log("baa"), console.log("bar"), console.log("baz"), n)
+                : (console.log("moo"), console.log("mor"), console.log("moz"), o)).f)();
+        }
+        console.log(g());
+        console.log(g(42));
+    }
+    expect_stdout: [
+        "moo",
+        "mor",
+        "moz",
+        "foz",
+        "PASS",
+        "baa",
+        "bar",
+        "baz",
+        "foo",
+        "PASS",
+    ]
+}
+
+consequent_sequence_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(x, y, a) {
+            return x ? (console.log("seq"), y && a) : a;
+        }
+        console.log(f(false, false, 1));
+        console.log(f(false, true, 2));
+        console.log(f(true, false, 3));
+        console.log(f(true, true, 4));
+    }
+    expect: {
+        function f(x, y, a) {
+            return (!x || (console.log("seq"), y)) && a;
+        }
+        console.log(f(false, false, 1));
+        console.log(f(false, true, 2));
+        console.log(f(true, false, 3));
+        console.log(f(true, true, 4));
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "seq",
+        "false",
+        "seq",
+        "4",
+    ]
+}
+
+consequent_sequence_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(x, y, a) {
+            return x ? (console.log("seq"), y || a) : a;
+        }
+        console.log(f(false, false, 1));
+        console.log(f(false, true, 2));
+        console.log(f(true, false, 3));
+        console.log(f(true, true, 4));
+    }
+    expect: {
+        function f(x, y, a) {
+            return x && (console.log("seq"), y) || a;
+        }
+        console.log(f(false, false, 1));
+        console.log(f(false, true, 2));
+        console.log(f(true, false, 3));
+        console.log(f(true, true, 4));
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "seq",
+        "3",
+        "seq",
+        "true",
+    ]
+}
+
+consequent_sequence_3: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(x, y, a, b) {
+            return x ? (console.log("seq"), y ? a : b) : b;
+        }
+        console.log(f(false, false, 1, -1));
+        console.log(f(false, true, 2, -2));
+        console.log(f(true, false, 3, -3));
+        console.log(f(true, true, 4, -4));
+    }
+    expect: {
+        function f(x, y, a, b) {
+            return x && (console.log("seq"), y) ? a : b;
+        }
+        console.log(f(false, false, 1, -1));
+        console.log(f(false, true, 2, -2));
+        console.log(f(true, false, 3, -3));
+        console.log(f(true, true, 4, -4));
+    }
+    expect_stdout: [
+        "-1",
+        "-2",
+        "seq",
+        "-3",
+        "seq",
+        "4",
+    ]
+}
+
+consequent_sequence_4: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(x, y, a, b) {
+            return x ? (console.log("seq"), y ? a : b) : a;
+        }
+        console.log(f(false, false, 1, -1));
+        console.log(f(false, true, 2, -2));
+        console.log(f(true, false, 3, -3));
+        console.log(f(true, true, 4, -4));
+    }
+    expect: {
+        function f(x, y, a, b) {
+            return !x || (console.log("seq"), y) ? a : b;
+        }
+        console.log(f(false, false, 1, -1));
+        console.log(f(false, true, 2, -2));
+        console.log(f(true, false, 3, -3));
+        console.log(f(true, true, 4, -4));
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "seq",
+        "-3",
+        "seq",
+        "4",
+    ]
+}
+
+alternative_sequence_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(x, y, a) {
+            return x ? a : (console.log("seq"), y && a);
+        }
+        console.log(f(false, false, 1));
+        console.log(f(false, true, 2));
+        console.log(f(true, false, 3));
+        console.log(f(true, true, 4));
+    }
+    expect: {
+        function f(x, y, a) {
+            return (x || (console.log("seq"), y)) && a;
+        }
+        console.log(f(false, false, 1));
+        console.log(f(false, true, 2));
+        console.log(f(true, false, 3));
+        console.log(f(true, true, 4));
+    }
+    expect_stdout: [
+        "seq",
+        "false",
+        "seq",
+        "2",
+        "3",
+        "4",
+    ]
+}
+
+alternative_sequence_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(x, y, a) {
+            return x ? a : (console.log("seq"), y || a);
+        }
+        console.log(f(false, false, 1));
+        console.log(f(false, true, 2));
+        console.log(f(true, false, 3));
+        console.log(f(true, true, 4));
+    }
+    expect: {
+        function f(x, y, a) {
+            return !x && (console.log("seq"), y) || a;
+        }
+        console.log(f(false, false, 1));
+        console.log(f(false, true, 2));
+        console.log(f(true, false, 3));
+        console.log(f(true, true, 4));
+    }
+    expect_stdout: [
+        "seq",
+        "1",
+        "seq",
+        "true",
+        "3",
+        "4",
+    ]
+}
+
+alternative_sequence_3: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(x, y, a, b) {
+            return x ? a : (console.log("seq"), y ? a : b);
+        }
+        console.log(f(false, false, 1, -1));
+        console.log(f(false, true, 2, -2));
+        console.log(f(true, false, 3, -3));
+        console.log(f(true, true, 4, -4));
+    }
+    expect: {
+        function f(x, y, a, b) {
+            return x || (console.log("seq"), y) ? a : b;
+        }
+        console.log(f(false, false, 1, -1));
+        console.log(f(false, true, 2, -2));
+        console.log(f(true, false, 3, -3));
+        console.log(f(true, true, 4, -4));
+    }
+    expect_stdout: [
+        "seq",
+        "-1",
+        "seq",
+        "2",
+        "3",
+        "4",
+    ]
+}
+
+alternative_sequence_4: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(x, y, a, b) {
+            return x ? b : (console.log("seq"), y ? a : b);
+        }
+        console.log(f(false, false, 1, -1));
+        console.log(f(false, true, 2, -2));
+        console.log(f(true, false, 3, -3));
+        console.log(f(true, true, 4, -4));
+    }
+    expect: {
+        function f(x, y, a, b) {
+            return !x && (console.log("seq"), y) ? a : b;
+        }
+        console.log(f(false, false, 1, -1));
+        console.log(f(false, true, 2, -2));
+        console.log(f(true, false, 3, -3));
+        console.log(f(true, true, 4, -4));
+    }
+    expect_stdout: [
+        "seq",
+        "-1",
+        "seq",
+        "2",
+        "-3",
+        "-4",
+    ]
+}
+
 delete_conditional_1: {
     options = {
         booleans: true,
@@ -1704,7 +2295,7 @@ issue_3576: {
     expect_stdout: "PASS"
 }
 
-issue_3668: {
+issue_3668_1: {
     options = {
         conditionals: true,
         if_return: true,
@@ -1721,6 +2312,38 @@ issue_3668: {
         }
         console.log(f());
     }
+    expect: {
+        function f() {
+            try {
+                var undefined = typeof f;
+                if (!f) return undefined;
+            } catch (e) {
+                return "FAIL";
+            }
+        }
+        console.log(f());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_3668_2: {
+    options = {
+        conditionals: true,
+        if_return: true,
+    }
+    input: {
+        function f() {
+            try {
+                var undefined = typeof f;
+                if (!f) return undefined;
+                return;
+            } catch (e) {
+                return "FAIL";
+            }
+            FAIL;
+        }
+        console.log(f());
+    }
     expect: {
         function f() {
             try {
@@ -1729,6 +2352,7 @@ issue_3668: {
             } catch (e) {
                 return "FAIL";
             }
+            FAIL;
         }
         console.log(f());
     }
@@ -1897,3 +2521,314 @@ object_super: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_5232_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        (function() {
+            if (Math) {
+                function f() {}
+                for (var a in [ 42 ])
+                    console.log(typeof f);
+            } else {
+                var b = null;
+                return true;
+            }
+        })();
+    }
+    expect: {
+        (function() {
+            var b;
+            if (!Math)
+                return b = null, true;
+            function f() {}
+            for (var a in [ 42 ]) console.log(typeof f);
+        })();
+    }
+    expect_stdout: "function"
+}
+
+issue_5232_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        console.log(function() {
+            if (!Math);
+            else {
+                var b = null;
+                return "PASS";
+            }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var b;
+            if (Math)
+                return b = null, "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5232_3: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        console.log(function() {
+            return function() {
+                if (console)
+                    console.log("PASS");
+                else {
+                    var a = null;
+                    return "FAIL";
+                }
+            };
+        }()());
+    }
+    expect: {
+        console.log(function() {
+            return function() {
+                var a;
+                if (!console)
+                    return a = null, "FAIL";
+                console.log("PASS");
+            };
+        }()());
+    }
+    expect_stdout: [
+        "PASS",
+        "undefined",
+    ]
+}
+
+issue_5334_1: {
+    options = {
+        conditionals: true,
+        hoist_props: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            if (console.log("PASS"))
+                var o = true, o = {
+                    p: o += console.log("FAIL"),
+                };
+        }
+        f();
+    }
+    expect: {
+        (function() {
+            var o;
+            console.log("PASS") && (o = true, o = {
+                p: o += console.log("FAIL"),
+            });
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5334_2: {
+    options = {
+        conditionals: true,
+        hoist_props: true,
+        inline: true,
+        passes: 3,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            if (console.log("PASS"))
+                var o = true, o = {
+                    p: o += console.log("FAIL"),
+                };
+        }
+        f();
+    }
+    expect: {
+        console.log("PASS") && console.log("FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5544_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (a)
+            switch (42) {
+              case console.log("FAIL"):
+              case console:
+            }
+        else
+            switch (false) {
+              case console.log("PASS"):
+              case console:
+            }
+    }
+    expect: {
+        var a;
+        if (a)
+            switch (42) {
+              case console.log("FAIL"):
+              case console:
+            }
+        else
+            switch (false) {
+              case console.log("PASS"):
+              case console:
+            }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5544_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (a)
+            switch (42) {
+              case console.log("FAIL"):
+              case console:
+            }
+        else
+            switch (42) {
+              case console.log("PASS"):
+              case console:
+            }
+    }
+    expect: {
+        var a;
+        if (a)
+            switch (42) {
+              case console.log("FAIL"):
+              case console:
+            }
+        else
+            switch (42) {
+              case console.log("PASS"):
+              case console:
+            }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5546_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (a)
+            try {
+                console;
+            } finally {
+                console.log("FAIL");
+            }
+        else
+            try {
+                console;
+            } finally {
+                console.log("PASS");
+            }
+    }
+    expect: {
+        var a;
+        if (a)
+            try {
+                console;
+            } finally {
+                console.log("FAIL");
+            }
+        else
+            try {
+                console;
+            } finally {
+                console.log("PASS");
+            }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5546_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (a)
+            try {
+                console;
+            } catch (e) {}
+        else
+            try {
+                console;
+            } finally {
+                console.log("PASS");
+            }
+    }
+    expect: {
+        var a;
+        if (a)
+            try {
+                console;
+            } catch (e) {}
+        else
+            try {
+                console;
+            } finally {
+                console.log("PASS");
+            }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5546_3: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a;
+        if (a)
+            try {
+                FAIL;
+            } catch (e) {
+                console.log("FAIL");
+            }
+        else
+            try {
+                FAIL;
+            } catch (e) {
+                console.log("PASS");
+            }
+    }
+    expect: {
+        var a;
+        if (a)
+            try {
+                FAIL;
+            } catch (e) {
+                console.log("FAIL");
+            }
+        else
+            try {
+                FAIL;
+            } catch (e) {
+                console.log("PASS");
+            }
+    }
+    expect_stdout: "PASS"
+}

test/compress/const.js

@@ -142,6 +142,80 @@ if_dead_branch: {
     expect_stdout: "undefined"
 }
 
+retain_tail_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                const b = "bar";
+                while (console.log("baz"));
+                console.log(b);
+            } else {
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                const b = "bar";
+                while (console.log("baz"));
+                console.log(b);
+            } else {
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: true
+}
+
+retain_tail_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                const b = "baz";
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                const b = "baz";
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: true
+}
+
 merge_vars_1: {
     options = {
         merge_vars: true,
@@ -220,6 +294,32 @@ merge_vars_3: {
     expect_stdout: true
 }
 
+merge_vars_4: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        console.log(typeof a);
+        {
+            var b = console;
+            console.log(typeof b);
+            const a = 0;
+        }
+    }
+    expect: {
+        var a = 1;
+        console.log(typeof a);
+        {
+            var b = console;
+            console.log(typeof b);
+            const a = 0;
+        }
+    }
+    expect_stdout: true
+}
+
 use_before_init_1: {
     options = {
         reduce_vars: true,
@@ -486,7 +586,7 @@ do_continue: {
 
 catch_ie8_1: {
     options = {
-        ie8: true,
+        ie: true,
         unused: true,
     }
     input: {
@@ -506,7 +606,7 @@ catch_ie8_1: {
 catch_ie8_2: {
     options = {
         dead_code: true,
-        ie8: true,
+        ie: true,
         passes: 2,
         toplevel: true,
         unused: true,
@@ -553,6 +653,37 @@ dead_block_after_return: {
     expect_stdout: true
 }
 
+if_return_3: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        var a = "PASS";
+        function f(b) {
+            if (console) {
+                const b = a;
+                return b;
+            } else
+                while (console.log("FAIL 1"));
+            return b;
+        }
+        console.log(f("FAIL 2"));
+    }
+    expect: {
+        var a = "PASS";
+        function f(b) {
+            if (console) {
+                const b = a;
+                return b;
+            } else
+                while (console.log("FAIL 1"));
+            return b;
+        }
+        console.log(f("FAIL 2"));
+    }
+    expect_stdout: true
+}
+
 do_if_continue_1: {
     options = {
         if_return: true,
@@ -571,8 +702,7 @@ do_if_continue_1: {
     }
     expect: {
         do {
-            if (!console);
-            else {
+            if (console) {
                 console.log("PASS");
                 {
                     const a = 0;
@@ -602,8 +732,7 @@ do_if_continue_2: {
     }
     expect: {
         do {
-            if (!console);
-            else {
+            if (console) {
                 console.log("PASS");
                 {
                     const a = 0;
@@ -727,7 +856,7 @@ issue_4193: {
 
 issue_4195: {
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         console.log(function f(a) {
@@ -838,12 +967,10 @@ issue_4202: {
     expect: {
         {
             const o = {};
-            (function() {
-                function f() {
-                    o.p = 42;
-                }
-                f(f);
-            })();
+            function f() {
+                o.p = 42;
+            }
+            f(f);
             console.log(o.p++);
         }
     }
@@ -1131,7 +1258,7 @@ issue_4225: {
 
 issue_4229: {
     options = {
-        ie8: true,
+        ie: true,
         side_effects: true,
     }
     input: {
@@ -1151,7 +1278,7 @@ issue_4229: {
 
 issue_4231: {
     options = {
-        ie8: true,
+        ie: true,
         side_effects: true,
     }
     input: {
@@ -1219,9 +1346,9 @@ issue_4248: {
     expect_stdout: "PASS"
 }
 
-issue_4261: {
+issue_4261_1: {
     options = {
-        inline: true,
+        inline: 3,
         reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
@@ -1259,6 +1386,43 @@ issue_4261: {
     expect_stdout: "42"
 }
 
+issue_4261_2: {
+    options = {
+        if_return: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        {
+            const a = 42;
+            (function() {
+                function f() {
+                    console.log(a);
+                }
+                function g() {
+                    while (f());
+                }
+                (function() {
+                    while (g());
+                })();
+            })();
+        }
+    }
+    expect: {
+        {
+            const a = 42;
+            function g() {
+                while (void console.log(a));
+            }
+            while (g());
+        }
+    }
+    expect_stdout: "42"
+}
+
 issue_4274_1: {
     options = {
         loops: true,
@@ -1457,6 +1621,7 @@ issue_4689: {
 
 issue_4691: {
     options = {
+        conditionals: true,
         if_return: true,
         toplevel: true,
     }
@@ -1498,3 +1663,484 @@ issue_4691: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4848: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        function f(a) {
+            a(function() {
+                console.log(b);
+            });
+            if (!console)
+                return;
+            const b = "PASS";
+        }
+        var g;
+        f(function(h) {
+            g = h;
+        });
+        g();
+    }
+    expect: {
+        function f(a) {
+            a(function() {
+                console.log(b);
+            });
+            if (!console)
+                return;
+            const b = "PASS";
+        }
+        var g;
+        f(function(h) {
+            g = h;
+        });
+        g();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4954_1: {
+    rename = true
+    input: {
+        "use strict";
+        (function() {
+            {
+                const a = "foo";
+                console.log(a);
+            }
+            {
+                const a = "bar";
+                console.log(a);
+            }
+        })();
+    }
+    expect: {
+        "use strict";
+        (function() {
+            {
+                const a = "foo";
+                console.log(a);
+            }
+            {
+                const b = "bar";
+                console.log(b);
+            }
+        })();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+issue_4954_2: {
+    mangle = {}
+    input: {
+        "use strict";
+        const a = null;
+        (function(b) {
+            for (const a in null);
+            for (const a in b)
+                console.log("PASS");
+        })([ null ]);
+    }
+    expect: {
+        "use strict";
+        const a = null;
+        (function(o) {
+            for (const n in null);
+            for (const n in o)
+                console.log("PASS");
+        })([ null ]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4960: {
+    mangle = {}
+    input: {
+        "use strict";
+        var a;
+        (function() {
+            {
+                const a = console.log("PASS");
+            }
+            try {} catch (e) {
+                const a = console.log("FAIL");
+            }
+        })();
+    }
+    expect: {
+        "use strict";
+        var a;
+        (function() {
+            {
+                const o = console.log("PASS");
+            }
+            try {} catch (o) {
+                const c = console.log("FAIL");
+            }
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4965_1: {
+    mangle = {}
+    input: {
+        "use strict";
+        try {
+            c;
+        } catch (a) {
+            {
+                const a = 1;
+            }
+            {
+                const a = console.log(typeof c);
+            }
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            c;
+        } catch (t) {
+            {
+                const c = 1;
+            }
+            {
+                const t = console.log(typeof c);
+            }
+        }
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_4965_2: {
+    mangle = {}
+    input: {
+        "use strict";
+        try {
+            throw 1;
+        } catch (e) {
+            try {
+                {
+                    const e = 2;
+                }
+            } finally {
+                const e = 3;
+                console.log(typeof t);
+            }
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            throw 1;
+        } catch (o) {
+            try {
+                {
+                    const t = 2;
+                }
+            } finally {
+                const o = 3;
+                console.log(typeof t);
+            }
+        }
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5254: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        do {
+            (function() {
+                const a = console.log;
+                a && a("foo");
+            })();
+        } while (console.log("bar"));
+    }
+    expect: {
+        do {
+            const a = console.log;
+            a && a("foo");
+        } while (console.log("bar"));
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+issue_5260: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = "foo", o;
+        while (console.log("bar"));
+        o = {
+            baz: function(b) {
+                console.log(a, b);
+            },
+        };
+        for (const a in o)
+            o[a](a);
+    }
+    expect: {
+        "use strict";
+        var a = "foo", o;
+        while (console.log("bar"));
+        o = {
+            baz: function(b) {
+                console.log(a, b);
+            },
+        };
+        for (const a in o)
+            o[a](a);
+    }
+    expect_stdout: [
+        "bar",
+        "foo baz",
+    ]
+    node_version: ">=4"
+}
+
+issue_5319: {
+    options = {
+        collapse_vars: true,
+        merge_vars: true,
+    }
+    input: {
+        (function(a, c) {
+            var b = a, c = b;
+            {
+                const a = c;
+                console.log(c());
+            }
+        })(function() {
+            return "PASS";
+        });
+    }
+    expect: {
+        (function(a, c) {
+            var b = a, c;
+            {
+                const a = c = b;
+                console.log(c());
+            }
+        })(function() {
+            return "PASS";
+        });
+    }
+    expect_stdout: true
+}
+
+issue_5338: {
+    options = {
+        unused: true,
+    }
+    input: {
+        const a = a;
+    }
+    expect: {
+        const a = a;
+    }
+    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"
+}
+
+issue_5516: {
+    options = {
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function() {
+            try {} catch (a) {
+                (function f() {
+                    a;
+                })();
+            }
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            try {} catch (a) {
+                void a;
+            }
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect_stdout: "function"
+}
+
+issue_5580_1: {
+    mangle = {}
+    input: {
+        "use strict";
+        console.log(function(a, b, c) {
+            try {
+                FAIL;
+            } catch (e) {
+                return function() {
+                    var d = e, i, j;
+                    {
+                        const e = j;
+                    }
+                    return a;
+                }();
+            } finally {
+                const e = 42;
+            }
+        }("PASS"));
+    }
+    expect: {
+        "use strict";
+        console.log(function(r, n, t) {
+            try {
+                FAIL;
+            } catch (o) {
+                return function() {
+                    var n = o, t, c;
+                    {
+                        const o = c;
+                    }
+                    return r;
+                }();
+            } finally {
+                const c = 42;
+            }
+        }("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_5580_2: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        (function() {
+            try {
+                throw "PASS";
+            } catch (e) {
+                return function() {
+                    console.log(e);
+                    {
+                        const e = "FAIL 1";
+                    }
+                }();
+            } finally {
+                const e = "FAIL 2";
+            }
+        })();
+    }
+    expect: {
+        "use strict";
+        (function() {
+            try {
+                throw "PASS";
+            } catch (e) {
+                console.log(e);
+                {
+                    const e = "FAIL 1";
+                }
+                return;
+            } finally {
+                var e = "FAIL 2";
+            }
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_5591: {
+    options = {
+        dead_code: true,
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            switch (console.log("foo")) {
+              case console.log("bar"):
+                if (console.log("baz"))
+                    return;
+                else {
+                    const a = 42;
+                    return;
+                }
+                break;
+              case null:
+                FAIL;
+            }
+        }
+        f();
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            switch (console.log("foo")) {
+              case console.log("bar"):
+                if (console.log("baz"))
+                    return;
+                else {
+                    const a = 42;
+                    return;
+                }
+              case null:
+                FAIL;
+            }
+        }
+        f();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
+    node_version: ">=4"
+}

test/compress/dead-code.js

@@ -939,6 +939,185 @@ catch_return_assign: {
     expect_stdout: "PASS"
 }
 
+catch_return_assign_may_throw: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        function f() {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return e = console.log("PASS");
+            }
+        }
+        f();
+    }
+    expect: {
+        function f() {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return console.log("PASS");
+            }
+        }
+        f();
+    }
+    expect_stdout: "PASS"
+}
+
+finally_return_assign: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(function(a) {
+            try {
+                throw "FAIL";
+            } finally {
+                return a = "PASS";
+            }
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            try {
+                throw "FAIL";
+            } finally {
+                return "PASS";
+            }
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+last_assign_statement: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        function f(a) {
+            a = a("PASS");
+        }
+        f(console.log);
+    }
+    expect: {
+        function f(a) {
+            a("PASS");
+        }
+        f(console.log);
+    }
+    expect_stdout: "PASS"
+}
+
+last_assign_if_else: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        function f(a) {
+            if (a)
+                a = console.log("foo");
+            else {
+                console.log("bar");
+                a = console.log("baz");
+            }
+        }
+        f(42);
+        f(null);
+    }
+    expect: {
+        function f(a) {
+            if (a)
+                console.log("foo");
+            else {
+                console.log("bar");
+                console.log("baz");
+            }
+        }
+        f(42);
+        f(null);
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
+}
+
+last_assign_catch: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        function f() {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                e = console.log("PASS");
+            }
+        }
+        f();
+    }
+    expect: {
+        function f() {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                console.log("PASS");
+            }
+        }
+        f();
+    }
+    expect_stdout: "PASS"
+}
+
+last_assign_finally: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        function f(a) {
+            try {
+                throw a.log;
+            } catch (e) {
+                a = e;
+            } finally {
+                a = a("PASS");
+            }
+        }
+        f(console);
+    }
+    expect: {
+        function f(a) {
+            try {
+                throw a.log;
+            } catch (e) {
+                a = e;
+            } finally {
+                a("PASS");
+            }
+        }
+        f(console);
+    }
+    expect_stdout: "PASS"
+}
+
+consecutive_assignments: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        while (a = void 0, a = "PASS", console.log(a));
+        var a;
+    }
+    expect: {
+        while (void 0, a = "PASS", console.log(a));
+        var a;
+    }
+    expect_stdout: "PASS"
+}
+
 issue_3578: {
     options = {
         dead_code: true,
@@ -1420,3 +1599,111 @@ issue_4570: {
     }
     expect_stdout: "NaN"
 }
+
+issue_5030: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        (function(a, b) {
+            a = function f() {
+                if (a)
+                    if (b--)
+                        setImmediate(f);
+                    else
+                        console.log("FAIL");
+                else
+                    console.log("PASS");
+            }();
+        })(42, 1);
+    }
+    expect: {
+        (function(a, b) {
+            a = function f() {
+                if (a)
+                    if (b--)
+                        setImmediate(f);
+                    else
+                        console.log("FAIL");
+                else
+                    console.log("PASS");
+            }();
+        })(42, 1);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=0.12"
+}
+
+issue_5106_1: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(typeof function(a) {
+            return a = arguments;
+        }("FAIL")[0]);
+    }
+    expect: {
+        console.log(typeof function(a) {
+            return a = arguments;
+        }("FAIL")[0]);
+    }
+    expect_stdout: "object"
+}
+
+issue_5106_2: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        "use strict";
+        console.log(function(a) {
+            return a = arguments;
+        }("PASS")[0]);
+    }
+    expect: {
+        "use strict";
+        console.log(function(a) {
+            return arguments;
+        }("PASS")[0]);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5506: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        try {
+            (function(a) {
+                var b = 1;
+                (function f() {
+                    try {
+                        b-- && f();
+                    } catch (c) {}
+                    console.log(a);
+                    a = 42 in (a = "bar");
+                })();
+            })("foo");
+        } catch (e) {}
+    }
+    expect: {
+        try {
+            (function(a) {
+                var b = 1;
+                (function f() {
+                    try {
+                        b-- && f();
+                    } catch (c) {}
+                    console.log(a);
+                    a = 42 in (a = "bar");
+                })();
+            })("foo");
+        } catch (e) {}
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}

test/compress/directives.js

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

test/compress/drop-unused.js

@@ -671,6 +671,76 @@ iife: {
     }
 }
 
+drop_instanceof: {
+    options = {
+        booleans: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {}
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        console.log(!1, (Math, !1));
+    }
+    expect_stdout: "false false"
+}
+
+keep_instanceof_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {}
+        var f;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        function f() {}
+        var f;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect_stdout: "false false"
+}
+
+keep_instanceof_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {}
+        var f = Object;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        function f() {}
+        var f = Object;
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect_stdout: "true true"
+}
+
+keep_instanceof_3: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        f = Object;
+        function f() {}
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect: {
+        f = Object;
+        function f() {}
+        console.log({} instanceof f, Math instanceof f);
+    }
+    expect_stdout: "true true"
+}
+
 issue_1539: {
     options = {
         collapse_vars: true,
@@ -795,9 +865,9 @@ issue_1656: {
         beautify: true,
     }
     input: {
-        for(var a=0;;);
+        for (var a=0;;);
     }
-    expect_exact: "for (;;) ;"
+    expect_exact: "for (;;);"
 }
 
 issue_1709: {
@@ -1110,7 +1180,7 @@ issue_1838: {
     }
     expect_exact: [
         "function f() {",
-        "    for (a; c; ) ;",
+        "    for (a; c; );",
         "}",
     ]
 }
@@ -1233,8 +1303,11 @@ issue_2105_2: {
 issue_2105_3: {
     options = {
         inline: true,
-        passes: 2,
+        join_vars: true,
+        passes: 3,
         reduce_vars: true,
+        side_effects: true,
+        sequences: true,
         unused: true,
     }
     input: {
@@ -1258,12 +1331,12 @@ issue_2105_3: {
         });
     }
     expect: {
-        !void void {
+        ({
             prop: function() {
-                console.log;
-                void console.log("PASS");
-            }
-        }.prop();
+                console.log,
+                console.log("PASS");
+            },
+        }).prop();
     }
     expect_stdout: "PASS"
 }
@@ -1557,9 +1630,9 @@ issue_2665: {
     }
     expect: {
         var a = 1;
-        !function g() {
+        (function g() {
             a-- && g();
-        }();
+        })();
         console.log(a);
     }
     expect_stdout: "-1"
@@ -1728,7 +1801,8 @@ issue_2768: {
     }
     expect: {
         var a = "FAIL";
-        var c = (d = a, void (d && (a = "PASS")));
+        d = a;
+        var c = void (d && (a = "PASS"));
         var d;
         console.log(a, typeof c);
     }
@@ -1765,7 +1839,7 @@ issue_2846: {
 issue_805_1: {
     options = {
         inline: true,
-        passes: 2,
+        passes: 3,
         pure_getters: "strict",
         reduce_vars: true,
         sequences: true,
@@ -1798,7 +1872,7 @@ issue_805_1: {
 issue_805_2: {
     options = {
         inline: true,
-        passes: 2,
+        passes: 3,
         pure_getters: "strict",
         reduce_vars: true,
         sequences: true,
@@ -2345,7 +2419,7 @@ function_argument_reference: {
 
 function_parameter_ie8: {
     options = {
-        ie8: true,
+        ie: true,
         reduce_vars: true,
         unused: true,
     }
@@ -2371,6 +2445,7 @@ function_parameter_ie8: {
 issue_3664: {
     options = {
         pure_getters: "strict",
+        side_effects: true,
         unused: true,
     }
     input: {
@@ -2381,7 +2456,8 @@ issue_3664: {
     }
     expect: {
         console.log(function() {
-            var b = ([ b && console.log("FAIL") ].p = 0, 0);
+            a = (a = [ b && console.log("FAIL") ]).p = 0;
+            var a, b = 0;
             return "PASS";
         }());
     }
@@ -2391,6 +2467,7 @@ issue_3664: {
 issue_3673: {
     options = {
         pure_getters: "strict",
+        sequences: true,
         side_effects: true,
         toplevel: true,
         unused: true,
@@ -2401,8 +2478,6 @@ issue_3673: {
         console.log("PASS");
     }
     expect: {
-        var a;
-        (a = [ a ]).p = 42;
         console.log("PASS");
     }
     expect_stdout: "PASS"
@@ -2551,10 +2626,9 @@ issue_3899: {
         console.log(typeof a);
     }
     expect: {
-        function a() {
+        console.log(typeof function() {
             return 2;
-        }
-        console.log(typeof a);
+        });
     }
     expect_stdout: "function"
 }
@@ -2652,7 +2726,7 @@ issue_3956: {
         collapse_vars: true,
         evaluate: true,
         inline: true,
-        passes: 2,
+        passes: 3,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -2783,7 +2857,7 @@ issue_3986: {
     expect_stdout: "0"
 }
 
-issue_4017: {
+issue_4017_1: {
     options = {
         pure_getters: "strict",
         reduce_vars: true,
@@ -2801,7 +2875,31 @@ issue_4017: {
         var a = 0;
         console.log(function() {
             c &= 0;
-            var c;
+            var c = a++ + (A = a);
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4017_2: {
+    options = {
+        passes: 2,
+        pure_getters: "strict",
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        console.log(function f() {
+            var b = c &= 0;
+            var c = a++ + (A = a);
+            var d = c && c[f];
+        }());
+    }
+    expect: {
+        var a = 0;
+        console.log(function() {
+            0;
             a++,
             A = a;
         }());
@@ -2916,7 +3014,7 @@ issue_4133: {
         console.log(a);
     }
     expect: {
-        var b = 1;
+        var a = 1;
         console.log(0);
     }
     expect_stdout: "0"
@@ -3062,7 +3160,7 @@ issue_4184: {
     expect_stdout: "42"
 }
 
-issue_4235: {
+issue_4235_1: {
     options = {
         inline: true,
         reduce_vars: true,
@@ -3080,12 +3178,35 @@ issue_4235: {
         })();
     }
     expect: {
+        void function() {
+            var f = console.log(f);
+        }();
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4235_2: {
+    options = {
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
         (function() {
-            f = console.log(f),
-            void 0;
-            var f;
+            {
+                const f = 0;
+            }
+            (function f() {
+                var f = console.log(f);
+            })();
         })();
     }
+    expect: {
+        console.log(void 0);
+    }
     expect_stdout: "undefined"
 }
 
@@ -3221,7 +3342,7 @@ issue_4558_1: {
     expect: {
         var a = 0;
         var b = c >>>= a;
-        var c;
+        var c = 0;
         b && a++,
         console.log(a);
     }
@@ -3231,7 +3352,7 @@ issue_4558_1: {
 issue_4558_2: {
     options = {
         evaluate: true,
-        ie8: true,
+        ie: true,
         reduce_vars: true,
         unused: true,
     }
@@ -3307,6 +3428,7 @@ issue_4806_1: {
 issue_4806_2: {
     options = {
         sequences: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }
@@ -3357,3 +3479,291 @@ issue_4806_3: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4834: {
+    options = {
+        inline: true,
+        keep_fargs: false,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        try {
+            new function(a, b) {
+                b;
+                b.p;
+            }(42);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            b.p;
+        } catch (e) {
+            console.log("PASS");
+        }
+        var b;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4912_1: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = A = function() {};
+        A;
+        a.prototype = {
+            f: function() {
+                console.log("PASS");
+            },
+        };
+        new A().f();
+    }
+    expect: {
+        var a = A = function() {};
+        A;
+        a.prototype = {
+            f: function() {
+                console.log("PASS");
+            },
+        };
+        new A().f();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4912_2: {
+    options = {
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var g, f = function() {};
+            f.p = {};
+            (g = f.p.q = function() {}).r = "PASS";
+            return f;
+        }().p.q.r);
+    }
+    expect: {
+        console.log(function() {
+            var g, f = function() {};
+            f.p = {};
+            (f.p.q = function() {}).r = "PASS";
+            return f;
+        }().p.q.r);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4912_3: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(f, g) {
+            f = function() {};
+            f.p = {};
+            g = f.p.q = function() {};
+            g.r = "PASS";
+            return f;
+        }().p.q.r);
+    }
+    expect: {
+        console.log(function(f, g) {
+            f = function() {};
+            f.p = {};
+            g = f.p.q = function() {};
+            g.r = "PASS";
+            return f;
+        }().p.q.r);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5079: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        do {
+            (a = 123456).p = a;
+            a.q = null;
+        } while (console.log("PASS"));
+    }
+    expect: {
+        do {
+            0, 0, null;
+        } while (console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5224: {
+    options = {
+        evaluate: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            try {
+                var b = function() {
+                    var a = "FAIL 1";
+                    null && a;
+                    a = console.log(a);
+                }(new function(c, d) {
+                    console.log(d);
+                    a;
+                }("FAIL 2", Infinity));
+            } finally {
+                return f;
+            }
+        }
+        f();
+    }
+    expect: {
+        (function f() {
+            try {
+                (function() {
+                    var a = "FAIL 1";
+                    null;
+                    a = console.log(a);
+                })(function() {
+                    console.log(1 / 0);
+                    a;
+                }());
+            } finally {
+                return f;
+            }
+        })();
+    }
+    expect_stdout: "Infinity"
+}
+
+issue_5271: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            do {
+                var a = b = 0 ^ f, b = b;
+            } while (console.log(42 - b));
+        }
+        f();
+    }
+    expect: {
+        (function f() {
+            do {
+                var b;
+                b = 0 ^ f;
+            } while (console.log(42 - b));
+        })();
+    }
+    expect_stdout: "42"
+}
+
+issue_5533_keep_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: true,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5533_drop_fargs: {
+    options = {
+        evaluate: true,
+        inline: true,
+        join_vars: true,
+        keep_fargs: false,
+        loops: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function() {
+                var a;
+                for (; 1;)
+                    a = function() {
+                        (function f(b) {
+                            b;
+                            throw "PASS";
+                        })();
+                    }();
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function() {
+                for (;;)
+                    throw "PASS";
+            })();
+        } catch (e) {
+            console.log(e);
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/evaluate.js

@@ -684,26 +684,47 @@ prototype_function: {
         side_effects: true,
     }
     input: {
-        var a = ({valueOf: 0}) < 1;
-        var b = ({toString: 0}) < 1;
-        var c = ({valueOf: 0}) + "";
-        var d = ({toString: 0}) + "";
-        var e = (({valueOf: 0}) + "")[2];
-        var f = (({toString: 0}) + "")[2];
-        var g = ({valueOf: 0}).valueOf();
-        var h = ({toString: 0}).toString();
+        function v() {
+            return this.valueOf === v ? "PASS" : "FAIL";
+        }
+        console.log(({ valueOf: v }) < 1);
+        console.log(({ valueOf: v }) + "");
+        console.log((( {valueOf: v }) + "")[2]);
+        console.log(({ valueOf: v }).valueOf());
+        function t() {
+            return this.toString === t ? "PASS" : "FAIL";
+        }
+        console.log(({ toString: t }) < 1);
+        console.log(({ toString: t }) + "");
+        console.log((( {toString: t }) + "")[2]);
+        console.log(({ toString: t }).toString());
     }
     expect: {
-        var a = ({valueOf: 0}) < 1;
-        var b = ({toString: 0}) < 1;
-        var c = ({valueOf: 0}) + "";
-        var d = ({toString: 0}) + "";
-        var e = (({valueOf: 0}) + "")[2];
-        var f = (({toString: 0}) + "")[2];
-        var g = 0();
-        var h = 0();
+        function v() {
+            return this.valueOf === v ? "PASS" : "FAIL";
+        }
+        console.log(({ valueOf: v }) < 1);
+        console.log(({ valueOf: v }) + "");
+        console.log((( {valueOf: v }) + "")[2]);
+        console.log(({ valueOf: v }).valueOf());
+        function t() {
+            return this.toString === t ? "PASS" : "FAIL";
+        }
+        console.log(({ toString: t }) < 1);
+        console.log(({ toString: t }) + "");
+        console.log((( {toString: t }) + "")[2]);
+        console.log(({ toString: t }).toString());
     }
-    expect_stdout: true
+    expect_stdout: [
+        "false",
+        "PASS",
+        "S",
+        "PASS",
+        "false",
+        "PASS",
+        "S",
+        "PASS",
+    ]
 }
 
 call_args: {
@@ -724,7 +745,7 @@ call_args: {
     expect: {
         var a = 1;
         console.log(1);
-        +(1, 1);
+        1, 1;
     }
     expect_stdout: true
 }
@@ -748,7 +769,7 @@ call_args_drop_param: {
     }
     expect: {
         console.log(1);
-        +(b, 1);
+        b, 1;
     }
     expect_stdout: true
 }
@@ -867,6 +888,39 @@ unsafe_charAt_noop: {
     expect_stdout: "f  n"
 }
 
+chained_side_effects: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log("foo") || (console.log("bar"), "baz") || console.log("moo");
+    }
+    expect: {
+        console.log("foo") || (console.log("bar"), "baz");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    expect_warnings: [
+        "WARN: Condition left of || always true [test/compress/evaluate.js:1,8]",
+    ]
+}
+
+instanceof_lambda: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(42 instanceof function() {});
+    }
+    expect: {
+        console.log(false);
+    }
+    expect_stdout: "false"
+}
+
 issue_1649: {
     options = {
         evaluate: true,
@@ -2731,8 +2785,7 @@ issue_3944: {
     }
     expect: {
         void function f() {
-            while (a = 0 == (a = void 0), console.log(a), void 0);
-            var a;
+            while (0 == void 0, console.log(false), void 0);
             f;
         }();
     }
@@ -3181,3 +3234,185 @@ issue_4552: {
     }
     expect_stdout: "NaN"
 }
+
+issue_4886_1: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log("length" in {
+            __proto__: function() {},
+            length: void 0,
+        });
+    }
+    expect: {
+        console.log("length" in {
+            __proto__: function() {},
+            length: void 0,
+        });
+    }
+    expect_stdout: "true"
+}
+
+issue_4886_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log("foo" in {
+            "foo": null,
+            __proto__: 42,
+        });
+    }
+    expect: {
+        console.log("foo" in {
+            "foo": null,
+            __proto__: 42,
+        });
+    }
+    expect_stdout: "true"
+}
+
+issue_5354: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        function f(a) {
+            return +a.toExponential(1);
+        }
+        function g(b) {
+            return 0 + b.toFixed(2);
+        }
+        function h(c) {
+            return 1 * c.toPrecision(3);
+        }
+        console.log(typeof f(45), typeof g(67), typeof h(89));
+    }
+    expect: {
+        function f(a) {
+            return +a.toExponential(1);
+        }
+        function g(b) {
+            return 0 + b.toFixed(2);
+        }
+        function h(c) {
+            return +c.toPrecision(3);
+        }
+        console.log(typeof f(45), typeof g(67), typeof h(89));
+    }
+    expect_stdout: "number string number"
+}
+
+issue_5356: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            return a++;
+            var a = a;
+        }());
+    }
+    expect: {
+        console.log(+a);
+        var a;
+    }
+    expect_stdout: "NaN"
+}
+
+issue_5362_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = -console;
+        console.log(delete +a);
+    }
+    expect: {
+        var a = -console;
+        console.log((+a, true));
+    }
+    expect_stdout: "true"
+}
+
+issue_5362_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var a = -console;
+        console.log(delete +a);
+    }
+    expect: {
+        console.log(true);
+    }
+    expect_stdout: "true"
+}
+
+issue_5380: {
+    options = {
+        evaluate: true,
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f(b) {
+            return function g() {
+                for (b in { PASS: 42 });
+            }(), b;
+        }("FAIL");
+        console.log(a);
+    }
+    expect: {
+        var a = function f(b) {
+            return function g() {
+                for (b in { PASS: 42 });
+            }(), b;
+        }("FAIL");
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5558: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        sequences: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 99, b = 0;
+        a++;
+        b++;
+        b += a;
+        b *= a;
+        b += a;
+        console.log(a);
+    }
+    expect: {
+        var a = 99, b = 0;
+        b++,
+        b = (b += ++a) * a + a,
+        console.log(a);
+    }
+    expect_stdout: "100"
+}

test/compress/exponentiation.js

@@ -62,7 +62,7 @@ assignment_2: {
     }
     expect_exact: "var a=8n;a**=a;console.log(a);"
     expect_stdout: "16777216n"
-    node_version: ">=10"
+    node_version: ">=10.4.0"
 }
 
 evaluate: {
@@ -100,7 +100,7 @@ issue_4664: {
         (function f() {
             new function(a) {
                 console.log(typeof f, 2 ** 30, typeof this);
-            }(0, A = 0);
+            }(A = 0);
         })();
     }
     expect_stdout: "function 1073741824 object"

test/compress/exports.js

@@ -91,6 +91,13 @@ defaults_parentheses_6: {
     expect_exact: 'export default(function(){while(!console);})()?"FAIL":"PASS";'
 }
 
+defaults_regexp: {
+    input: {
+        export default /foo/;
+    }
+    expect_exact: "export default/foo/;"
+}
+
 foreign: {
     input: {
         export * from "foo";
@@ -102,6 +109,17 @@ foreign: {
     expect_exact: 'export*from"foo";export{}from"bar";export*as a from"baz";export{default}from"moo";export{b,c as case,default as delete,d}from"moz";'
 }
 
+non_identifiers: {
+    beautify = {
+        quote_style: 3,
+    }
+    input: {
+        export * as "42" from 'foo';
+        export { '42', "delete" as 'foo' } from "bar";
+    }
+    expect_exact: "export*as\"42\"from'foo';export{'42',delete as foo}from\"bar\";"
+}
+
 same_quotes: {
     beautify = {
         beautify: true,
@@ -242,7 +260,7 @@ hoist_exports_2: {
         }
     }
     expect: {
-        let e, { foo: a } = 42;
+        let e, a = 42["foo"];
         function f(t, { [e]: o }) {
             t(o, f);
         }
@@ -410,6 +428,46 @@ hoist_funs: {
     expect_exact: "export function f(){}export default async function*g(){}"
 }
 
+instanceof_default_class: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class A {
+            f(a) {
+                return a instanceof A;
+            }
+        }
+    }
+    expect: {
+        export default class A {
+            f(a) {
+                return a instanceof A;
+            }
+        }
+    }
+}
+
+instanceof_default_function: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f() {
+            if (!(this instanceof f))
+                throw new Error("must instantiate");
+        }
+    }
+    expect: {
+        export default function f() {
+            if (!(this instanceof f))
+                throw new Error("must instantiate");
+        }
+    }
+}
+
 issue_4742_join_vars_1: {
     options = {
         join_vars: true,
@@ -489,3 +547,16 @@ issue_4766: {
         export var a = "bar";
     }
 }
+
+issue_5444: {
+    options = {
+        unused: true,
+    }
+    input: {
+        export var a = (console, console);
+    }
+    expect: {
+        console;
+        export var a = console;
+    }
+}

test/compress/hoist_props.js

@@ -217,7 +217,8 @@ name_collision_1: {
         var obj_foo = 1;
         var obj_bar = 2;
         function f() {
-            var obj_foo$0 = 3,
+            var obj,
+                obj_foo$0 = 3,
                 obj_bar = 4,
                 obj_b_r = 5,
                 obj_b_r$0 = 6,
@@ -249,7 +250,8 @@ name_collision_2: {
         console.log(o.p === o.p, o["+"](4), o["-"](5), o__$0, o__$1);
     }
     expect: {
-        var o_p = 1,
+        var o,
+            o_p = 1,
             o__ = function(x) {
                 return x;
             },
@@ -283,7 +285,8 @@ name_collision_3: {
         console.log(o.p === o.p, o["+"](4), o["-"](5));
     }
     expect: {
-        var o_p = 1,
+        var o,
+            o_p = 1,
             o__ = function(x) {
                 return x;
             },
@@ -315,7 +318,7 @@ name_collision_4: {
     }
     expect: {
         console.log(function() {
-            var o_p$0 = 0, o_q = "PASS";
+            var o, o_p$0 = 0, o_q = "PASS";
             return function(o_p) {
                 if (!o_p$0) return o_p;
             }(o_q);
@@ -768,7 +771,7 @@ issue_3046: {
     expect: {
         console.log(function(a) {
             do {
-                var b_c = a++;
+                var b, b_c = a++;
             } while (b_c && a);
             return a;
         }(0));
@@ -777,6 +780,32 @@ issue_3046: {
 }
 
 issue_3071_1: {
+    options = {
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        join_vars: true,
+        passes: 3,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var obj = {};
+            obj.one = 1;
+            obj.two = 2;
+            console.log(obj.one, obj.two);
+        })();
+    }
+    expect: {
+        console.log(1, 2);
+    }
+    expect_stdout: "1 2"
+}
+
+issue_3071_1_toplevel: {
     options = {
         evaluate: true,
         hoist_props: true,
@@ -905,7 +934,7 @@ issue_3411: {
     expect: {
         var c = 1;
         !function f() {
-            var o_p = --c && f();
+            var o, o_p = --c && f();
             +{} || console.log("PASS");
         }();
     }
@@ -1016,9 +1045,7 @@ issue_3945_1: {
     expect: {
         function f() {
             o.p;
-            var o = {
-                q: 0,
-            };
+            var o, o_q = 0;
         }
     }
 }
@@ -1037,9 +1064,7 @@ issue_3945_2: {
     }
     expect: {
         console.log(typeof o);
-        var o = {
-            p: 0,
-        };
+        var o, o_p = 0;
     }
     expect_stdout: "undefined"
 }
@@ -1094,3 +1119,108 @@ object_super: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_4985: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = { p: 42 };
+        console.log(function() {
+            a;
+        }());
+    }
+    expect: {
+        var a, a_p = 42;
+        console.log(function() {
+            ({});
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_5182: {
+    options = {
+        hoist_props: true,
+        merge_vars: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = console;
+        log = o.log;
+        o = {
+            p: function(a) {
+                console.log(a ? "PASS" : "FAIL");
+                return a;
+            },
+        };
+        log(o.p(42));
+    }
+    expect: {
+        var o = console;
+        log = o.log;
+        o = function(a) {
+            console.log(a ? "PASS" : "FAIL");
+            return a;
+        };
+        log(o(42));
+    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+}
+
+issue_5441: {
+    options = {
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(a) {
+            (function() {
+                a = { p: this };
+            })();
+            return typeof a;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            (function() {
+                a_p = this;
+            })();
+            var a_p;
+            return typeof {};
+        }());
+    }
+    expect_stdout: "object"
+}
+
+issue_5498: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            __proto__: 42,
+        };
+        while (console.log(typeof o.__proto__));
+    }
+    expect: {
+        var o = {
+            __proto__: 42,
+        };
+        while (console.log(typeof o.__proto__));
+    }
+    expect_stdout: "object"
+}

test/compress/hoist_vars.js

@@ -135,7 +135,31 @@ issue_2295: {
     }
 }
 
-issue_4487: {
+issue_4487_1: {
+    options = {
+        functions: true,
+        hoist_vars: true,
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f() {
+            var f = console.log(typeof f);
+        };
+        var b = a();
+    }
+    expect: {
+        var a = function f() {
+            var f = console.log(typeof f);
+        };
+        a();
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4487_2: {
     options = {
         functions: true,
         hoist_vars: true,
@@ -160,6 +184,30 @@ issue_4487: {
     expect_stdout: "undefined"
 }
 
+issue_4487_3: {
+    options = {
+        functions: true,
+        hoist_vars: true,
+        keep_fnames: true,
+        passes: 3,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f() {
+            var f = console.log(typeof f);
+        };
+        var b = a();
+    }
+    expect: {
+        (function a() {
+            console.log(typeof void 0);
+        })();
+    }
+    expect_stdout: "undefined"
+}
+
 issue_4489: {
     options = {
         collapse_vars: true,
@@ -176,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"
@@ -202,8 +249,7 @@ issue_4517: {
     expect: {
         console.log(function() {
             var a = 2;
-            A = a;
-            return A + typeof !1;
+            return (A = a) + typeof !1;
         }());
     }
     expect_stdout: "2boolean"
@@ -234,9 +280,326 @@ issue_4736: {
         (function() {
             (function() {
                 0,
-                console.log(1073741824);
+                console.log(1 << 30);
             })();
         })();
     }
     expect_stdout: "1073741824"
 }
+
+issue_4839: {
+    options = {
+        evaluate: true,
+        hoist_vars: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var log = console.log, o = function(a, b) {
+            return b && b;
+        }("foo");
+        for (var k in o)
+            throw "FAIL";
+        log("PASS");
+    }
+    expect: {
+        var k, log = console.log;
+        for (k in void 0)
+            throw "FAIL";
+        log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4859: {
+    options = {
+        evaluate: true,
+        hoist_vars: true,
+        keep_infinity: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var b = (a = 2, 1 / 0), c = 3;
+            var d = a + b;
+            console.log(d);
+            return f;
+        }
+        f();
+    }
+    expect: {
+        (function f(a) {
+            console.log(2 + 1 / 0);
+            return f;
+        })();
+    }
+    expect_stdout: "Infinity"
+}
+
+issue_4893_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {}
+            var a = null;
+            var b = null;
+            var c = null;
+            b.p += a = 42;
+            f;
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try{
+            (function f() {
+                null.p += 42;
+                f;
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4893_2: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {}
+            var a = null;
+            var b = null;
+            var c = null;
+            b.p += a = 42;
+            f;
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try{
+            (function() {
+                var a;
+                a = null;
+                a.p += 42;
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4898: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        hoist_vars: true,
+        loops: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        do {
+            var b = [ console.log("PASS") ];
+            var c = b;
+        } while (c.p = 0);
+    }
+    expect: {
+        var b;
+        b = [ console.log("PASS") ];
+        b.p = 0;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5187: {
+    options = {
+        hoist_props: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var a = 42;
+            do {
+                var b = { 0: a++ };
+            } while (console.log(b[b ^= 0]));
+        }
+        f();
+    }
+    expect: {
+        (function() {
+            var b, a = 42;
+            do {
+                b = { 0: a++ };
+            } while (console.log(b[b ^= 0]));
+        })();
+    }
+    expect_stdout: "42"
+}
+
+issue_5195: {
+    options = {
+        hoist_props: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var a;
+            do {
+                var b = { p: a };
+            } while (console.log(b += ""));
+        }
+        f();
+    }
+    expect: {
+        (function() {
+            var a, b;
+            do {
+                b = { p: a };
+            } while (console.log(b += ""));
+        })();
+    }
+    expect_stdout: "[object Object]"
+}
+
+issue_5378: {
+    options = {
+        hoist_vars: true,
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 2;
+        while (a--)
+            (function() {
+                var b;
+                var c;
+                while (console.log(b));
+                --b;
+            })();
+    }
+    expect: {
+        var a = 2;
+        while (a--) {
+            b = void 0;
+            var b, c;
+            while (console.log(b));
+            --b;
+        }
+    }
+    expect_stdout: [
+        "undefined",
+        "undefined",
+    ]
+}
+
+issue_5411_1: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        b++;
+        b = a;
+        var b = b, c = c && c[b];
+        console.log(b);
+    }
+    expect: {
+        var b, c, a = "PASS";
+        b++;
+        b = a;
+        c = c && c[b];
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5411_2: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        evaluate: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        b++;
+        b = a;
+        var b = b, c = c && c[b];
+        console.log(b);
+    }
+    expect: {
+        var b, c;
+        b++;
+        b = "PASS",
+        c = c && c[b];
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5411_3: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = console;
+        a++;
+        var a = A = a;
+        console.log(A);
+    }
+    expect: {
+        var a = console;
+        a = A = ++a;
+        console.log(A);
+    }
+    expect_stdout: "NaN"
+}

test/compress/imports.js

@@ -40,6 +40,17 @@ default_keys: {
     expect_exact: 'import foo,{bar}from"baz";'
 }
 
+non_identifiers: {
+    beautify = {
+        quote_style: 3,
+    }
+    input: {
+        import { '42' as foo } from "bar";
+        import { "foo" as bar } from 'baz';
+    }
+    expect_exact: "import{'42'as foo}from\"bar\";import{foo as bar}from'baz';"
+}
+
 dynamic: {
     input: {
         (async a => await import(a))("foo").then(bar);
@@ -54,13 +65,22 @@ dynamic_nought: {
     expect_exact: "import(foo);"
 }
 
-import_meta: {
+import_meta_1: {
     input: {
         console.log(import.meta, import.meta.url);
     }
     expect_exact: "console.log(import.meta,import.meta.url);"
 }
 
+import_meta_2: {
+    input: {
+        import.meta.url.split("/").forEach(function(part, index) {
+            console.log(index, part);
+        });
+    }
+    expect_exact: 'import.meta.url.split("/").forEach(function(part,index){console.log(index,part)});'
+}
+
 same_quotes: {
     beautify = {
         beautify: true,
@@ -85,13 +105,31 @@ drop_unused: {
     }
     input: {
         import a, * as b from "foo";
-        import { c, bar as d } from "baz";
-        console.log(c);
+        import { c } from "bar";
+        import { d, _ as e } from "baz";
+        console.log(d);
     }
     expect: {
         import "foo";
-        import { c as c } from "baz";
-        console.log(c);
+        import "bar";
+        import { d as d } from "baz";
+        console.log(d);
+    }
+}
+
+drop_side_effect_free: {
+    options = {
+        imports: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        import foo from "bar";
+        var a = foo;
+    }
+    expect: {
+        import "bar";
     }
 }
 
@@ -200,3 +238,33 @@ issue_4708_2: {
         import a from "foo";
     }
 }
+
+pr_5550_1: {
+    input: {
+        if (console)
+            import("foo");
+        else
+            import.meta.url.replace(/bar/g, console.log);
+    }
+    expect: {
+        if (console)
+            import("foo");
+        else
+            import.meta.url.replace(/bar/g, console.log);
+    }
+}
+
+pr_5550_2: {
+    input: {
+        L: {
+            import("foo");
+            import.meta.url.replace(/bar/g, console.log);
+        }
+    }
+    expect: {
+        L: {
+            import("foo");
+            import.meta.url.replace(/bar/g, console.log);
+        }
+    }
+}

test/compress/indentation.js

@@ -0,0 +1,100 @@
+numeric: {
+    beautify = {
+        beautify: true,
+        indent_start: 1,
+        indent_level: 3,
+    }
+    input: {
+        switch (42) {
+          case null:
+            console.log("FAIL");
+        }
+        console.log("PASS");
+    }
+    expect_exact: [
+        " switch (42) {",
+        "  case null:",
+        '    console.log("FAIL");',
+        " }",
+        "",
+        ' console.log("PASS");',
+    ]
+    expect_stdout: "PASS"
+}
+
+spaces: {
+    beautify = {
+        beautify: true,
+        indent_start: " ",
+        indent_level: "   ",
+    }
+    input: {
+        switch (42) {
+          case null:
+            console.log("FAIL");
+        }
+        console.log("PASS");
+    }
+    expect_exact: [
+        " switch (42) {",
+        "  case null:",
+        '    console.log("FAIL");',
+        " }",
+        "",
+        ' console.log("PASS");',
+    ]
+    expect_stdout: "PASS"
+}
+
+tabs: {
+    beautify = {
+        beautify: true,
+        indent_start: "\t",
+        indent_level: "\t",
+    }
+    input: {
+        switch (42) {
+          case null:
+            console.log("FAIL");
+        }
+        console.log("PASS");
+    }
+    expect_exact: [
+        "\tswitch (42) {",
+        "\tcase null:",
+        '\t\tconsole.log("FAIL");',
+        "\t}",
+        "",
+        '\tconsole.log("PASS");',
+    ]
+    expect_stdout: "PASS"
+}
+
+mixed: {
+    beautify = {
+        beautify: true,
+        indent_start: "\n",
+        indent_level: "       \t",
+    }
+    input: {
+        switch (42) {
+          case null:
+            console.log("FAIL");
+        }
+        console.log("PASS");
+    }
+    expect_exact: [
+        "",
+        "switch (42) {",
+        "",
+        "    case null:",
+        "",
+        '       \tconsole.log("FAIL");',
+        "",
+        "}",
+        "",
+        "",
+        'console.log("PASS");',
+    ]
+    expect_stdout: "PASS"
+}

test/compress/issue-1052.js

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

test/compress/issue-1446.js

@@ -24,7 +24,7 @@ typeof_eq_undefined: {
 typeof_eq_undefined_ie8: {
     options = {
         comparisons: true,
-        ie8: true,
+        ie: true,
         typeofs: true,
     }
     input: {

test/compress/issue-1447.js

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

test/compress/issue-1588.js

@@ -1,9 +1,9 @@
 screw_ie8: {
     options = {
-        ie8: false,
+        ie: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         try { throw "foo"; } catch (x) { console.log(x); }
@@ -16,10 +16,10 @@ screw_ie8: {
 
 support_ie8: {
     options = {
-        ie8: true,
+        ie: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         try { throw "foo"; } catch (x) { console.log(x); }

test/compress/issue-1704.js

@@ -1,10 +1,10 @@
 mangle_catch: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -22,11 +22,11 @@ mangle_catch: {
 
 mangle_catch_ie8: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -44,11 +44,11 @@ mangle_catch_ie8: {
 
 mangle_catch_var: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -66,11 +66,11 @@ mangle_catch_var: {
 
 mangle_catch_var_ie8: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -88,11 +88,11 @@ mangle_catch_var_ie8: {
 
 mangle_catch_toplevel: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -110,11 +110,11 @@ mangle_catch_toplevel: {
 
 mangle_catch_ie8_toplevel: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -132,11 +132,11 @@ mangle_catch_ie8_toplevel: {
 
 mangle_catch_var_toplevel: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -154,11 +154,11 @@ mangle_catch_var_toplevel: {
 
 mangle_catch_var_ie8_toplevel: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -176,11 +176,11 @@ mangle_catch_var_ie8_toplevel: {
 
 mangle_catch_redef_1: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -198,11 +198,11 @@ mangle_catch_redef_1: {
 
 mangle_catch_redef_1_ie8: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -220,11 +220,11 @@ mangle_catch_redef_1_ie8: {
 
 mangle_catch_redef_1_toplevel: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -242,11 +242,11 @@ mangle_catch_redef_1_toplevel: {
 
 mangle_catch_redef_1_ie8_toplevel: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -264,11 +264,11 @@ mangle_catch_redef_1_ie8_toplevel: {
 
 mangle_catch_redef_2: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -285,11 +285,11 @@ mangle_catch_redef_2: {
 
 mangle_catch_redef_2_ie8: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -306,11 +306,11 @@ mangle_catch_redef_2_ie8: {
 
 mangle_catch_redef_2_toplevel: {
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -327,11 +327,11 @@ mangle_catch_redef_2_toplevel: {
 
 mangle_catch_redef_2_ie8_toplevel: {
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -348,7 +348,7 @@ mangle_catch_redef_2_ie8_toplevel: {
 
 mangle_catch_redef_3: {
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -356,6 +356,7 @@ mangle_catch_redef_3: {
         try {
             throw 0;
         } catch (o) {
+            // prints "FAIL" if inlined on Node.js v4-
             (function() {
                 function f() {
                     o = "FAIL";
@@ -366,12 +367,13 @@ mangle_catch_redef_3: {
         console.log(o);
     }
     expect_exact: 'var o="PASS";try{throw 0}catch(o){(function(){function c(){o="FAIL"}c(),c()})()}console.log(o);'
-    expect_stdout: true
+    expect_stdout: "PASS"
+    node_version: ">=6"
 }
 
 mangle_catch_redef_3_toplevel: {
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -379,6 +381,7 @@ mangle_catch_redef_3_toplevel: {
         try {
             throw 0;
         } catch (o) {
+            // prints "FAIL" if inlined on Node.js v4-
             (function() {
                 function f() {
                     o = "FAIL";
@@ -389,12 +392,13 @@ mangle_catch_redef_3_toplevel: {
         console.log(o);
     }
     expect_exact: 'var c="PASS";try{throw 0}catch(c){(function(){function o(){c="FAIL"}o(),o()})()}console.log(c);'
-    expect_stdout: true
+    expect_stdout: "PASS"
+    node_version: ">=6"
 }
 
 mangle_catch_redef_3_ie8: {
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -402,6 +406,7 @@ mangle_catch_redef_3_ie8: {
         try {
             throw 0;
         } catch (o) {
+            // prints "FAIL" if inlined on Node.js v4-
             (function() {
                 function f() {
                     o = "FAIL";
@@ -412,12 +417,13 @@ mangle_catch_redef_3_ie8: {
         console.log(o);
     }
     expect_exact: 'var o="PASS";try{throw 0}catch(o){(function(){function c(){o="FAIL"}c(),c()})()}console.log(o);'
-    expect_stdout: true
+    expect_stdout: "PASS"
+    node_version: ">=6"
 }
 
 mangle_catch_redef_3_ie8_toplevel: {
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -425,6 +431,7 @@ mangle_catch_redef_3_ie8_toplevel: {
         try {
             throw 0;
         } catch (o) {
+            // prints "FAIL" if inlined on Node.js v4-
             (function() {
                 function f() {
                     o = "FAIL";
@@ -435,5 +442,6 @@ mangle_catch_redef_3_ie8_toplevel: {
         console.log(o);
     }
     expect_exact: 'var c="PASS";try{throw 0}catch(c){(function(){function o(){c="FAIL"}o(),o()})()}console.log(c);'
-    expect_stdout: true
+    expect_stdout: "PASS"
+    node_version: ">=6"
 }

test/compress/issue-1733.js

@@ -1,6 +1,6 @@
 function_iife_catch: {
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         function f(n) {
@@ -21,7 +21,7 @@ function_iife_catch: {
 
 function_iife_catch_ie8: {
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         function f(n) {
@@ -42,7 +42,7 @@ function_iife_catch_ie8: {
 
 function_catch_catch: {
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         var o = 0;
@@ -70,7 +70,7 @@ function_catch_catch: {
 
 function_catch_catch_ie8: {
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         var o = 0;

test/compress/issue-1770.js

@@ -110,7 +110,9 @@ numeric_literal: {
 
 identifier: {
     mangle = {
-        properties: true,
+        properties: {
+            builtins: true,
+        },
     }
     input: {
         var obj = {
@@ -209,37 +211,37 @@ identifier: {
             B: 28,
             C: 29,
             D: 30,
-            F: 31,
-            G: 32,
-            false: 33,
-            null: 34,
-            true: 35,
-            H: 36,
-            I: 37,
-            J: 38,
-            K: 39,
-            L: 40,
-            M: 41,
-            N: 42,
-            O: 43,
-            P: 44,
-            Q: 45,
-            R: 46,
-            S: 47,
-            T: 48,
-            U: 49,
-            V: 50,
-            W: 51,
-            X: 52,
-            Y: 53,
-            Z: 54,
-            $: 55,
-            _: 56,
-            ee: 57,
-            te: 58,
-            ne: 59,
-            ae: 60,
-            ie: 61,
+            E: 31,
+            F: 32,
+            G: 33,
+            H: 34,
+            I: 35,
+            J: 36,
+            K: 37,
+            L: 38,
+            M: 39,
+            N: 40,
+            O: 41,
+            P: 42,
+            Q: 43,
+            R: 44,
+            S: 45,
+            T: 46,
+            U: 47,
+            V: 48,
+            W: 49,
+            X: 50,
+            Y: 51,
+            Z: 52,
+            $: 53,
+            _: 54,
+            ee: 55,
+            te: 56,
+            ne: 57,
+            ae: 58,
+            ie: 59,
+            oe: 60,
+            re: 61,
         };
     }
 }

test/compress/issue-281.js

@@ -108,6 +108,7 @@ safe_undefined: {
 }
 
 negate_iife_3: {
+    expression = true
     options = {
         conditionals: true,
         expression: true,
@@ -123,6 +124,7 @@ negate_iife_3: {
 }
 
 negate_iife_3_off: {
+    expression = true
     options = {
         conditionals: true,
         expression: true,
@@ -203,6 +205,7 @@ negate_iife_5_off: {
 }
 
 issue_1254_negate_iife_true: {
+    expression = true
     options = {
         expression: true,
         inline: true,
@@ -215,11 +218,12 @@ issue_1254_negate_iife_true: {
             };
         })()();
     }
-    expect_exact: 'void console.log("test");'
+    expect_exact: 'void console.log("test")'
     expect_stdout: true
 }
 
 issue_1254_negate_iife_nested: {
+    expression = true
     options = {
         expression: true,
         inline: true,
@@ -232,7 +236,7 @@ issue_1254_negate_iife_nested: {
             };
         })()()()()();
     }
-    expect_exact: '(void console.log("test"))()()();'
+    expect_exact: '(void console.log("test"))()()()'
 }
 
 negate_iife_issue_1073: {

test/compress/issue-640.js

@@ -68,6 +68,7 @@ drop_console_2: {
 }
 
 drop_value: {
+    expression = true
     options = {
         expression: true,
         side_effects: true,
@@ -106,6 +107,7 @@ wrongly_optimized: {
 }
 
 negate_iife_1: {
+    expression = true
     options = {
         expression: true,
         negate_iife: true,
@@ -119,6 +121,7 @@ negate_iife_1: {
 }
 
 negate_iife_3: {
+    expression = true
     options = {
         conditionals: true,
         expression: true,
@@ -133,6 +136,7 @@ negate_iife_3: {
 }
 
 negate_iife_3_off: {
+    expression = true
     options = {
         conditionals: true,
         expression: true,
@@ -215,6 +219,7 @@ negate_iife_5_off: {
 }
 
 issue_1254_negate_iife_true: {
+    expression = true
     options = {
         expression: true,
         negate_iife: true,
@@ -226,11 +231,12 @@ issue_1254_negate_iife_true: {
             };
         })()();
     }
-    expect_exact: '(function(){return function(){console.log("test")}})()();'
+    expect_exact: 'function(){return function(){console.log("test")}}()()'
     expect_stdout: true
 }
 
 issue_1254_negate_iife_nested: {
+    expression = true
     options = {
         expression: true,
         negate_iife: true,
@@ -242,7 +248,7 @@ issue_1254_negate_iife_nested: {
             };
         })()()()()();
     }
-    expect_exact: '(function(){return function(){console.log("test")}})()()()()();'
+    expect_exact: 'function(){return function(){console.log("test")}}()()()()()'
     expect_stdout: true
 }
 
@@ -317,7 +323,35 @@ iife: {
         typeof function g() {}();
     }
     expect: {
-        x = 42, function a() {}(), function b() {}(), function c() {}(),
-        function d() {}(), function e() {}(), function f() {}(), typeof function g() {}();
+        x = 42,
+        function a() {}(),
+        !function b() {}(),
+        ~function c() {}(),
+        +function d() {}(),
+        -function e() {}(),
+        void function f() {}(),
+        typeof function g() {}();
+    }
+}
+
+iife_drop_side_effect_free: {
+    options = {
+        expression: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        x = 42;
+        (function a() {})();
+        !function b() {}();
+        ~function c() {}();
+        +function d() {}();
+        -function e() {}();
+        void function f() {}();
+        typeof function g() {}();
+    }
+    expect: {
+        x = 42,
+        typeof void 0;
     }
 }

test/compress/issue-892.js

@@ -1,6 +1,4 @@
 dont_mangle_arguments: {
-    mangle = {
-    };
     options = {
         booleans: true,
         comparisons: true,
@@ -21,12 +19,13 @@ dont_mangle_arguments: {
         side_effects: true,
         unused: true,
     }
+    mangle = {}
     input: {
         (function(){
             var arguments = arguments, not_arguments = 9;
             console.log(not_arguments, arguments);
-        })(5,6,7);
+        })(5, 6, 7);
     }
-    expect_exact: "(function(){var arguments=arguments,o=9;console.log(o,arguments)})(5,6,7);"
+    expect_exact: "(function(){var arguments,o=9;console.log(o,arguments)})(5,6,7);"
     expect_stdout: true
 }

test/compress/issue-979.js

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

test/compress/join_vars.js

@@ -489,6 +489,160 @@ join_object_assignments_regex: {
     expect_stdout: "1"
 }
 
+chained_assignments: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        var a, b = a = {};
+        b.p = "PASS";
+        console.log(a.p);
+    }
+    expect: {
+        var a, b = a = {
+            p: "PASS",
+        };
+        console.log(a.p);
+    }
+    expect_stdout: "PASS"
+}
+
+folded_assignments_1: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+    }
+    input: {
+        var a = {};
+        a[a.PASS = 42] = "PASS";
+        console.log(a[42], a.PASS);
+    }
+    expect: {
+        var a = {
+            PASS: 42,
+            42: "PASS",
+        };
+        console.log(a[42], a.PASS);
+    }
+    expect_stdout: "PASS 42"
+}
+
+folded_assignments_2: {
+    options = {
+        evaluate: true,
+        join_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = {};
+        a[42] = "FAIL";
+        a[a.PASS = 42] = "PASS";
+        console.log(a[42], a.PASS);
+    }
+    expect: {
+        "use strict";
+        var a = {
+            42: "FAIL",
+            PASS: 42,
+        };
+        a[42] = "PASS";
+        console.log(a[42], a.PASS);
+    }
+    expect_stdout: "PASS 42"
+}
+
+inlined_assignments: {
+    options = {
+        join_vars: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        (a = {}).p = "PASS";
+        console.log(a.p);
+    }
+    expect: {
+        var a = {
+            p: "PASS",
+        };
+        console.log(a.p);
+    }
+    expect_stdout: "PASS"
+}
+
+inilne_for: {
+    options = {
+        inline: true,
+        join_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function() {
+            for (; console.log("PASS"););
+        };
+        a();
+    }
+    expect: {
+        for (; console.log("PASS"););
+    }
+    expect_stdout: "PASS"
+}
+
+inilne_var: {
+    options = {
+        inline: true,
+        join_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        A = "PASS";
+        var a = function() {
+            var b = A;
+            for (b in console.log(b));
+        };
+        a();
+    }
+    expect: {
+        A = "PASS";
+        var b = A;
+        for (b in console.log(b));
+    }
+    expect_stdout: "PASS"
+}
+
+typescript_enum: {
+    rename = true
+    options = {
+        assignments: true,
+        collapse_vars: true,
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        join_vars: true,
+        passes: 4,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var Enum;
+        (function (Enum) {
+            Enum[Enum.PASS = 42] = "PASS";
+        })(Enum || (Enum = {}));
+        console.log(Enum[42], Enum.PASS);
+    }
+    expect: {
+        console.log("PASS", 42);
+    }
+    expect_stdout: "PASS 42"
+}
+
 issue_2816: {
     options = {
         join_vars: true,
@@ -990,7 +1144,7 @@ conditional_assignments_3: {
     expect_stdout: "PASS"
 }
 
-issue_3856: {
+issue_3856_1: {
     options = {
         booleans: true,
         conditionals: true,
@@ -1015,16 +1169,53 @@ issue_3856: {
         console.log(function() {
             (function() {
                 var a, b;
-                if (a) return !!a;
-                for (a = 0; !console;);
-                return 0;
+                if (a) a;
+                else {
+                    a = 0;
+                    for (; !console;);
+                }
             })();
         }());
     }
     expect_stdout: "undefined"
 }
 
-issue_3916: {
+issue_3856_2: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        if_return: true,
+        join_vars: true,
+        passes: 2,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function() {
+            (function() {
+                var a;
+                if (!a) {
+                    a = 0;
+                    for (var b; !console;);
+                    return 0;
+                }
+                if (a) return 1;
+            })();
+        }());
+    }
+    expect: {
+        console.log(function() {
+            (function() {
+                var a, b;
+                if (!a)
+                    for (a = 0; !console;);
+            })();
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_3916_1: {
     options = {
         join_vars: true,
     }
@@ -1044,8 +1235,8 @@ issue_3916: {
         var o = {
             p: "PASS",
             __proto__: 42,
-            q: "FAIL",
         };
+        o.q = "FAIL";
         o.__proto__ = {
             p: "FAIL",
             q: "PASS",
@@ -1056,6 +1247,62 @@ issue_3916: {
     expect_stdout: "object PASS true PASS"
 }
 
+issue_3916_2: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        var log = console.log, o = {};
+        o.p = "FAIL 1";
+        o.__proto__ = {
+            get p() {
+                return "FAIL 2";
+            },
+            set p(u) {
+                log("FAIL 3");
+            },
+            set q(v) {
+                log("PASS 1");
+            },
+            get q() {
+                return "PASS 3";
+            },
+        };
+        o.p = "PASS 2";
+        o.q = "FAIL 4";
+        log(o.p);
+        log(o.q);
+    }
+    expect: {
+        var log = console.log, o = {
+            p: "FAIL 1",
+            __proto__: {
+                get p() {
+                    return "FAIL 2";
+                },
+                set p(u) {
+                    log("FAIL 3");
+                },
+                set q(v) {
+                    log("PASS 1");
+                },
+                get q() {
+                    return "PASS 3";
+                },
+            },
+        };
+        o.p = "PASS 2";
+        o.q = "FAIL 4";
+        log(o.p);
+        log(o.q);
+    }
+    expect_stdout: [
+        "PASS 1",
+        "PASS 2",
+        "PASS 3",
+    ]
+}
+
 assign_var: {
     options = {
         join_vars: true,
@@ -1116,10 +1363,7 @@ assign_sequence_var: {
         console.log(a, b, c);
     }
     expect: {
-        var a = 0, b = 1;
-        console.log(a),
-        a++;
-        var b = 2, c = 3;
+        var a = 0, b = 1, c = (console.log(a), a++, b = 2, 3);
         console.log(a, b, c);
     }
     expect_stdout: [
@@ -1127,3 +1371,26 @@ assign_sequence_var: {
         "1 2 3",
     ]
 }
+
+issue_5175: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        function log(f) {
+            console.log(f(), A.p);
+        }
+        log(function() {
+            return (A = {}).p = "PASS";
+        });
+    }
+    expect: {
+        function log(f) {
+            console.log(f(), A.p);
+        }
+        log(function() {
+            return (A = {}).p = "PASS";
+        });
+    }
+    expect_stdout: "PASS PASS"
+}

test/compress/keep_fargs.js

@@ -117,6 +117,7 @@ issue_1858: {
         collapse_vars: true,
         keep_fargs: false,
         pure_getters: true,
+        reduce_vars: true,
         unused: true,
     }
     input: {
@@ -180,10 +181,10 @@ issue_2203_2: {
             a: "FAIL",
             b: function() {
                 return function() {
-                    return (String, (Object, function() {
+                    return (Object, function() {
                         return this;
-                    }())).a;
-                }();
+                    }()).a;
+                }(String);
             }
         }.b());
     }
@@ -924,6 +925,28 @@ duplicate_lambda_defun_name_2: {
     expect_stdout: "0"
 }
 
+function_argument_mangle: {
+    mangle = {
+        keep_fargs: true,
+        toplevel: true,
+    }
+    input: {
+        A = "PASS";
+        var a = A;
+        (function(o) {
+            console.log(a);
+        })("FAIL");
+    }
+    expect: {
+        A = "PASS";
+        var n = A;
+        (function(o) {
+            console.log(n);
+        })("FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
 function_name_mangle: {
     options = {
         keep_fargs: false,
@@ -950,7 +973,7 @@ function_name_mangle_ie8: {
         unused: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -1157,8 +1180,8 @@ replace_all_var_scope: {
         var a = 100, b = 10;
         (function(r, a) {
             switch (~a) {
-            case (b += a):
-            case a++:
+              case (b += a):
+              case a++:
             }
         })(--b, a);
         console.log(a, b);
@@ -1167,8 +1190,8 @@ replace_all_var_scope: {
         var a = 100, b = 10;
         (function(c) {
             switch (~a) {
-            case (b += a):
-            case c++:
+              case (b += a):
+              case c++:
             }
         })((--b, a));
         console.log(a, b);
@@ -1216,6 +1239,7 @@ issues_3267_1: {
         evaluate: true,
         inline: true,
         keep_fargs: false,
+        negate_iife: true,
         reduce_vars: true,
         sequences: true,
         side_effects: true,

test/compress/labels.js

@@ -83,8 +83,9 @@ labels_5: {
         conditionals: true,
         dead_code: true,
         if_return: true,
+        unused: true,
     }
-    // should keep the break-s in the following
+    // should keep `break`s below
     input: {
         while (foo) {
             if (bar) break;
@@ -100,8 +101,8 @@ labels_5: {
             if (bar) break;
             console.log("foo");
         }
-        out: while (foo) {
-            if (bar) break out;
+        while (foo) {
+            if (bar) break;
             console.log("foo");
         }
     }
@@ -110,6 +111,7 @@ labels_5: {
 labels_6: {
     options = {
         dead_code: true,
+        unused: true,
     }
     input: {
         out: break out;
@@ -189,23 +191,75 @@ labels_10: {
         conditionals: true,
         dead_code: true,
         if_return: true,
+        unused: true,
     }
     input: {
-        out: while (foo) {
-            x();
-            y();
+        out: while (42) {
+            console.log("PASS");
             break out;
-            z();
-            k();
+            console.log("FAIL");
         }
     };
     expect: {
-        out: while (foo) {
-            x();
-            y();
-            break out;
+        while (42) {
+            console.log("PASS");
+            break;
         }
     }
+    expect_stdout: "PASS"
+}
+
+labels_11: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        unused: true,
+    }
+    input: {
+        L: if (console.log("PASS"))
+            break L;
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+labels_12: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        if_return: true,
+    }
+    input: {
+        L: try {
+            if (console.log("foo"))
+                break L;
+            throw "bar";
+        } catch (e) {
+            console.log(e);
+            break L;
+        } finally {
+            if (console.log("baz"))
+                break L;
+        }
+    }
+    expect: {
+        L: try {
+            if (!console.log("foo"))
+                throw "bar";
+        } catch (e) {
+            console.log(e);
+        } finally {
+            if (console.log("baz"))
+                break L;
+        }
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
 }
 
 issue_4466_1: {
@@ -327,3 +381,53 @@ issue_4466_2_toplevel_v8: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5522: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(function() {
+            L: try {
+                return "FAIL";
+            } finally {
+                break L;
+            }
+            return "PASS";
+        }());
+    }
+    expect: {
+        console.log(function() {
+            L: try {
+                return "FAIL";
+            } finally {
+                break L;
+            }
+            return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5524: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        L: try {
+            FAIL;
+        } finally {
+            break L;
+        }
+        console.log("PASS");
+    }
+    expect: {
+        L: try {
+            FAIL;
+        } finally {
+            break L;
+        }
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}

test/compress/let.js

@@ -1,4 +1,4 @@
-retain_block: {
+retain_block_1: {
     options = {}
     input: {
         "use strict";
@@ -20,6 +20,127 @@ retain_block: {
     node_version: ">=4"
 }
 
+retain_block_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        {
+            var a;
+            let a;
+        }
+    }
+    expect: {
+        "use strict";
+        {
+            var a;
+            let a;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+retain_block_2_mangle: {
+    rename = true
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        {
+            var a;
+            let a;
+        }
+    }
+    expect: {
+        "use strict";
+        {
+            var t;
+            let t;
+        }
+    }
+}
+
+retain_block_3: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        {
+            let a;
+            var a;
+        }
+    }
+    expect: {
+        "use strict";
+        {
+            let a;
+            var a;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+retain_block_3_mangle: {
+    rename = true
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        {
+            let a;
+            var a;
+        }
+    }
+    expect: {
+        "use strict";
+        {
+            let t;
+            var t;
+        }
+    }
+}
+
+retain_assignment: {
+    options = {
+        dead_code: true,
+        reduce_vars: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            return a = 0;
+            let a;
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        function f() {
+            return a = 0;
+            let a;
+        }
+        try {
+            f();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 retain_catch: {
     options = {
         dead_code: true,
@@ -69,6 +190,96 @@ if_dead_branch: {
     node_version: ">=4"
 }
 
+retain_tail_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                let b = "bar";
+                while (console.log("baz"));
+                console.log(b);
+            } else {
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                let b = "bar";
+                while (console.log("baz"));
+                console.log(b);
+            } else {
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "moo",
+        "foo",
+        "baz",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+retain_tail_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                let b = "baz";
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            var b = "foo";
+            if (a) {
+                while (console.log("bar"));
+                console.log(b);
+            } else {
+                let b = "baz";
+                while (console.log("moo"));
+                console.log(b);
+            }
+        }
+        f();
+        f(42);
+    }
+    expect_stdout: [
+        "moo",
+        "baz",
+        "bar",
+        "foo",
+    ]
+    node_version: ">=4"
+}
+
 merge_vars_1: {
     options = {
         merge_vars: true,
@@ -149,8 +360,8 @@ merge_vars_3: {
             var b = console;
             console.log(typeof b);
         }
-        var a = 1;
-        console.log(typeof a);
+        var b = 1;
+        console.log(typeof b);
     }
     expect_stdout: [
         "object",
@@ -159,6 +370,38 @@ merge_vars_3: {
     node_version: ">=4"
 }
 
+merge_vars_4: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        var a = 1;
+        console.log(typeof a);
+        {
+            var b = console;
+            console.log(typeof b);
+            let a = 0;
+        }
+    }
+    expect: {
+        "use strict";
+        var a = 1;
+        console.log(typeof a);
+        {
+            var b = console;
+            console.log(typeof b);
+            let a = 0;
+        }
+    }
+    expect_stdout: [
+        "number",
+        "object",
+    ]
+    node_version: ">=4"
+}
+
 use_before_init_1: {
     options = {
         evaluate: true,
@@ -461,6 +704,41 @@ reduce_vars_3: {
     node_version: ">=4"
 }
 
+reduce_lambda: {
+    options = {
+        evaluate: true,
+        functions: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        let f = function() {
+            console.log(a, b);
+        };
+        let a = "foo", b = 42;
+        f();
+        b = "bar";
+        f();
+    }
+    expect: {
+        "use strict";
+        function f() {
+            console.log("foo", b);
+        }
+        let b = 42;
+        f();
+        b = "bar";
+        f();
+    }
+    expect_stdout: [
+        "foo 42",
+        "foo bar",
+    ]
+    node_version: ">=4"
+}
+
 hoist_props: {
     options = {
         hoist_props: true,
@@ -536,6 +814,38 @@ loop_block_2: {
     node_version: ">=4"
 }
 
+do_break: {
+    options = {
+        loops: true,
+    }
+    input: {
+        "use strict";
+        try {
+            do {
+                if (a)
+                    break;
+                let a;
+            } while (!console);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            do {
+                if (a)
+                    break;
+                let a;
+            } while (!console);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 do_continue: {
     options = {
         loops: true,
@@ -596,6 +906,116 @@ dead_block_after_return: {
     node_version: ">=4"
 }
 
+if_return_1: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            function g() {
+                return b = "PASS";
+            }
+            if (a)
+                return g();
+            let b;
+            return g();
+        };
+        console.log(f());
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            function g() {
+                return b = "PASS";
+            }
+            if (a)
+                return g();
+            let b;
+            return g();
+        };
+        console.log(f());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+if_return_2: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            function g() {
+                return b = "FAIL";
+            }
+            if (a)
+                return g();
+            let b;
+            return g();
+        };
+        try {
+            console.log(f(42));
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            function g() {
+                return b = "FAIL";
+            }
+            if (a)
+                return g();
+            let b;
+            return g();
+        };
+        try {
+            console.log(f(42));
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+if_return_3: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        var a = "PASS";
+        function f(b) {
+            if (console) {
+                let b = a;
+                return b;
+            } else
+                while (console.log("FAIL 1"));
+            return b;
+        }
+        console.log(f("FAIL 2"));
+    }
+    expect: {
+        "use strict";
+        var a = "PASS";
+        function f(b) {
+            if (console) {
+                let b = a;
+                return b;
+            } else
+                while (console.log("FAIL 1"));
+            return b;
+        }
+        console.log(f("FAIL 2"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 do_if_continue_1: {
     options = {
         if_return: true,
@@ -616,8 +1036,7 @@ do_if_continue_1: {
     expect: {
         "use strict";
         do {
-            if (!console);
-            else {
+            if (console) {
                 console.log("PASS");
                 {
                     let a = 0;
@@ -650,8 +1069,7 @@ do_if_continue_2: {
     expect: {
         "use strict";
         do {
-            if (!console);
-            else {
+            if (console) {
                 console.log("FAIL");
                 {
                     let a = 0;
@@ -790,12 +1208,10 @@ issue_4202: {
         "use strict";
         {
             let o = {};
-            (function() {
-                function f() {
-                    o.p = 42;
-                }
-                f(f);
-            })();
+            function f() {
+                o.p = 42;
+            }
+            f(f);
             console.log(o.p++);
         }
     }
@@ -897,6 +1313,7 @@ issue_4210: {
 issue_4212_1: {
     options = {
         dead_code: true,
+        reduce_vars: true,
     }
     input: {
         "use strict";
@@ -987,7 +1404,7 @@ issue_4225: {
 
 issue_4229: {
     options = {
-        ie8: true,
+        ie: true,
         side_effects: true,
     }
     input: {
@@ -1018,7 +1435,7 @@ issue_4229: {
 
 issue_4231: {
     options = {
-        ie8: true,
+        ie: true,
         side_effects: true,
     }
     input: {
@@ -1311,48 +1728,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,
@@ -1372,9 +1747,7 @@ issue_4438: {
     expect: {
         "use strict";
         function f() {
-            if (!console)
-                ;
-            else {
+            if (console) {
                 let a = console.log;
                 a("PASS");
             }
@@ -1387,7 +1760,7 @@ issue_4438: {
 
 issue_4531_1: {
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -1413,11 +1786,11 @@ issue_4531_1: {
 issue_4531_2: {
     options = {
         evaluate: true,
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -1462,6 +1835,7 @@ issue_4689: {
 
 issue_4691: {
     options = {
+        conditionals: true,
         if_return: true,
         toplevel: true,
     }
@@ -1506,3 +1880,293 @@ issue_4691: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_4848: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            a(function() {
+                console.log(b);
+            });
+            if (!console)
+                return;
+            let b = "PASS";
+        }
+        var g;
+        f(function(h) {
+            g = h;
+        });
+        g();
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            a(function() {
+                console.log(b);
+            });
+            if (!console)
+                return;
+            let b = "PASS";
+        }
+        var g;
+        f(function(h) {
+            g = h;
+        });
+        g();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4985: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        let a = { p: 42 };
+        console.log(function() {
+            a;
+        }());
+    }
+    expect: {
+        "use strict";
+        let a = { p: 42 };
+        console.log(function() {
+            a;
+        }());
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_5240: {
+    options = {
+        inline: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            if (console) {
+                let g = function() {
+                    e;
+                }, e;
+                (function() {
+                    if (console) {
+                        console.log(e);
+                        var e = "FAIL";
+                    }
+                })(console.log(e));
+            }
+        }
+        f();
+    }
+    expect: {
+        "use strict";
+        function f() {
+            if (console) {
+                let g = function() {
+                    e;
+                }, e;
+                (function() {
+                    if (console) {
+                        console.log(e);
+                        var e = "FAIL";
+                    }
+                })(console.log(e));
+            }
+        }
+        f();
+    }
+    expect_stdout: [
+        "undefined",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_5254: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        do {
+            (function() {
+                let a = console.log;
+                a && a("foo");
+            })();
+        } while (console.log("bar"));
+    }
+    expect: {
+        "use strict";
+        do {
+            let a = console.log;
+            a && a("foo");
+        } while (console.log("bar"));
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+issue_5260: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = "foo", o;
+        while (console.log("bar"));
+        o = {
+            baz: function(b) {
+                console.log(a, b);
+            },
+        };
+        for (let a in o)
+            o[a](a);
+    }
+    expect: {
+        "use strict";
+        var a = "foo", o;
+        while (console.log("bar"));
+        o = {
+            baz: function(b) {
+                console.log(a, b);
+            },
+        };
+        for (let a in o)
+            o[a](a);
+    }
+    expect_stdout: [
+        "bar",
+        "foo baz",
+    ]
+    node_version: ">=4"
+}
+
+issue_5319: {
+    options = {
+        collapse_vars: true,
+        merge_vars: true,
+    }
+    input: {
+        "use strict";
+        (function(a, c) {
+            var b = a, c = b;
+            {
+                let a = c;
+                console.log(c());
+            }
+        })(function() {
+            return "PASS";
+        });
+    }
+    expect: {
+        "use strict";
+        (function(a, c) {
+            var b = a, c;
+            {
+                let a = c = b;
+                console.log(c());
+            }
+        })(function() {
+            return "PASS";
+        });
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_5338: {
+    options = {
+        unused: true,
+    }
+    input: {
+        "use strict";
+        let a = a;
+    }
+    expect: {
+        "use strict";
+        a;
+        let a;
+    }
+    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"
+}
+
+issue_5591: {
+    options = {
+        dead_code: true,
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            switch (console.log("foo")) {
+              case console.log("bar"):
+                if (console.log("baz"))
+                    return;
+                else {
+                    let a;
+                    return;
+                }
+                break;
+              case null:
+                FAIL;
+            }
+        }
+        f();
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            switch (console.log("foo")) {
+              case console.log("bar"):
+                if (console.log("baz"))
+                    return;
+                else {
+                    let a;
+                    return;
+                }
+              case null:
+                FAIL;
+            }
+        }
+        f();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
+    node_version: ">=4"
+}

test/compress/loops.js

@@ -193,9 +193,9 @@ evaluate: {
         } while (false);
     }
     expect: {
-        for(;;)
+        for (;;)
             a();
-        for(;;)
+        for (;;)
             c();
         d();
     }
@@ -265,7 +265,7 @@ issue_1532_2: {
 issue_186: {
     beautify = {
         beautify: false,
-        ie8: false,
+        ie: false,
     }
     input: {
         var x = 3;
@@ -284,7 +284,7 @@ issue_186: {
 issue_186_ie8: {
     beautify = {
         beautify: false,
-        ie8: true,
+        ie: true,
     }
     input: {
         var x = 3;
@@ -303,7 +303,7 @@ issue_186_ie8: {
 issue_186_beautify: {
     beautify = {
         beautify: true,
-        ie8: false,
+        ie: false,
     }
     input: {
         var x = 3;
@@ -330,7 +330,7 @@ issue_186_beautify: {
 issue_186_beautify_ie8: {
     beautify = {
         beautify: true,
-        ie8: true,
+        ie: true,
     }
     input: {
         var x = 3;
@@ -360,7 +360,7 @@ issue_186_braces: {
     beautify = {
         beautify: false,
         braces: true,
-        ie8: false,
+        ie: false,
     }
     input: {
         var x = 3;
@@ -380,7 +380,7 @@ issue_186_braces_ie8: {
     beautify = {
         beautify: false,
         braces: true,
-        ie8: true,
+        ie: true,
     }
     input: {
         var x = 3;
@@ -400,7 +400,7 @@ issue_186_beautify_braces: {
     beautify = {
         beautify: true,
         braces: true,
-        ie8: false,
+        ie: false,
     }
     input: {
         var x = 3;
@@ -432,7 +432,7 @@ issue_186_beautify_braces_ie8: {
     beautify = {
         beautify: true,
         braces: true,
-        ie8: true,
+        ie: true,
     }
     input: {
         var x = 3;
@@ -829,6 +829,18 @@ empty_for_in_prop_init: {
 }
 
 for_of: {
+    input: {
+        var a = [ "PASS", 42 ];
+        a.p = "FAIL";
+        for (a of (null, a))
+            console.log(a);
+    }
+    expect_exact: 'var a=["PASS",42];a.p="FAIL";for(a of(null,a))console.log(a);'
+    expect_stdout: true
+    node_version: ">=0.12"
+}
+
+for_async_of: {
     input: {
         var async = [ "PASS", 42 ];
         async.p = "FAIL";
@@ -837,7 +849,21 @@ for_of: {
     }
     expect_exact: 'var async=["PASS",42];async.p="FAIL";for(async of(null,async))console.log(async);'
     expect_stdout: true
-    node_version: ">=0.12"
+    node_version: ">=0.12 <16"
+}
+
+for_of_regexp: {
+    input: {
+        for (var a of /foo/);
+    }
+    expect_exact: "for(var a of/foo/);"
+}
+
+for_await_of_regexp: {
+    input: {
+        for await (var a of /foo/);
+    }
+    expect_exact: "for await(var a of/foo/);"
 }
 
 issue_3631_1: {

test/compress/max_line_len.js

@@ -37,6 +37,51 @@ just_enough: {
     expect_warnings: []
 }
 
+drop_semicolon: {
+    beautify = {
+        max_line_len: 5,
+        semicolons: true,
+    }
+    input: {
+        var a;
+        console.log(a || 42);
+    }
+    expect_exact: [
+        "var a",
+        "console.log(",
+        "a||42",
+        ");",
+    ]
+    expect_stdout: "42"
+    expect_warnings: [
+        "WARN: Output exceeds 5 characters",
+    ]
+}
+
+template_newline: {
+    beautify = {
+        max_line_len: 2,
+    }
+    input: {
+        console.log(`foo
+bar`);
+    }
+    expect_exact: [
+        "console.log(",
+        "`foo",
+        "bar`",
+        ");",
+    ]
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    expect_warnings: [
+        "WARN: Output exceeds 2 characters",
+    ]
+    node_version: ">=4"
+}
+
 issue_304: {
     beautify = {
         max_line_len: 10,

test/compress/negate-iife.js

@@ -122,13 +122,41 @@ negate_iife_4: {
         sequences: true,
     }
     input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-        (function(){
+        (function() {
+            return t;
+        })() ? console.log(true) : console.log(false);
+        (function() {
             console.log("something");
         })();
     }
     expect: {
-        !function(){ return t }() ? console.log(false) : console.log(true), function(){
+        !function() {
+            return t;
+        }() ? console.log(false) : console.log(true), !function() {
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_4_drop_side_effect_free: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        (function() {
+            return t;
+        })() ? console.log(true) : console.log(false);
+        (function() {
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function() {
+            return t;
+        }() ? console.log(false) : console.log(true), function() {
             console.log("something");
         }();
     }
@@ -176,17 +204,49 @@ negate_iife_5: {
         sequences: true,
     }
     input: {
-        if ((function(){ return t })()) {
+        if (function() {
+            return t;
+        }()) {
             foo(true);
         } else {
             bar(false);
         }
-        (function(){
+        (function() {
             console.log("something");
         })();
     }
     expect: {
-        !function(){ return t }() ? bar(false) : foo(true), function(){
+        !function() {
+            return t;
+        }() ? bar(false) : foo(true), !function() {
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_5_drop_side_effect_free: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        if (function() {
+            return t;
+        }()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function() {
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function() {
+            return t;
+        }() ? bar(false) : foo(true), function() {
             console.log("something");
         }();
     }
@@ -389,6 +449,7 @@ issue_1288_side_effects: {
     options = {
         conditionals: true,
         negate_iife: true,
+        sequences: true,
         side_effects: true,
     }
     input: {
@@ -409,10 +470,10 @@ issue_1288_side_effects: {
             })(0);
     }
     expect: {
-        w;
+        w,
         x || function() {
             x = {};
-        }();
+        }(),
         y;
     }
 }

test/compress/nullish.js

@@ -110,10 +110,186 @@ conditional_assignment_4: {
     node_version: ">=14"
 }
 
+de_morgan_1: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        function f(a) {
+            return a ?? a;
+        }
+        console.log(f(null), f(42));
+    }
+    expect: {
+        function f(a) {
+            return a;
+        }
+        console.log(f(null), f(42));
+    }
+    expect_stdout: "null 42"
+    node_version: ">=14"
+}
+
+de_morgan_2a: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+    }
+    input: {
+        function f(a, b) {
+            return a || (a ?? b);
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect: {
+        function f(a, b) {
+            return a || (a ?? b);
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect_stdout: [
+        "undefined {}",
+        "42 42",
+    ]
+    node_version: ">=14"
+}
+
+de_morgan_2b: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        function f(a, b) {
+            return a && (a ?? b);
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect: {
+        function f(a, b) {
+            return a;
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect_stdout: [
+        "null null",
+        "42 42",
+    ]
+    node_version: ">=14"
+}
+
+de_morgan_2c: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a, b) {
+            return a ?? (a || b);
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect: {
+        function f(a, b) {
+            return a ?? b;
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect_stdout: [
+        "undefined {}",
+        "42 42",
+    ]
+    node_version: ">=14"
+}
+
+de_morgan_2d: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        function f(a, b) {
+            return a ?? (a && b);
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect: {
+        function f(a, b) {
+            return a;
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect_stdout: [
+        "null null",
+        "42 42",
+    ]
+    node_version: ">=14"
+}
+
+de_morgan_2e: {
+    options = {
+        booleans: true,
+        conditionals: true,
+    }
+    input: {
+        function f(a, b) {
+            return a ?? (a ?? b);
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect: {
+        function f(a, b) {
+            return a ?? b;
+        }
+        console.log(f(null), f(null, {}));
+        console.log(f(42), f(42, {}));
+    }
+    expect_stdout: [
+        "undefined {}",
+        "42 42",
+    ]
+    node_version: ">=14"
+}
+
+inline_binary_nullish: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (function() {
+            while (console.log("foo"));
+        })() ?? (function() {
+            while (console.log("bar"));
+        })();
+    }
+    expect: {
+        if (null == function() {
+            while (console.log("foo"));
+        }())
+            while (console.log("bar"));
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=14"
+}
+
 issue_4679: {
     options = {
         comparisons: true,
-        ie8: true,
+        ie: true,
     }
     input: {
         var a;
@@ -128,3 +304,43 @@ issue_4679: {
     expect_stdout: "PASS"
     node_version: ">=14"
 }
+
+issue_5266: {
+    options = {
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        [
+            42,
+            null,
+            false,
+            void 0,
+            "FAIL",
+        ].forEach(function (a) {
+            a ?? function() {
+                while (console.log(a));
+            }();
+        });
+    }
+    expect: {
+        [
+            42,
+            null,
+            false,
+            void 0,
+            "FAIL",
+        ].forEach(function (a) {
+            if (null == a) {
+                while (console.log(a));
+                return;
+            } else
+                return;
+        });
+    }
+    expect_stdout: [
+        "null",
+        "undefined",
+    ]
+    node_version: ">=14"
+}

test/compress/numbers.js

@@ -104,6 +104,40 @@ parentheses_for_prototype_functions_galio: {
     expect_stdout: true
 }
 
+octal: {
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        (function() {
+            console.log(052);
+            console.log(-052);
+
+            console.log(018);
+            console.log(-018);
+
+            console.log(052.toFixed(0));
+            console.log(-052.toFixed(0));
+
+            console.log(018..toFixed(0));
+            console.log(-018..toFixed(0));
+        })();
+    }
+    expect_exact: [
+        "(function() {",
+        "    console.log(42);",
+        "    console.log(-42);",
+        "    console.log(18);",
+        "    console.log(-18);",
+        "    console.log(42..toFixed(0));",
+        "    console.log(-42..toFixed(0));",
+        "    console.log(18..toFixed(0));",
+        "    console.log(-18..toFixed(0));",
+        "})();",
+    ]
+    expect_stdout: true
+}
+
 comparisons: {
     options = {
         comparisons: true,
@@ -808,9 +842,9 @@ unary_binary_parentheses: {
         v.forEach(function(x) {
             v.forEach(function(y) {
                 console.log(
-                    +x*y,
-                    +x/y,
-                    +x%y,
+                    x*y,
+                    x/y,
+                    x%y,
                     -x*y,
                     -x/y,
                     -x%y
@@ -1363,7 +1397,7 @@ issue_3695: {
     }
     expect: {
         var a = [];
-        console.log(+(a * (a[0] = false)));
+        console.log(a * (a[0] = false));
     }
     expect_stdout: "NaN"
 }

test/compress/objects.js

@@ -521,3 +521,25 @@ issue_4415: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_5213: {
+    options = {
+        objects: true,
+    }
+    input: {
+        var a = "FAIL";
+        console.log({
+            p: a = "PASS",
+            0: a,
+            p: null,
+        }[0]);
+    }
+    expect: {
+        var a = "FAIL";
+        console.log({
+            p: (a = "PASS", null),
+            0: a,
+        }[0]);
+    }
+    expect_stdout: "PASS"
+}

test/compress/optional-chains.js

@@ -0,0 +1,619 @@
+call: {
+    input: {
+        console.log?.(undefined?.(console.log("FAIL")));
+    }
+    expect_exact: 'console.log?.((void 0)?.(console.log("FAIL")));'
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+dot: {
+    input: {
+        console?.log((void 0)?.p);
+    }
+    expect_exact: "console?.log((void 0)?.p);"
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+dot_in: {
+    input: {
+        var o = { in: 42 };
+        console.log(o.in, o?.in);
+    }
+    expect_exact: "var o={in:42};console.log(o.in,o?.in);"
+    expect_stdout: "42 42"
+    node_version: ">=14"
+}
+
+sub: {
+    input: {
+        console?.["log"](null?.[console.log("FAIL")]);
+    }
+    expect_exact: 'console?.["log"](null?.[console.log("FAIL")]);'
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+ternary_decimal: {
+    input: {
+        null ? .42 : console.log("PASS");
+    }
+    expect_exact: 'null?.42:console.log("PASS");'
+    expect_stdout: "PASS"
+}
+
+assign_parentheses_call: {
+    input: {
+        var o = {};
+        ((() => o)?.()).p = "PASS";
+        console.log(o.p);
+    }
+    expect_exact: 'var o={};((()=>o)?.()).p="PASS";console.log(o.p);'
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+assign_parentheses_dot: {
+    input: {
+        (console?.log).name.p = console.log("PASS");
+    }
+    expect_exact: '(console?.log).name.p=console.log("PASS");'
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+assign_no_parentheses: {
+    input: {
+        console[console.log?.("PASS")] = 42;
+    }
+    expect_exact: 'console[console.log?.("PASS")]=42;'
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+call_parentheses: {
+    input: {
+        (function(o) {
+            console.log(o.f("FAIL"), (o.f)("FAIL"), (0, o.f)(42));
+            console.log(o?.f("FAIL"), (o?.f)("FAIL"), (0, o?.f)(42));
+        })({
+            a: "PASS",
+            f(b) {
+                return this.a || b;
+            },
+        });
+    }
+    expect_exact: '(function(o){console.log(o.f("FAIL"),o.f("FAIL"),(0,o.f)(42));console.log(o?.f("FAIL"),(o?.f)("FAIL"),(0,o?.f)(42))})({a:"PASS",f(b){return this.a||b}});'
+    expect_stdout: [
+        "PASS PASS 42",
+        "PASS PASS 42",
+    ]
+    node_version: ">=14"
+}
+
+unary_parentheses: {
+    input: {
+        var o = { p: 41 };
+        (function() {
+            return o;
+        }?.()).p++;
+        console.log(o.p);
+    }
+    expect_exact: "var o={p:41};(function(){return o}?.()).p++;console.log(o.p);"
+    expect_stdout: "42"
+    node_version: ">=14"
+}
+
+collapse_vars_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a;
+        A = 42;
+        a?.[42];
+        console.log(typeof A);
+    }
+    expect: {
+        var a;
+        A = 42;
+        a?.[42];
+        console.log(typeof A);
+    }
+    expect_stdout: "number"
+    node_version: ">=14"
+}
+
+collapse_vars_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a;
+        A = 42;
+        a?.(42);
+        console.log(typeof A);
+    }
+    expect: {
+        var a;
+        A = 42;
+        a?.(42);
+        console.log(typeof A);
+    }
+    expect_stdout: "number"
+    node_version: ">=14"
+}
+
+properties: {
+    options = {
+        evaluate: true,
+        properties: true,
+    }
+    input: {
+        var a;
+        console.log(a?.["FAIL"]);
+    }
+    expect: {
+        var a;
+        console.log(a?.FAIL);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+reduce_vars_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        null?.[a = 0];
+        console.log(a ? "PASS" : "FAIL");
+    }
+    expect: {
+        var a = 1;
+        null?.[a = 0];
+        console.log(a ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+reduce_vars_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        null?.(a = 0);
+        console.log(a ? "PASS" : "FAIL");
+    }
+    expect: {
+        var a = 1;
+        null?.(a = 0);
+        console.log(a ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+side_effects: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        var a;
+        a?.[a = "FAIL"];
+        console.log(a);
+    }
+    expect: {
+        var a;
+        a?.[a = "FAIL"];
+        console.log(a);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+trim_1: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        (function(a, b) {
+            console?.log?.(a?.p, b?.[console.log("FAIL")]);
+        })?.({ p: "PASS" });
+    }
+    expect: {
+        (function(a, b) {
+            console?.log?.(a.p, void 0);
+        })({ p: "PASS" });
+    }
+    expect_stdout: "PASS undefined"
+    node_version: ">=14"
+}
+
+trim_2: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+        side_effects: true,
+    }
+    input: {
+        (void console.log("PASS"))?.[console.log("FAIL")];
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+trim_dot_call_1: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+    }
+    input: {
+        console.log(null?.f());
+    }
+    expect: {
+        console.log(void 0);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+trim_dot_call_2: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+        unsafe: true,
+    }
+    input: {
+        try {
+            (null?.p)();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (void 0)();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+trim_dot_call_3: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+        unsafe: true,
+    }
+    input: {
+        try {
+            ({ p: null })?.p();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            null();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+trim_dot_sub: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+    }
+    input: {
+        console.log(null?.p[42]);
+    }
+    expect: {
+        console.log(void 0);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+trim_sub_call_call: {
+    options = {
+        evaluate: true,
+        optional_chains: true,
+    }
+    input: {
+        console.log(null?.[42]()());
+    }
+    expect: {
+        console.log(void 0);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+issue_4906: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        do {
+            var a = a?.[42];
+        } while (console.log("PASS"));
+    }
+    expect: {
+        do {
+            var a = a?.[42];
+        } while (console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_4928: {
+    options = {
+        ie: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = a?.[function f() {
+            f(a);
+        }];
+        console.log(typeof f);
+    }
+    expect: {
+        var a = a?.[function f() {
+            f(a);
+        }];
+        console.log(typeof f);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+issue_4947_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        console.log(console.foo ? 42..p : console.bar?.p);
+    }
+    expect: {
+        console.log(console.foo ? 42..p : console.bar?.p);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=14"
+}
+
+issue_4947_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var log = console.log, fail;
+        log("PASS") ? log(42) : fail?.(42);
+    }
+    expect: {
+        var log = console.log, fail;
+        log("PASS") ? log(42) : fail?.(42);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_5039: {
+    options = {
+        ie: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = a?.[function f() {
+            f;
+            a;
+        }];
+        console.log("PASS");
+    }
+    expect: {
+        var a = a?.[function f() {}];
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_5091: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a) {
+            var b = a.p;
+            var c;
+            b?.[c = "FAIL 2"];
+            return b || c;
+        }
+        console.log(f("FAIL 1") || "PASS");
+    }
+    expect: {
+        function f(a) {
+            var a = a.p;
+            var c;
+            a?.[c = "FAIL 2"];
+            return a || c;
+        }
+        console.log(f("FAIL 1") || "PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_5292_dot: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+        o?.p;
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+        o?.p;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_5292_dot_pure_getters: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+        o?.p;
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+    }
+}
+
+issue_5292_dot_pure_getters_strict: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+        o?.p;
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("PASS");
+            }
+        };
+        o?.p;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_5292_sub: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        o?.[console.log("bar"), "p"];
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        o?.[console.log("bar"), "p"];
+    }
+    expect_stdout: [
+        "bar",
+        "foo",
+    ]
+    node_version: ">=14"
+}
+
+issue_5292_sub_pure_getters: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        o?.[console.log("bar"), "p"];
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        console.log("bar");
+    }
+}
+
+issue_5292_sub_pure_getters_strict: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        o?.[console.log("bar"), "p"];
+    }
+    expect: {
+        var o = {
+            get p() {
+                console.log("foo");
+            }
+        };
+        o?.[console.log("bar"), "p"];
+    }
+    expect_stdout: [
+        "bar",
+        "foo",
+    ]
+    node_version: ">=14"
+}

test/compress/preserve_line.js

@@ -97,10 +97,10 @@ return_5: {
     }
     expect_exact: [
         "_is_selected=function(tags,slug){",
-        "var ref",
+        "var ref;",
         "",
         "",
-        ";return null!=(ref=_.find(tags,{slug:slug}))?ref.selected:void 0};",
+        "return null!=(ref=_.find(tags,{slug:slug}))?ref.selected:void 0};",
     ]
 }
 
@@ -146,10 +146,10 @@ return_7: {
     }
     expect_exact: [
         "_is_selected=function(e,l){",
-        "var n",
+        "var n;",
         "",
         "",
-        ";return null!=(n=_.find(e,{slug:l}))?n.selected:void 0};",
+        "return null!=(n=_.find(e,{slug:l}))?n.selected:void 0};",
     ]
 }
 

test/compress/properties.js

@@ -17,7 +17,7 @@ dot_properties: {
         properties: true,
     }
     beautify = {
-        ie8: true,
+        ie: true,
     }
     input: {
         a["foo"] = "bar";
@@ -43,7 +43,7 @@ dot_properties_es5: {
         properties: true,
     }
     beautify = {
-        ie8: false,
+        ie: false,
     }
     input: {
         a["foo"] = "bar";
@@ -206,6 +206,7 @@ mangle_unquoted_properties: {
     }
     mangle = {
         properties: {
+            builtins: true,
             keep_quoted: true,
         },
     }
@@ -305,6 +306,7 @@ mangle_debug_suffix_keep_quoted: {
     }
     mangle = {
         properties: {
+            builtins: true,
             debug: "XYZ",
             keep_quoted: true,
             reserved: [],
@@ -1400,3 +1402,181 @@ object_super: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_4831_1: {
+    options = {
+        properties: true,
+    }
+    input: {
+        console.log({
+            f() {
+                return arguments;
+            },
+        }.f("PASS")[0]);
+    }
+    expect: {
+        console.log([
+            function() {
+                return arguments;
+            },
+        ][0]("PASS")[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4831_2: {
+    options = {
+        properties: true,
+    }
+    input: {
+        var f = {
+            f() {
+                return arguments;
+            },
+        }.f;
+        console.log(f("PASS")[0]);
+    }
+    expect: {
+        var f = {
+            f() {
+                return arguments;
+            },
+        }.f;
+        console.log(f("PASS")[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4888: {
+    options = {
+        properties: true,
+    }
+    input: {
+        console.log(typeof {
+            __proto__: 42,
+        }.__proto__);
+    }
+    expect: {
+        console.log(typeof {
+            __proto__: 42,
+        }.__proto__);
+    }
+    expect_stdout: "object"
+}
+
+issue_5093: {
+    beautify = {
+        keep_quoted_props: true,
+    }
+    input: {
+        console.log({
+            a: true,
+            '42': "PASS",
+            "null": [],
+        }[6 * 7]);
+    }
+    expect_exact: 'console.log({a:true,"42":"PASS","null":[]}[6*7]);'
+    expect_stdout: "PASS"
+}
+
+issue_5093_quote_keys: {
+    beautify = {
+        keep_quoted_props: true,
+        quote_keys: true,
+    }
+    input: {
+        console.log({
+            a: true,
+            '42': "PASS",
+            "null": [],
+        }[6 * 7]);
+    }
+    expect_exact: 'console.log({"a":true,"42":"PASS","null":[]}[6*7]);'
+    expect_stdout: "PASS"
+}
+
+issue_5093_quote_style: {
+    beautify = {
+        keep_quoted_props: true,
+        quote_style: 3,
+    }
+    input: {
+        console.log({
+            a: true,
+            '42': "PASS",
+            "null": [],
+        }[6 * 7]);
+    }
+    expect_exact: 'console.log({a:true,\'42\':"PASS","null":[]}[6*7]);'
+    expect_stdout: "PASS"
+}
+
+object_methods: {
+    options = {
+        properties: true,
+    }
+    input: {
+        ({
+            p() {
+                console.log("FAIL 1");
+            },
+            *q() {
+                console.log("FAIL 2");
+            },
+            async r() {
+                console.log("FAIL 3");
+            },
+            async *s() {
+                console.log("PASS");
+            },
+        }).s().next();
+    }
+    expect: {
+        [
+            () => {
+                console.log("FAIL 1");
+            },
+            function*() {
+                console.log("FAIL 2");
+            },
+            async () => {
+                console.log("FAIL 3");
+            },
+            async function*() {
+                console.log("PASS");
+            },
+        ][3]().next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=10"
+}
+
+issue_5177: {
+    options = {
+        properties: true,
+    }
+    input: {
+        var a = "FAIL";
+        var o = { a: "PASS" };
+        o.p = {
+            q() {
+                return this.a;
+            },
+        }.q;
+        console.log(o.p());
+    }
+    expect: {
+        var a = "FAIL";
+        var o = { a: "PASS" };
+        o.p = {
+            q() {
+                return this.a;
+            },
+        }.q;
+        console.log(o.p());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/pure_funcs.js

@@ -133,7 +133,7 @@ conditional: {
 relational: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         foo() in new foo();
@@ -147,7 +147,7 @@ relational: {
         "bar" >= "bar";
     }
     expect: {
-        bar();
+        0 instanceof bar();
         bar();
         bar(), bar();
         bar();
@@ -158,7 +158,7 @@ relational: {
 arithmetic: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         foo() + foo();
@@ -183,7 +183,7 @@ arithmetic: {
 boolean_and: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         foo() && foo();
@@ -208,7 +208,7 @@ boolean_and: {
 boolean_or: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         foo() || foo();
@@ -233,7 +233,7 @@ boolean_or: {
 assign: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         var a;
@@ -256,7 +256,7 @@ assign: {
 unary: {
     options = {
         pure_funcs: [ "foo" ],
-        side_effects :true,
+        side_effects: true,
     }
     input: {
         typeof foo();

test/compress/pure_getters.js

@@ -1289,6 +1289,7 @@ issue_2878: {
         collapse_vars: true,
         pure_getters: true,
         sequences: true,
+        side_effects: true,
     }
     input: {
         var c = 0;
@@ -1320,6 +1321,7 @@ issue_2878: {
 
 issue_3427: {
     options = {
+        assignments: true,
         evaluate: true,
         inline: true,
         pure_getters: "strict",
@@ -1362,9 +1364,8 @@ issue_3490_1: {
     }
     expect: {
         var b = 42, c = "FAIL";
-        if (function() {
-            var a;
-        }(), c = "PASS", b) while ("" == typeof d);
+        var a;
+        if (c = "PASS", b) while ("" == typeof d);
         console.log(c, b);
     }
     expect_stdout: "PASS 42"
@@ -1564,3 +1565,123 @@ issue_4803: {
     }
     expect_stdout: "PASS"
 }
+
+nested_property_assignments_1: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var f;
+        ((f = function() {
+            console.log("FAIL");
+        }).p = f).q = console.log("PASS");
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+nested_property_assignments_2: {
+    options = {
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        var o = {};
+        (function() {
+            var a;
+            (o.p = a = {}).q = "PASS";
+        })();
+        console.log(o.p.q);
+    }
+    expect: {
+        var o = {};
+        (function() {
+            (o.p = {}).q = "PASS";
+        })();
+        console.log(o.p.q);
+    }
+    expect_stdout: "PASS"
+}
+
+nested_property_assignments_3: {
+    options = {
+        collapse_vars: true,
+        pure_getters: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var o = { p: {} };
+        (function(a) {
+            console && a;
+            if (console) {
+                a = a.p;
+                a.q = a;
+            }
+        })(o);
+        console.log(o.p.q === o.p ? "PASS" : "FAIL");
+    }
+    expect: {
+        var o = { p: {} };
+        (function(a) {
+            console;
+            if (console)
+                (a = a.p).q = a;
+        })(o);
+        console.log(o.p.q === o.p ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+nested_property_assignments_4: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var n, o = { p: { q: { r: "PASS" } } };
+        (n = o.p).r = n.q.r;
+        console.log(o.p.r);
+    }
+    expect: {
+        var n, o = { p: { q: { r: "PASS" } } };
+        (n = o.p).r = n.q.r;
+        console.log(o.p.r);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4939: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        ({
+            __proto__: {
+                get p() {
+                    console.log("PASS");
+                },
+            },
+        }).p;
+    }
+    expect: {
+        ({
+            __proto__: {
+                get p() {
+                    console.log("PASS");
+                },
+            },
+        }).p;
+    }
+    expect_stdout: "PASS"
+}

test/compress/reduce_vars.js

@@ -6,6 +6,7 @@ reduce_vars: {
             C: 0,
         },
         inline: true,
+        passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
@@ -41,10 +42,8 @@ reduce_vars: {
     }
     expect: {
         var A = 1;
-        (function() {
-            console.log(-3);
-            console.log(A - 5);
-        })();
+        console.log(-3);
+        console.log(A - 5);
         (function f1() {
             var a = 2;
             console.log(a - 5);
@@ -905,7 +904,7 @@ use_before_var: {
     }
     expect: {
         function f(){
-            console.log(void 0);
+            console.log(t);
             var t = 1;
         }
     }
@@ -981,7 +980,7 @@ inner_var_for_1: {
     expect: {
         function f() {
             var a = 1;
-            x(1, void 0, d);
+            x(1, b, d);
             for (var b = 2, c = 3; x(1, 2, 3, d); x(1, 2, 3, d)) {
                 var d = 4, e = 5;
                 x(1, 2, 3, d, e);
@@ -1292,6 +1291,7 @@ toplevel_on_loops_3: {
         loops: true,
         reduce_funcs: true,
         reduce_vars: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }
@@ -2071,72 +2071,6 @@ issue_1670_2: {
 }
 
 issue_1670_3: {
-    options = {
-        comparisons: true,
-        conditionals: true,
-        dead_code: true,
-        evaluate: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        switches: true,
-        typeofs: true,
-        unused: true,
-    }
-    input: {
-        (function f() {
-            switch (1) {
-              case 0:
-                var a = true;
-                break;
-              case 1:
-                if (typeof a === "undefined") console.log("PASS");
-                else console.log("FAIL");
-            }
-        })();
-    }
-    expect: {
-        (function() {
-            var a;
-            void 0 === a ? console.log("PASS") : console.log("FAIL");
-        })();
-    }
-    expect_stdout: "PASS"
-}
-
-issue_1670_4: {
-    options = {
-        conditionals: true,
-        dead_code: true,
-        evaluate: true,
-        passes: 2,
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        switches: true,
-        unused: true,
-    }
-    input: {
-        (function f() {
-            switch (1) {
-              case 0:
-                var a = true;
-                break;
-              case 1:
-                if (typeof a === "undefined") console.log("PASS");
-                else console.log("FAIL");
-            }
-        })();
-    }
-    expect: {
-        (function() {
-            console.log("PASS");
-        })();
-    }
-    expect_stdout: "PASS"
-}
-
-issue_1670_5: {
     options = {
         conditionals: true,
         dead_code: true,
@@ -2168,7 +2102,7 @@ issue_1670_5: {
     expect_stdout: "1"
 }
 
-issue_1670_6: {
+issue_1670_4: {
     options = {
         conditionals: true,
         dead_code: true,
@@ -3158,7 +3092,7 @@ accessor_1: {
                 a = 2;
                 return a;
             },
-            b: 1
+            b: 1,
         }.b, a);
     }
     expect: {
@@ -3168,7 +3102,7 @@ accessor_1: {
                 a = 2;
                 return a;
             },
-            b: 1
+            b: 1,
         }.b, a);
     }
     expect_stdout: "1 1"
@@ -3188,7 +3122,7 @@ accessor_2: {
         var B = {
             get c() {
                 console.log(A);
-            }
+            },
         };
         B.c;
     }
@@ -3196,7 +3130,7 @@ accessor_2: {
         ({
             get c() {
                 console.log(1);
-            }
+            },
         }).c;
     }
     expect_stdout: "1"
@@ -3242,7 +3176,7 @@ obj_var_1: {
         var obj = {
             bar: function() {
                 return C + C;
-            }
+            },
         };
         console.log(obj.bar());
     }
@@ -3250,7 +3184,7 @@ obj_var_1: {
         console.log({
             bar: function() {
                 return 2;
-            }
+            },
         }.bar());
     }
     expect_stdout: "2"
@@ -3274,7 +3208,7 @@ obj_var_2: {
         var obj = {
             bar: function() {
                 return C + C;
-            }
+            },
         };
         console.log(obj.bar());
     }
@@ -4488,6 +4422,7 @@ perf_2: {
 
 perf_3: {
     options = {
+        passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
         toplevel: true,
@@ -4496,10 +4431,10 @@ perf_3: {
     input: {
         var foo = function(x, y, z) {
             return x < y ? x * y + z : x * z - y;
-        }
+        };
         var indirect_foo = function(x, y, z) {
             return foo(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -4528,10 +4463,10 @@ perf_4: {
     input: {
         var foo = function(x, y, z) {
             return x < y ? x * y + z : x * z - y;
-        }
+        };
         var indirect_foo = function(x, y, z) {
             return foo(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -4540,10 +4475,10 @@ perf_4: {
     expect: {
         var foo = function(x, y, z) {
             return x < y ? x * y + z : x * z - y;
-        }
+        };
         var indirect_foo = function(x, y, z) {
             return foo(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -4632,9 +4567,9 @@ perf_7: {
         var indirect_foo = function(x, y, z) {
             var foo = function(x, y, z) {
                 return x < y ? x * y + z : x * z - y;
-            }
+            };
             return foo(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -4664,9 +4599,9 @@ perf_8: {
         var indirect_foo = function(x, y, z) {
             var foo = function(x, y, z) {
                 return x < y ? x * y + z : x * z - y;
-            }
+            };
             return foo(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -4677,7 +4612,7 @@ perf_8: {
             return function(x, y, z) {
                 return x < y ? x * y + z : x * z - y;
             }(x, y, z);
-        }
+        };
         var sum = 0;
         for (var i = 0; i < 100; ++i)
             sum += indirect_foo(i, i + 1, 3 * i);
@@ -6735,6 +6670,7 @@ issues_3267_1: {
         dead_code: true,
         evaluate: true,
         inline: true,
+        negate_iife: true,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -6752,7 +6688,7 @@ issues_3267_1: {
         });
     }
     expect: {
-        !function(i) {
+        !function(x) {
             if (Object())
                 return console.log("PASS");
             throw "FAIL";
@@ -6769,6 +6705,7 @@ issues_3267_2: {
         evaluate: true,
         inline: true,
         keep_fargs: false,
+        negate_iife: true,
         passes: 2,
         reduce_vars: true,
         sequences: true,
@@ -7384,6 +7321,64 @@ local_assignment_loop: {
     expect_stdout: "PASS"
 }
 
+local_assignment_modified: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a;
+        (a = a || {}).p = 42;
+        console.log(a.p);
+    }
+    expect: {
+        var a;
+        (a = {}).p = 42;
+        console.log(a.p);
+    }
+    expect_stdout: "42"
+}
+
+local_declaration: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a;
+        a || console.log(a = "PASS");
+    }
+    expect: {
+        var a;
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+local_definition_modified: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = a || {};
+        a.p = 42;
+        console.log(a.p);
+    }
+    expect: {
+        var a = {};
+        a.p = 42;
+        console.log(a.p);
+    }
+    expect_stdout: "42"
+}
+
 issue_3957_1: {
     options = {
         evaluate: true,
@@ -7499,6 +7494,7 @@ issue_4030: {
         collapse_vars: true,
         evaluate: true,
         reduce_vars: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }
@@ -7631,3 +7627,272 @@ issue_4568: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4937: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            while (console.log("PASS"));
+        }
+        do {
+            function g() {
+                f();
+            }
+        } while (!g);
+        f();
+    }
+    expect: {
+        function f() {
+            while (console.log("PASS"));
+        }
+        do {
+            function g() {
+                f();
+            }
+        } while (!g);
+        f();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4943_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b = 1;
+        (function f() {
+            a = "foo";
+            b-- && f();
+            console.log(a);
+            a = "bar";
+        })();
+    }
+    expect: {
+        var a, b = 1;
+        (function f() {
+            a = "foo";
+            b-- && f();
+            console.log(a);
+            a = "bar";
+        })();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+issue_4943_2: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a, b = 1;
+        (function f() {
+            a = "foo";
+            b-- && f();
+            console.log(a);
+            a = "bar";
+        })();
+    }
+    expect: {
+        var a, b = 1;
+        (function f() {
+            a = "foo";
+            b-- && f();
+            console.log(a);
+            a = "bar";
+        })();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+}
+
+issue_4949: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function f(a) {
+            a = 0;
+            console.log(a++, arguments[0]);
+        })(0);
+    }
+    expect: {
+        (function(a) {
+            a = 0;
+            console.log(a++, arguments[0]);
+        })(0);
+    }
+    expect_stdout: "0 1"
+}
+
+issue_5048: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = function() {
+                return a + 42;
+            };
+        }());
+    }
+    expect: {
+        console.log(function() {}());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_5050: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        function f() {
+            console.log(a);
+        }
+        this;
+        var a = 1;
+        f(console.log(2), f(), a = 3);
+    }
+    expect: {
+        function f() {
+            console.log(a);
+        }
+        this;
+        var a = 1;
+        f(console.log(2), f(), a = 3);
+    }
+    expect_stdout: [
+        "2",
+        "1",
+        "3",
+    ]
+}
+
+issue_5055_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        function f() {
+            console.log(a || "FAIL");
+        }
+        f(0 && (a = 0)(f(this)));
+    }
+    expect: {
+        var a = "PASS";
+        function f() {
+            console.log(a || "FAIL");
+        }
+        f(0);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5055_2: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        function f() {
+            console.log(a || "FAIL");
+        }
+        f(0 && (a = 0)(f(this)));
+    }
+    expect: {
+        var a = "PASS";
+        function f() {
+            console.log(a || "FAIL");
+        }
+        f(0 && (a = 0)(f()));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5324: {
+    options = {
+        inline: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        A = 0;
+        do {
+            var a, b = A;
+            for (a in b)
+                var c = b;
+        } while (function() {
+            var d;
+            console.log(d *= A);
+        }());
+    }
+    expect: {
+        A = 0;
+        do {
+            var a, b = A;
+            for (a in b);
+        } while (b = void 0, void console.log(b *= A));
+    }
+    expect_stdout: "NaN"
+}
+
+issue_5434: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            for (var i = 0; i < 2; i++) {
+                var b = "FAIL";
+                f && f();
+                a = b;
+                var f = function() {
+                    b = "PASS";
+                };
+            }
+            return a;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            for (var i = 0; i < 2; i++) {
+                var b = "FAIL";
+                f && f();
+                a = b;
+                var f = function() {
+                    b = "PASS";
+                };
+            }
+            return a;
+        }());
+    }
+    expect_stdout: "PASS"
+}

test/compress/regexp.js

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

test/compress/rename.js

@@ -1,11 +1,11 @@
 mangle_catch: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -24,11 +24,11 @@ mangle_catch: {
 mangle_catch_ie8: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -47,11 +47,11 @@ mangle_catch_ie8: {
 mangle_catch_var: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -70,11 +70,11 @@ mangle_catch_var: {
 mangle_catch_var_ie8: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -93,11 +93,11 @@ mangle_catch_var_ie8: {
 mangle_catch_toplevel: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -116,11 +116,11 @@ mangle_catch_toplevel: {
 mangle_catch_ie8_toplevel: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -139,11 +139,11 @@ mangle_catch_ie8_toplevel: {
 mangle_catch_var_toplevel: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -162,11 +162,11 @@ mangle_catch_var_toplevel: {
 mangle_catch_var_ie8_toplevel: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -185,11 +185,11 @@ mangle_catch_var_ie8_toplevel: {
 mangle_catch_redef_1: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -208,11 +208,11 @@ mangle_catch_redef_1: {
 mangle_catch_redef_1_ie8: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -231,11 +231,11 @@ mangle_catch_redef_1_ie8: {
 mangle_catch_redef_1_toplevel: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -254,11 +254,11 @@ mangle_catch_redef_1_toplevel: {
 mangle_catch_redef_1_ie8_toplevel: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -277,11 +277,11 @@ mangle_catch_redef_1_ie8_toplevel: {
 mangle_catch_redef_2: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -299,11 +299,11 @@ mangle_catch_redef_2: {
 mangle_catch_redef_2_ie8: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -321,11 +321,11 @@ mangle_catch_redef_2_ie8: {
 mangle_catch_redef_2_toplevel: {
     rename = true
     options = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -343,11 +343,11 @@ mangle_catch_redef_2_toplevel: {
 mangle_catch_redef_2_ie8_toplevel: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -365,7 +365,7 @@ mangle_catch_redef_2_ie8_toplevel: {
 issue_2120_1: {
     rename = true
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         "aaaaaaaa";
@@ -401,7 +401,7 @@ issue_2120_1: {
 issue_2120_2: {
     rename = true
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         "aaaaaaaa";
@@ -436,7 +436,7 @@ issue_2120_2: {
 function_iife_catch: {
     rename = true
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         function f(n) {
@@ -458,7 +458,7 @@ function_iife_catch: {
 function_iife_catch_ie8: {
     rename = true
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         function f(n) {
@@ -480,7 +480,7 @@ function_iife_catch_ie8: {
 function_catch_catch: {
     rename = true
     mangle = {
-        ie8: false,
+        ie: false,
     }
     input: {
         var o = 0;
@@ -509,7 +509,7 @@ function_catch_catch: {
 function_catch_catch_ie8: {
     rename = true
     mangle = {
-        ie8: true,
+        ie: true,
     }
     input: {
         var o = 0;
@@ -538,12 +538,12 @@ function_catch_catch_ie8: {
 function_do_catch_ie8: {
     rename = true
     options = {
-        ie8: true,
+        ie: true,
         side_effects: true,
         unused: true,
     }
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {
@@ -615,7 +615,7 @@ function_do_catch_ie8: {
 issue_3480: {
     rename = true,
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: false,
     }
     input: {
@@ -647,7 +647,7 @@ issue_3480: {
 issue_3480_ie8: {
     rename = true,
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: false,
     }
     input: {
@@ -679,7 +679,7 @@ issue_3480_ie8: {
 issue_3480_toplevel: {
     rename = true,
     mangle = {
-        ie8: false,
+        ie: false,
         toplevel: true,
     }
     input: {
@@ -711,7 +711,7 @@ issue_3480_toplevel: {
 issue_3480_ie8_toplevel: {
     rename = true,
     mangle = {
-        ie8: true,
+        ie: true,
         toplevel: true,
     }
     input: {

test/compress/sandbox.js

@@ -201,3 +201,20 @@ issue_4811_2: {
     expect_stdout: "PASS [object global] true"
     node_version: ">=8"
 }
+
+issue_5197: {
+    rename = true
+    input: {
+        function f(async) {
+            async(")=>{}");
+        }
+        console.log("" + this.__proto__);
+    }
+    expect: {
+        function f(a) {
+            a(")=>{}");
+        }
+        console.log("" + this.__proto__);
+    }
+    expect_stdout: "[object global]"
+}

test/compress/sequences.js

@@ -289,8 +289,34 @@ iife: {
         typeof function g() {}();
     }
     expect: {
-        x = 42, function a() {}(), function b() {}(), function c() {}(),
-        function d() {}(), function e() {}(), function f() {}(), function g() {}();
+        x = 42,
+        function a() {}(),
+        !function b() {}(),
+        ~function c() {}(),
+        +function d() {}(),
+        -function e() {}(),
+        void function f() {}(),
+        typeof function g() {}();
+    }
+}
+
+iife_drop_side_effect_free: {
+    options = {
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        x = 42;
+        (function a() {})();
+        !function b() {}();
+        ~function c() {}();
+        +function d() {}();
+        -function e() {}();
+        void function f() {}();
+        typeof function g() {}();
+    }
+    expect: {
+        x = 42;
     }
 }
 
@@ -774,7 +800,7 @@ side_effects_cascade_3: {
     }
     expect: {
         function f(a, b) {
-            (b += a) || (b = a) || (b -= a, b ^= a),
+            (b += a) || (b = a) || (b = b - a ^ a),
             a--;
         }
     }
@@ -910,9 +936,7 @@ hoist_decl: {
         var d;
     }
     expect: {
-        var a;
-        w();
-        var b = x(), c, d;
+        var a, b = (w(), x()), c, d;
         for (y(); 0;) z();
     }
 }
@@ -1047,11 +1071,102 @@ call: {
         b.c = function() {
             console.log(this === b ? "bar" : "baz");
         },
+        a,
         b(),
+        a,
         b.c(),
         (a, b.c)(),
+        a,
         b["c"](),
         (a, b["c"])(),
+        a,
+        function() {
+            console.log(this === a);
+        }(),
+        a,
+        new b(),
+        a,
+        new b.c(),
+        a,
+        new b.c(),
+        a,
+        new b["c"](),
+        a,
+        new b["c"](),
+        a,
+        new function() {
+            console.log(this === a);
+        }(),
+        console.log((a, typeof b.c)),
+        console.log((a, typeof b["c"]));
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+        "bar",
+        "baz",
+        "true",
+        "foo",
+        "baz",
+        "baz",
+        "baz",
+        "baz",
+        "false",
+        "function",
+        "function",
+    ]
+}
+
+call_drop_side_effect_free: {
+    options = {
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = function() {
+            return this;
+        }();
+        function b() {
+            console.log("foo");
+        }
+        b.c = function() {
+            console.log(this === b ? "bar" : "baz");
+        };
+        (a, b)();
+        (a, b).c();
+        (a, b.c)();
+        (a, b)["c"]();
+        (a, b["c"])();
+        (a, function() {
+            console.log(this === a);
+        })();
+        new (a, b)();
+        new (a, b).c();
+        new (a, b.c)();
+        new (a, b)["c"]();
+        new (a, b["c"])();
+        new (a, function() {
+            console.log(this === a);
+        })();
+        console.log(typeof (a, b).c);
+        console.log(typeof (a, b)["c"]);
+    }
+    expect: {
+        var a = function() {
+            return this;
+        }();
+        function b() {
+            console.log("foo");
+        }
+        b.c = function() {
+            console.log(this === b ? "bar" : "baz");
+        },
+        b(),
+        b.c(),
+        (0, b.c)(),
+        b["c"](),
+        (0, b["c"])(),
         function() {
             console.log(this === a);
         }(),
@@ -1063,8 +1178,8 @@ call: {
         new function() {
             console.log(this === a);
         }(),
-        console.log((a, typeof b.c)),
-        console.log((a, typeof b["c"]));
+        console.log(typeof b.c),
+        console.log(typeof b["c"]);
     }
     expect_stdout: [
         "foo",
@@ -1099,6 +1214,26 @@ missing_link: {
     expect: {
         var a = 100;
         a,
+        a++ + (0, 1),
+        console.log(a);
+    }
+}
+
+missing_link_drop_side_effect_free: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 100;
+        a;
+        a++ + (0 ? 2 : 1);
+        console.log(a);
+    }
+    expect: {
+        var a = 100;
         a++,
         console.log(a);
     }
@@ -1162,10 +1297,8 @@ issue_3490_1: {
     }
     expect: {
         var b = 42, c = "FAIL";
-        if (function() {
-            var a;
-            a && a.p;
-        }(), c = "PASS", b) while ("" == typeof d);
+        var a;
+        if (a && a.p, c = "PASS", b) while ("" == typeof d);
         console.log(c, b);
     }
     expect_stdout: "PASS 42"
@@ -1195,9 +1328,8 @@ issue_3490_2: {
     }
     expect: {
         var b = 42, c = "FAIL";
-        for (function() {
-            var a;
-        }(), c = "PASS", b; "" == typeof d;);
+        var a;
+        for (c = "PASS"; "" == typeof d;);
         console.log(c, b);
     }
     expect_stdout: "PASS 42"

test/compress/side_effects.js

@@ -198,6 +198,36 @@ global_fns: {
     ]
 }
 
+global_constructors: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        Map;
+        new Map(console.log("foo"));
+        Set;
+        new Set(console.log("bar"));
+        WeakMap;
+        new WeakMap(console.log("baz"));
+        WeakSet;
+        new WeakSet(console.log("moo"));
+    }
+    expect: {
+        console.log("foo");
+        console.log("bar");
+        console.log("baz");
+        console.log("moo");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+        "moo",
+    ]
+    node_version: ">=0.12"
+}
+
 unsafe_builtin_1: {
     options = {
         side_effects: true,
@@ -288,6 +318,32 @@ unsafe_string_replace: {
     expect_stdout: "PASS"
 }
 
+unsafe_Object_call: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        var o = {
+            f: function(a) {
+                console.log(a ? this.p : "FAIL 1");
+            },
+            p: "FAIL 2",
+        }, p = "PASS";
+        Object(o.f)(42);
+    }
+    expect: {
+        var o = {
+            f: function(a) {
+                console.log(a ? this.p : "FAIL 1");
+            },
+            p: "FAIL 2",
+        }, p = "PASS";
+        (0, o.f)(42);
+    }
+    expect_stdout: "PASS"
+}
+
 drop_value: {
     options = {
         side_effects: true,
@@ -587,7 +643,7 @@ issue_4730_2: {
     }
     expect: {
         var a;
-        !console.log("PASS") || a && a[a.p];
+        console.log("PASS") && a && a[a.p];
     }
     expect_stdout: "PASS"
 }
@@ -615,3 +671,56 @@ issue_4751: {
     }
     expect_stdout: "PASS"
 }
+
+drop_instanceof: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        42 instanceof function() {};
+        console.log("PASS");
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+drop_instanceof_reference: {
+    options = {
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        function f() {}
+        42 instanceof f;
+        console.log("PASS");
+    }
+    expect: {
+        function f() {}
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+retain_instanceof: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        try {
+            42 instanceof "foo";
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            0 instanceof "foo";
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/spreads.js

@@ -1,3 +1,12 @@
+decimal: {
+    input: {
+        console.log({... 0.42});
+    }
+    expect_exact: "console.log({....42});"
+    expect_stdout: "{}"
+    node_version: ">=8.3.0"
+}
+
 collapse_vars_1: {
     options = {
         collapse_vars: true,
@@ -147,7 +156,7 @@ dont_inline: {
     node_version: ">=6"
 }
 
-do_inline: {
+do_inline_1: {
     options = {
         inline: true,
         spreads: true,
@@ -164,6 +173,46 @@ do_inline: {
     node_version: ">=6"
 }
 
+do_inline_2: {
+    options = {
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        (function() {
+            (function() {
+                console.log("PASS");
+            })(..."");
+        })();
+    }
+    expect: {
+        [] = [ ..."" ],
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+do_inline_3: {
+    options = {
+        if_return: true,
+        inline: true,
+    }
+    input: {
+        (function() {
+            (function() {
+                while (console.log("PASS"));
+            })(..."");
+        })();
+    }
+    expect: {
+        var [] = [ ..."" ];
+        while (console.log("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 drop_empty_call_1: {
     options = {
         side_effects: true,
@@ -201,7 +250,29 @@ drop_empty_call_2: {
     node_version: ">=6"
 }
 
-convert_hole: {
+convert_hole_array: {
+    options = {
+        spreads: true,
+    }
+    input: {
+        [ ...[ "PASS", , 42 ] ].forEach(function(a) {
+            console.log(a);
+        });
+    }
+    expect: {
+        [ "PASS", void 0, 42 ].forEach(function(a) {
+            console.log(a);
+        });
+    }
+    expect_stdout: [
+        "PASS",
+        "undefined",
+        "42",
+    ]
+    node_version: ">=6"
+}
+
+convert_hole_call: {
     options = {
         spreads: true,
     }
@@ -341,7 +412,7 @@ convert_setter: {
             console.log(k, o[k]);
     }
     expect_stdout: "PASS undefined"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 keep_getter_1: {
@@ -370,7 +441,7 @@ keep_getter_1: {
         });
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 keep_getter_2: {
@@ -399,7 +470,7 @@ keep_getter_2: {
         "foo",
         "bar",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 keep_getter_3: {
@@ -429,7 +500,7 @@ keep_getter_3: {
         });
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 keep_getter_4: {
@@ -460,7 +531,7 @@ keep_getter_4: {
         });
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 keep_accessor: {
@@ -508,7 +579,7 @@ keep_accessor: {
         "q undefined",
         "r null",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 object_key_order_1: {
@@ -538,7 +609,7 @@ object_key_order_1: {
         "a 3",
         "b 2",
     ]
-    node_version: ">=8 <=10"
+    node_version: ">=8.3.0 <=10"
 }
 
 object_key_order_2: {
@@ -568,7 +639,7 @@ object_key_order_2: {
         "a 3",
         "b 2",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 object_key_order_3: {
@@ -598,7 +669,7 @@ object_key_order_3: {
         "a 3",
         "b 2",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 object_key_order_4: {
@@ -628,7 +699,7 @@ object_key_order_4: {
         "a 3",
         "b 2",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 object_spread_array: {
@@ -654,7 +725,7 @@ object_spread_array: {
         "0 foo",
         "1 bar",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 object_spread_string: {
@@ -681,7 +752,7 @@ object_spread_string: {
         "1 o",
         "2 o",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 unused_var_side_effects: {
@@ -711,7 +782,7 @@ unused_var_side_effects: {
         });
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 unsafe_join_1: {
@@ -793,7 +864,7 @@ issue_4329: {
         }[0]);
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4331: {
@@ -871,7 +942,7 @@ issue_4345: {
         }[42]);
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4361: {
@@ -901,7 +972,7 @@ issue_4361: {
         "foo",
         "undefined",
     ]
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4363: {
@@ -922,7 +993,7 @@ issue_4363: {
         });
     }
     expect_stdout: "PASS"
-    node_version: ">=8"
+    node_version: ">=8.3.0"
 }
 
 issue_4556: {
@@ -945,78 +1016,6 @@ issue_4556: {
     node_version: ">=6"
 }
 
-issue_4560_1: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        toplevel: true,
-    }
-    input: {
-        var a = 0;
-        (function(...{
-            [a++]: {},
-        }) {})(2);
-        console.log(a);
-    }
-    expect: {
-        var a = 0;
-        (function(...{
-            [a++]: {},
-        }) {})(2);
-        console.log(a);
-    }
-    expect_stdout: "1"
-    node_version: ">=6"
-}
-
-issue_4560_2: {
-    options = {
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a = 0;
-        (function(...{
-            [a++]: {},
-        }) {})(2);
-        console.log(a);
-    }
-    expect: {
-        var a = 0;
-        (function(...{
-            [a++]: {},
-        }) {})(2);
-        console.log(a);
-    }
-    expect_stdout: "1"
-    node_version: ">=6"
-}
-
-issue_4560_3: {
-    options = {
-        collapse_vars: true,
-        reduce_vars: true,
-        toplevel: true,
-    }
-    input: {
-        var a = 0, b;
-        [ ...{
-            [a++]: b,
-        } ] = [ "PASS" ];
-        console.log(b);
-    }
-    expect: {
-        var a = 0, b;
-        [ ...{
-            [a++]: b,
-        } ] = [ "PASS" ];
-        console.log(b);
-    }
-    expect_stdout: "PASS"
-    node_version: ">=6"
-}
-
 issue_4614: {
     options = {
         pure_getters: "strict",
@@ -1045,3 +1044,212 @@ issue_4614: {
     expect_stdout: true
     node_version: ">=6"
 }
+
+issue_4849: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        while (function() {
+            while (!console);
+        }(new function(a) {
+            console.log(typeof { ...a });
+        }(function() {})));
+    }
+    expect: {
+        while (function() {
+            while (!console);
+        }(function(a) {
+            console.log(typeof { ...function() {} });
+        }()));
+    }
+    expect_stdout: "object"
+    node_version: ">=8.3.0"
+}
+
+issue_4882_1: {
+    options = {
+        objects: true,
+        spreads: true,
+    }
+    input: {
+        var o = {
+            p: "PASS",
+            ... {
+                __proto__: {
+                    p: "FAIL 1",
+                    q: "FAIL 2",
+                },
+            },
+        };
+        console.log(o.p);
+        console.log(o.q);
+    }
+    expect: {
+        var o = {
+            p: "PASS",
+        };
+        console.log(o.p);
+        console.log(o.q);
+    }
+    expect_stdout: [
+        "PASS",
+        "undefined",
+    ]
+    node_version: ">=8.3.0"
+}
+
+issue_4882_2: {
+    options = {
+        objects: true,
+        spreads: true,
+    }
+    input: {
+        console.log(null == Object.getPrototypeOf({
+            ... {
+                __proto__: (console.log(42), null),
+            },
+        }) ? "FAIL" : "PASS");
+    }
+    expect: {
+        console.log(null == Object.getPrototypeOf({
+            ... {
+                __proto__: (console.log(42), null),
+            },
+        }) ? "FAIL" : "PASS");
+    }
+    expect_stdout: [
+        "42",
+        "PASS",
+    ]
+    node_version: ">=8.3.0"
+}
+
+issue_4882_3: {
+    options = {
+        objects: true,
+        spreads: true,
+    }
+    input: {
+        var o = {
+            __proto__: { p: 42 },
+            ... {
+                set __proto__(v) {},
+            },
+        };
+        console.log(o.__proto__ === Object.getPrototypeOf(o) ? "FAIL" : "PASS");
+        console.log(o.p);
+    }
+    expect: {
+        var o = {
+            __proto__: { p: 42 },
+            ["__proto__"]: void 0,
+        };
+        console.log(o.__proto__ === Object.getPrototypeOf(o) ? "FAIL" : "PASS");
+        console.log(o.p);
+    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=8.3.0"
+}
+
+issue_5006: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        console.log(function(b, c) {
+            c = "FAIL 2";
+            return arguments[1];
+        }(...[], "FAIL 1") || "PASS");
+    }
+    expect: {
+        console.log(function(b, c) {
+            c = "FAIL 2";
+            return arguments[1];
+        }(...[], "FAIL 1") || "PASS");
+    }
+    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"
+}
+
+issue_5602: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        if_return: true,
+        inline: true,
+        passes: 2,
+        sequences: true,
+        spreads: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            try {
+                var b = function(c) {
+                    if (c)
+                        return FAIL;
+                    var d = 42;
+                }(...[ null, A = 0 ]);
+            } catch (e) {
+                b();
+            }
+        })();
+        console.log(A);
+    }
+    expect: {
+        (function() {
+            try {
+                var b = void (A = 0);
+            } catch (e) {
+                b();
+            }
+        })(),
+        console.log(A);
+    }
+    expect_stdout: "0"
+    expect_warnings: [
+        "INFO: Dropping unused variable d [test/compress/spreads.js:6,24]",
+        "INFO: Collapsing c [test/compress/spreads.js:4,24]",
+        "INFO: Dropping unused variable c [test/compress/spreads.js:3,33]",
+        "INFO: pass 0: last_count: Infinity, count: 27",
+        "WARN: Condition always false [test/compress/spreads.js:4,20]",
+        "INFO: Collapsing null [test/compress/spreads.js:7,23]",
+        "INFO: Collapsing 0 [test/compress/spreads.js:3,24]",
+        "INFO: pass 1: last_count: 27, count: 22",
+    ]
+    node_version: ">=6"
+}

test/compress/switches.js

@@ -113,7 +113,7 @@ constant_switch_5: {
         // the break inside the if ruins our job
         // we can still get rid of irrelevant cases.
         switch (1) {
-          case 1:
+          default:
             x();
             if (foo) break;
             y();
@@ -300,6 +300,37 @@ drop_default_2: {
     }
 }
 
+drop_default_3: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        function f() {
+            console.log("PASS");
+            return 42;
+        }
+        switch (42) {
+          case f():
+            break;
+          case void console.log("FAIL"):
+          default:
+        }
+    }
+    expect: {
+        function f() {
+            console.log("PASS");
+            return 42;
+        }
+        switch (42) {
+          case f():
+          case void console.log("FAIL"):
+        }
+    }
+    expect_stdout: "PASS"
+}
+
 keep_default: {
     options = {
         dead_code: true,
@@ -423,7 +454,6 @@ drop_case_3: {
         switch ({}.p) {
           default:
           case void 0:
-            break;
           case c = "FAIL":
         }
         console.log(c);
@@ -454,7 +484,168 @@ drop_case_4: {
     expect_stdout: "PASS"
 }
 
-keep_case: {
+drop_case_5: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        switch (42) {
+          case void console.log("PASS 1"):
+            console.log("FAIL 1");
+          case 42:
+          case console.log("FAIL 2"):
+            console.log("PASS 2");
+        }
+    }
+    expect: {
+        switch (42) {
+          default:
+            void console.log("PASS 1");
+            console.log("PASS 2");
+        }
+    }
+    expect_stdout: [
+        "PASS 1",
+        "PASS 2",
+    ]
+}
+
+drop_case_6: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        switch (console.log("PASS 1"), 2) {
+          case 0:
+            console.log("FAIL 1");
+          case (console.log("PASS 2"), 1):
+            console.log("FAIL 2");
+        }
+    }
+    expect: {
+        switch (console.log("PASS 1"), 2) {
+          case (console.log("PASS 2"), 1):
+        }
+    }
+    expect_stdout: [
+        "PASS 1",
+        "PASS 2",
+    ]
+}
+
+drop_case_7: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        switch (2) {
+          case 0:
+            console.log("FAIL 1");
+          case (console.log("PASS 1"), 1):
+            console.log("FAIL 2");
+          case 2:
+            console.log("PASS 2");
+        }
+    }
+    expect: {
+        switch (2) {
+          default:
+            console.log("PASS 1"), 1;
+            console.log("PASS 2");
+        }
+    }
+    expect_stdout: [
+        "PASS 1",
+        "PASS 2",
+    ]
+}
+
+drop_case_8: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        function log(msg) {
+            console.log(msg);
+            return msg;
+        }
+        switch (log("foo")) {
+          case "bar":
+            log("moo");
+            break;
+          case log("baz"):
+            log("moo");
+            break;
+          default:
+            log("moo");
+        }
+    }
+    expect: {
+        function log(msg) {
+            console.log(msg);
+            return msg;
+        }
+        switch (log("foo")) {
+          case "bar":
+          case log("baz"):
+          default:
+            log("moo");
+        }
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+        "moo",
+    ]
+}
+
+drop_case_9: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        function log(msg) {
+            console.log(msg);
+            return msg;
+        }
+        switch (log("foo")) {
+          case log("bar"):
+            log("moo");
+            break;
+          case "baz":
+            log("moo");
+            break;
+          default:
+            log("moo");
+        }
+    }
+    expect: {
+        function log(msg) {
+            console.log(msg);
+            return msg;
+        }
+        switch (log("foo")) {
+          default:
+            log("bar");
+            log("moo");
+        }
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "moo",
+    ]
+}
+
+keep_case_1: {
     options = {
         dead_code: true,
         switches: true,
@@ -474,6 +665,76 @@ keep_case: {
     }
 }
 
+keep_case_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        switch ("foo") {
+          case console.log("bar"):
+          case console.log("baz"), "moo":
+        }
+    }
+    expect: {
+        switch ("foo") {
+          case console.log("bar"):
+          case console.log("baz"), "moo":
+        }
+    }
+    expect_stdout: [
+        "bar",
+        "baz",
+    ]
+}
+
+keep_case_3: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        var a;
+        switch (void console.log("PASS")) {
+          case a:
+          case console.log("FAIL"), 42:
+        }
+    }
+    expect: {
+        var a;
+        switch (void console.log("PASS")) {
+          case a:
+          case console.log("FAIL"), 42:
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+keep_case_4: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        var a;
+        switch (void console.log("PASS")) {
+          case a:
+          case void console.log("FAIL"):
+        }
+    }
+    expect: {
+        var a;
+        switch (void console.log("PASS")) {
+          case a:
+          case void console.log("FAIL"):
+        }
+    }
+    expect_stdout: "PASS"
+}
+
 issue_376: {
     options = {
         dead_code: true,
@@ -661,7 +922,7 @@ issue_1680_1: {
           case f(0):
           case f(1):
             f(2);
-          case 2:
+          default:
             f(5);
         }
     }
@@ -924,7 +1185,6 @@ issue_2535: {
     }
     expect: {
         w(), 42;
-        42;
         y();
         z();
     }
@@ -950,7 +1210,6 @@ issue_1750: {
     expect: {
         var a = 0, b = 1;
         true;
-        a, true;
         b = 2;
         console.log(a, b);
     }
@@ -1088,7 +1347,8 @@ drop_switch_6: {
         }
     }
     expect: {
-        A === B;
+        A;
+        B;
         x();
         C !== D;
         y();
@@ -1181,3 +1441,250 @@ issue_4059: {
     }
     expect_stdout: "PASS"
 }
+
+issue_5008_1: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        reduce_vars: true,
+        switches: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(function f() {
+            switch (f) {
+              case f:
+                return "PASS";
+              default:
+                return "FAIL";
+            }
+        }());
+    }
+    expect: {
+        console.log(function f() {
+            switch (f) {
+              default:
+                return "PASS";
+            }
+        }());
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5008_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        reduce_vars: true,
+        switches: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(function(a) {
+            switch (a) {
+              case a:
+                return "PASS";
+              default:
+                return "FAIL";
+            }
+        }([]));
+    }
+    expect: {
+        console.log(function(a) {
+            switch (a) {
+              default:
+                return "PASS";
+            }
+        }([]));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5008_3: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        reduce_vars: true,
+        switches: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(function(a) {
+            switch (a) {
+              case a:
+                return "PASS";
+              default:
+                return "FAIL";
+            }
+        }({}));
+    }
+    expect: {
+        console.log(function(a) {
+            switch (a) {
+              default:
+                return "PASS";
+            }
+        }({}));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5008_4: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        reduce_vars: true,
+        switches: true,
+    }
+    input: {
+        console.log(function(a) {
+            switch (a) {
+              case a:
+                return "PASS";
+              default:
+                return "FAIL";
+            }
+        }(/foo/));
+    }
+    expect: {
+        console.log(function(a) {
+            switch (a) {
+              default:
+                return "PASS";
+            }
+        }(/foo/));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5010: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        var a;
+        switch (42) {
+          case console.log("PASS"):
+          case a:
+            console.log("FAIL");
+          case 42:
+        }
+    }
+    expect: {
+        var a;
+        switch (42) {
+          case console.log("PASS"):
+          case a:
+            console.log("FAIL");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5012: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        switch (void 0) {
+          case console.log("PASS"):
+            break;
+          case void 0:
+          case 42:
+            console.log("FAIL");
+        }
+    }
+    expect: {
+        switch (void 0) {
+          case console.log("PASS"):
+            break;
+          default:
+            console.log("FAIL");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5543_1: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (false) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (false) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_5543_2: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (42) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect: {
+        var a;
+        switch (a) {
+          default:
+            switch (42) {
+              case a:
+              case console.log("PASS"):
+            }
+            break;
+          case null:
+            switch (42) {
+              case a:
+              case console.log("FAIL"):
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/templates.js

@@ -62,6 +62,23 @@ tag_parentheses_arrow: {
     node_version: ">=4"
 }
 
+tag_parentheses_binary: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var f = function() {
+            console.log("PASS");
+        } || console
+        f``;
+    }
+    expect_exact: '(function(){console.log("PASS")}||console)``;'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 tag_parentheses_new: {
     input: {
         (new function() {
@@ -87,6 +104,21 @@ tag_parentheses_sequence: {
     node_version: ">=4"
 }
 
+tag_parentheses_unary: {
+    input: {
+        var a;
+        try {
+            (~a)``;
+            (a++)``;
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_exact: 'var a;try{(~a)``;(a++)``}catch(e){console.log("PASS")}'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 malformed_escape: {
     input: {
         (function(s) {
@@ -99,6 +131,105 @@ malformed_escape: {
     node_version: ">=4"
 }
 
+booleans: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        var a;
+        console.log(`$${a}${a}` ? "PASS" : "FAIL");
+    }
+    expect: {
+        var a;
+        console.log("$" + a + a ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+escape_placeholder_1: {
+    options = {
+        templates: true,
+    }
+    input: {
+        console.log(`\${\n`);
+    }
+    expect: {
+        console.log(`\${
+`);
+    }
+    expect_stdout: [
+        "${",
+        "",
+    ]
+    node_version: ">=4"
+}
+
+escape_placeholder_2: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\n${"${"}\n`);
+    }
+    expect: {
+        console.log(`
+\${
+`);
+    }
+    expect_stdout: [
+        "",
+        "${",
+        "",
+    ]
+    node_version: ">=4"
+}
+
+escape_placeholder_3: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\n$${"{"}\n`);
+    }
+    expect: {
+        console.log(`
+\${
+`);
+    }
+    expect_stdout: [
+        "",
+        "${",
+        "",
+    ]
+    node_version: ">=4"
+}
+
+escape_placeholder_4: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\n${"$"}${"{"}\n`);
+    }
+    expect: {
+        console.log(`
+\${
+`);
+    }
+    expect_stdout: [
+        "",
+        "${",
+        "",
+    ]
+    node_version: ">=4"
+}
+
 evaluate: {
     options = {
         evaluate: true,
@@ -142,7 +273,7 @@ partial_evaluate: {
         console.log(`${6 * 7} foo ${console ? `PA` + "SS" : `FA` + `IL`}`);
     }
     expect: {
-        console.log(`42 foo ${console ? "PASS" : "FAIL"}`);
+        console.log("42 foo " + (console ? "PASS" : "FAIL"));
     }
     expect_stdout: "42 foo PASS"
     node_version: ">=4"
@@ -172,7 +303,7 @@ malformed_evaluate_2: {
         console.log(`\u0${0}b${5}`);
     }
     expect: {
-        console.log(`\u0${0}b5`);
+        console.log(`\u00b` + 5);
     }
     expect_stdout: true
     node_version: ">=4"
@@ -206,7 +337,7 @@ malformed_evaluate_4: {
         console.log("\\u00b5");
     }
     expect_stdout: "\\u00b5"
-    node_version: ">=8"
+    node_version: ">=8.10.0"
 }
 
 unsafe_evaluate: {
@@ -222,7 +353,7 @@ unsafe_evaluate: {
         console.log("\\uFo");
     }
     expect_stdout: "\\uFo"
-    node_version: ">=8"
+    node_version: ">=8.10.0"
 }
 
 side_effects_1: {
@@ -283,6 +414,21 @@ unsafe_side_effects: {
     node_version: ">=4"
 }
 
+pure_funcs: {
+    options = {
+        pure_funcs: "Math.random",
+        side_effects: true,
+    }
+    input: {
+        Math.random`${console.log("PASS")}`;
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 issue_4604: {
     options = {
         collapse_vars: true,
@@ -310,13 +456,14 @@ issue_4604: {
 issue_4606: {
     options = {
         evaluate: true,
+        strings: true,
         templates: true,
     }
     input: {
         console.log(`${typeof A} ${"\r"} ${"\\"} ${"`"}`);
     }
     expect: {
-        console.log(`${typeof A} \r \\ \``);
+        console.log(typeof A + " \r \\ `");
     }
     expect_stdout: "undefined \r \\ `"
     node_version: ">=4"
@@ -343,7 +490,7 @@ issue_4676: {
         reduce_vars: true,
         templates: true,
         toplevel: true,
-        unsafe:true,
+        unsafe: true,
         unused: true,
     }
     input: {
@@ -366,3 +513,259 @@ issue_4676: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_4931: {
+    options = {
+        evaluate: true,
+        templates: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(String.raw`${typeof A} ${"\r"}`);
+        console.log(String.raw`${"\\"} ${"`"}`);
+    }
+    expect: {
+        console.log(String.raw`${typeof A} ${"\r"}`);
+        console.log("\\ `");
+    }
+    expect_stdout: [
+        "undefined \r",
+        "\\ `",
+    ]
+    node_version: ">=4"
+}
+
+issue_5125_1: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`PASS ${typeof A}`);
+    }
+    expect: {
+        console.log("PASS " + typeof A);
+    }
+    expect_stdout: "PASS undefined"
+    node_version: ">=4"
+}
+
+issue_5125_2: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`PASS
+${typeof A}`);
+    }
+    expect: {
+        console.log(`PASS
+` + typeof A);
+    }
+    expect_stdout: [
+        "PASS",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_5125_3: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`PASS\n${typeof A}`);
+    }
+    expect: {
+        console.log(`PASS
+` + typeof A);
+    }
+    expect_stdout: [
+        "PASS",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_5125_4: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`PASS
+
+${typeof A}`);
+    }
+    expect: {
+        console.log(`PASS
+
+` + typeof A);
+    }
+    expect_stdout: [
+        "PASS",
+        "",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_5125_5: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`PASS\n\n${typeof A}`);
+    }
+    expect: {
+        console.log(`PASS
+
+` + typeof A);
+    }
+    expect_stdout: [
+        "PASS",
+        "",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+issue_5125_6: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${typeof A} ${typeof B} PASS`);
+    }
+    expect: {
+        console.log(typeof A + ` ${typeof B} PASS`);
+    }
+    expect_stdout: "undefined undefined PASS"
+    node_version: ">=4"
+}
+
+issue_5125_7: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${typeof A} ${typeof B} ${typeof C} PASS`);
+    }
+    expect: {
+        console.log(typeof A + ` ${typeof B} ${typeof C} PASS`);
+    }
+    expect_stdout: "undefined undefined undefined PASS"
+    node_version: ">=4"
+}
+
+issue_5125_8: {
+    options = {
+        evaluate: true,
+        strings: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${typeof A}${typeof B}${typeof C} PASS`);
+    }
+    expect: {
+        console.log(typeof A + typeof B + typeof C + " PASS");
+    }
+    expect_stdout: "undefinedundefinedundefined PASS"
+    node_version: ">=4"
+}
+
+issue_5136: {
+    options = {
+        templates: true,
+    }
+    input: {
+        console.log(`${A = []}${A[0] = 42}`);
+    }
+    expect: {
+        console.log(`` + (A = []) + (A[0] = 42));
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+issue_5145_1: {
+    options = {
+        strings: true,
+        templates: true,
+    }
+    input: {
+        var a = [];
+        console.log(`${a}${a[0] = 42}
+`);
+    }
+    expect: {
+        var a = [];
+        console.log(`${a}${a[0] = 42}
+`);
+    }
+    expect_stdout: [
+        "42",
+        "",
+    ]
+    node_version: ">=4"
+}
+
+issue_5145_2: {
+    options = {
+        strings: true,
+        templates: true,
+    }
+    input: {
+        var a = [];
+        console.log(`${a}${a}${a[0] = 42}
+`);
+    }
+    expect: {
+        var a = [];
+        console.log("" + a + a + (a[0] = 42) + `
+`);
+    }
+    expect_stdout: [
+        "42",
+        "",
+    ]
+    node_version: ">=4"
+}
+
+issue_5199: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function() {
+            console.log(typeof b);
+        }``;
+        {
+            const b = a;
+        }
+    }
+    expect: {
+        var a = function() {
+            console.log(typeof b);
+        }``;
+        {
+            const b = a;
+        }
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}

test/compress/transform.js

@@ -95,7 +95,7 @@ while_if_break: {
         }
     }
     expect: {
-        for(; a && (b && c && d, !e););
+        for (; a && (b && c && d, !e););
     }
 }
 
@@ -127,7 +127,7 @@ if_return: {
                 if (w) {
                     if (y) return;
                 } else if (z) return;
-                return x == y || (x && w(), y && z()), !0;
+                return x != y && (x && w(), y && z()), !0;
             }
         }
     }

test/compress/typeof.js

@@ -307,7 +307,7 @@ typeof_defined_1: {
     }
     expect: {
         "undefined" == typeof A && A;
-        "undefined" != typeof A || A;
+        "undefined" == typeof A && A;
     }
 }
 
@@ -324,7 +324,7 @@ typeof_defined_2: {
     }
     expect: {
         "function" != typeof A && A;
-        "function" == typeof A || A;
+        "function" != typeof A && A;
     }
 }
 
@@ -355,16 +355,19 @@ typeof_defined_3: {
         "undefined" == typeof A && "undefined" == typeof B && (A, B);
         "undefined" == typeof A && "undefined" != typeof B && A;
         "undefined" != typeof A && "undefined" == typeof B && B;
+        // dropped
         "undefined" == typeof A && "undefined" == typeof B || (A, B);
         "undefined" == typeof A && "undefined" != typeof B || (A, B);
         "undefined" != typeof A && "undefined" == typeof B || (A, B);
         "undefined" != typeof A && "undefined" != typeof B || (A, B);
-        "undefined" == typeof A || "undefined" == typeof B && B;
-        "undefined" != typeof A || "undefined" == typeof B && (A, B);
-        "undefined" != typeof A || "undefined" != typeof B && A;
-        "undefined" == typeof A || "undefined" != typeof B || B;
-        "undefined" != typeof A || "undefined" == typeof B || A;
-        "undefined" != typeof A || "undefined" != typeof B || (A, B);
+        "undefined" != typeof A && "undefined" == typeof B && B;
+        // dropped
+        "undefined" == typeof A && "undefined" == typeof B && (A, B);
+        "undefined" == typeof A && "undefined" != typeof B && A;
+        // dropped
+        "undefined" != typeof A && "undefined" == typeof B && B;
+        "undefined" == typeof A && "undefined" != typeof B && A;
+        "undefined" == typeof A && "undefined" == typeof B && (A, B);
     }
 }
 
@@ -392,6 +395,7 @@ typeof_defined_4: {
         "object" != typeof A || "object" != typeof B || (A, B);
     }
     expect: {
+        // dropped
         "object" == typeof A && "object" != typeof B && B;
         "object" != typeof A && "object" == typeof B && A;
         "object" != typeof A && "object" != typeof B && (A, B);
@@ -399,12 +403,14 @@ typeof_defined_4: {
         "object" == typeof A && "object" != typeof B || (A, B);
         "object" != typeof A && "object" == typeof B || (A, B);
         "object" != typeof A && "object" != typeof B || (A, B);
-        "object" == typeof A || "object" == typeof B && A;
-        "object" == typeof A || "object" != typeof B && (A, B);
-        "object" != typeof A || "object" != typeof B && B;
-        "object" == typeof A || "object" == typeof B || (A, B);
-        "object" == typeof A || "object" != typeof B || A;
-        "object" != typeof A || "object" == typeof B || B;
+        "object" != typeof A && "object" == typeof B && A;
+        "object" != typeof A && "object" != typeof B && (A, B);
+        // dropped
+        "object" == typeof A && "object" != typeof B && B;
+        "object" != typeof A && "object" != typeof B && (A, B);
+        "object" != typeof A && "object" == typeof B && A;
+        "object" == typeof A && "object" != typeof B && B;
+        // dropped
     }
 }
 
@@ -436,6 +442,245 @@ emberjs_global: {
     expect_stdout: Error("PASS")
 }
 
+reassign: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A = void 0;
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A = void 0;
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+reassign_call: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        function f() {
+            A = void 0;
+        }
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            f();
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect: {
+        A = console;
+        function f() {
+            A = void 0;
+        }
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            f();
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+reassign_conditional: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A &&= void 0;
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A &&= void 0;
+            while (console.log(void 0 === A ? "PASS" : "FAIL 2"));
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=15"
+}
+
+reassign_do: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        if_return: true,
+        passes: 2,
+        reduce_vars: true,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        (function() {
+            if ("undefined" == typeof A)
+                return;
+            var a = A, i = 2;
+            do {
+                console.log(void 0 === A, void 0 === a);
+                A = void 0;
+            } while (--i);
+        })();
+    }
+    expect: {
+        A = console;
+        (function() {
+            if ("undefined" != typeof A) {
+                var a = A, i = 2;
+                do {
+                    console.log(void 0 === A, (a, false));
+                    A = void 0;
+                } while (--i);
+            }
+        })();
+    }
+    expect_stdout: [
+        "false false",
+        "true false",
+    ]
+}
+
+reassign_for: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        typeofs: true,
+    }
+    input: {
+        if (A = console, "undefined" != typeof A)
+            for (var a = A, i = 0; i < 2; i++)
+                console.log(void 0 === A, void 0 === a),
+                A = void 0;
+    }
+    expect: {
+        if (A = console, "undefined" != typeof A)
+            for (var a = A, i = 0; i < 2; i++)
+                console.log(void 0 === A, (a, false)),
+                A = void 0;
+    }
+    expect_stdout: [
+        "false false",
+        "true false",
+    ]
+}
+
+reassign_for_in: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        reduce_vars: true,
+        typeofs: true,
+    }
+    input: {
+        (A = console) && "undefined" != typeof A && function(a) {
+            for (var k in [ a = A, 42 ]) {
+                console.log(void 0 === A, void 0 === a);
+                A = void 0;
+            }
+        }();
+    }
+    expect: {
+        (A = console) && "undefined" != typeof A && function(a) {
+            for (var k in [ a = A, 42 ]) {
+                console.log(void 0 === A, (a, false));
+                A = void 0;
+            }
+        }();
+    }
+    expect_stdout: [
+        "false false",
+        "true false",
+    ]
+}
+
+reassign_iife: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else (function() {
+            A = void 0;
+        })(console.log(void 0 === A ? "FAIL 2" : "PASS"));
+    }
+    expect: {
+        A = console;
+        "undefined" == typeof A ? console.log("FAIL 1") : function() {
+            A = void 0;
+        }(console.log((A, false) ? "FAIL 2" : "PASS"));
+    }
+    expect_stdout: "PASS"
+}
+
+reassign_property: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        passes: 2,
+        typeofs: true,
+    }
+    input: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A.p = void 0;
+            console.log(void 0 === A ? "FAIL 2" : "PASS");
+        }
+    }
+    expect: {
+        A = console;
+        if ("undefined" == typeof A)
+            console.log("FAIL 1");
+        else {
+            A.p = void 0;
+            console.log((A, false) ? "FAIL 2" : "PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
 issue_3817: {
     options = {
         comparisons: true,

test/compress/unicode.js

@@ -67,7 +67,8 @@ unicode_escaped_identifier_2: {
     }
     expect_exact: 'var a="foo";var \u{10000}="bar";console.log(a,\u{10000});'
     expect_stdout: "foo bar"
-    node_version: ">=4"
+    // non-BMP support is platform-dependent on Node.js v4
+    node_version: ">=6"
 }
 
 unicode_identifier_ascii_only: {
@@ -200,7 +201,8 @@ surrogate_pair: {
     }
     expect_exact: 'var \ud87e\udc00={"\ud87e\udc01":"\udbc0\udc00"};\ud87e\udc00.\ud87e\udc02="\udbc0\udc01";console.log(typeof \ud87e\udc00,\ud87e\udc00.\ud87e\udc01,\ud87e\udc00["\ud87e\udc02"]);'
     expect_stdout: "object \udbc0\udc00 \udbc0\udc01"
-    node_version: ">=4"
+    // non-BMP support is platform-dependent on Node.js v4
+    node_version: ">=6"
 }
 
 surrogate_pair_ascii: {
@@ -216,5 +218,6 @@ surrogate_pair_ascii: {
     }
     expect_exact: 'var \\u{2f800}={"\\ud87e\\udc01":"\\udbc0\\udc00"};\\u{2f800}.\\u{2f802}="\\udbc0\\udc01";console.log(typeof \\u{2f800},\\u{2f800}.\\u{2f801},\\u{2f800}["\\ud87e\\udc02"]);'
     expect_stdout: "object \udbc0\udc00 \udbc0\udc01"
-    node_version: ">=4"
+    // non-BMP support is platform-dependent on Node.js v4
+    node_version: ">=6"
 }

test/compress/varify.js

@@ -13,10 +13,10 @@ reduce_merge_const: {
         console.log(b);
     }
     expect: {
-        var b = console;
-        console.log(typeof b);
-        b = typeof b;
-        console.log(b);
+        var a = console;
+        console.log(typeof a);
+        a = typeof a;
+        console.log(a);
     }
     expect_stdout: [
         "object",
@@ -41,10 +41,10 @@ reduce_merge_let: {
     }
     expect: {
         "use strict";
-        var b = console;
-        console.log(typeof b);
-        b = typeof b;
-        console.log(b);
+        var a = console;
+        console.log(typeof a);
+        a = typeof a;
+        console.log(a);
     }
     expect_stdout: [
         "object",
@@ -111,7 +111,7 @@ hoist_props_const: {
         }
     }
     expect: {
-        var o_p = "PASS";
+        var o, o_p = "PASS";
         console.log(o_p);
     }
     expect_stdout: "PASS"
@@ -136,7 +136,7 @@ hoist_props_let: {
     }
     expect: {
         "use strict";
-        var o_p = "PASS";
+        var o, o_p = "PASS";
         console.log(o_p);
     }
     expect_stdout: "PASS"
@@ -523,3 +523,125 @@ default_init: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_4933_1: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        console.log(f());
+        function f() {
+            var a;
+            for (console in a = [ f ]) {
+                const b = a;
+            }
+        }
+    }
+    expect: {
+        console.log(function f() {
+            var a;
+            for (console in a = [ f ]) {
+                const b = a;
+            }
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4933_2: {
+    options = {
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        console.log(f());
+        function f() {
+            var a;
+            for (console in a = [ f ]) {
+                const b = a;
+            }
+        }
+    }
+    expect: {
+        console.log(function f() {
+            for (console in [ f ]);
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4954: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        (function() {
+            {
+                let a = console;
+                console.log(typeof a);
+            }
+            {
+                let a = function() {};
+                a && console.log(typeof a);
+            }
+        })();
+    }
+    expect: {
+        "use strict";
+        (function() {
+            var a = console;
+            console.log(typeof a);
+            {
+                let a = function() {};
+                a && console.log(typeof a);
+            }
+        })();
+    }
+    expect_stdout: [
+        "object",
+        "function",
+    ]
+    node_version: ">=4"
+}
+
+issue_5516: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        console.log(typeof function() {
+            {
+                let a;
+            }
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect: {
+        "use strict";
+        console.log(typeof function() {
+            {
+                const a = function() {};
+                return a;
+            }
+        }());
+    }
+    expect_stdout: "function"
+    node_version: ">=4"
+}

test/compress/webkit.js

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

test/compress/yields.js

@@ -96,7 +96,7 @@ pause_resume: {
     node_version: ">=4"
 }
 
-arrow_yield: {
+arrow_yield_1: {
     input: {
         yield = "PASS";
         console.log(function*() {
@@ -108,6 +108,18 @@ arrow_yield: {
     node_version: ">=4"
 }
 
+arrow_yield_2: {
+    input: {
+        console.log(typeof function *() {
+            // Syntax error on Node.js v6+
+            return (yield) => {};
+        }().next().value);
+    }
+    expect_exact: "console.log(typeof function*(){return(yield)=>{}}().next().value);"
+    expect_stdout: "function"
+    node_version: "4"
+}
+
 for_of: {
     input: {
         function* f() {
@@ -150,6 +162,27 @@ for_await_of: {
     node_version: ">=10"
 }
 
+comment_newline: {
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        console.log(function*() {
+            yield (
+                /* */
+                "PASS"
+            );
+        }().next().value);
+    }
+    expect_exact: [
+        "console.log(function*(){",
+        "/* */",
+        'yield"PASS"}().next().value);',
+    ]
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 collapse_vars_1: {
     options = {
         collapse_vars: true,
@@ -716,7 +749,7 @@ lift_sequence: {
     node_version: ">=4"
 }
 
-inline_nested_yield: {
+inline_nested: {
     options = {
         inline: true,
         sequences: true,
@@ -751,6 +784,118 @@ inline_nested_yield: {
     node_version: ">=4"
 }
 
+inline_nested_async: {
+    options = {
+        awaits: true,
+        inline: true,
+        sequences: true,
+        side_effects: true,
+        yields: true,
+    }
+    input: {
+        console.log("foo");
+        var a = async function*() {
+            console.log(await(yield* async function*() {
+                yield {
+                    then: r => r("bar"),
+                };
+                return "baz";
+            }()));
+        }();
+        console.log("moo");
+        a.next().then(function f(b) {
+            console.log(b.value);
+            b.done || a.next().then(f);
+        });
+        console.log("moz");
+    }
+    expect: {
+        console.log("foo");
+        var a = async function*() {
+            console.log((yield {
+                then: r => r("bar"),
+            }, await "baz"));
+        }();
+        console.log("moo"),
+        a.next().then(function f(b) {
+            console.log(b.value),
+            b.done || a.next().then(f);
+        }),
+        console.log("moz");
+    }
+    expect_stdout: [
+        "foo",
+        "moo",
+        "moz",
+        "bar",
+        "baz",
+        "undefined",
+    ]
+    node_version: ">=10"
+}
+
+inline_nested_block: {
+    options = {
+        if_return: true,
+        inline: true,
+        yields: true,
+    }
+    input: {
+        var a = function*() {
+            yield* function*() {
+                for (var a of [ "foo", "bar" ])
+                    yield a;
+                return "FAIL";
+            }();
+        }(), b;
+        do {
+            b = a.next();
+            console.log(b.value);
+        } while (!b.done);
+    }
+    expect: {
+        var a = function*() {
+            for (var a of [ "foo", "bar" ])
+                yield a;
+            "FAIL";
+        }(), b;
+        do {
+            b = a.next();
+            console.log(b.value);
+        } while (!b.done);
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+dont_inline_nested: {
+    options = {
+        inline: true,
+    }
+    input: {
+        var yield = "PASS";
+        (function*() {
+            (function() {
+                console.log(yield);
+            })();
+        })().next();
+    }
+    expect: {
+        var yield = "PASS";
+        (function*() {
+            (function() {
+                console.log(yield);
+            })();
+        })().next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 drop_body: {
     options = {
         side_effects: true,
@@ -762,7 +907,7 @@ drop_body: {
         })([ console.log("baz") ]);
     }
     expect: {
-        [ [ , [].e = console.log("foo") ] ] = [ [ console.log("baz") ] ];
+        [ [ , [][0] = console.log("foo") ] ] = [ [ console.log("baz") ] ];
     }
     expect_stdout: [
         "baz",
@@ -789,6 +934,21 @@ drop_unused_call: {
     node_version: ">=4"
 }
 
+instanceof_lambda: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(42 instanceof function*() {});
+    }
+    expect: {
+        console.log(false);
+    }
+    expect_stdout: "false"
+    node_version: ">=4"
+}
+
 issue_4454_1: {
     rename = false
     options = {
@@ -831,8 +991,8 @@ issue_4454_2: {
         f("PASS");
     }
     expect: {
-        function f(b) {
-            (function*(c = console.log(b)) {})();
+        function f(a) {
+            (function*(c = console.log(a)) {})();
             var b = 42..toString();
             console.log(b);
         }
@@ -937,7 +1097,7 @@ issue_4639_1: {
         }().next().value());
     }
     expect_stdout: "PASS"
-    node_version: ">=4"
+    node_version: ">=4 <7 || >=8.7.0"
 }
 
 issue_4639_2: {
@@ -1023,6 +1183,35 @@ issue_4641_2: {
     node_version: ">=10"
 }
 
+issue_4641_3: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        console.log(typeof async function*() {
+            try {
+                return void "FAIL";
+            } finally {
+                console.log("PASS");
+            }
+        }().next().then);
+    }
+    expect: {
+        console.log(typeof async function*() {
+            try {
+                return void "FAIL";
+            } finally {
+                console.log("PASS");
+            }
+        }().next().then);
+    }
+    expect_stdout: [
+        "function",
+        "PASS",
+    ]
+    node_version: ">=10"
+}
+
 issue_4769_1: {
     options = {
         side_effects: true,
@@ -1062,3 +1251,487 @@ issue_4769_2: {
     expect_stdout: "PASS"
     node_version: ">=6"
 }
+
+issue_5019_1: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        (function(a) {
+            return a = function*() {
+                console.log(typeof a);
+            }();
+        })().next();
+    }
+    expect: {
+        (function(a) {
+            return a = function*() {
+                console.log(typeof a);
+            }();
+        })().next();
+    }
+    expect_stdout: "object"
+    node_version: ">=4"
+}
+
+issue_5019_2: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        var a = [];
+        for (var b in "foo")
+            a.push(function(c) {
+                return function*() {
+                    console.log(c);
+                }();
+            }(b));
+        a.map(function(d) {
+            return d.next();
+        });
+    }
+    expect: {
+        var a = [];
+        for (var b in "foo")
+            a.push(function(c) {
+                return function*() {
+                    console.log(c);
+                }();
+            }(b));
+        a.map(function(d) {
+            return d.next();
+        });
+    }
+    expect_stdout: [
+        "0",
+        "1",
+        "2",
+    ]
+    node_version: ">=4"
+}
+
+issue_5034: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var yield = function f() {
+                return function*() {
+                    return f;
+                };
+            };
+            return yield()().next().value === yield;
+        }() ? "PASS" : "FAIL");
+    }
+    expect: {
+        console.log(function() {
+            var yield = function f() {
+                return function*() {
+                    return f;
+                };
+            };
+            return yield()().next().value === yield;
+        }() ? "PASS" : "FAIL");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_5076_1: {
+    options = {
+        evaluate: true,
+        hoist_vars: true,
+        keep_fargs: false,
+        pure_getters: "strict",
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+        yields: true,
+    }
+    input: {
+        var a;
+        console.log("PASS");
+        var b = function*({
+            p: {},
+        }) {}({
+            p: { a } = 42,
+        });
+    }
+    expect: {
+        var a;
+        console.log("PASS"),
+        a = 42["a"];
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5076_2: {
+    options = {
+        evaluate: true,
+        hoist_vars: true,
+        keep_fargs: false,
+        passes: 2,
+        pure_getters: "strict",
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+        yields: true,
+    }
+    input: {
+        var a;
+        console.log("PASS");
+        var b = function*({
+            p: {},
+        }) {}({
+            p: { a } = 42,
+        });
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_5177: {
+    options = {
+        properties: true,
+    }
+    input: {
+        console.log(typeof function*() {
+            return {
+                p(yield) {},
+            }.p;
+        }().next().value);
+    }
+    expect: {
+        console.log(typeof function*() {
+            return {
+                p(yield) {},
+            }.p;
+        }().next().value);
+    }
+    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_5385_3: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function*() {
+            return function() {
+                try {
+                    throw console.log("foo");
+                } catch (e) {
+                    return console.log("bar");
+                }
+            }();
+        })().next();
+        console.log("moo");
+    }
+    expect: {
+        (async function*() {
+            try {
+                throw console.log("foo");
+            } catch (e) {
+                return console.log("bar");
+            }
+            return void 0;
+        })().next();
+        console.log("moo");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "moo",
+    ]
+    node_version: ">=10"
+}
+
+issue_5385_4: {
+    options = {
+        awaits: true,
+        inline: true,
+    }
+    input: {
+        (async function*() {
+            return async function() {
+                try {
+                    return {
+                        then(resolve) {
+                            resolve(console.log("FAIL"));
+                        },
+                    };
+                } finally {
+                    return "PASS";
+                }
+            }();
+        })().next().then(o => console.log(o.value, o.done));
+    }
+    expect: {
+        (async function*() {
+            return async function() {
+                try {
+                    return {
+                        then(resolve) {
+                            resolve(console.log("FAIL"));
+                        },
+                    };
+                } finally {
+                    return "PASS";
+                }
+            }();
+        })().next().then(o => console.log(o.value, o.done));
+    }
+    expect_stdout: "PASS true"
+    node_version: ">=10"
+}
+
+issue_5425: {
+    options = {
+        assignments: true,
+        ie: true,
+        toplevel: true,
+        unused: true,
+        yields: true,
+    }
+    input: {
+        var a = "FAIL";
+        var b = function* f() {}(a ? a = "PASS" : 42);
+        console.log(a, typeof f);
+    }
+    expect: {
+        var a = "FAIL";
+        (function* f() {})(a && (a = "PASS"));
+        console.log(a, typeof f);
+    }
+    expect_stdout: "PASS undefined"
+    node_version: ">=4"
+}
+
+issue_5456: {
+    options = {
+        inline: true,
+        merge_vars: true,
+    }
+    input: {
+        var a = true;
+        (function() {
+            (function(b, c) {
+                var d = function*() {
+                    c = null;
+                }();
+                var e = function() {
+                    if (c)
+                        console.log(typeof d);
+                    while (b);
+                }();
+            })(function(i) {
+                return console.log("foo") && i;
+            }(a));
+        })();
+    }
+    expect: {
+        var a = true;
+        (function() {
+            b = (i = a, console.log("foo") && i),
+            d = function*() {
+                c = null;
+            }(),
+            e = function() {
+                if (c) console.log(typeof d);
+                while (b);
+            }(),
+            void 0;
+            var b, c, d, e;
+            var i;
+        })();
+    }
+    expect_stdout: "foo"
+    node_version: ">=4"
+}
+
+issue_5506: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        console.log(function(a) {
+            var b = function*() {
+                a = null in (a = "PASS");
+            }();
+            try {
+                b.next();
+            } catch (e) {
+                return a;
+            }
+        }("FAIL"));
+    }
+    expect: {
+        console.log(function(a) {
+            var b = function*() {
+                a = null in (a = "PASS");
+            }();
+            try {
+                b.next();
+            } catch (e) {
+                return a;
+            }
+        }("FAIL"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_5526: {
+    options = {
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        (async function*() {
+            try {
+                return function() {
+                    while (console.log("foo"));
+                }();
+            } finally {
+                console.log("bar");
+            }
+        })().next();
+        console.log("baz");
+    }
+    expect: {
+        (async function*() {
+            try {
+                while (console.log("foo"));
+                return void 0;
+            } finally {
+                console.log("bar");
+            }
+        })().next();
+        console.log("baz");
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+        "bar",
+    ]
+    node_version: ">=10"
+}
+
+issue_5576: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (async function*() {
+            try {
+                (function() {
+                    while (console.log("foo"));
+                })();
+            } finally {
+                console.log("bar");
+            }
+        })().next();
+        console.log("baz");
+    }
+    expect: {
+        (async function*() {
+            try {
+                while (console.log("foo"));
+            } finally {
+                console.log("bar");
+            }
+        })().next();
+        console.log("baz");
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
+    node_version: ">=10"
+}

test/input/invalid/assign_4.js

@@ -1 +1 @@
-++null
+console.log(4 || (null = 4));

test/input/invalid/assign_5.js

@@ -0,0 +1 @@
+console.log(5 || ([]?.length ^= 5));

test/input/invalid/for-await.js

@@ -0,0 +1 @@
+for await (; console.log(42););

test/input/invalid/optional-template.js

@@ -0,0 +1 @@
+console?.log``;

test/input/issue-3040/expect.js

@@ -38,4 +38,4 @@ var _require = require("bar"), foo = _require.foo;
 var _require2 = require("world"), hello = _require2.hello;
 
 foo.x.apply(foo, _toConsumableArray(foo.y(hello.z)));
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImlucHV0LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImNvbnN0IHtmb299ID0gcmVxdWlyZShcImJhclwiKTtcbmNvbnN0IHtoZWxsb30gPSByZXF1aXJlKFwid29ybGRcIik7XG5cbmZvby54KC4uLmZvby55KGhlbGxvLnopKTtcbiJdLCJuYW1lcyI6WyJyZXF1aXJlIiwiZm9vIiwiaGVsbG8iLCJ4IiwiYXBwbHkiLCJfdG9Db25zdW1hYmxlQXJyYXkiLCJ5IiwieiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7ZUFBY0EsUUFBUSxRQUFmQyxNLFNBQUFBOztBLGdCQUNTRCxRQUFRLFVBQWpCRSxRLFVBQUFBOztBQUVQRCxJQUFJRSxFQUFKQyxNQUFBSCxLQUFHSSxtQkFBTUosSUFBSUssRUFBRUosTUFBTUsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImlucHV0LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImNvbnN0IHtmb299ID0gcmVxdWlyZShcImJhclwiKTtcbmNvbnN0IHtoZWxsb30gPSByZXF1aXJlKFwid29ybGRcIik7XG5cbmZvby54KC4uLmZvby55KGhlbGxvLnopKTtcbiJdLCJuYW1lcyI6WyJyZXF1aXJlIiwiZm9vIiwiaGVsbG8iLCJ4IiwiYXBwbHkiLCJfdG9Db25zdW1hYmxlQXJyYXkiLCJ5IiwieiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7ZUFBY0EsUUFBUSxLQUFELEdBQWRDLE0sU0FBQUE7O0EsZ0JBQ1NELFFBQVEsT0FBRCxHQUFoQkUsUSxVQUFBQTs7QUFFUEQsSUFBSUUsRUFBSkMsTUFBQUgsS0FBR0ksbUJBQU1KLElBQUlLLEVBQUVKLE1BQU1LLENBQVosQ0FBTixDQUFBIn0=

test/input/issue-3294/output.js

@@ -1,2 +1,2 @@
 console.log(3);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSxDQUFHIn0=

test/input/issue-505/output.js

@@ -1,5 +1,5 @@
 function test(a){
-"aaaaaaaaaaaaaaaa"
-;a(err,data),a(err,
+"aaaaaaaaaaaaaaaa";
+a(err,data),a(err,
 data)}
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsidGVzdCIsImNhbGxiYWNrIiwiZXJyIiwiZGF0YSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsS0FBS0M7O0NBRVZBLEVBQVNDLElBQUtDLE1BQ2RGLEVBQVNDO0FBQUtDIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsidGVzdCIsImNhbGxiYWNrIiwiZXJyIiwiZGF0YSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0E7SEFBS0MsR0FDVjtBQUNBQTtoQkFBU0MsSUFBS0MsSUFBSSxFQUNsQkYsRUFBU0MsSUFBS0MsSUFBSSxDQUN0QiJ9

test/input/issue-520/output.js

@@ -1,2 +1,2 @@
 console.log(3);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSxDQUFHIn0=

test/input/module/expect.js

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

test/input/module/input.js

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

test/input/reduce/diff_error.reduced.js

@@ -1,7 +1,5 @@
 // (beautified)
-console.log(function() {
-    return 1 + .1 + .1;
-}());
+console.log(1 + .1 + .1);
 // output: 1.2000000000000002
 // 
 // minify: 1.2