v3.13.0

fixes #4708

.github/ISSUE_TEMPLATE.md

@@ -1,25 +0,0 @@
-**Bug report or feature request?**
-
-<!-- Note: sub-optimal but correct code is not a bug -->
-
-**Uglify version (`uglifyjs -V`)**
-
-**JavaScript input**
-
-<!--
-    A complete parsable JS program exhibiting the issue with
-    UglifyJS alone - without third party tools or libraries.
-    Ideally the input should be as small as possible.
-    Post a link to a gist if necessary.
-
-    Issues without a reproducible test case will be closed.
--->
-
-**The `uglifyjs` CLI command executed or `minify()` options used.**
-
-**JavaScript output or error produced.**
-
-<!--
-    Note: `uglify-js` only supports JavaScript.
-    Those wishing to minify ES6+ should transpile first.
--->

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,51 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+<!-- Note: sub-optimal but correct code is not a bug -->
+
+**Uglify version (`uglifyjs -V`)**
+
+**JavaScript input**
+
+<!--
+A complete parsable JS program exhibiting the issue with UglifyJS alone
+- without third party tools or libraries.
+
+Ideally the input should be as small as possible, but may be large if isolating
+the problem proves to be difficult. The most important thing is that the
+standalone program reliably exhibits the bug when minified. Provide a link to a
+gist if necessary.
+
+Solely providing minified output without the original uglify JS input is not
+useful in determining the cause of the problem. Issues without a reproducible
+test case will be closed.
+-->
+
+**The `uglifyjs` CLI command executed or `minify()` options used.**
+
+<!--
+Command-line or API call to UglifyJS without third party tools or libraries.
+
+For users using bundlers or transpilers, you may be able to gather the required
+information through setting the `UGLIFY_BUG_REPORT` environment variable:
+
+    export UGLIFY_BUG_REPORT=1      (bash)
+    set UGLIFY_BUG_REPORT=1         (Command Prompt)
+    $Env:UGLIFY_BUG_REPORT=1        (PowerShell)
+
+before running your usual build process. The resulting "minified" output should
+contain the necessary details for this report.
+-->
+
+**JavaScript output or error produced.**
+
+<!--
+Only minified code that produces different output (or error) from the original
+upon execution would be considered a bug.
+-->

.github/workflows/ci.yml

@@ -7,13 +7,13 @@ jobs:
   test:
     strategy:
       matrix:
-        node: [ "0.8", "0.10", "0.12", "4", "6", "8", "10", "12", latest ]
+        node: [ '0.8', '0.10', '0.12', '4', '6', '8', '10', '12', latest ]
         os: [ ubuntu-latest, windows-latest ]
         script: [ compress, mocha, release/benchmark, release/jetstream ]
         exclude:
-          - node: "0.8"
+          - node: '0.8'
             script: release/benchmark
-          - node: "0.8"
+          - node: '0.8'
             script: release/jetstream
     name: ${{ matrix.node }} ${{ matrix.os }} ${{ matrix.script }}
     runs-on: ${{ matrix.os }}
@@ -29,7 +29,7 @@ jobs:
       - name: Perform tests
         shell: bash
         run: |
-          git clone --branch v1.5.4 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
+          git clone --branch v1.6.0 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
           while ! timeout 60 bash -c '. ~/.nvs/nvs.sh add $NODE && nvs use $NODE'; do
             cd ~/.nvs
             while !(git clean -xdf); do echo "'git clean' failed - retrying..."; done

.github/workflows/ufuzz.yml

@@ -2,7 +2,7 @@ name: Fuzzing
 on:
   pull_request:
   schedule:
-    - cron: "*/5 * * * *"
+    - cron: '*/5 * * * *'
 env:
   BASE_URL: https://api.github.com/repos/${{ github.repository }}
   CAUSE: ${{ github.event_name }}
@@ -13,22 +13,42 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ ubuntu-latest, windows-latest ]
-    name: ${{ matrix.os }}
+        include:
+          - node: latest
+            os: macos-latest
+          - node: '8'
+            os: ubuntu-latest
+          - node: '8'
+            os: ubuntu-latest
+          - node: '8'
+            os: windows-latest
+          - node: '8'
+            os: windows-latest
+    name: ${{ matrix.node }} ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
+    env:
+      NODE: ${{ matrix.node }}
     steps:
       - uses: actions/checkout@v2
+      - name: Install GNU Core Utilities
+        if: ${{ startsWith(matrix.os, 'macos') }}
+        env:
+          HOMEBREW_NO_BOTTLE_SOURCE_FALLBACK: 1
+          HOMEBREW_NO_INSTALL_CLEANUP: 1
+        shell: bash
+        run: |
+          while !(brew install coreutils); do echo "'brew install' failed - retrying..."; done
       - name: Perform fuzzing
         shell: bash
         run: |
-          git clone --branch v1.5.4 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
-          while ! timeout 60 bash -c '. ~/.nvs/nvs.sh add 8 && nvs use 8'; do
+          git clone --branch v1.6.0 --depth 1 https://github.com/jasongin/nvs.git ~/.nvs
+          while ! timeout 60 bash -c '. ~/.nvs/nvs.sh add $NODE && nvs use $NODE'; do
             cd ~/.nvs
             while !(git clean -xdf); do echo "'git clean' failed - retrying..."; done
             cd -
           done
           . ~/.nvs/nvs.sh --version
-          nvs use 8
+          nvs use $NODE
           node --version
           npm config set audit false
           npm config set optional false

README.md

@@ -4,12 +4,11 @@ UglifyJS 3
 UglifyJS is a JavaScript parser, minifier, compressor and beautifier toolkit.
 
 #### Note:
-- **`uglify-js@3` has a simplified [API](#api-reference) and [CLI](#command-line-usage)
-  that is not backwards compatible with [`uglify-js@2`](https://github.com/mishoo/UglifyJS/tree/v2.x)**.
-- **Documentation for UglifyJS `2.x` releases can be found [here](https://github.com/mishoo/UglifyJS/tree/v2.x)**.
-- `uglify-js` supports ECMAScript 5 and some newer language features.
-- To minify ECMAScript 2015 or above, you may need to transpile using tools like
-  [Babel](https://babeljs.io/).
+- `uglify-js` supports JavaScript and most language features in ECMAScript.
+- For more exotic parts of ECMAScript, process your source file with transpilers
+  like [Babel](https://babeljs.io/) before passing onto `uglify-js`.
+- `uglify-js@3` has a simplified [API](#api-reference) and [CLI](#command-line-usage)
+  that is not backwards compatible with [`uglify-js@2`](https://github.com/mishoo/UglifyJS/tree/v2.x).
 
 Install
 -------
@@ -86,7 +85,7 @@ a double dash to prevent input files being used as option arguments:
                                                1 - single
                                                2 - double
                                                3 - original
-                                `wrap_iife`  Wrap IIFEs in parenthesis. Note: you may
+                                `wrap_iife`  Wrap IIFEs in parentheses. Note: you may
                                              want to disable `negate_iife` under
                                              compressor options.
     -O, --output-opts [options] Specify output options (`beautify` disabled by default).
@@ -135,6 +134,10 @@ a double dash to prevent input files being used as option arguments:
                                        `//# sourceMappingURL`.
     --timings                   Display operations run time on STDERR.
     --toplevel                  Compress and/or mangle variables in top level scope.
+    --v8                        Support non-standard Chrome & Node.js
+                                Equivalent to setting `v8: true` in `minify()`
+                                for `mangle` and `output` options.
+                                By default UglifyJS will not try to be v8-proof.
     --verbose                   Print diagnostic messages.
     --warn                      Print warning messages.
     --webkit                    Support non-standard Safari/Webkit.
@@ -522,6 +525,8 @@ if (result.error) throw result.error;
 - `toplevel` (default `false`) -- set to `true` if you wish to enable top level
   variable and function name mangling and to drop unused variables and functions.
 
+- `v8` (default `false`) -- enable workarounds for Chrome & Node.js bugs.
+
 - `warnings` (default `false`) — pass `true` to return compressor warnings
   in `result.warnings`. Use the value `"verbose"` for more detailed warnings.
 
@@ -621,7 +626,11 @@ to be `false` and all symbol names will be omitted.
 - `arguments` (default: `true`) -- replace `arguments[index]` with function
   parameter name whenever possible.
 
-- `assignments` (default: `true`) -- apply optimizations to assignment expressions.
+- `arrows` (default: `true`) -- apply optimizations to arrow functions
+
+- `assignments` (default: `true`) -- apply optimizations to assignment expressions
+
+- `awaits` (default: `true`) -- apply optimizations to `await` expressions
 
 - `booleans` (default: `true`) -- various optimizations for boolean context,
   for example `!!a ? b : c → a ? b : c`
@@ -638,6 +647,8 @@ to be `false` and all symbol names will be omitted.
 
 - `dead_code` (default: `true`) -- remove unreachable code
 
+- `default_values` (default: `true`) -- drop overshadowed default values
+
 - `directives` (default: `true`) -- remove redundant or non-standard directives
 
 - `drop_console` (default: `false`) -- Pass `true` to discard calls to
@@ -655,11 +666,14 @@ to be `false` and all symbol names will be omitted.
 - `expression` (default: `false`) -- Pass `true` to preserve completion values
   from terminal statements without `return`, e.g. in bookmarklets.
 
-- `functions` (default: `true`) -- convert declarations from `var`to `function`
+- `functions` (default: `true`) -- convert declarations from `var` to `function`
   whenever possible.
 
 - `global_defs` (default: `{}`) -- see [conditional compilation](#conditional-compilation)
 
+- `hoist_exports` (default: `true`) -- hoist `export` statements to facilitate
+  various `compress` and `mangle` optimizations.
+
 - `hoist_funs` (default: `false`) -- hoist function declarations
 
 - `hoist_props` (default: `true`) -- hoist properties from constant object and
@@ -673,6 +687,8 @@ to be `false` and all symbol names will be omitted.
 
 - `if_return` (default: `true`) -- optimizations for if/return and if/continue
 
+- `imports` (default: `true`) -- drop unreferenced import symbols when used with `unused`
+
 - `inline` (default: `true`) -- inline calls to function with simple/`return` statement:
   - `false` -- same as `0`
   - `0` -- disabled inlining
@@ -683,13 +699,9 @@ to be `false` and all symbol names will be omitted.
 
 - `join_vars` (default: `true`) -- join consecutive `var` statements
 
-- `keep_fargs` (default: `strict`) -- Discard unused function arguments. Code
-  which relies on `Function.length` will break if this is done indiscriminately,
-  i.e. when passing `true`. Pass `false` to always retain function arguments.
-
-- `keep_fnames` (default: `false`) -- Pass `true` to prevent the
-  compressor from discarding function names.  Useful for code relying on
-  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle-options).
+- `keep_fargs` (default: `false`) -- discard unused function arguments except
+  when unsafe to do so, e.g. code which relies on `Function.prototype.length`.
+  Pass `true` to always retain function arguments.
 
 - `keep_infinity` (default: `false`) -- Pass `true` to prevent `Infinity` from
   being compressed into `1/0`, which may cause performance issues on Chrome.
@@ -739,6 +751,8 @@ to be `false` and all symbol names will be omitted.
 - `reduce_vars` (default: `true`) -- Improve optimization on variables assigned with and
   used as constant values.
 
+- `rests` (default: `true`) -- apply optimizations to rest parameters
+
 - `sequences` (default: `true`) -- join consecutive simple statements using the
   comma operator.  May be set to a positive integer to specify the maximum number
   of consecutive comma sequences that will be generated. If this option is set to
@@ -753,20 +767,23 @@ to be `false` and all symbol names will be omitted.
   annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
   example: `/*@__PURE__*/foo();`
 
-- `spread` (default: `true`) -- flatten spread expressions.
+- `spreads` (default: `true`) -- flatten spread expressions.
 
 - `strings` (default: `true`) -- compact string concatenations.
 
 - `switches` (default: `true`) -- de-duplicate and remove unreachable `switch` branches
 
-- `toplevel` (default: `false`) -- drop unreferenced functions (`"funcs"`) and/or
-  variables (`"vars"`) in the top level scope (`false` by default, `true` to drop
-  both unreferenced functions and variables)
+- `templates` (default: `true`) -- compact template literals by embedding expressions
+  and/or converting to string literals, e.g. `` `foo ${42}` → "foo 42"``
 
 - `top_retain` (default: `null`) -- prevent specific toplevel functions and
   variables from `unused` removal (can be array, comma-separated, RegExp or
   function. Implies `toplevel`)
 
+- `toplevel` (default: `false`) -- drop unreferenced functions (`"funcs"`) and/or
+  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.
@@ -798,15 +815,13 @@ to be `false` and all symbol names will be omitted.
 - `varify` (default: `true`) -- convert block-scoped declaractions into `var`
   whenever safe to do so
 
+- `yields` (default: `true`) -- apply optimizations to `yield` expressions
+
 ## Mangle options
 
 - `eval` (default `false`) -- Pass `true` to mangle names visible in scopes
   where `eval` or `with` are used.
 
-- `keep_fnames` (default `false`) -- Pass `true` to not mangle function names.
-  Useful for code relying on `Function.prototype.name`. See also: the `keep_fnames`
-  [compress option](#compress-options).
-
 - `reserved` (default `[]`) -- Pass an array of identifiers that should be
   excluded from mangling. Example: `["foo", "bar"]`.
 
@@ -873,7 +888,7 @@ can pass additional arguments that control the code output:
   comments, `"some"` to preserve multi-line comments that contain `@cc_on`,
   `@license`, or `@preserve` (case-insensitive), a regular expression string
   (e.g. `/^!/`), or a function which returns `boolean`, e.g.
-  ```js
+  ```javascript
   function(node, comment) {
       return comment.value.indexOf("@type " + node.TYPE) >= 0;
   }
@@ -919,8 +934,6 @@ can pass additional arguments that control the code output:
 
 - `shebang` (default `true`) -- preserve shebang `#!` in preamble (bash scripts)
 
-- `v8` (default `false`) -- enable workarounds for Chrome & Node.js bugs
-
 - `width` (default `80`) -- only takes effect when beautification is on, this
   specifies an (orientative) line width that the beautifier will try to
   obey.  It refers to the width of the line text (excluding indentation).
@@ -1146,7 +1159,7 @@ To enable fast minify mode from the CLI use:
 uglifyjs file.js -m
 ```
 To enable fast minify mode with the API use:
-```js
+```javascript
 UglifyJS.minify(code, { compress: false, mangle: true });
 ```
 
@@ -1178,10 +1191,10 @@ To allow for better optimizations, the compiler makes various assumptions:
   `Object.defineProperty()`, `Object.defineProperties()`, `Object.freeze()`,
   `Object.preventExtensions()` or `Object.seal()`).
 - Earlier versions of JavaScript will throw `SyntaxError` with the following:
-  ```js
+  ```javascript
   ({
-    p: 42,
-    get p() {},
+      p: 42,
+      get p() {},
   });
   // SyntaxError: Object literal may not have data and accessor property with
   //              the same name
@@ -1191,7 +1204,7 @@ To allow for better optimizations, the compiler makes various assumptions:
   versions of Chrome and Node.js may be altered.
 - When `toplevel` is enabled, UglifyJS effectively assumes input code is wrapped
   within `function(){ ... }`, thus forbids aliasing of declared global variables:
-  ```js
+  ```javascript
   A = "FAIL";
   var B = "FAIL";
   // can be `global`, `self`, `window` etc.
@@ -1211,7 +1224,7 @@ To allow for better optimizations, the compiler makes various assumptions:
   suppress those errors.
 - Earlier versions of Chrome and Node.js will throw `ReferenceError` with the
   following:
-  ```js
+  ```javascript
   var a;
   try {
       throw 42;
@@ -1224,20 +1237,51 @@ To allow for better optimizations, the compiler makes various assumptions:
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
 - Later versions of JavaScript will throw `SyntaxError` with the following:
-  ```js
+  ```javascript
   a => {
-    let a;
+      let a;
   };
   // SyntaxError: Identifier 'a' has already been declared
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
 - Later versions of JavaScript will throw `SyntaxError` with the following:
-  ```js
+  ```javascript
   try {
-    // ...
+      // ...
   } catch ({ message: a }) {
-    var a;
+      var a;
   }
   // SyntaxError: Identifier 'a' has already been declared
   ```
   UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of Chrome and Node.js will throw `ReferenceError` with the
+  following:
+  ```javascript
+  console.log(((a, b = function() {
+      return a;
+      // ReferenceError: a is not defined
+  }()) => b)());
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some arithmetic operations with `BigInt` may throw `TypeError`:
+  ```javascript
+  1n + 1;
+  // TypeError: can't convert BigInt to number
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of JavaScript will throw `SyntaxError` with the
+  following:
+  ```javascript
+  console.log(String.raw`\uFo`);
+  // SyntaxError: Invalid Unicode escape sequence
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.
+- Some versions of JavaScript will throw `SyntaxError` with the
+  following:
+  ```javascript
+  try {} catch (e) {
+      for (var e of []);
+  }
+  // SyntaxError: Identifier 'e' has already been declared
+  ```
+  UglifyJS may modify the input which in turn may suppress those errors.

bin/uglifyjs

@@ -3,14 +3,14 @@
 
 "use strict";
 
-require("../tools/exit");
+require("../tools/tty");
 
 var fs = require("fs");
 var info = require("../package.json");
 var path = require("path");
 var UglifyJS = require("../tools/node");
 
-var skip_keys = [ "cname", "inlined", "parent_scope", "scope", "uses_eval", "uses_with" ];
+var skip_keys = [ "cname", "fixed", "inlined", "parent_scope", "scope", "uses_eval", "uses_with" ];
 var files = {};
 var options = {};
 var short_forms = {
@@ -260,12 +260,17 @@ if (paths.length) {
     });
     run();
 } else {
+    var timerId = process.stdin.isTTY && process.argv.length < 3 && setTimeout(function() {
+        print_error("Waiting for input... (use `--help` to print usage information)");
+    }, 1500);
     var chunks = [];
     process.stdin.setEncoding("utf8");
-    process.stdin.on("data", function(chunk) {
+    process.stdin.once("data", function() {
+        clearTimeout(timerId);
+    }).on("data", function(chunk) {
         chunks.push(chunk);
     }).on("end", function() {
-        files = [ chunks.join("") ];
+        files = { STDIN: chunks.join("") };
         run();
     });
     process.stdin.resume();
@@ -360,14 +365,14 @@ function run() {
         }
         print(JSON.stringify(result.ast, function(key, value) {
             if (value) switch (key) {
-              case "thedef":
-                return symdef(value);
               case "enclosed":
                 return value.length ? value.map(symdef) : undefined;
-              case "variables":
               case "functions":
               case "globals":
+              case "variables":
                 return value.size() ? value.map(symdef) : undefined;
+              case "thedef":
+                return symdef(value);
             }
             if (skip_key(key)) return;
             if (value instanceof UglifyJS.AST_Token) return;

lib/minify.js

@@ -87,6 +87,7 @@ function minify(files, options) {
             sourceMap: false,
             timings: false,
             toplevel: false,
+            v8: false,
             validate: false,
             warnings: false,
             webkit: false,
@@ -102,6 +103,7 @@ function minify(files, options) {
         set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
         set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
         set_shorthand("toplevel", options, [ "compress", "mangle" ]);
+        set_shorthand("v8", options, [ "mangle", "output" ]);
         set_shorthand("webkit", options, [ "mangle", "output" ]);
         var quoted_props;
         if (options.mangle) {
@@ -113,6 +115,7 @@ function minify(files, options) {
                 properties: false,
                 reserved: [],
                 toplevel: false,
+                v8: false,
                 webkit: false,
             }, true);
             if (options.mangle.properties) {

lib/output.js

@@ -662,18 +662,23 @@ function OutputStream(options) {
     // a function expression needs parens around it when it's provably
     // the first token to appear in a statement.
     function needs_parens_function(output) {
-        if (!output.has_parens() && first_in_statement(output)) return true;
-        if (output.option("webkit")) {
-            var p = output.parent();
-            if (p instanceof AST_PropAccess && p.expression === this) return true;
-        }
-        if (output.option("wrap_iife")) {
-            var p = output.parent();
-            if (p instanceof AST_Call && p.expression === this) return true;
+        var p = output.parent();
+        if (!output.has_parens() && first_in_statement(output, false, true)) {
+            // export default function() {}
+            // export default (function foo() {});
+            // export default (function() {})(foo);
+            // export default (function() {})`foo`;
+            // export default (function() {}) ? foo : bar;
+            return this.name || !(p instanceof AST_ExportDefault);
         }
+        if (output.option("webkit") && p instanceof AST_PropAccess && p.expression === this) return true;
+        if (output.option("wrap_iife") && p instanceof AST_Call && p.expression === this) return true;
     }
     PARENS(AST_AsyncFunction, needs_parens_function);
+    PARENS(AST_AsyncGeneratorFunction, needs_parens_function);
+    PARENS(AST_ClassExpression, needs_parens_function);
     PARENS(AST_Function, needs_parens_function);
+    PARENS(AST_GeneratorFunction, needs_parens_function);
 
     // same goes for an object literal, because otherwise it would be
     // interpreted as a block of code.
@@ -682,52 +687,88 @@ function OutputStream(options) {
     }
     PARENS(AST_Object, needs_parens_obj);
 
-    PARENS(AST_Unary, function(output) {
+    function needs_parens_unary(output) {
         var p = output.parent();
-        return (p instanceof AST_Call || p instanceof AST_PropAccess) && p.expression === this;
-    });
+        // (-x) ** y
+        if (p instanceof AST_Binary) return p.operator == "**" && p.left === this;
+        // (await x)(y)
+        // new (await x)
+        if (p instanceof AST_Call) return p.expression === this;
+        // class extends (x++) {}
+        // class x extends (typeof y) {}
+        if (p instanceof AST_Class) return true;
+        // (x++)[y]
+        // (typeof x).y
+        if (p instanceof AST_PropAccess) return p.expression === this;
+    }
+    PARENS(AST_Await, needs_parens_unary);
+    PARENS(AST_Unary, needs_parens_unary);
 
     PARENS(AST_Sequence, function(output) {
         var p = output.parent();
-            // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
+            // [ 1, (2, 3), 4 ] ---> [ 1, 3, 4 ]
         return p instanceof AST_Array
-            // () => (foo, bar)
-            || p instanceof AST_Arrow && p.value === this
+            // () ---> (foo, bar)
+            || is_arrow(p) && p.value === this
             // await (foo, bar)
             || p instanceof AST_Await
-            // 1 + (2, 3) + 4 ==> 8
+            // 1 + (2, 3) + 4 ---> 8
             || p instanceof AST_Binary
             // new (foo, bar) or foo(1, (2, 3), 4)
             || p instanceof AST_Call
+            // class extends (foo, bar) {}
+            // class foo extends (bar, baz) {}
+            || p instanceof AST_Class
+            // class { foo = (bar, baz) }
+            // class { [(foo, bar)]() {} }
+            || p instanceof AST_ClassProperty
             // (false, true) ? (a = 10, b = 20) : (c = 30)
-            // ==> 20 (side effect, set a := 10 and b := 20)
+            // ---> 20 (side effect, set a := 10 and b := 20)
             || p instanceof AST_Conditional
-            // { [(1, 2)]: 3 }[2] ==> 3
-            // { foo: (1, 2) }.foo ==> 2
+            // [ a = (1, 2) ] = [] ---> a == 2
+            || p instanceof AST_DefaultValue
+            // { [(1, 2)]: foo } = bar
+            // { 1: (2, foo) } = bar
             || p instanceof AST_DestructuredKeyVal
+            // export default (foo, bar)
+            || p instanceof AST_ExportDefault
+            // for (foo of (bar, baz));
+            || p instanceof AST_ForOf
+            // { [(1, 2)]: 3 }[2] ---> 3
+            // { foo: (1, 2) }.foo ---> 2
             || p instanceof AST_ObjectProperty
-            // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
+            // (1, {foo:2}).foo or (1, {foo:2})["foo"] ---> 2
             || p instanceof AST_PropAccess && p.expression === this
             // ...(foo, bar, baz)
             || p instanceof AST_Spread
             // !(foo, bar, baz)
             || p instanceof AST_Unary
-            // var a = (1, 2), b = a + a; ==> b == 4
-            || p instanceof AST_VarDef;
+            // var a = (1, 2), b = a + a; ---> b == 4
+            || p instanceof AST_VarDef
+            // yield (foo, bar)
+            || p instanceof AST_Yield;
     });
 
     PARENS(AST_Binary, function(output) {
         var p = output.parent();
         // await (foo && bar)
         if (p instanceof AST_Await) return true;
-        // this deals with precedence: 3 * (2 + 1)
+        // this deals with precedence:
+        //   3 * (2 + 1)
+        //   3 - (2 - 1)
+        //   (1 ** 2) ** 3
         if (p instanceof AST_Binary) {
             var po = p.operator, pp = PRECEDENCE[po];
             var so = this.operator, sp = PRECEDENCE[so];
-            return pp > sp || (pp == sp && this === p.right);
+            return pp > sp
+                || po == "??" && (so == "&&" || so == "||")
+                || (pp == sp && this === p[po == "**" ? "left" : "right"]);
         }
         // (foo && bar)()
         if (p instanceof AST_Call) return p.expression === this;
+        // class extends (foo && bar) {}
+        // class foo extends (bar || null) {}
+        if (p instanceof AST_Class) return true;
         // (foo && bar)["prop"], (foo && bar).prop
         if (p instanceof AST_PropAccess) return p.expression === this;
         // typeof (foo && bar)
@@ -771,18 +812,16 @@ function OutputStream(options) {
         // (new foo)(bar)
         if (p instanceof AST_Call) return p.expression === this;
         // (new Date).getTime(), (new Date)["getTime"]()
-        return p instanceof AST_PropAccess;
+        if (p instanceof AST_PropAccess) return true;
+        // (new foo)`bar`
+        if (p instanceof AST_Template) return p.tag === this;
     });
 
     PARENS(AST_Number, function(output) {
+        if (!output.option("galio")) return false;
+        // https://github.com/mishoo/UglifyJS/pull/1009
         var p = output.parent();
-        if (p instanceof AST_PropAccess && p.expression === this) {
-            var value = this.value;
-                // https://github.com/mishoo/UglifyJS/issues/115
-            return value < 0
-                // https://github.com/mishoo/UglifyJS/pull/1009
-                || output.option("galio") && /^0/.test(make_num(value));
-        }
+        return p instanceof AST_PropAccess && p.expression === this && /^0/.test(make_num(this.value));
     });
 
     function needs_parens_assign_cond(self, output) {
@@ -793,10 +832,15 @@ function OutputStream(options) {
         if (p instanceof AST_Binary) return !(p instanceof AST_Assign);
         // (a = func)() —or— new (a = Object)()
         if (p instanceof AST_Call) return p.expression === self;
+        // class extends (a = foo) {}
+        // class foo extends (bar ? baz : moo) {}
+        if (p instanceof AST_Class) return true;
         // (a = foo) ? bar : baz
         if (p instanceof AST_Conditional) return p.condition === self;
         // (a = foo)["prop"] —or— (a = foo).prop
         if (p instanceof AST_PropAccess) return p.expression === self;
+        // (a = foo)`bar`
+        if (p instanceof AST_Template) return p.tag === self;
         // !(a = false) → true
         if (p instanceof AST_Unary) return true;
     }
@@ -805,24 +849,20 @@ function OutputStream(options) {
     });
     PARENS(AST_Assign, function(output) {
         if (needs_parens_assign_cond(this, output)) return true;
-        //  v8 parser bug   =>     workaround
-        // f([1], [a] = []) => f([1], ([a] = []))
+        //  v8 parser bug   --->     workaround
+        // f([1], [a] = []) ---> f([1], ([a] = []))
         if (output.option("v8")) return this.left instanceof AST_Destructured;
         // ({ p: a } = o);
         if (this.left instanceof AST_DestructuredObject) return needs_parens_obj(output);
     });
+    PARENS(AST_AsyncArrow, function(output) {
+        return needs_parens_assign_cond(this, output);
+    });
     PARENS(AST_Conditional, function(output) {
         return needs_parens_assign_cond(this, output);
     });
-
-    PARENS(AST_Await, function(output) {
-        var p = output.parent();
-        // new (await foo)
-        // (await foo)(bar)
-        if (p instanceof AST_Call) return p.expression === this;
-        // (await foo).prop
-        // (await foo)["prop"]
-        if (p instanceof AST_PropAccess) return p.expression === this;
+    PARENS(AST_Yield, function(output) {
+        return needs_parens_assign_cond(this, output);
     });
 
     /* -----[ PRINTERS ]----- */
@@ -874,10 +914,6 @@ function OutputStream(options) {
         use_asm = was_asm;
     }
 
-    DEFPRINT(AST_Statement, function(output) {
-        this.body.print(output);
-        output.semicolon();
-    });
     DEFPRINT(AST_Toplevel, function(output) {
         display_body(this.body, true, output, true);
         output.print("");
@@ -964,20 +1000,25 @@ function OutputStream(options) {
         output.space();
         force_statement(self.body, output);
     });
-    DEFPRINT(AST_ForIn, function(output) {
-        var self = this;
-        output.print("for");
-        output.space();
-        output.with_parens(function() {
-            self.init.print(output);
+    function print_for_enum(prefix, infix) {
+        return function(output) {
+            var self = this;
+            output.print(prefix);
             output.space();
-            output.print("in");
+            output.with_parens(function() {
+                self.init.print(output);
+                output.space();
+                output.print(infix);
+                output.space();
+                self.object.print(output);
+            });
             output.space();
-            self.object.print(output);
-        });
-        output.space();
-        force_statement(self.body, output);
-    });
+            force_statement(self.body, output);
+        };
+    }
+    DEFPRINT(AST_ForAwaitOf, print_for_enum("for await", "of"));
+    DEFPRINT(AST_ForIn, print_for_enum("for", "in"));
+    DEFPRINT(AST_ForOf, print_for_enum("for", "of"));
     DEFPRINT(AST_With, function(output) {
         var self = this;
         output.print("with");
@@ -988,18 +1029,115 @@ function OutputStream(options) {
         output.space();
         force_statement(self.body, output);
     });
+    DEFPRINT(AST_ExportDeclaration, function(output) {
+        output.print("export");
+        output.space();
+        this.body.print(output);
+    });
+    DEFPRINT(AST_ExportDefault, function(output) {
+        output.print("export");
+        output.space();
+        output.print("default");
+        output.space();
+        var body = this.body;
+        body.print(output);
+        if (body instanceof AST_ClassExpression) {
+            if (!body.name) return;
+        }
+        if (body instanceof AST_DefClass) return;
+        if (body instanceof AST_LambdaDefinition) return;
+        if (body instanceof AST_LambdaExpression) {
+            if (!body.name && !is_arrow(body)) return;
+        }
+        output.semicolon();
+    });
+    DEFPRINT(AST_ExportForeign, function(output) {
+        var self = this;
+        output.print("export");
+        output.space();
+        var len = self.keys.length;
+        if (len == 0) {
+            print_braced_empty(self, output);
+        } else if (self.keys[0] == "*") {
+            print_entry(0);
+        } else output.with_block(function() {
+            output.indent();
+            print_entry(0);
+            for (var i = 1; i < len; i++) {
+                output.print(",");
+                output.newline();
+                output.indent();
+                print_entry(i);
+            }
+            output.newline();
+        });
+        output.space();
+        output.print("from");
+        output.space();
+        output.print_string(self.path, self.quote);
+        output.semicolon();
+
+        function print_entry(index) {
+            var alias = self.aliases[index];
+            var key = self.keys[index];
+            output.print_name(key);
+            if (alias != key) {
+                output.space();
+                output.print("as");
+                output.space();
+                output.print_name(alias);
+            }
+        }
+    });
+    DEFPRINT(AST_ExportReferences, function(output) {
+        var self = this;
+        output.print("export");
+        output.space();
+        print_properties(self, output);
+        output.semicolon();
+    });
+    DEFPRINT(AST_Import, function(output) {
+        var self = this;
+        output.print("import");
+        output.space();
+        if (self.default) self.default.print(output);
+        if (self.all) {
+            if (self.default) output.comma();
+            self.all.print(output);
+        }
+        if (self.properties) {
+            if (self.default) output.comma();
+            print_properties(self, output);
+        }
+        if (self.all || self.default || self.properties) {
+            output.space();
+            output.print("from");
+            output.space();
+        }
+        output.print_string(self.path, self.quote);
+        output.semicolon();
+    });
 
     /* -----[ functions ]----- */
-    DEFPRINT(AST_Arrow, function(output) {
-        var self = this;
-        if (self.argnames.length == 1 && self.argnames[0] instanceof AST_SymbolFunarg) {
-            self.argnames[0].print(output);
-        } else output.with_parens(function() {
+    function print_funargs(self, output) {
+        output.with_parens(function() {
             self.argnames.forEach(function(arg, i) {
                 if (i) output.comma();
                 arg.print(output);
             });
+            if (self.rest) {
+                if (self.argnames.length) output.comma();
+                output.print("...");
+                self.rest.print(output);
+            }
         });
+    }
+    function print_arrow(self, output) {
+        if (self.argnames.length == 1 && self.argnames[0] instanceof AST_SymbolFunarg && !self.rest) {
+            self.argnames[0].print(output);
+        } else {
+            print_funargs(self, output);
+        }
         output.space();
         output.print("=>");
         output.space();
@@ -1008,18 +1146,21 @@ function OutputStream(options) {
         } else {
             print_braced(self, output, true);
         }
+    }
+    DEFPRINT(AST_Arrow, function(output) {
+        print_arrow(this, output);
+    });
+    DEFPRINT(AST_AsyncArrow, function(output) {
+        output.print("async");
+        output.space();
+        print_arrow(this, output);
     });
     function print_lambda(self, output) {
         if (self.name) {
             output.space();
             self.name.print(output);
         }
-        output.with_parens(function() {
-            self.argnames.forEach(function(arg, i) {
-                if (i) output.comma();
-                arg.print(output);
-            });
-        });
+        print_funargs(self, output);
         output.space();
         print_braced(self, output, true);
     }
@@ -1035,6 +1176,73 @@ function OutputStream(options) {
     }
     DEFPRINT(AST_AsyncDefun, print_async);
     DEFPRINT(AST_AsyncFunction, print_async);
+    function print_async_generator(output) {
+        output.print("async");
+        output.space();
+        output.print("function*");
+        print_lambda(this, output);
+    }
+    DEFPRINT(AST_AsyncGeneratorDefun, print_async_generator);
+    DEFPRINT(AST_AsyncGeneratorFunction, print_async_generator);
+    function print_generator(output) {
+        output.print("function*");
+        print_lambda(this, output);
+    }
+    DEFPRINT(AST_GeneratorDefun, print_generator);
+    DEFPRINT(AST_GeneratorFunction, print_generator);
+
+    /* -----[ classes ]----- */
+    DEFPRINT(AST_Class, function(output) {
+        var self = this;
+        output.print("class");
+        if (self.name) {
+            output.space();
+            self.name.print(output);
+        }
+        if (self.extends) {
+            output.space();
+            output.print("extends");
+            output.space();
+            self.extends.print(output);
+        }
+        output.space();
+        print_properties(self, output, true);
+    });
+    DEFPRINT(AST_ClassField, function(output) {
+        var self = this;
+        if (self.static) {
+            output.print("static");
+            output.space();
+        }
+        print_property_key(self, output);
+        if (self.value) {
+            output.space();
+            output.print("=");
+            output.space();
+            self.value.print(output);
+        }
+        output.semicolon();
+    });
+    DEFPRINT(AST_ClassGetter, print_accessor("get"));
+    DEFPRINT(AST_ClassSetter, print_accessor("set"));
+    function print_method(self, output) {
+        var fn = self.value;
+        if (is_async(fn)) {
+            output.print("async");
+            output.space();
+        }
+        if (is_generator(fn)) output.print("*");
+        print_property_key(self, output);
+        print_lambda(self.value, output);
+    }
+    DEFPRINT(AST_ClassMethod, function(output) {
+        var self = this;
+        if (self.static) {
+            output.print("static");
+            output.space();
+        }
+        print_method(self, output);
+    });
 
     /* -----[ jumps ]----- */
     function print_jump(kind, prop) {
@@ -1186,7 +1394,7 @@ function OutputStream(options) {
                 def.print(output);
             });
             var p = output.parent();
-            if (p && p.init !== self || !(p instanceof AST_For || p instanceof AST_ForIn)) output.semicolon();
+            if (!(p instanceof AST_IterationStatement && p.init === self)) output.semicolon();
         };
     }
     DEFPRINT(AST_Const, print_definitinos("const"));
@@ -1200,7 +1408,7 @@ function OutputStream(options) {
         if (noin) node.walk(new TreeWalker(function(node) {
             if (parens) return true;
             if (node instanceof AST_Binary && node.operator == "in") return parens = true;
-            if (node instanceof AST_Scope && !(node instanceof AST_Arrow && node.value)) return true;
+            if (node instanceof AST_Scope && !(is_arrow(node) && node.value)) return true;
         }));
         node.print(output, parens);
     }
@@ -1213,11 +1421,20 @@ function OutputStream(options) {
             output.print("=");
             output.space();
             var p = output.parent(1);
-            var noin = p instanceof AST_For || p instanceof AST_ForIn;
+            var noin = p instanceof AST_For || p instanceof AST_ForEnumeration;
             parenthesize_for_noin(self.value, output, noin);
         }
     });
 
+    DEFPRINT(AST_DefaultValue, function(output) {
+        var self = this;
+        self.name.print(output);
+        output.space();
+        output.print("=");
+        output.space();
+        self.value.print(output);
+    });
+
     /* -----[ other expressions ]----- */
     function print_call_args(self, output) {
         if (self.expression instanceof AST_Call || self.expression instanceof AST_Lambda) {
@@ -1325,6 +1542,13 @@ function OutputStream(options) {
         output.space();
         this.expression.print(output);
     });
+    DEFPRINT(AST_Yield, function(output) {
+        output.print(this.nested ? "yield*" : "yield");
+        if (this.expression) {
+            output.space();
+            this.expression.print(output);
+        }
+    });
 
     /* -----[ literals ]----- */
     DEFPRINT(AST_Array, function(output) {
@@ -1344,25 +1568,30 @@ function OutputStream(options) {
         } : noop);
     });
     DEFPRINT(AST_DestructuredArray, function(output) {
-        var a = this.elements, len = a.length;
-        output.with_square(len > 0 ? function() {
+        var a = this.elements, len = a.length, rest = this.rest;
+        output.with_square(len || rest ? function() {
             output.space();
             a.forEach(function(exp, i) {
                 if (i) output.comma();
                 exp.print(output);
+            });
+            if (rest) {
+                if (len) output.comma();
+                output.print("...");
+                rest.print(output);
+            } else if (a[len - 1] instanceof AST_Hole) {
                 // If the final element is a hole, we need to make sure it
                 // doesn't look like a trailing comma, by inserting an actual
                 // trailing comma.
-                if (i === len - 1 && exp instanceof AST_Hole)
-                  output.comma();
-            });
+                output.comma();
+            }
             output.space();
         } : noop);
     });
     DEFPRINT(AST_DestructuredKeyVal, print_key_value);
     DEFPRINT(AST_DestructuredObject, function(output) {
-        var props = this.properties;
-        if (props.length > 0) output.with_block(function() {
+        var props = this.properties, len = props.length, rest = this.rest;
+        if (len || rest) output.with_block(function() {
             props.forEach(function(prop, i) {
                 if (i) {
                     output.print(",");
@@ -1371,16 +1600,25 @@ function OutputStream(options) {
                 output.indent();
                 prop.print(output);
             });
+            if (rest) {
+                if (len) {
+                    output.print(",");
+                    output.newline();
+                }
+                output.indent();
+                output.print("...");
+                rest.print(output);
+            }
             output.newline();
         });
         else print_braced_empty(this, output);
     });
-    DEFPRINT(AST_Object, function(output) {
-        var props = this.properties;
+    function print_properties(self, output, no_comma) {
+        var props = self.properties;
         if (props.length > 0) output.with_block(function() {
             props.forEach(function(prop, i) {
                 if (i) {
-                    output.print(",");
+                    if (!no_comma) output.print(",");
                     output.newline();
                 }
                 output.indent();
@@ -1388,7 +1626,10 @@ function OutputStream(options) {
             });
             output.newline();
         });
-        else print_braced_empty(this, output);
+        else print_braced_empty(self, output);
+    }
+    DEFPRINT(AST_Object, function(output) {
+        print_properties(this, output);
     });
 
     function print_property_key(self, output) {
@@ -1403,7 +1644,9 @@ function OutputStream(options) {
             output.print(make_num(key));
         } else {
             var quote = self.start && self.start.quote;
-            if (RESERVED_WORDS[key] ? !output.option("ie8") : is_identifier_string(key)) {
+            if (self.private) {
+                output.print_name(key);
+            } else if (RESERVED_WORDS[key] ? !output.option("ie8") : is_identifier_string(key)) {
                 if (quote && output.option("keep_quoted_props")) {
                     output.print_string(key, quote);
                 } else {
@@ -1422,9 +1665,16 @@ function OutputStream(options) {
         self.value.print(output);
     }
     DEFPRINT(AST_ObjectKeyVal, print_key_value);
+    DEFPRINT(AST_ObjectMethod, function(output) {
+        print_method(this, output);
+    });
     function print_accessor(type) {
         return function(output) {
             var self = this;
+            if (self.static) {
+                output.print("static");
+                output.space();
+            }
             output.print(type);
             output.space();
             print_property_key(self, output);
@@ -1433,13 +1683,46 @@ function OutputStream(options) {
     }
     DEFPRINT(AST_ObjectGetter, print_accessor("get"));
     DEFPRINT(AST_ObjectSetter, print_accessor("set"));
+    function print_symbol(self, output) {
+        var def = self.definition();
+        output.print_name(def && def.mangled_name || self.name);
+    }
     DEFPRINT(AST_Symbol, function(output) {
-        var def = this.definition();
-        output.print_name(def && def.mangled_name || this.name);
+        print_symbol(this, output);
+    });
+    DEFPRINT(AST_SymbolExport, function(output) {
+        var self = this;
+        print_symbol(self, output);
+        if (self.alias) {
+            output.space();
+            output.print("as");
+            output.space();
+            output.print_name(self.alias);
+        }
+    });
+    DEFPRINT(AST_SymbolImport, function(output) {
+        var self = this;
+        if (self.key) {
+            output.print_name(self.key);
+            output.space();
+            output.print("as");
+            output.space();
+        }
+        print_symbol(self, output);
     });
     DEFPRINT(AST_Hole, noop);
-    DEFPRINT(AST_This, function(output) {
-        output.print("this");
+    DEFPRINT(AST_Template, function(output) {
+        var self = this;
+        if (self.tag) self.tag.print(output);
+        output.print("`");
+        for (var i = 0; i < self.expressions.length; i++) {
+            output.print(self.strings[i]);
+            output.print("${");
+            self.expressions[i].print(output);
+            output.print("}");
+        }
+        output.print(self.strings[i]);
+        output.print("`");
     });
     DEFPRINT(AST_Constant, function(output) {
         output.print(this.value);

lib/propmangle.js

@@ -228,7 +228,7 @@ function mangle_properties(ast, options) {
         var mangled = cache.get(name);
         if (!mangled) {
             if (debug) {
-                // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_.
+                // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo ---> o._$foo$NNN_.
                 var debug_mangled = "_$" + name + "$" + debug_suffix + "_";
                 if (can_mangle(debug_mangled)) mangled = debug_mangled;
             }

lib/scope.js

@@ -45,10 +45,10 @@
 
 function SymbolDef(id, scope, orig, init) {
     this.eliminated = 0;
+    this.exported = false;
     this.global = false;
     this.id = id;
     this.init = init;
-    this.lambda = orig instanceof AST_SymbolLambda;
     this.mangled_name = null;
     this.name = orig.name;
     this.orig = [ orig ];
@@ -92,6 +92,7 @@ SymbolDef.prototype = {
     },
     unmangleable: function(options) {
         return this.global && !options.toplevel
+            || this.exported
             || this.undeclared
             || !options.eval && this.scope.pinned()
             || options.keep_fnames
@@ -102,6 +103,15 @@ SymbolDef.prototype = {
 
 var unary_side_effects = makePredicate("delete ++ --");
 
+function is_lhs(node, parent) {
+    if (parent instanceof AST_Assign) return parent.left === node && node;
+    if (parent instanceof AST_DefaultValue) return parent.name === node && node;
+    if (parent instanceof AST_Destructured) return node;
+    if (parent instanceof AST_DestructuredKeyVal) return node;
+    if (parent instanceof AST_ForEnumeration) return parent.init === node && node;
+    if (parent instanceof AST_Unary) return unary_side_effects[parent.operator] && parent.expression;
+}
+
 AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     options = defaults(options, {
         cache: null,
@@ -111,15 +121,40 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
     // pass 1: setup scope chaining and handle definitions
     var self = this;
     var defun = null;
+    var exported = false;
     var next_def_id = 0;
     var scope = self.parent_scope = null;
     var tw = new TreeWalker(function(node, descend) {
-        if (is_defun(node)) {
+        if (node instanceof AST_DefClass) {
+            var save_exported = exported;
+            exported = tw.parent() instanceof AST_ExportDeclaration;
             node.name.walk(tw);
+            exported = save_exported;
+            walk_scope(function() {
+                if (node.extends) node.extends.walk(tw);
+                node.properties.forEach(function(prop) {
+                    prop.walk(tw);
+                });
+            });
+            return true;
+        }
+        if (node instanceof AST_Definitions) {
+            var save_exported = exported;
+            exported = tw.parent() instanceof AST_ExportDeclaration;
+            descend();
+            exported = save_exported;
+            return true;
+        }
+        if (node instanceof AST_LambdaDefinition) {
+            var save_exported = exported;
+            exported = tw.parent() instanceof AST_ExportDeclaration;
+            node.name.walk(tw);
+            exported = save_exported;
             walk_scope(function() {
                 node.argnames.forEach(function(argname) {
                     argname.walk(tw);
                 });
+                if (node.rest) node.rest.walk(tw);
                 walk_body(node, tw);
             });
             return true;
@@ -161,9 +196,11 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         if (node instanceof AST_SymbolCatch) {
             scope.def_variable(node).defun = defun;
         } else if (node instanceof AST_SymbolConst) {
-            scope.def_variable(node).defun = defun;
+            var def = scope.def_variable(node);
+            def.defun = defun;
+            def.exported = exported;
         } else if (node instanceof AST_SymbolDefun) {
-            defun.def_function(node, tw.parent());
+            defun.def_function(node, tw.parent()).exported = exported;
             entangle(defun, scope);
         } else if (node instanceof AST_SymbolFunarg) {
             defun.def_variable(node);
@@ -172,9 +209,9 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             var def = defun.def_function(node, node.name == "arguments" ? undefined : defun);
             if (options.ie8) def.defun = defun.parent_scope.resolve();
         } else if (node instanceof AST_SymbolLet) {
-            scope.def_variable(node);
+            scope.def_variable(node).exported = exported;
         } else if (node instanceof AST_SymbolVar) {
-            defun.def_variable(node, null);
+            defun.def_variable(node, node instanceof AST_SymbolImport ? undefined : null).exported = exported;
             entangle(defun, scope);
         }
 
@@ -221,31 +258,33 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             node.argnames.forEach(function(argname) {
                 argname.walk(tw);
             });
+            if (node.rest) node.rest.walk(tw);
             in_arg.pop();
-            if (node instanceof AST_Arrow && node.value) {
-                node.value.walk(tw);
-            } else {
-                walk_body(node, tw);
-            }
+            walk_lambda(node, tw);
             return true;
         }
         if (node instanceof AST_LoopControl) {
             if (node.label) node.label.thedef.references.push(node);
             return true;
         }
-        // ensure mangling works if `catch` reuses a scope variable
-        if (node instanceof AST_SymbolCatch) {
-            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;
+        if (node instanceof AST_SymbolDeclaration) {
+            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;
+                }
+            } else if (node instanceof AST_SymbolConst) {
+                // ensure compression works if `const` reuses a scope variable
+                var redef = node.definition().redefined();
+                if (redef) redef.const_redefs = true;
             }
-            return true;
-        }
-        // ensure compression works if `const` reuses a scope variable
-        if (node instanceof AST_SymbolConst) {
-            var redef = node.definition().redefined();
-            if (redef) redef.const_redefs = true;
+            if (node.name != "arguments") return true;
+            var parent = node instanceof AST_SymbolVar && tw.parent();
+            if (parent instanceof AST_VarDef && !parent.value) return true;
+            var sym = node.scope.resolve().find_variable("arguments");
+            if (sym && is_arguments(sym)) sym.scope.uses_arguments = 3;
             return true;
         }
         if (node instanceof AST_SymbolRef) {
@@ -265,13 +304,9 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
             }
             if (!sym) {
                 sym = self.def_global(node);
-            } else if (name == "arguments"
-                && sym.orig[0] instanceof AST_SymbolFunarg
-                && !(sym.orig[1] instanceof AST_SymbolFunarg)
-                && !(sym.scope instanceof AST_Arrow)) {
+            } else if (name == "arguments" && is_arguments(sym)) {
                 var parent = tw.parent();
-                if (parent instanceof AST_Assign && parent.left === node
-                    || parent instanceof AST_Unary && unary_side_effects[parent.operator]) {
+                if (is_lhs(node, parent)) {
                     sym.scope.uses_arguments = 3;
                 } else if (sym.scope.uses_arguments < 2
                     && !(parent instanceof AST_PropAccess && parent.expression === node)) {
@@ -293,6 +328,13 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
                     self.uses_eval = true;
                 }
             }
+            if (sym.init instanceof AST_LambdaDefinition && sym.scope !== sym.init.name.scope) {
+                var scope = node.scope;
+                do {
+                    if (scope === sym.init.name.scope) break;
+                } while (scope = scope.parent_scope);
+                if (!scope) sym.init = undefined;
+            }
             node.thedef = sym;
             node.reference(options);
             return true;
@@ -312,8 +354,9 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         }
         if (node instanceof AST_SymbolLambda) {
             var def = node.thedef;
-            redefine(node, node.scope.parent_scope.resolve());
-            if (typeof node.thedef.init !== "undefined") {
+            if (!redefine(node, node.scope.parent_scope.resolve())) {
+                delete def.defun;
+            } else if (typeof node.thedef.init !== "undefined") {
                 node.thedef.init = false;
             } else if (def.init) {
                 node.thedef.init = def.init;
@@ -322,12 +365,18 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         }
     }));
 
+    function is_arguments(sym) {
+        return sym.orig[0] instanceof AST_SymbolFunarg
+            && !(sym.orig[1] instanceof AST_SymbolFunarg || sym.orig[2] instanceof AST_SymbolFunarg)
+            && !is_arrow(sym.scope);
+    }
+
     function redefine(node, scope) {
         var name = node.name;
         var old_def = node.thedef;
         if (!all(old_def.orig, function(sym) {
             return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet);
-        })) return;
+        })) return false;
         var new_def = scope.find_variable(name);
         if (new_def) {
             var redef = new_def.redefined();
@@ -342,12 +391,12 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
         }
         old_def.defun = new_def.scope;
         old_def.forEach(function(node) {
-            node.redef = true;
+            node.redef = old_def;
             node.thedef = new_def;
             node.reference(options);
         });
-        if (old_def.lambda) new_def.lambda = true;
         if (new_def.undeclared) self.variables.set(name, new_def);
+        return true;
     }
 });
 
@@ -387,6 +436,9 @@ AST_Scope.DEFMETHOD("init_vars", function(parent_scope) {
 AST_Arrow.DEFMETHOD("init_vars", function(parent_scope) {
     init_scope_vars(this, parent_scope);
 });
+AST_AsyncArrow.DEFMETHOD("init_vars", function(parent_scope) {
+    init_scope_vars(this, parent_scope);
+});
 AST_Lambda.DEFMETHOD("init_vars", function(parent_scope) {
     init_scope_vars(this, parent_scope);
     this.uses_arguments = false;
@@ -402,7 +454,9 @@ 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 (options.keep_fnames) {
+        if (!options) {
+            delete s._var_names;
+        } else if (options.keep_fnames) {
             s.functions.each(function(d) {
                 push_uniq(def.scope.enclosed, d);
             });
@@ -423,7 +477,7 @@ AST_BlockScope.DEFMETHOD("find_variable", function(name) {
 
 AST_BlockScope.DEFMETHOD("def_function", function(symbol, init) {
     var def = this.def_variable(symbol, init);
-    if (!def.init || is_defun(def.init)) def.init = init;
+    if (!def.init || def.init instanceof AST_LambdaDefinition) def.init = init;
     this.functions.set(symbol.name, def);
     return def;
 });
@@ -432,7 +486,7 @@ AST_BlockScope.DEFMETHOD("def_variable", function(symbol, init) {
     var def = this.variables.get(symbol.name);
     if (def) {
         def.orig.push(symbol);
-        if (is_function(def.init)) def.init = init;
+        if (def.init instanceof AST_LambdaExpression) def.init = init;
     } else {
         def = this.make_def(symbol, init);
         this.variables.set(symbol.name, def);
@@ -512,6 +566,7 @@ function _default_mangler_options(options) {
         keep_fnames : false,
         reserved    : [],
         toplevel    : false,
+        v8          : false,
         webkit      : false,
     });
     if (!Array.isArray(options.reserved)) options.reserved = [];
@@ -543,7 +598,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             // lname is incremented when we get to the AST_Label
             var save_nesting = lname;
             descend();
-            lname = save_nesting;
+            if (!options.v8 || !in_label(tw)) lname = save_nesting;
             return true;
         }
         if (node instanceof AST_BlockScope) {
@@ -602,6 +657,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             if (!(sym instanceof AST_SymbolConst)) return false;
             var scope = def.scope.resolve();
             if (def.scope === scope) return false;
+            if (def.scope.parent_scope.find_variable(sym.name)) return false;
             redef = scope.def_variable(sym);
             scope.to_mangle.push(redef);
         }
@@ -616,6 +672,14 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
             sym.thedef = def;
         }
     }
+
+    function in_label(tw) {
+        var level = 0, parent;
+        while (parent = tw.parent(level++)) {
+            if (parent instanceof AST_Block) return parent instanceof AST_Toplevel && !options.toplevel;
+            if (parent instanceof AST_LabeledStatement) return true;
+        }
+    }
 });
 
 AST_Toplevel.DEFMETHOD("find_colliding_names", function(options) {

lib/sourcemap.js

@@ -144,7 +144,9 @@ function SourceMap(options) {
             add(source, gen_line, gen_col, orig_line, orig_col, name);
         } : add,
         setSourceContent: sources_content ? function(source, content) {
-            sources_content[source] = content;
+            if (!(source in sources_content)) {
+                sources_content[source] = content;
+            }
         } : noop,
         toString: function() {
             return JSON.stringify({

lib/transform.js

@@ -82,7 +82,7 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.step) self.step = self.step.transform(tw);
         self.body = self.body.transform(tw);
     });
-    DEF(AST_ForIn, function(self, tw) {
+    DEF(AST_ForEnumeration, function(self, tw) {
         self.init = self.init.transform(tw);
         self.object = self.object.transform(tw);
         self.body = self.body.transform(tw);
@@ -126,18 +126,35 @@ TreeTransformer.prototype = new TreeWalker;
         self.name = self.name.transform(tw);
         if (self.value) self.value = self.value.transform(tw);
     });
+    DEF(AST_DefaultValue, function(self, tw) {
+        self.name = self.name.transform(tw);
+        self.value = self.value.transform(tw);
+    });
     DEF(AST_Lambda, function(self, tw) {
         if (self.name) self.name = self.name.transform(tw);
         self.argnames = do_list(self.argnames, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
         self.body = do_list(self.body, tw);
     });
-    DEF(AST_Arrow, function(self, tw) {
+    function transform_arrow(self, tw) {
         self.argnames = do_list(self.argnames, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
         if (self.value) {
             self.value = self.value.transform(tw);
         } else {
             self.body = do_list(self.body, tw);
         }
+    }
+    DEF(AST_Arrow, transform_arrow);
+    DEF(AST_AsyncArrow, transform_arrow);
+    DEF(AST_Class, function(self, tw) {
+        if (self.name) self.name = self.name.transform(tw);
+        if (self.extends) self.extends = self.extends.transform(tw);
+        self.properties = do_list(self.properties, tw);
+    });
+    DEF(AST_ClassProperty, function(self, tw) {
+        if (self.key instanceof AST_Node) self.key = self.key.transform(tw);
+        if (self.value) self.value = self.value.transform(tw);
     });
     DEF(AST_Call, function(self, tw) {
         self.expression = self.expression.transform(tw);
@@ -149,6 +166,9 @@ TreeTransformer.prototype = new TreeWalker;
     DEF(AST_Await, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
+    DEF(AST_Yield, function(self, tw) {
+        if (self.expression) self.expression = self.expression.transform(tw);
+    });
     DEF(AST_Dot, function(self, tw) {
         self.expression = self.expression.transform(tw);
     });
@@ -176,6 +196,7 @@ TreeTransformer.prototype = new TreeWalker;
     });
     DEF(AST_DestructuredArray, function(self, tw) {
         self.elements = do_list(self.elements, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
     });
     DEF(AST_DestructuredKeyVal, function(self, tw) {
         if (self.key instanceof AST_Node) self.key = self.key.transform(tw);
@@ -183,6 +204,7 @@ TreeTransformer.prototype = new TreeWalker;
     });
     DEF(AST_DestructuredObject, function(self, tw) {
         self.properties = do_list(self.properties, tw);
+        if (self.rest) self.rest = self.rest.transform(tw);
     });
     DEF(AST_Object, function(self, tw) {
         self.properties = do_list(self.properties, tw);
@@ -191,6 +213,24 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.key instanceof AST_Node) self.key = self.key.transform(tw);
         self.value = self.value.transform(tw);
     });
+    DEF(AST_ExportDeclaration, function(self, tw) {
+        self.body = self.body.transform(tw);
+    });
+    DEF(AST_ExportDefault, function(self, tw) {
+        self.body = self.body.transform(tw);
+    });
+    DEF(AST_ExportReferences, function(self, tw) {
+        self.properties = do_list(self.properties, tw);
+    });
+    DEF(AST_Import, function(self, tw) {
+        if (self.all) self.all = self.all.transform(tw);
+        if (self.default) self.default = self.default.transform(tw);
+        if (self.properties) self.properties = do_list(self.properties, tw);
+    });
+    DEF(AST_Template, function(self, tw) {
+        if (self.tag) self.tag = self.tag.transform(tw);
+        self.expressions = do_list(self.expressions, tw);
+    });
 })(function(node, descend) {
     node.DEFMETHOD("transform", function(tw, in_list) {
         var x, y;

lib/utils.js

@@ -238,10 +238,10 @@ function HOP(obj, prop) {
 // return true if the node at the top of the stack (that means the
 // innermost node in the current output) is lexically the first in
 // a statement.
-function first_in_statement(stack, arrow) {
+function first_in_statement(stack, arrow, export_default) {
     var node = stack.parent(-1);
     for (var i = 0, p; p = stack.parent(i++); node = p) {
-        if (p instanceof AST_Arrow) {
+        if (is_arrow(p)) {
             return arrow && p.value === node;
         } else if (p instanceof AST_Binary) {
             if (p.left === node) continue;
@@ -249,12 +249,16 @@ function first_in_statement(stack, arrow) {
             if (p.expression === node) continue;
         } else if (p instanceof AST_Conditional) {
             if (p.condition === node) continue;
+        } else if (p instanceof AST_ExportDefault) {
+            return export_default;
         } else if (p instanceof AST_PropAccess) {
             if (p.expression === node) continue;
         } else if (p instanceof AST_Sequence) {
             if (p.expressions[0] === node) continue;
-        } else if (p instanceof AST_Statement) {
-            return p.body === node;
+        } else if (p instanceof AST_SimpleStatement) {
+            return true;
+        } else if (p instanceof AST_Template) {
+            if (p.tag === node) continue;
         } else if (p instanceof AST_UnaryPostfix) {
             if (p.expression === node) continue;
         }

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.12.3",
+  "version": "3.13.0",
   "engines": {
     "node": ">=0.8.0"
   },

test/compress.js

@@ -1,6 +1,6 @@
 "use strict";
 
-require("../tools/exit");
+require("../tools/tty");
 
 var assert = require("assert");
 var child_process = require("child_process");
@@ -209,7 +209,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 = run_code(result.code, toplevel);
+            var actual = sandbox.run_code(result.code, toplevel);
             if (typeof expected != "string" && typeof actual != "string" && expected.name == actual.name) {
                 actual = expected;
             }
@@ -244,11 +244,6 @@ function reminify(orig_options, input_code, input_formatted, stdout) {
     return true;
 }
 
-function run_code(code, toplevel) {
-    var result = sandbox.run_code(code, toplevel);
-    return typeof result == "string" ? result.replace(/\u001b\[\d+m/g, "") : result;
-}
-
 function test_case(test) {
     log("    Running test [{name}]", { name: test.name });
     U.AST_Node.enable_validation();
@@ -380,7 +375,7 @@ function test_case(test) {
         }
     }
     if (test.expect_stdout && (!test.node_version || semver.satisfies(process.version, test.node_version))) {
-        var stdout = [ run_code(input_code), run_code(input_code, true) ];
+        var stdout = [ sandbox.run_code(input_code), sandbox.run_code(input_code, true) ];
         var toplevel = sandbox.has_toplevel({
             compress: test.options,
             mangle: test.mangle
@@ -409,7 +404,7 @@ function test_case(test) {
             });
             return false;
         }
-        actual = run_code(output_code, toplevel);
+        actual = sandbox.run_code(output_code, toplevel);
         if (!sandbox.same_stdout(test.expect_stdout, actual)) {
             log([
                 "!!! failed",

test/compress/arguments.js

@@ -78,7 +78,7 @@ replace_index_strict: {
     ]
 }
 
-replace_index_keep_fargs: {
+replace_index_drop_fargs_1: {
     options = {
         arguments: true,
         evaluate: true,
@@ -101,6 +101,13 @@ replace_index_keep_fargs: {
             var arguments;
             console.log(arguments[1], arguments["1"], arguments["foo"]);
         })("bar", 42);
+        (function() {
+            var arguments = {
+                1: "foo",
+                foo: "bar",
+            };
+            console.log(arguments[1], arguments["1"], arguments["foo"]);
+        })("bar", 42);
     }
     expect: {
         var arguments = [];
@@ -114,8 +121,15 @@ replace_index_keep_fargs: {
         (function(arguments) {
             console.log(arguments[1], arguments[1], arguments.foo);
         })("bar", 42);
-        (function() {
+        (function(argument_0, argument_1) {
             var arguments;
+            console.log(argument_1, argument_1, arguments.foo);
+        })("bar", 42);
+        (function() {
+            var arguments = {
+                1: "foo",
+                foo: "bar",
+            };
             console.log(arguments[1], arguments[1], arguments.foo);
         })("bar", 42);
     }
@@ -125,10 +139,11 @@ replace_index_keep_fargs: {
         "42 42 undefined",
         "a a undefined",
         "42 42 undefined",
+        "foo foo bar",
     ]
 }
 
-replace_index_keep_fargs_strict: {
+replace_index_drop_fargs_2: {
     options = {
         arguments: true,
         evaluate: true,
@@ -412,7 +427,7 @@ issue_3273_global_strict_reduce_vars: {
     ]
 }
 
-issue_3273_keep_fargs_false: {
+issue_3273_drop_fargs_1: {
     options = {
         arguments: true,
         keep_fargs: false,
@@ -435,10 +450,10 @@ issue_3273_keep_fargs_false: {
     expect_stdout: "1"
 }
 
-issue_3273_keep_fargs_strict: {
+issue_3273_drop_fargs_2: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
     }
     input: {
@@ -633,7 +648,7 @@ issue_3282_2_passes: {
 issue_3420_1: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         console.log(function() {
@@ -655,7 +670,7 @@ issue_3420_1: {
 issue_3420_2: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         var foo = function() {
@@ -675,7 +690,7 @@ issue_3420_2: {
 issue_3420_3: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         "use strict";
@@ -697,7 +712,7 @@ issue_3420_3: {
 issue_3420_4: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         !function() {
@@ -722,7 +737,7 @@ issue_3420_4: {
 issue_3420_5: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         "use strict";
@@ -749,7 +764,7 @@ issue_3420_5: {
 issue_3420_6: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         console.log(function() {
@@ -767,7 +782,7 @@ issue_3420_6: {
 issue_3420_7: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         "use strict";
@@ -811,7 +826,7 @@ issue_4200: {
 issue_4291_1: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         console.log(function() {
@@ -831,7 +846,7 @@ issue_4291_1: {
 issue_4291_2: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         var a = function() {
@@ -855,7 +870,7 @@ issue_4291_2: {
 issue_4397: {
     options = {
         arguments: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         console.log(typeof function() {
@@ -962,3 +977,25 @@ issue_4432: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4696: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        console.log(function() {
+            for (arguments in [ 42 ]);
+            for (var a in arguments[0])
+                return "PASS";
+        }());
+    }
+    expect: {
+        console.log(function() {
+            for (arguments in [ 42 ]);
+            for (var a in arguments[0])
+                return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+}

test/compress/arrays.js

@@ -13,9 +13,10 @@ holes_and_undefined: {
     }
 }
 
-constant_join: {
+constant_join_1: {
     options = {
         evaluate: true,
+        side_effects: true,
         strings: true,
         unsafe: true,
     }
@@ -57,7 +58,7 @@ constant_join: {
         var c5 = [ boo() + bar() + "foo", 1, 2, 3, "bar", bar() + "foo" ].join();
         var c6 = [ "1,2,,,foo,bar", baz() ].join();
         var d = "foo-3bar-baz";
-        var e = [].join(foo + bar);
+        var e = (foo, bar, "");
         var f = "";
         var g = "";
     }
@@ -354,3 +355,72 @@ constructor_good: {
     expect_stdout: true
     expect_warnings: []
 }
+
+unsafe_evaluate_modified_binary: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        (function(a) {
+            (console && a).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect: {
+        (function(a) {
+            (console && a).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect_stdout: "PASS"
+}
+
+unsafe_evaluate_modified_conditional: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        (function(a) {
+            (console ? a : []).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect: {
+        (function(a) {
+            (console ? a : []).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect_stdout: "PASS"
+}
+
+unsafe_evaluate_modified_sequence: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        (function(a) {
+            (0, a).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect: {
+        (function(a) {
+            (0, a).push(1);
+            if (a.length)
+                console.log("PASS");
+        })([]);
+    }
+    expect_stdout: "PASS"
+}

test/compress/arrows.js

@@ -34,7 +34,7 @@ destructured_funarg: {
     node_version: ">=6"
 }
 
-await_parenthesis: {
+await_parentheses: {
     input: {
         async function f() {
             await (a => a);
@@ -43,7 +43,7 @@ await_parenthesis: {
     expect_exact: "async function f(){await(a=>a)}"
 }
 
-for_parenthesis_init: {
+for_parentheses_init: {
     input: {
         for (a => (a in a); console.log(42););
     }
@@ -52,7 +52,7 @@ for_parenthesis_init: {
     node_version: ">=4"
 }
 
-for_parenthesis_condition: {
+for_parentheses_condition: {
     input: {
         for (console.log(42); a => (a in a);)
             break;
@@ -62,7 +62,7 @@ for_parenthesis_condition: {
     node_version: ">=4"
 }
 
-for_parenthesis_step: {
+for_parentheses_step: {
     input: {
         for (; console.log(42); a => (a in a));
     }
@@ -71,7 +71,7 @@ for_parenthesis_step: {
     node_version: ">=4"
 }
 
-for_assign_parenthesis_init: {
+for_assign_parentheses_init: {
     input: {
         for (f = a => (a in a); console.log(42););
     }
@@ -80,7 +80,7 @@ for_assign_parenthesis_init: {
     node_version: ">=4"
 }
 
-for_assign_parenthesis_condition: {
+for_assign_parentheses_condition: {
     input: {
         for (console.log(42); f = a => (a in a);)
             break;
@@ -90,7 +90,7 @@ for_assign_parenthesis_condition: {
     node_version: ">=4"
 }
 
-for_assign_parenthesis_step: {
+for_assign_parentheses_step: {
     input: {
         for (; console.log(42); f = a => (a in a));
     }
@@ -99,7 +99,7 @@ for_assign_parenthesis_step: {
     node_version: ">=4"
 }
 
-for_declaration_parenthesis_init: {
+for_declaration_parentheses_init: {
     input: {
         for (var f = a => (a in a); console.log(42););
     }
@@ -108,7 +108,7 @@ for_declaration_parenthesis_init: {
     node_version: ">=4"
 }
 
-for_statement_parenthesis_init: {
+for_statement_parentheses_init: {
     input: {
         for (a => {
             a in a;
@@ -419,7 +419,7 @@ collapse_value: {
     options = {
         arrows: true,
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -434,10 +434,66 @@ collapse_value: {
     node_version: ">=4"
 }
 
+collapse_property_lambda: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+    }
+    input: {
+        console.log(function f() {
+            f.g = () => 42;
+            return f.g();
+        }());
+    }
+    expect: {
+        console.log(function f() {
+            return (f.g = () => 42)();
+        }());
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+drop_return: {
+    options = {
+        arrows: true,
+        side_effects: true,
+    }
+    input: {
+        (a => {
+            while (!console);
+            return console.log(a);
+        })(42);
+    }
+    expect: {
+        (a => {
+            while (!console);
+            console.log(a);
+        })(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+drop_value: {
+    options = {
+        arrows: true,
+        side_effects: true,
+    }
+    input: {
+        ((a, b) => a + b)(console.log(42));
+    }
+    expect: {
+        ((a, b) => {})(console.log(42));
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
 reduce_iife_1: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -587,3 +643,163 @@ issue_4401: {
     ]
     node_version: ">=4"
 }
+
+issue_4448: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var A;
+        try {
+            (arguments => {
+                arguments[0];
+            })(A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        var A;
+        try {
+            (arguments => {
+                arguments[0];
+            })(A);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4476: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        (function(a, b) {
+            (a => {
+                console.log(arguments[0], a);
+            })(b);
+        })("foo", "bar");
+    }
+    expect: {
+        (function(a, b) {
+            (a => {
+                console.log(arguments[0], a);
+            })(b);
+        })("foo", "bar");
+    }
+    expect_stdout: "foo bar"
+    node_version: ">=4"
+}
+
+issue_4666: {
+    input: {
+        console.log((a => /[0-9]/.test(a))(42));
+    }
+    expect_exact: "console.log((a=>/[0-9]/.test(a))(42));"
+    expect_stdout: "true"
+    node_version: ">=4"
+}
+
+issue_4685_1: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        new function(f) {
+            if (f() !== this)
+                console.log("PASS");
+        }(() => this);
+    }
+    expect: {
+        new function(f) {
+            if (f() !== this)
+                console.log("PASS");
+        }(() => this);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4685_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        new function(f) {
+            if (f() !== this)
+                console.log("PASS");
+        }(() => {
+            if (console)
+                return this;
+        });
+    }
+    expect: {
+        new function(f) {
+            if (f() !== this)
+                console.log("PASS");
+        }(() => {
+            if (console)
+                return this;
+        });
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4687_1: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        new function() {
+            console.log(function(f) {
+                return f() === this;
+            }(() => this) || "PASS");
+        }
+    }
+    expect: {
+        new function() {
+            console.log(function(f) {
+                return f() === this;
+            }(() => this) || "PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4687_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        new function() {
+            console.log(function(f) {
+                return f() === this;
+            }(() => {
+                if (console)
+                    return this;
+            }) || "PASS");
+        }
+    }
+    expect: {
+        new function() {
+            console.log(function(f) {
+                return f() === this;
+            }(() => {
+                if (console)
+                    return this;
+            }) || "PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/assignments.js

@@ -461,3 +461,17 @@ issue_3949_2: {
     }
     expect_stdout: "100"
 }
+
+issue_4521: {
+    options = {
+        assignments: true,
+        dead_code: true,
+    }
+    input: {
+        var a = (a = 42 | a) ? console.log(a) : 0;
+    }
+    expect: {
+        var a = (a |= 42) ? console.log(a) : 0;
+    }
+    expect_stdout: "42"
+}

test/compress/async.js

@@ -1,642 +0,0 @@
-await_await: {
-    input: {
-        (async function() {
-            console.log("PASS");
-            await await 42;
-        })();
-    }
-    expect: {
-        (async function() {
-            console.log("PASS");
-            await await 42;
-        })();
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-defun_name: {
-    input: {
-        async function await() {
-            console.log("PASS");
-        }
-        await();
-    }
-    expect: {
-        async function await() {
-            console.log("PASS");
-        }
-        await();
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-nested_await: {
-    input: {
-        (async function() {
-            console.log(function(await) {
-                return await;
-            }("PASS"));
-        })();
-    }
-    expect: {
-        (async function() {
-            console.log(function(await) {
-                return await;
-            }("PASS"));
-        })();
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-reduce_single_use_defun: {
-    options = {
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        async function f(a) {
-            console.log(a);
-        }
-        f("PASS");
-    }
-    expect: {
-        (async function(a) {
-            console.log(a);
-        })("PASS");
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-dont_inline: {
-    options = {
-        inline: true,
-    }
-    input: {
-        (async function() {
-            A;
-        })().catch(function() {});
-        console.log("PASS");
-    }
-    expect: {
-        (async function() {
-            A;
-        })().catch(function() {});
-        console.log("PASS");
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-evaluate: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a = async function() {}();
-        console.log(typeof a);
-    }
-    expect: {
-        var a = async function() {}();
-        console.log(typeof a);
-    }
-    expect_stdout: "object"
-    node_version: ">=8"
-}
-
-negate: {
-    options = {
-        side_effects: true,
-    }
-    input: {
-        console && async function() {} && console.log("PASS");
-    }
-    expect: {
-        console && async function() {} && console.log("PASS");
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-negate_iife: {
-    options = {
-        negate_iife: true,
-    }
-    input: {
-        (async function() {
-            console.log("PASS");
-        })();
-    }
-    expect: {
-        !async function() {
-            console.log("PASS");
-        }();
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-object_function: {
-    options = {
-        properties: true,
-        side_effects: true,
-    }
-    input: {
-        ({
-            async f() {
-                console.log("PASS");
-            },
-        }).f();
-    }
-    expect: {
-        (async function() {
-            console.log("PASS");
-        })();
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-collapse_vars_1: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        var a = "FAIL";
-        (async function() {
-            a = "PASS";
-            await 42;
-            return "PASS";
-        })();
-        console.log(a);
-    }
-    expect: {
-        var a = "FAIL";
-        (async function() {
-            a = "PASS";
-            await 42;
-            return "PASS";
-        })();
-        console.log(a);
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-collapse_vars_2: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        var a = "FAIL";
-        (async function() {
-            await (a = "PASS");
-            return "PASS";
-        })();
-        console.log(a);
-    }
-    expect: {
-        var a = "FAIL";
-        (async function() {
-            await (a = "PASS");
-            return "PASS";
-        })();
-        console.log(a);
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-collapse_vars_3: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        var a = "FAIL";
-        (async function() {
-            await (a = "PASS", 42);
-            return "PASS";
-        })();
-        console.log(a);
-    }
-    expect: {
-        var a = "FAIL";
-        (async function() {
-            await (a = "PASS", 42);
-            return "PASS";
-        })();
-        console.log(a);
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-issue_4335_1: {
-    options = {
-        inline: true,
-    }
-    input: {
-        var await = "PASS";
-        (async function() {
-            console.log(function() {
-                return await;
-            }());
-        })();
-    }
-    expect: {
-        var await = "PASS";
-        (async function() {
-            console.log(function() {
-                return await;
-            }());
-        })();
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-issue_4335_2: {
-    options = {
-        inline: true,
-    }
-    input: {
-        (async function() {
-            console.log(function() {
-                function await() {}
-                return "PASS";
-            }());
-        })();
-    }
-    expect: {
-        (async function() {
-            console.log(function() {
-                function await() {}
-                return "PASS";
-            }());
-        })();
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-issue_4337: {
-    options = {
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        (function(a) {
-            a();
-        })(async function() {
-            console.log("PASS");
-        });
-    }
-    expect: {
-        (function(a) {
-            (async function() {
-                console.log("PASS");
-            })();
-        })();
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-issue_4340: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-    }
-    input: {
-        (async function a(a) {
-            console.log(a || "PASS");
-        })();
-    }
-    expect: {
-        (async function a(a) {
-            console.log(a || "PASS");
-        })();
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-call_expression: {
-    input: {
-        console.log(typeof async function(log) {
-            (await log)("FAIL");
-        }(console.log).then);
-    }
-    expect_exact: 'console.log(typeof async function(log){(await log)("FAIL")}(console.log).then);'
-    expect_stdout: "function"
-    node_version: ">=8"
-}
-
-property_access_expression: {
-    input: {
-        console.log(typeof async function(con) {
-            (await con).log("FAIL");
-        }(console).then);
-    }
-    expect_exact: 'console.log(typeof async function(con){(await con).log("FAIL")}(console).then);'
-    expect_stdout: "function"
-    node_version: ">=8"
-}
-
-reduce_iife_1: {
-    options = {
-        evaluate: true,
-        keep_fargs: "strict",
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        (async function(a) {
-            console.log(a + a);
-        })(21);
-    }
-    expect: {
-        (async function() {
-            console.log(42);
-        })();
-    }
-    expect_stdout: "42"
-    node_version: ">=8"
-}
-
-reduce_iife_2: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a = 21;
-        (async function() {
-            console.log(a + a);
-        })();
-    }
-    expect: {
-        (async function() {
-            console.log(42);
-        })();
-    }
-    expect_stdout: "42"
-    node_version: ">=8"
-}
-
-reduce_iife_3: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        side_effects: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a = "foo";
-        (async function() {
-            console.log(a);
-            console.log(await a);
-        })();
-        a = "bar";
-    }
-    expect: {
-        var a = "foo";
-        (async function() {
-            console.log(a);
-            console.log(await a);
-        })();
-        a = "bar";
-    }
-    expect_stdout: "foo"
-    node_version: ">=8"
-}
-
-issue_4347_1: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a = "foo";
-        f();
-        a = "bar";
-        f();
-        async function f() {
-            console.log(a);
-        }
-    }
-    expect: {
-        var a = "foo";
-        f();
-        a = "bar";
-        f();
-        async function f() {
-            console.log(a);
-        }
-    }
-    expect_stdout: [
-        "foo",
-        "bar",
-    ]
-    node_version: ">=8"
-}
-
-issue_4347_2: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a = "PASS";
-        (async function() {
-            throw 42;
-            a = "FAIL";
-        })();
-        console.log(a);
-    }
-    expect: {
-        var a = "PASS";
-        (async function() {
-            throw 42;
-            a = "FAIL";
-        })();
-        console.log(a);
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-issue_4349_1: {
-    input: {
-        console.log(typeof async function() {
-            await /abc/;
-        }().then);
-    }
-    expect_exact: "console.log(typeof async function(){await/abc/}().then);"
-    expect_stdout: "function"
-    node_version: ">=8"
-}
-
-issue_4349_2: {
-    options = {
-        collapse_vars: true,
-        unused: true,
-    }
-    input: {
-        console.log(typeof async function() {
-            (function(a) {
-                this[a];
-            }(await 0));
-        }().then);
-    }
-    expect: {
-        console.log(typeof async function() {
-            (function(a) {
-                this[a];
-            }(await 0));
-        }().then);
-    }
-    expect_stdout: "function"
-    node_version: ">=8"
-}
-
-issue_4349_3: {
-    options = {
-        collapse_vars: true,
-        unused: true,
-    }
-    input: {
-        console.log(typeof function(await) {
-            return async function(a) {
-                this[a];
-            }(await);
-        }(this).then);
-    }
-    expect: {
-        console.log(typeof function(await) {
-            return async function(a) {
-                this[a];
-            }(await);
-        }(this).then);
-    }
-    expect_stdout: "function"
-    node_version: ">=8"
-}
-
-issue_4359: {
-    options = {
-        collapse_vars: true,
-        unused: true,
-    }
-    input: {
-        try {
-            (async function(a) {
-                return a;
-            })(A);
-        } catch (e) {
-            console.log("PASS");
-        }
-    }
-    expect: {
-        try {
-            (async function(a) {
-                return a;
-            })(A);
-        } catch (e) {
-            console.log("PASS");
-        }
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-issue_4377: {
-    options = {
-        dead_code: true,
-        inline: true,
-        side_effects: true,
-    }
-    input: {
-        console.log(typeof function() {
-            return function() {
-                f;
-                async function f() {}
-                return f();
-            }();
-        }().then);
-    }
-    expect: {
-        console.log(typeof function() {
-            return f();
-            async function f() {}
-        }().then);
-    }
-    expect_stdout: "function"
-    node_version: ">=8"
-}
-
-issue_4406: {
-    options = {
-        merge_vars: true,
-    }
-    input: {
-        A = "PASS";
-        B = "FAIL";
-        (function() {
-            var a, b;
-            a = A;
-            (async function({
-                [console.log(a)]: {},
-            }) {})((b = B) && { undefined: b });
-        })();
-    }
-    expect: {
-        A = "PASS";
-        B = "FAIL";
-        (function() {
-            var a, b;
-            a = A;
-            (async function({
-                [console.log(a)]: {},
-            }) {})((b = B) && { undefined: b });
-        })();
-    }
-    expect_stdout: "PASS"
-    node_version: ">=8"
-}
-
-issue_4417: {
-    options = {
-        inline: true,
-    }
-    input: {
-        (async function() {
-            console.log(function() {
-                return await => 0;
-            }().prototype);
-        })();
-    }
-    expect: {
-        (async function() {
-            console.log(function() {
-                return await => 0;
-            }().prototype);
-        })();
-    }
-    expect_stdout: "undefined"
-    node_version: ">=8"
-}

test/compress/bigint.js

@@ -0,0 +1,62 @@
+arithmetic: {
+    input: {
+        console.log(((1n + 0x2n) * (0o3n - -4n)) >> (5n - 6n));
+    }
+    expect_exact: "console.log((1n+0x2n)*(0o3n- -4n)>>5n-6n);"
+    expect_stdout: "42n"
+    node_version: ">=10"
+}
+
+minus_dot: {
+    input: {
+        console.log(typeof -42n.toString(), typeof (-42n).toString());
+    }
+    expect_exact: "console.log(typeof-42n.toString(),typeof(-42n).toString());"
+    expect_stdout: "number string"
+    node_version: ">=10"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log((0xDEAD_BEEFn).toString(16));
+    }
+    expect: {
+        console.log(0xdeadbeefn.toString(16));
+    }
+    expect_stdout: "deadbeef"
+    node_version: ">=10"
+}
+
+Number: {
+    options = {
+        unsafe: true,
+    }
+    input: {
+        console.log(Number(-0xfeed_dead_beef_badn));
+    }
+    expect: {
+        console.log(+("" + -0xfeed_dead_beef_badn));
+    }
+    expect_stdout: "-1148098955808013200"
+    node_version: ">=10"
+}
+
+issue_4590: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        A = 1;
+        0n || console.log("PASS");
+    }
+    expect: {
+        A = 1;
+        0n || console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=10"
+}

test/compress/classes.js

@@ -0,0 +1,770 @@
+constructor_1: {
+    input: {
+        "use strict";
+        console.log(new class {
+            constructor(a) {
+                this.a = a;
+            }
+        }("PASS").a);
+    }
+    expect_exact: '"use strict";console.log(new class{constructor(a){this.a=a}}("PASS").a);'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+constructor_2: {
+    input: {
+        "use strict";
+        console.log(new class {
+            "constructor"(a) {
+                this.a = a;
+            }
+        }("PASS").a);
+    }
+    expect_exact: '"use strict";console.log(new class{constructor(a){this.a=a}}("PASS").a);'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+constructor_3: {
+    input: {
+        "use strict";
+        console.log(new class {
+            ["constructor"](a) {
+                this.a = a;
+            }
+        }("FAIL").a || "PASS");
+    }
+    expect_exact: '"use strict";console.log(new class{["constructor"](a){this.a=a}}("FAIL").a||"PASS");'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+constructor_4: {
+    input: {
+        "use strict";
+        class A {
+            static constructor(a) {
+                console.log(a);
+            }
+        }
+        A.constructor("PASS");
+    }
+    expect_exact: '"use strict";class A{static constructor(a){console.log(a)}}A.constructor("PASS");'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+fields: {
+    input: {
+        var o = new class A {
+            "#p";
+            static #p = "PASS";
+            async
+            get
+            q() {
+                return A.#p;
+            }
+            ;
+            [6 * 7] = console ? "foo" : "bar"
+        };
+        for (var k in o)
+            console.log(k, o[k]);
+        console.log(o.q);
+    }
+    expect_exact: 'var o=new class A{"#p";static #p="PASS";async;get q(){return A.#p}[6*7]=console?"foo":"bar"};for(var k in o)console.log(k,o[k]);console.log(o.q);'
+    expect_stdout: [
+        "42 foo",
+        "#p undefined",
+        "async undefined",
+        "PASS",
+    ]
+    node_version: ">=12"
+}
+
+methods: {
+    input: {
+        "use strict";
+        class A {
+            static f() {
+                return "foo";
+            }
+            *g() {
+                yield A.f();
+                yield "bar";
+            }
+        }
+        for (var a of new A().g())
+            console.log(a);
+    }
+    expect_exact: '"use strict";class A{static f(){return"foo"}*g(){yield A.f();yield"bar"}}for(var a of(new A).g())console.log(a);'
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+private_methods: {
+    input: {
+        new class A {
+            static *#f() {
+                yield A.#p * 3;
+            }
+            async #g() {
+                for (var a of A.#f())
+                    return a * await 2;
+            }
+            static get #p() {
+                return 7;
+            }
+            get q() {
+                return this.#g();
+            }
+        }().q.then(console.log);
+    }
+    expect_exact: "(new class A{static*#f(){yield 3*A.#p}async #g(){for(var a of A.#f())return a*await 2}static get #p(){return 7}get q(){return this.#g()}}).q.then(console.log);"
+    expect_stdout: "42"
+    node_version: ">=14"
+}
+
+await: {
+    input: {
+        var await = "PASS";
+        (async function() {
+            return await new class extends (await function() {}) { [await 42] = await };
+        })().then(function(o) {
+            console.log(o[42]);
+        });
+    }
+    expect_exact: 'var await="PASS";(async function(){return await new class extends(await function(){}){[await 42]=await}})().then(function(o){console.log(o[42])});'
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+yield: {
+    input: {
+        var a = function*() {
+            yield new class { [yield "foo"] = "bar" };
+        }();
+        console.log(a.next().value);
+        console.log(a.next(42).value[42]);
+    }
+    expect_exact: 'var a=function*(){yield new class{[yield"foo"]="bar"}}();console.log(a.next().value);console.log(a.next(42).value[42]);'
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=12"
+}
+
+conditional_parentheses: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        "use strict";
+        if (class {})
+            console.log("PASS");
+    }
+    expect_exact: '"use strict";(class{})&&console.log("PASS");'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+class_super: {
+    input: {
+        "use strict";
+        class A {
+            static get p() {
+                return "Foo";
+            }
+            static get q() {
+                return super.p || 42;
+            }
+            constructor() {
+                console.log("a.p", super.p, this.p);
+                console.log("a.q", super.q, this.q);
+            }
+            get p() {
+                return "foo";
+            }
+            get q() {
+                return super.p || null;
+            }
+        }
+        class B extends A {
+            static get p() {
+                return "Bar";
+            }
+            static get q() {
+                return super.p;
+            }
+            constructor() {
+                super();
+                console.log("b.p", super.p, this.p);
+                console.log("b.q", super.q, this.q);
+            }
+            get p() {
+                return "bar";
+            }
+            get q() {
+                return super.p;
+            }
+        }
+        console.log("A", A.p, A.q);
+        console.log("B", B.p, B.q);
+        new B();
+    }
+    expect_exact: '"use strict";class A{static get p(){return"Foo"}static get q(){return super.p||42}constructor(){console.log("a.p",super.p,this.p);console.log("a.q",super.q,this.q)}get p(){return"foo"}get q(){return super.p||null}}class B extends A{static get p(){return"Bar"}static get q(){return super.p}constructor(){super();console.log("b.p",super.p,this.p);console.log("b.q",super.q,this.q)}get p(){return"bar"}get q(){return super.p}}console.log("A",A.p,A.q);console.log("B",B.p,B.q);new B;'
+    expect_stdout: [
+        "A Foo 42",
+        "B Bar Foo",
+        "a.p undefined bar",
+        "a.q undefined foo",
+        "b.p foo bar",
+        "b.q null foo",
+    ]
+    node_version: ">=4"
+}
+
+block_scoped: {
+    options = {
+        evaluate: true,
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        "use strict";
+        while (0) {
+            class A {}
+        }
+        if (console) {
+            class B {}
+        }
+        console.log(typeof A, typeof B);
+    }
+    expect: {
+        "use strict";
+        0;
+        if (console) {
+            class B {}
+        }
+        console.log(typeof A, typeof B);
+    }
+    expect_stdout: "undefined undefined"
+    node_version: ">=4"
+}
+
+keep_extends: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            class A extends 42 {}
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (class extends 42 {});
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+drop_name: {
+    options = {
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            console.log(class A extends 42 {})
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            console.log(class extends 42 {})
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+separate_name: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        class A {
+            constructor(v) {
+                this.p = v;
+            }
+        }
+        var a = new A("PASS");
+        console.log(a.p);
+    }
+    expect: {
+        "use strict";
+        class A {
+            constructor(v) {
+                this.p = v;
+            }
+        }
+        var a = new A("PASS");
+        console.log(a.p);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+static_side_effects: {
+    options = {
+        inline: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL 1";
+        class A {
+            static p = a = "PASS";
+            q = a = "FAIL 2";
+        }
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL 1";
+        a = "PASS";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+single_use: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        class A {}
+        console.log(typeof new A());
+    }
+    expect: {
+        "use strict";
+        console.log(typeof new class {}());
+    }
+    expect_stdout: "object"
+    node_version: ">=4"
+}
+
+collapse_non_strict: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 42..p++;
+        new class extends (a || function() {
+            console.log("PASS");
+        }) {}
+    }
+    expect: {
+        var a = 42..p++;
+        new class extends (a || function() {
+            console.log("PASS");
+        }) {}
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+collapse_rhs: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = "FAIL";
+        a = "PASS";
+        class A {
+            p = "PASS";
+        }
+        console.log(a);
+    }
+    expect: {
+        "use strict";
+        var a = "FAIL";
+        a = "PASS";
+        class A {
+            p = "PASS";
+        }
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+collapse_rhs_static: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = "FAIL";
+        a = "PASS";
+        class A {
+            static p = "PASS";
+        }
+        console.log(a);
+    }
+    expect: {
+        "use strict";
+        var a = "FAIL";
+        class A {
+            static p = a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+property_side_effects: {
+    options = {
+        inline: true,
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        (function f(a, b) {
+            class A {
+                [a.log("PASS")]() {
+                    b.log("FAIL");
+                }
+            }
+        })(console, console);
+    }
+    expect: {
+        "use strict";
+        (function(a) {
+            a.log("PASS");
+        })(console, console);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+property_side_effects_static: {
+    options = {
+        inline: true,
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        (function f(a, b) {
+            class A {
+                static [a.log("PASS")]() {
+                    b.log("FAIL");
+                }
+            }
+        })(console, console);
+    }
+    expect: {
+        "use strict";
+        (function(a) {
+            a.log("PASS");
+        })(console, console);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+unused_await: {
+    options = {
+        inline: true,
+        unused: true,
+    }
+    input: {
+        var await = "PASS";
+        (async function() {
+            class A {
+                static p = console.log(await);
+            }
+        })();
+    }
+    expect: {
+        var await = "PASS";
+        (async function() {
+            (() => console.log(await))();
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+computed_key_side_effects: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var a = 0;
+        class A {
+            [(a++, 0)]() {}
+        }
+        console.log(a);
+    }
+    expect: {
+        "use strict";
+        console.log(1);
+    }
+    expect_stdout: "1"
+    node_version: ">=4"
+}
+
+computed_key_generator: {
+    options = {
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var a = function*() {
+            class A {
+                static [console.log(yield)]() {}
+            }
+        }();
+        a.next("FAIL");
+        a.next("PASS");
+    }
+    expect: {
+        "use strict";
+        var a = function*() {
+            console.log(yield);
+        }();
+        a.next("FAIL");
+        a.next("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4681: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            class A {
+                static p = a = this;
+            }
+            return typeof a;
+        }());
+    }
+    expect: {
+        console.log(function(a) {
+            class A {
+                static p = a = this;
+            }
+            return typeof a;
+        }());
+    }
+    expect_stdout: "function"
+    node_version: ">=12"
+}
+
+issue_4683: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+    }
+    input: {
+        "use strict";
+        for (class extends null {}; void console.log("PASS"); );
+    }
+    expect: {
+        "use strict";
+        (class extends null {});
+        void console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4685_1: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        new class {
+            f() {
+                (function(g) {
+                    if (g() !== this)
+                        console.log("PASS");
+                })(() => this);
+            }
+        }().f();
+    }
+    expect: {
+        "use strict";
+        new class {
+            f() {
+                (function(g) {
+                    if (g() !== this)
+                        console.log("PASS");
+                })(() => this);
+            }
+        }().f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4685_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        new class {
+            f() {
+                (function(g) {
+                    if (g() !== this)
+                        console.log("PASS");
+                })(() => {
+                    if (console)
+                        return this;
+                });
+            }
+        }().f();
+    }
+    expect: {
+        "use strict";
+        new class {
+            f() {
+                (function(g) {
+                    if (g() !== this)
+                        console.log("PASS");
+                })(() => {
+                    if (console)
+                        return this;
+                });
+            }
+        }().f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4687_1: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        new class {
+            f() {
+                console.log(function(g) {
+                    return g() === this;
+                }(() => this) || "PASS");
+            }
+        }().f();
+    }
+    expect: {
+        "use strict";
+        new class {
+            f() {
+                console.log(function(g) {
+                    return g() === this;
+                }(() => this) || "PASS");
+            }
+        }().f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4687_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        new class {
+            f() {
+                console.log(function(g) {
+                    return g() === this;
+                }(() => {
+                    if (console)
+                        return this;
+                }) || "PASS");
+            }
+        }().f();
+    }
+    expect: {
+        "use strict";
+        new class {
+            f() {
+                console.log(function(g) {
+                    return g() === this;
+                }(() => {
+                    if (console)
+                        return this;
+                }) || "PASS");
+            }
+        }().f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4705: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        class A {
+            p = a = "FAIL";
+            [console.log(a)];
+        }
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}

test/compress/collapse_vars.js

@@ -3145,8 +3145,8 @@ issue_2313_2: {
         var c = 0;
         !function a() {
             a && c++;
-            var a = 0;
-            a && c++;
+            var a;
+            (a = 0) && c++;
         }();
         console.log(c);
     }
@@ -4273,8 +4273,8 @@ issue_2436_14: {
         var b = {};
         (function() {
             a && function(c, d) {
-                console.log(c, d);
-            }(b, a);
+                console.log(b, d);
+            }(0, a);
         })();
     }
     expect_stdout: true
@@ -5502,8 +5502,7 @@ collapse_rhs_lhs_2: {
     expect: {
         var b = 1;
         (function f(f) {
-            f = b;
-            f[b] = 0;
+            b[b] = 0;
         })();
         console.log("PASS");
     }
@@ -5609,6 +5608,7 @@ collapse_rhs_array: {
 collapse_rhs_boolean_1: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5634,6 +5634,7 @@ collapse_rhs_boolean_1: {
 collapse_rhs_boolean_2: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a;
@@ -5668,6 +5669,7 @@ collapse_rhs_boolean_3: {
         booleans: true,
         collapse_vars: true,
         conditionals: true,
+        evaluate: true,
     }
     input: {
         var a, f, g, h, i, n, s, t, x, y;
@@ -5721,6 +5723,7 @@ collapse_rhs_function: {
 collapse_rhs_number: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5800,6 +5803,7 @@ collapse_rhs_regexp: {
 collapse_rhs_string: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5875,6 +5879,7 @@ collapse_rhs_this: {
 collapse_rhs_undefined: {
     options = {
         collapse_vars: true,
+        side_effects: true,
     }
     input: {
         var a, b;
@@ -5996,7 +6001,7 @@ issue_3215_1: {
         }());
     }
     expect: {
-        console.log(typeof 42);
+        console.log("number");
     }
     expect_stdout: "number"
 }
@@ -8662,3 +8667,92 @@ issue_4430_2: {
     }
     expect_stdout: "PASS"
 }
+
+collapse_and_assign: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var log = console.log;
+        var a = {
+            p: "PASS",
+        };
+        console && (a = a.p);
+        log(a);
+    }
+    expect: {
+        var log = console.log;
+        var a = {
+            p: "PASS",
+        };
+        log(a = console ? a.p : a);
+    }
+    expect_stdout: "PASS"
+}
+
+collapse_or_assign: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var log = console.log;
+        var a = {
+            p: "PASS",
+        };
+        a.q || (a = a.p);
+        log(a);
+    }
+    expect: {
+        var log = console.log;
+        var a = {
+            p: "PASS",
+        };
+        log(a = !a.q ? a.p : a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4586_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 42;
+        (function f(b) {
+            var b = a;
+            if (b === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect: {
+        var a = 42;
+        (function f(b) {
+            var b = a;
+            if (b === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4586_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 42;
+        (function f(b) {
+            b = a;
+            if (b === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect: {
+        var a = 42;
+        (function f(b) {
+            if ((b = a) === arguments[0])
+                console.log("PASS");
+        })(console);
+    }
+    expect_stdout: "PASS"
+}

test/compress/conditionals.js

@@ -1861,3 +1861,39 @@ issue_3808_2: {
     }
     expect_stdout: " PASS"
 }
+
+object_super: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        Object.setPrototypeOf({
+            f(a) {
+                a ? this.g("FAIL") : super.g("FAIL");
+            },
+            g(b) {
+                console.log(b);
+            },
+        }, {
+            g() {
+                console.log("PASS");
+            },
+        }).f();
+    }
+    expect: {
+        Object.setPrototypeOf({
+            f(a) {
+                a ? this.g("FAIL") : super.g("FAIL");
+            },
+            g(b) {
+                console.log(b);
+            },
+        }, {
+            g() {
+                console.log("PASS");
+            },
+        }).f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/const.js

@@ -658,6 +658,30 @@ legacy_scope: {
     expect_stdout: true
 }
 
+hoist_vars: {
+    options = {
+        hoist_vars: true,
+    }
+    input: {
+        {
+            const a = "FAIL";
+            var b = 42;
+        }
+        var a = "PASS";
+        console.log(a, b);
+    }
+    expect: {
+        var b;
+        {
+            const a = "FAIL";
+            b = 42;
+        }
+        var a = "PASS";
+        console.log(a, b);
+    }
+    expect_stdout: true
+}
+
 issue_4191: {
     options = {
         functions: true,
@@ -1375,3 +1399,102 @@ issue_4365_2: {
     }
     expect_stdout: true
 }
+
+issue_4527: {
+    mangle = {}
+    input: {
+        (function() {
+            try {
+                throw 1;
+            } catch (a) {
+                try {
+                    const a = FAIL;
+                } finally {
+                    if (!b)
+                        return console.log("aaaa");
+                }
+            }
+            var b;
+        })();
+    }
+    expect: {
+        (function() {
+            try {
+                throw 1;
+            } catch (a) {
+                try {
+                    const a = FAIL;
+                } finally {
+                    if (!t)
+                        return console.log("aaaa");
+                }
+            }
+            var t;
+        })();
+    }
+    expect_stdout: "aaaa"
+}
+
+issue_4689: {
+    options = {
+        sequences: true,
+    }
+    input: {
+        "use strict";
+        var a = "PASS";
+        console.log(a);
+        for (const a in 42);
+    }
+    expect: {
+        "use strict";
+        var a = "PASS";
+        console.log(a);
+        for (const a in 42);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4691: {
+    options = {
+        if_return: true,
+        toplevel: true,
+    }
+    input: {
+        function A() {}
+        A.prototype.f = function() {
+            if (!this)
+                return;
+            const a = "PA";
+            function g(b) {
+                h(a + b);
+            }
+            [ "SS" ].forEach(function(c) {
+                g(c);
+            });
+        };
+        function h(d) {
+            console.log(d);
+        }
+        new A().f();
+    }
+    expect: {
+        function A() {}
+        A.prototype.f = function() {
+            if (this) {
+                const a = "PA";
+                [ "SS" ].forEach(function(c) {
+                    g(c);
+                });
+                function g(b) {
+                    h(a + b);
+                }
+            }
+        };
+        function h(d) {
+            console.log(d);
+        }
+        new A().f();
+    }
+    expect_stdout: "PASS"
+}

test/compress/dead-code.js

@@ -53,8 +53,10 @@ dead_code_2_should_warn: {
             g();
             x = 10;
             throw new Error("foo");
-            var x;
-            function g(){};
+            {
+                var x;
+                function g(){};
+            }
         }
         f();
     }
@@ -62,7 +64,6 @@ dead_code_2_should_warn: {
     expect_warnings: [
         "WARN: Dropping unreachable code [test/compress/dead-code.js:8,12]",
     ]
-    node_version: "<=4"
 }
 
 dead_code_constant_boolean_should_warn_more: {
@@ -88,8 +89,10 @@ dead_code_constant_boolean_should_warn_more: {
         bar();
     }
     expect: {
-        var foo;
-        function bar() {}
+        {
+            var foo;
+            function bar() {}
+        }
         // nothing for the while
         // as for the for, it should keep:
         var x = 10, y;
@@ -725,7 +728,7 @@ issue_2749: {
     expect: {
         var a = 2, c = "PASS";
         while (a--)
-            b = void 0, b ? c = "FAIL" : b = 1;
+            b = void 0, b ? c = "FAIL" : 1;
         var b;
         console.log(c);
     }
@@ -1399,3 +1402,21 @@ issue_4366: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_4570: {
+    options = {
+        dead_code: true,
+        inline: true,
+    }
+    input: {
+        var a = function(b) {
+            return a += b;
+        }() ? 0 : a;
+        console.log(a);
+    }
+    expect: {
+        var a = (a += void 0) ? 0 : a;
+        console.log(a);
+    }
+    expect_stdout: "NaN"
+}

test/compress/destructured.js

@@ -40,7 +40,7 @@ redefine_arguments_2: {
 
 redefine_arguments_3: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -188,7 +188,7 @@ funarg_side_effects_1: {
     }
     expect: {
         try {
-            (function({}) {})();
+            [ {} ] = [];
         } catch (e) {
             console.log("PASS");
         }
@@ -259,7 +259,7 @@ funarg_side_effects_3: {
 
 funarg_unused_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -318,7 +318,7 @@ funarg_unused_3: {
 
 funarg_unused_4: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         pure_getters: "strict",
         unused: true,
     }
@@ -384,7 +384,7 @@ funarg_unused_6_inline: {
 
 funarg_unused_6_keep_fargs: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -426,7 +426,7 @@ funarg_collapse_vars_1: {
 funarg_collapse_vars_2: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -505,7 +505,7 @@ funarg_reduce_vars_1: {
 funarg_reduce_vars_2: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         pure_getters: "strict",
         reduce_vars: true,
         unsafe: true,
@@ -682,7 +682,7 @@ funarg_inline: {
     }
     expect: {
         try {
-            (function({}) {})();
+            [ {} ] = [];
         } catch (e) {
             console.log("PASS");
         }
@@ -691,6 +691,28 @@ funarg_inline: {
     node_version: ">=6"
 }
 
+process_boolean_returns: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        console.log(function({ length }) {
+            return length ? "FAIL" : "PASS";
+        }(function() {
+            return 42;
+        }));
+    }
+    expect: {
+        console.log(function({ length }) {
+            return length ? "FAIL" : "PASS";
+        }(function() {
+            return 42;
+        }));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 simple_const: {
     options = {
         evaluate: true,
@@ -1101,7 +1123,7 @@ join_vars: {
 
 keep_fargs: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1336,6 +1358,24 @@ fn_name_unused: {
     node_version: ">=6"
 }
 
+hoist_vars: {
+    options = {
+        hoist_vars: true,
+    }
+    input: {
+        var a = "PASS";
+        var [ b ] = [ 42 ];
+        console.log(a, b);
+    }
+    expect: {
+        var a = "PASS";
+        var [ b ] = [ 42 ];
+        console.log(a, b);
+    }
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
 issue_4280: {
     options = {
         evaluate: true,
@@ -1678,10 +1718,14 @@ issue_4312: {
     expect: {
         var a;
         b = "PASS",
-        (function({
-            [a = b]: d,
-        }){})((c = "FAIL") && c);
-        var b, c;
+        c = "FAIL",
+        [
+            {
+                [a = b]: d,
+            },
+        ] = [ c && c ],
+        void 0;
+        var b, c, d;
         console.log(a);
     }
     expect_stdout: "PASS"
@@ -1743,9 +1787,7 @@ issue_4319: {
         function f(a) {
             while (!a);
         }
-        console.log(function({}) {
-            return f(console);
-        }(0));
+        console.log(([ {} ] = [ 0 ], f(console)));
     }
     expect_stdout: "undefined"
     node_version: ">=6"
@@ -1754,7 +1796,7 @@ issue_4319: {
 issue_4321: {
     options = {
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         try {
@@ -1769,11 +1811,9 @@ issue_4321: {
     }
     expect: {
         try {
-            console.log(function({}) {
-                return function() {
-                    while (!console);
-                }();
-            }());
+            console.log(([ {} ] = [], function() {
+                while (!console);
+            }()));
         } catch (e) {
             console.log("PASS");
         }
@@ -1804,11 +1844,15 @@ issue_4323: {
     }
     expect: {
         var a = 0;
-        (function({
-            [function a() {
-                console.log(typeof a);
-            }()]: d,
-        }) {})(0);
+        [
+            {
+                [function a() {
+                    console.log(typeof a);
+                }()]: d,
+            },
+        ] = [ 0 ],
+        void 0;
+        var d;
         e = 1,
         console.log,
         void e.p;
@@ -2037,3 +2081,478 @@ issue_4425: {
     expect_stdout: "PASS"
     node_version: ">=8"
 }
+
+issue_4436_Infinity: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function({
+            [delete Infinity]: a,
+        }) {
+            var Infinity;
+            return a;
+        }({
+            true: "FAIL",
+            false: "PASS",
+        }));
+    }
+    expect: {
+        console.log(function({
+            [delete Infinity]: a,
+        }) {
+            return a;
+        }({
+            true: "FAIL",
+            false: "PASS",
+        }));
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_4436_NaN: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function({
+            [delete NaN]: a,
+        }) {
+            var NaN;
+            return a;
+        }({
+            true: "FAIL",
+            false: "PASS",
+        }));
+    }
+    expect: {
+        console.log(function({
+            [delete NaN]: a,
+        }) {
+            return a;
+        }({
+            true: "FAIL",
+            false: "PASS",
+        }));
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_4436_undefined: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function({
+            [delete undefined]: a,
+        }) {
+            var undefined;
+            return a;
+        }({
+            true: "FAIL",
+            false: "PASS",
+        }));
+    }
+    expect: {
+        console.log(function({
+            [delete undefined]: a,
+        }) {
+            return a;
+        }({
+            true: "FAIL",
+            false: "PASS",
+        }));
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_4446: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        a = "PASS";
+        var a = [ a[0] ] = [ a ];
+        console.log(a[0]);
+    }
+    expect: {
+        a = "PASS";
+        var a = [ a[0] ] = [ a ];
+        console.log(a[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4456: {
+    options = {
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        var o = {
+            set p(v) {
+                console.log(v);
+            },
+        };
+        [ function() {
+            try {
+                return o;
+            } catch ({}) {}
+        }().p ] = [ "PASS" ];
+    }
+    expect: {
+        var o = {
+            set p(v) {
+                console.log(v);
+            },
+        };
+        [ function() {
+            try {
+                return o;
+            } catch ({}) {}
+        }().p ] = [ "PASS" ];
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4485_1: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        (function([]) {
+            var arguments;
+            try {
+                arguments.length;
+            } catch (e) {
+                console.log("PASS");
+            }
+        })([]);
+    }
+    expect: {
+        (function([]) {
+            var arguments;
+            try {
+                arguments.length;
+            } catch (e) {
+                console.log("PASS");
+            }
+        })([]);
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_4485_2: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        (function([]) {
+            var arguments = null;
+            try {
+                arguments.length;
+            } catch (e) {
+                console.log("PASS");
+            }
+        })([]);
+    }
+    expect: {
+        (function([]) {
+            var arguments = null;
+            try {
+                arguments.length;
+            } catch (e) {
+                console.log("PASS");
+            }
+        })([]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4485_3: {
+    options = {
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        (function([]) {
+            var arguments;
+            try {
+                arguments.length;
+            } catch (e) {
+                console.log("PASS");
+            }
+        })([]);
+    }
+    expect: {
+        (function([]) {
+            var arguments;
+            try {
+                arguments.length;
+            } catch (e) {
+                console.log("PASS");
+            }
+        })([]);
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_4500: {
+    options = {
+        evaluate: true,
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f(b) {
+            return [ b ] = [], b;
+        }("FAIL");
+        console.log(a || "PASS");
+    }
+    expect: {
+        var a = function f(b) {
+            return [ b ] = [], b;
+        }("FAIL");
+        console.log(a || "PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4504: {
+    options = {
+        inline: true,
+        merge_vars: true,
+    }
+    input: {
+        A = "FAIL";
+        (function f(a) {
+            ({
+                [console.log(a)]: 0[(b => console + b)(A)]
+            } = 0);
+        })("PASS");
+    }
+    expect: {
+        A = "FAIL";
+        (function f(a) {
+            ({
+                [console.log(a)]: 0[b = A, console + b]
+            } = 0);
+            var b;
+        })("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4508: {
+    options = {
+        inline: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var i = 0; i < 2; i++)
+            (function f([ a ]) {
+                var a = console.log(a) && b, b = null;
+            })([ "PASS" ]);
+    }
+    expect: {
+        for (var i = 0; i < 2; i++)
+            [ [ a ] ] = [ [ "PASS" ] ],
+            b = void 0,
+            a = console.log(a) && b,
+            b = null,
+            void 0;
+        var a, b;
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+    ]
+    node_version: ">=6"
+}
+
+issue_4512: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        console.log(function([ a, b = a ]) {}([]));
+    }
+    expect: {
+        console.log(function([ a, b = a ]) {}([]));
+    }
+    expect_stdout: "undefined"
+    node_version: ">=6"
+}
+
+issue_4519_1: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        try {
+            (function() {
+                var [ arguments ] = [];
+                arguments[0];
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (function() {
+                var [ arguments ] = [];
+                arguments[0];
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4519_2: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        try {
+            (function() {
+                var [ arguments ] = [];
+                arguments[0];
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (function() {
+                var [ arguments ] = [];
+                arguments[0];
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4554: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        A = "PASS";
+        var a = "FAIL";
+        try {
+            (function({}, b) {
+                return b;
+            })(void 0, a = A);
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect: {
+        A = "PASS";
+        var a = "FAIL";
+        try {
+            (function({}, b) {
+                return b;
+            })(void 0, a = A);
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4584: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        try {
+            (function f({
+                [console.log(a = "FAIL")]: a,
+            }) {})(0);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (function f({
+                [console.log(a = "FAIL")]: a,
+            }) {})(0);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4608_1: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        (function() {
+            [ arguments ] = [ "foo" ];
+            console.log(arguments[0]);
+        })();
+    }
+    expect: {
+        (function() {
+            [ arguments ] = [ "foo" ];
+            console.log(arguments[0]);
+        })();
+    }
+    expect_stdout: "f"
+    node_version: ">=6"
+}
+
+issue_4608_2: {
+    options = {
+        arguments: true,
+        reduce_vars: true,
+    }
+    input: {
+        (function(a) {
+            [ arguments ] = [ "foo" ];
+            console.log(arguments[0]);
+        })();
+    }
+    expect: {
+        (function(a) {
+            [ arguments ] = [ "foo" ];
+            console.log(arguments[0]);
+        })();
+    }
+    expect_stdout: "f"
+    node_version: ">=6"
+}

test/compress/drop-unused.js

@@ -4,15 +4,16 @@ unused_funarg_1: {
         unused: true,
     }
     input: {
-        function f(a, b, c, d, e) {
+        console.log(function f(a, b, c, d, e) {
             return a + b;
-        }
+        }(14, 28));
     }
     expect: {
-        function f(a, b) {
+        console.log(function(a, b) {
             return a + b;
-        }
+        }(14, 28));
     }
+    expect_stdout: "42"
 }
 
 unused_funarg_2: {
@@ -21,15 +22,16 @@ unused_funarg_2: {
         unused: true,
     }
     input: {
-        function f(a, b, c, d, e) {
+        console.log(function f(a, b, c, d, e) {
             return a + c;
-        }
+        }(14, 21, 28));
     }
     expect: {
-        function f(a, b, c) {
+        console.log(function(a, c) {
             return a + c;
-        }
+        }(14, 28));
     }
+    expect_stdout: "42"
 }
 
 unused_nested_function: {
@@ -357,37 +359,6 @@ drop_toplevel_vars: {
     }
 }
 
-drop_toplevel_vars_fargs: {
-    options = {
-        keep_fargs: false,
-        toplevel: "vars",
-        unused: true,
-    }
-    input: {
-        var a, b = 1, c = g;
-        function f(d) {
-            return function() {
-                c = 2;
-            };
-        }
-        a = 2;
-        function g() {}
-        function h() {}
-        console.log(b = 3);
-    }
-    expect: {
-        function f() {
-            return function() {
-                2;
-            };
-        }
-        2;
-        function g() {}
-        function h() {}
-        console.log(3);
-    }
-}
-
 drop_toplevel_all: {
     options = {
         toplevel: true,
@@ -625,13 +596,14 @@ drop_fargs: {
         unused: true,
     }
     input: {
-        function f(a) {
+        console.log(function f(a) {
             var b = a;
-        }
+        }());
     }
     expect: {
-        function f() {}
+        console.log(function() {}());
     }
+    expect_stdout: "undefined"
 }
 
 drop_fnames: {
@@ -2027,7 +1999,7 @@ issue_3192_1: {
 
 issue_3192_2: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -2166,6 +2138,7 @@ issue_3497: {
 issue_3515_1: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         reduce_vars: true,
         unused: true,
     }
@@ -2217,6 +2190,7 @@ issue_3515_2: {
 issue_3515_3: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         unused: true,
     }
     input: {
@@ -2284,6 +2258,7 @@ function_assign: {
 issue_3598: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         reduce_vars: true,
         unused: true,
     }
@@ -2435,7 +2410,7 @@ issue_3673: {
 
 issue_3746: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         side_effects: true,
         unused: true,
     }
@@ -2697,8 +2672,7 @@ issue_3956: {
         })();
     }
     expect: {
-        var c, d;
-        c += 0,
+        var d;
         console.log(NaN),
         d = 1 ^ console.log(1),
         console.log(d);
@@ -2713,7 +2687,7 @@ issue_3956: {
 issue_3962_1: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -2731,13 +2705,13 @@ issue_3962_1: {
     }
     expect: {
         var a = 0;
-        a = (function(c) {
+        (function(c) {
             do {
                 console;
                 0..toString();
             } while (0);
             if (c) console.log("PASS");
-        }(1), 0);
+        })(1);
         void 0;
     }
     expect_stdout: "PASS"
@@ -2745,7 +2719,7 @@ issue_3962_1: {
 
 issue_3962_2: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         side_effects: true,
         toplevel: true,
@@ -2764,13 +2738,13 @@ issue_3962_2: {
     }
     expect: {
         var a = 0;
-        a = (function(c) {
+        (function(c) {
             do {
                 console;
                 0..toString();
             } while (0);
             if (c) console.log("PASS");
-        }(1), 0);
+        })(1);
     }
     expect_stdout: "PASS"
 }
@@ -2827,7 +2801,9 @@ issue_4017: {
         var a = 0;
         console.log(function() {
             c &= 0;
-            var c = (a++, A = a, 0);
+            var c;
+            a++,
+            A = a;
         }());
     }
     expect_stdout: "undefined"
@@ -2948,7 +2924,7 @@ issue_4133: {
 
 issue_4144: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -3153,3 +3129,148 @@ issue_4413: {
     }
     expect_stdout: "0"
 }
+
+issue_4464_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var a = function() {};
+            return [ arguments, a ];
+        }
+        console.log(typeof f()[1]);
+    }
+    expect: {
+        function f(a) {
+            a = function() {};
+            return [ arguments, a ];
+        }
+        console.log(typeof f()[1]);
+    }
+    expect_stdout: "function"
+}
+
+issue_4464_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var a = function() {};
+            return [ arguments, a ];
+        }
+        console.log(typeof f(42)[0][0]);
+    }
+    expect: {
+        function f(a) {
+            a = function() {};
+            return [ arguments, a ];
+        }
+        console.log(typeof f(42)[0][0]);
+    }
+    expect_stdout: "function"
+}
+
+issue_4464_3: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function a(a) {
+            var a = function() {};
+            return [ arguments[0], a ];
+        })(42).forEach(function(b) {
+            console.log(typeof b);
+        });
+    }
+    expect: {
+        (function(a) {
+            a = function() {};
+            return [ arguments[0], a ];
+        })(42).forEach(function(b) {
+            console.log(typeof b);
+        });
+    }
+    expect_stdout: [
+        "function",
+        "function",
+    ]
+}
+
+issue_4558_1: {
+    options = {
+        evaluate: true,
+        pure_getters: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        var b = 1, b = c >>>= a;
+        var c = 0;
+        b && 0[a++],
+        console.log(a);
+    }
+    expect: {
+        var a = 0;
+        var b = c >>>= a;
+        var c;
+        b && a++,
+        console.log(a);
+    }
+    expect_stdout: "0"
+}
+
+issue_4558_2: {
+    options = {
+        evaluate: true,
+        ie8: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a = 1;
+            var b = (a = NaN) || (console.log("PASS"), 2);
+            return a;
+        })();
+    }
+    expect: {
+        (function() {
+            var a;
+            (a = NaN) || console.log("PASS");
+            return a;
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4662: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        function f(b, c) {
+            console.log(b, c);
+        }
+        f(++a, a = a, a);
+    }
+    expect: {
+        var a = 0;
+        (function(b, c) {
+            console.log(b, c);
+        })(++a, a = 1);
+    }
+    expect_stdout: "1 1"
+}

test/compress/evaluate.js

@@ -399,18 +399,18 @@ unsafe_object_accessor: {
         function f() {
             var a = {
                 get b() {},
-                set b() {}
+                set b(v) {},
             };
-            return {a:a};
+            return { a: a };
         }
     }
     expect: {
         function f() {
             var a = {
                 get b() {},
-                set b() {}
+                set b(v) {},
             };
-            return {a:a};
+            return { a: a };
         }
     }
 }
@@ -703,6 +703,7 @@ prototype_function: {
         var g = 0();
         var h = 0();
     }
+    expect_stdout: true
 }
 
 call_args: {
@@ -2800,7 +2801,7 @@ operator_in: {
         console.log("PASS" in { });
         console.log("FAIL" in { });
         console.log("toString" in { });
-        console.log(true);
+        console.log("toString" in { toString: 3 });
     }
     expect_stdout: [
         "true",
@@ -3117,3 +3118,61 @@ issue_4422: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4480: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = function f(b) {
+            b = "FAIL";
+            arguments[0] = "PASS";
+            var arguments = 0;
+            console.log(b);
+        }(a);
+    }
+    expect: {
+        var a = function(b) {
+            b = "FAIL";
+            arguments[0] = "PASS";
+            var arguments = 0;
+            console.log(b);
+        }(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4552: {
+    options = {
+        evaluate: true,
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f(b) {
+            return function() {
+                b++;
+                try {
+                    return b;
+                } catch (e) {}
+            }();
+        }();
+        console.log(a);
+    }
+    expect: {
+        var a = function f(b) {
+            return function() {
+                b++;
+                try {
+                    return b;
+                } catch (e) {}
+            }();
+        }();
+        console.log(a);
+    }
+    expect_stdout: "NaN"
+}

test/compress/exponentiation.js

@@ -0,0 +1,86 @@
+precedence_1: {
+    input: {
+        console.log(-4 ** 3 ** 2);
+    }
+    expect_exact: "console.log((-4)**3**2);"
+    expect_stdout: "-262144"
+    node_version: ">=8"
+}
+
+precedence_2: {
+    input: {
+        console.log(-4 ** (3 ** 2));
+    }
+    expect_exact: "console.log((-4)**3**2);"
+    expect_stdout: "-262144"
+    node_version: ">=8"
+}
+
+precedence_3: {
+    input: {
+        console.log(-(4 ** 3) ** 2);
+    }
+    expect_exact: "console.log((-(4**3))**2);"
+    expect_stdout: "4096"
+    node_version: ">=8"
+}
+
+precedence_4: {
+    input: {
+        console.log((-4 ** 3) ** 2);
+    }
+    expect_exact: "console.log(((-4)**3)**2);"
+    expect_stdout: "4096"
+    node_version: ">=8"
+}
+
+await: {
+    input: {
+        (async a => a * await a ** ++a % a)(2).then(console.log);
+    }
+    expect_exact: "(async a=>a*(await a)**++a%a)(2).then(console.log);"
+    expect_stdout: "1"
+    node_version: ">=8"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log(1 + 2 ** 3 - 4);
+    }
+    expect: {
+        console.log(5);
+    }
+    expect_stdout: "5"
+    node_version: ">=8"
+}
+
+issue_4664: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            new function(a) {
+                console.log(typeof f, a, typeof this);
+            }((A = 0, (NaN ^ 1) * 2 ** 30), 0);
+        }
+        f();
+    }
+    expect: {
+        (function f() {
+            new function(a) {
+                console.log(typeof f, 2 ** 30, typeof this);
+            }(0, A = 0);
+        })();
+    }
+    expect_stdout: "function 1073741824 object"
+    node_version: ">=8"
+}

test/compress/exports.js

@@ -0,0 +1,384 @@
+refs: {
+    input: {
+        export {};
+        export { a, b as B, c as case, d as default };
+    }
+    expect_exact: "export{};export{a as a,b as B,c as case,d as default};"
+}
+
+var_defs: {
+    input: {
+        export const a = 1;
+        export let b = 2, c = 3;
+        export var { d, e: [] } = f;
+    }
+    expect_exact: "export const a=1;export let b=2,c=3;export var{d:d,e:[]}=f;"
+}
+
+defuns: {
+    input: {
+        export class A {}
+        export function e() {}
+        export function* f(a) {}
+        export async function g(b, c) {}
+        export async function* h({}, ...[]) {}
+    }
+    expect_exact: "export class A{}export function e(){}export function*f(a){}export async function g(b,c){}export async function*h({},...[]){}"
+}
+
+defaults: {
+    input: {
+        export default 42;
+        export default async;
+        export default (x, y) => x * x;
+        export default class {};
+        export default function*(a, b) {};
+        export default async function f({ c }, ...[ d ]) {};
+    }
+    expect_exact: "export default 42;export default async;export default(x,y)=>x*x;export default class{}export default function*(a,b){}export default async function f({c:c},...[d]){}"
+}
+
+defaults_parentheses_1: {
+    input: {
+        export default function() {
+            console.log("FAIL");
+        }(console.log("PASS"));
+    }
+    expect_exact: 'export default function(){console.log("FAIL")}console.log("PASS");'
+}
+
+defaults_parentheses_2: {
+    input: {
+        export default (async function() {
+            console.log("PASS");
+        })();
+    }
+    expect_exact: 'export default(async function(){console.log("PASS")})();'
+}
+
+defaults_parentheses_3: {
+    input: {
+        export default (42, "PASS");
+    }
+    expect_exact: 'export default(42,"PASS");'
+}
+
+defaults_parentheses_4: {
+    input: {
+        export default (function f() {});
+    }
+    expect_exact: "export default(function f(){});"
+}
+
+defaults_parentheses_5: {
+    input: {
+        export default (function(a) {
+            console.log(a[0]);
+        }`PASS`);
+    }
+    expect_exact: "export default(function(a){console.log(a[0])})`PASS`;"
+}
+
+defaults_parentheses_6: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        export default !function() {
+            while (!console);
+        }() ? "PASS" : "FAIL";
+    }
+    expect_exact: 'export default(function(){while(!console);})()?"FAIL":"PASS";'
+}
+
+foreign: {
+    input: {
+        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";
+    }
+    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";'
+}
+
+same_quotes: {
+    beautify = {
+        beautify: true,
+        quote_style: 3,
+    }
+    input: {
+        export * from 'foo';
+        export {} from "bar";
+    }
+    expect_exact: [
+        "export * from 'foo';",
+        "",
+        'export {} from "bar";',
+    ]
+}
+
+drop_unused: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default 42;
+        export default (x, y) => x * x;
+        export default class A extends B { get p() { h() } }
+        export default function*(a, b) {}
+        export default async function f({ c }, ...[ d ]) {}
+        export var e;
+        export function g(x, [ y ], ...z) {}
+        function h() {}
+    }
+    expect: {
+        export default 42;
+        export default (x, y) => x * x;
+        export default class extends B { get p() { h() } }
+        export default function*(a, b) {}
+        export default async function({}) {}
+        export var e;
+        export function g(x, []) {}
+        function h() {}
+    }
+}
+
+mangle: {
+    rename = false
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        const a = 42;
+        export let b, { foo: c } = a;
+        export function f(d, { [b]: e }) {
+            d(e, f);
+        }
+        export default a;
+        export default async function g(x, ...{ [c]: y }) {
+            (await x)(g, y);
+        }
+    }
+    expect: {
+        const t = 42;
+        export let b, { foo: c } = t;
+        export function f(t, { [b]: o }) {
+            t(o, f);
+        }
+        export default t;
+        export default async function e(t, ...{ [c]: o}) {
+            (await t)(e, o);
+        }
+    }
+}
+
+mangle_rename: {
+    rename = true
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        const a = 42;
+        export let b, { foo: c } = a;
+        export function f(d, { [b]: e }) {
+            d(e, f);
+        }
+        export default a;
+        export default async function g(x, ...{ [c]: y }) {
+            (await x)(g, y);
+        }
+    }
+    expect: {
+        const t = 42;
+        export let b, { foo: c } = t;
+        export function f(t, { [b]: o }) {
+            t(o, f);
+        }
+        export default t;
+        export default async function e(t, ...{ [c]: o}) {
+            (await t)(e, o);
+        }
+    }
+}
+
+hoist_exports: {
+    options = {
+        evaluate: true,
+        hoist_exports: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        const a = 42;
+        export let bbb, { foo: ccc } = a;
+        export function fff(d, { [bbb]: e }) {
+            d(e, fff);
+        }
+        export default a;
+        export default async function g(x, ...{ [ccc]: y }) {
+            (await x)(g, y);
+        }
+    }
+    expect: {
+        let f, { foo: o } = 42;
+        function c(t, { [f]: a }) {
+            t(a, c);
+        }
+        export default 42;
+        export default async function e(t, ...{ [o]: a }) {
+            (await t)(e, a);
+        };
+        export { f as bbb, o as ccc, c as fff };
+    }
+}
+
+hoist_vars: {
+    options = {
+        hoist_vars: true,
+    }
+    input: {
+        var a;
+        export var b = 42;
+    }
+    expect: {
+        var a;
+        export var b = 42;
+    }
+}
+
+keep_return_values: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        export default function() {
+            return [];
+        }
+        export default function f() {
+            return null;
+        }
+    }
+    expect: {
+        export default function() {
+            return [];
+        }
+        export default function f() {
+            return null;
+        }
+    }
+}
+
+in_use: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f() {}
+        f.prototype.p = 42;
+    }
+    expect: {
+        export function f() {}
+        f.prototype.p = 42;
+    }
+}
+
+in_use_default: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f() {}
+        f.prototype.p = 42;
+    }
+    expect: {
+        export default function f() {}
+        f.prototype.p = 42;
+    }
+}
+
+single_use: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f() {
+            console.log("PASS");
+        }
+        f();
+    }
+    expect: {
+        export function f() {
+            console.log("PASS");
+        }
+        f();
+    }
+}
+
+single_use_default: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f() {
+            console.log("PASS");
+        }
+        f();
+    }
+    expect: {
+        export default function f() {
+            console.log("PASS");
+        }
+        f();
+    }
+}
+
+single_use_class: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export class A {}
+        A.prototype.p = "PASS";
+    }
+    expect: {
+        export class A {}
+        A.prototype.p = "PASS";
+    }
+}
+
+single_use_class_default: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class A {}
+        A.prototype.p = "PASS";
+    }
+    expect: {
+        export default class A {}
+        A.prototype.p = "PASS";
+    }
+}

test/compress/functions.js

@@ -229,7 +229,7 @@ issue_203: {
     }
     expect: {
         var m = {};
-        var fn = Function("n,o", "o.exports=42");
+        var fn = Function("n,o,t", "o.exports=42");
         fn(null, m, m.exports);
         console.log(m.exports);
     }
@@ -2053,7 +2053,7 @@ issue_2898: {
     expect_stdout: "2"
 }
 
-deduplicate_parenthesis: {
+deduplicate_parentheses: {
     input: {
         ({}).a = b;
         (({}).a = b)();
@@ -2175,7 +2175,7 @@ issue_3016_3: {
     expect: {
         var b = 1;
         do {
-            console.log((a = void 0, a ? "FAIL" : a = "PASS"));
+            console.log((a = void 0, a ? "FAIL" : "PASS"));
         } while (b--);
         var a;
     }
@@ -2208,7 +2208,7 @@ issue_3016_3_ie8: {
     expect: {
         var b = 1;
         do {
-            console.log((a = void 0, a ? "FAIL" : a = "PASS"));
+            console.log((a = void 0, a ? "FAIL" : "PASS"));
         } while (b--);
         var a;
     }
@@ -3322,7 +3322,9 @@ issue_3506_1: {
     }
     expect: {
         var a = "FAIL";
-        a && (a = "PASS");
+        !function(b) {
+            b && (a = "PASS");
+        }(a);
         console.log(a);
     }
     expect_stdout: "PASS"
@@ -4230,7 +4232,7 @@ substitute: {
 substitute_add_farg: {
     options = {
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
     }
     input: {
         function f(g) {
@@ -4411,7 +4413,9 @@ substitute_drop_farg: {
                 return f;
             },
             function() {
-                return f;
+                return function(d, e) {
+                    return f(d, e);
+                };
             },
         ].forEach(function(g) {
             console.log(g()(o), g().call(o, o));
@@ -4594,7 +4598,7 @@ substitute_use_strict: {
 issue_3833: {
     options = {
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -4751,7 +4755,7 @@ issue_4006: {
         dead_code: true,
         evaluate: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -5014,9 +5018,12 @@ catch_no_argname: {
         try {
             throw a;
         } catch {
-            console.log(a, a, a);
+            function g() {
+                return a;
+            }
+            console.log(a, a, g());
         }
-        console.log(a, a, a);
+        console.log(a, a, g());
     }
     expect_stdout: [
         "PASS PASS PASS",
@@ -5132,8 +5139,8 @@ issue_4259: {
         console.log(typeof a);
     }
     expect: {
-        function a() {
-            for (a in a);
+        var a = function b() {
+            for (b in b);
         }
         a();
         console.log(typeof a);
@@ -5223,3 +5230,471 @@ trailing_comma: {
     expect_exact: 'new function(a,b){console.log(b,a)}(42,"PASS");'
     expect_stdout: "PASS 42"
 }
+
+issue_4451: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function f() {
+            for (f in "foo")
+                return f;
+        };
+        while (console.log(typeof a()));
+    }
+    expect: {
+        var a = function f() {
+            for (f in "foo")
+                return f;
+        };
+        while (console.log(typeof a()));
+    }
+    expect_stdout: "function"
+}
+
+issue_4471: {
+    options = {
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        f(f());
+        function f() {
+            return g();
+        }
+        function g() {
+            {
+                console.log("PASS");
+            }
+        }
+    }
+    expect: {
+        f(g());
+        function f() {
+            return g();
+        }
+        function g() {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: [
+        "PASS",
+        "PASS",
+    ]
+}
+
+issue_4612_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            function f() {
+                return g();
+            }
+            function g(a) {
+                return a || f();
+            }
+            return g("PASS");
+        }());
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4612_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            function fn() {
+                return h();
+            }
+            function g() {
+                return fn();
+            }
+            function h(a) {
+                return a || fn();
+            }
+            return h("PASS");
+        }());
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4612_3: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(typeof function() {
+            return g();
+            function f() {
+                return g;
+            }
+            function g() {
+                {
+                    return f;
+                }
+            }
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            return g();
+            function f() {
+                return g;
+            }
+            function g() {
+                return f;
+            }
+        }());
+    }
+    expect_stdout: "function"
+}
+
+issue_4612_4: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            function f() {
+                return h();
+            }
+            function g() {
+                {
+                    return h();
+                }
+            }
+            function h() {
+                {
+                    return g();
+                }
+            }
+        }());
+    }
+    expect: {
+        console.log(function() {
+            function f() {
+                return h();
+            }
+            function g() {
+                return h();
+            }
+            function h() {
+                return g();
+            }
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4655: {
+    options = {
+        functions: true,
+        loops: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function f() {
+            while (console.log("PASS")) {
+                var g = function() {};
+                for (var a in g)
+                    g();
+            }
+        })();
+    }
+    expect: {
+        (function() {
+            for (; console.log("PASS");) {
+                function g() {};
+            }
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4659_1: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+    }
+    input: {
+        var a = 0;
+        (function() {
+            function f() {
+                return a++;
+            }
+            (function() {
+                f && f();
+                (function() {
+                    var a = console && a;
+                })();
+            })();
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = 0;
+        (function() {
+            function f() {
+                return a++;
+            }
+            (function() {
+                f && a++;
+                (function() {
+                    var a = console && a;
+                })();
+            })();
+        })();
+        console.log(a);
+    }
+    expect_stdout: "1"
+}
+
+issue_4659_2: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+    }
+    input: {
+        var a = 0;
+        (function() {
+            function f() {
+                return a++;
+            }
+            (function() {
+                (function() {
+                    f && f();
+                })();
+                (function() {
+                    var a = console && a;
+                })();
+            })();
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = 0;
+        (function() {
+            function f() {
+                return a++;
+            }
+            (function() {
+                void (f && a++);
+                (function() {
+                    var a = console && a;
+                })();
+            })();
+        })();
+        console.log(a);
+    }
+    expect_stdout: "1"
+}
+
+issue_4659_3: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        (function() {
+            function f() {
+                return a++;
+            }
+            (function() {
+                function g() {
+                    while (!console);
+                }
+                g(f && f());
+                (function() {
+                    var a = console && a;
+                })();
+            })();
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = 0;
+        (function() {
+            function f() {
+                return a++;
+            }
+            (function() {
+                (function() {
+                    while (!console);
+                })(f && a++);
+                (function() {
+                    var a = console && a;
+                })();
+            })();
+        })();
+        console.log(a);
+    }
+    expect_stdout: "1"
+}
+
+block_scope_1: {
+    input: {
+        console.log(typeof f);
+        function f() {}
+    }
+    expect: {
+        console.log(typeof f);
+        function f() {}
+    }
+    expect_stdout: "function"
+}
+
+block_scope_1_compress: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        typeofs: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof f);
+        function f() {}
+    }
+    expect: {
+        console.log("function");
+    }
+    expect_stdout: "function"
+}
+
+block_scope_2: {
+    input: {
+        {
+            console.log(typeof f);
+        }
+        function f() {}
+    }
+    expect: {
+        console.log(typeof f);
+        function f() {}
+    }
+    expect_stdout: "function"
+}
+
+block_scope_2_compress: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        typeofs: true,
+        unused: true,
+    }
+    input: {
+        {
+            console.log(typeof f);
+        }
+        function f() {}
+    }
+    expect: {
+        console.log("function");
+    }
+    expect_stdout: "function"
+}
+
+block_scope_3: {
+    input: {
+        console.log(typeof f);
+        {
+            function f() {}
+        }
+    }
+    expect: {
+        console.log(typeof f);
+        {
+            function f() {}
+        }
+    }
+    expect_stdout: true
+}
+
+block_scope_3_compress: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        typeofs: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof f);
+        {
+            function f() {}
+        }
+    }
+    expect: {
+        console.log(typeof f);
+        {
+            function f() {}
+        }
+    }
+    expect_stdout: true
+}
+
+block_scope_4: {
+    input: {
+        {
+            console.log(typeof f);
+            function f() {}
+        }
+    }
+    expect: {
+        console.log(typeof f);
+        function f() {}
+    }
+    expect_stdout: "function"
+}
+
+block_scope_4_compress: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        typeofs: true,
+        unused: true,
+    }
+    input: {
+        {
+            console.log(typeof f);
+            function f() {}
+        }
+    }
+    expect: {
+        console.log("function");
+    }
+    expect_stdout: "function"
+}

test/compress/hoist_props.js

@@ -1068,3 +1068,29 @@ issue_4023: {
     }
     expect_stdout: "true"
 }
+
+object_super: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var o = {
+            f(a) {
+                return a ? console.log("PASS") : super.log("PASS");
+            },
+        };
+        o.f(42);
+    }
+    expect: {
+        var o = {
+            f(a) {
+                return a ? console.log("PASS") : super.log("PASS");
+            },
+        };
+        o.f(42);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/hoist_vars.js

@@ -89,6 +89,31 @@ sequences_funs: {
     }
 }
 
+catch_var: {
+    options = {
+        dead_code: true,
+        hoist_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            a;
+        } catch (a) {
+            var a = 0;
+            a;
+        }
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
 issue_2295: {
     options = {
         collapse_vars: true,
@@ -109,3 +134,76 @@ issue_2295: {
         }
     }
 }
+
+issue_4487: {
+    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: {
+        function a() {
+            var a = console.log(typeof a);
+        }
+        a();
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4489: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        hoist_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        A = 0;
+        var o = !0 || null;
+        for (var k in o);
+        console.log(k);
+    }
+    expect: {
+        !(A = 0);
+        for (var k in true);
+        console.log(k);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4517: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+        join_vars: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = 2;
+            A = a;
+            var b = typeof !1;
+            return A + b;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var a = 2;
+            A = a;
+            return A + typeof !1;
+        }());
+    }
+    expect_stdout: "2boolean"
+}

test/compress/ie8.js

@@ -2900,3 +2900,22 @@ issue_4250: {
     }
     expect_stdout: "0"
 }
+
+issue_4568: {
+    options = {
+        ie8: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof f, function(a) {
+            return a.length;
+        }([ function f() {} ]));
+    }
+    expect: {
+        console.log(typeof f, function(a) {
+            return a.length;
+        }([ function f() {} ]));
+    }
+    expect_stdout: "undefined 1"
+}

test/compress/imports.js

@@ -0,0 +1,202 @@
+nought: {
+    input: {
+        import "foo";
+    }
+    expect_exact: 'import"foo";'
+}
+
+default_only: {
+    input: {
+        import foo from "bar";
+    }
+    expect_exact: 'import foo from"bar";'
+}
+
+all_only: {
+    input: {
+        import * as foo from "bar";
+    }
+    expect_exact: 'import*as foo from"bar";'
+}
+
+keys_only: {
+    input: {
+        import { as as foo, bar, delete as baz } from "moo";
+    }
+    expect_exact: 'import{as as foo,bar as bar,delete as baz}from"moo";'
+}
+
+default_all: {
+    input: {
+        import foo, * as bar from "baz";
+    }
+    expect_exact: 'import foo,*as bar from"baz";'
+}
+
+default_keys: {
+    input: {
+        import foo, { bar } from "baz";
+    }
+    expect_exact: 'import foo,{bar as bar}from"baz";'
+}
+
+dynamic: {
+    input: {
+        (async a => await import(a))("foo").then(bar);
+    }
+    expect_exact: '(async a=>await import(a))("foo").then(bar);'
+}
+
+dynamic_nought: {
+    input: {
+        import(foo);
+    }
+    expect_exact: "import(foo);"
+}
+
+import_meta: {
+    input: {
+        console.log(import.meta, import.meta.url);
+    }
+    expect_exact: "console.log(import.meta,import.meta.url);"
+}
+
+same_quotes: {
+    beautify = {
+        beautify: true,
+        quote_style: 3,
+    }
+    input: {
+        import 'foo';
+        import "bar";
+    }
+    expect_exact: [
+        "import 'foo';",
+        "",
+        'import "bar";',
+    ]
+}
+
+drop_unused: {
+    options = {
+        imports: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        import a, * as b from "foo";
+        import { c, bar as d } from "baz";
+        console.log(c);
+    }
+    expect: {
+        import "foo";
+        import { c as c } from "baz";
+        console.log(c);
+    }
+}
+
+mangle: {
+    rename = false
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        import foo, { bar } from "baz";
+        consoe.log(moo);
+        import * as moo from "moz";
+    }
+    expect: {
+        import o, { bar as m } from "baz";
+        consoe.log(r);
+        import * as r from "moz";
+    }
+}
+
+rename_mangle: {
+    rename = true
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        import foo, { bar } from "baz";
+        consoe.log(moo);
+        import * as moo from "moz";
+    }
+    expect: {
+        import o, { bar as m } from "baz";
+        consoe.log(r);
+        import * as r from "moz";
+    }
+}
+
+keep_ref: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        import foo from "bar";
+        foo();
+    }
+    expect: {
+        import foo from "bar";
+        foo();
+    }
+}
+
+forbid_merge: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        import A from "foo";
+        export default class extends A {}
+        var f = () => () => {};
+        f();
+        f();
+    }
+    expect: {
+        import A from "foo";
+        export default class extends A {}
+        var f = () => () => {};
+        f();
+        f();
+    }
+}
+
+issue_4708_1: {
+    options = {
+        imports: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        import a from "foo";
+    }
+    expect: {
+        var a;
+        import a from "foo";
+    }
+}
+
+issue_4708_2: {
+    options = {
+        imports: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a;
+        console.log(a);
+        import a from "foo";
+    }
+    expect: {
+        var a;
+        console.log(a);
+        import a from "foo";
+    }
+}

test/compress/issue-12.js

@@ -2,61 +2,77 @@ keep_name_of_getter: {
     options = {
         unused: true,
     }
-    input: { a = { get foo () {} } }
-    expect: { a = { get foo () {} } }
+    input: {
+        a = {
+            get foo() {},
+        };
+    }
+    expect: {
+        a = {
+            get foo() {},
+        };
+    }
 }
 
 keep_name_of_setter: {
     options = {
         unused: true,
     }
-    input: { a = { set foo () {} } }
-    expect: { a = { set foo () {} } }
+    input: {
+        a = {
+            set foo(v) {},
+        };
+    }
+    expect: {
+        a = {
+            set foo(v) {},
+        };
+    }
 }
 
 setter_with_operator_keys: {
     input: {
-        var tokenCodes  = {
-            get instanceof(){
+        var tokenCodes = {
+            get instanceof() {
                 return test0;
             },
-            set instanceof(value){
+            set instanceof(value) {
                 test0 = value;
             },
-            set typeof(value){
+            set typeof(value) {
                 test1 = value;
             },
-            get typeof(){
+            get typeof() {
                 return test1;
             },
-            set else(value){
+            set else(value) {
                 test2 = value;
             },
-            get else(){
+            get else() {
                 return test2;
-            }
+            },
         };
     }
     expect: {
-        var tokenCodes  = {
-            get instanceof(){
+        var tokenCodes = {
+            get instanceof() {
                 return test0;
             },
-            set instanceof(value){
+            set instanceof(value) {
                 test0 = value;
             },
-            set typeof(value){
+            set typeof(value) {
                 test1 = value;
             },
-            get typeof(){
+            get typeof() {
                 return test1;
             },
-            set else(value){
+            set else(value) {
                 test2 = value;
             },
-            get else(){
+            get else() {
                 return test2;
-            }
+            },
         };
     }
-}
+}

test/compress/issue-269.js

@@ -17,7 +17,7 @@ issue_269_1: {
     expect: {
         var x = {};
         console.log(
-            x + "", +x, !!x,
+            "" + x, +("" + x), !!x,
             "", 0, false
         );
     }

test/compress/issue-976.js

@@ -63,42 +63,81 @@ eval_unused: {
         unused: true,
     }
     input: {
-        function f1(a, eval, c, d, e) {
-            return a('c') + eval;
-        }
-        function f2(a, b, c, d, e) {
-            return a + eval('c');
-        }
-        function f3(a, eval, c, d, e) {
-            return a + eval('c');
+        function o(k) {
+            return { c: 14 }[k];
         }
+        console.log(function f1(a, eval, c, d, e) {
+            return a("c") + eval;
+        }(o, 28, true));
+        console.log(function f2(a, b, c, d, e) {
+            return a + eval("c");
+        }(14, true, 28));
+        console.log(function f3(a, eval, c, d, e) {
+            return a + eval("c");
+        }(28, o, true));
     }
     expect: {
-        function f1(a, eval) {
-            return a('c') + eval;
-        }
-        function f2(a, b, c, d, e) {
-            return a + eval('c');
-        }
-        function f3(a, eval, c, d, e) {
-            return a + eval('c');
+        function o(k) {
+            return { c: 14 }[k];
         }
+        console.log(function(a, eval) {
+            return a("c") + eval;
+        }(o, 28));
+        console.log(function f2(a, b, c, d, e) {
+            return a + eval("c");
+        }(14, true, 28));
+        console.log(function f3(a, eval, c, d, e) {
+            return a + eval("c");
+        }(28, o, true));
     }
+    expect_stdout: [
+        "42",
+        "42",
+        "42",
+    ]
 }
 
 eval_mangle: {
-    mangle = {
-    };
-    input: {
-        function f1(a, eval, c, d, e) {
-            return a('c') + eval;
-        }
-        function f2(a, b, c, d, e) {
-            return a + eval('c');
-        }
-        function f3(a, eval, c, d, e) {
-            return a + eval('c');
-        }
+    mangle = {}
+    beautify = {
+        beautify: true,
     }
-    expect_exact: 'function f1(n,c,e,a,f){return n("c")+c}function f2(a,b,c,d,e){return a+eval("c")}function f3(a,eval,c,d,e){return a+eval("c")}'
+    input: {
+        function o(k) {
+            return { cc: 14 }[k + "c"];
+        }
+        console.log(function f1(a, eval, c, d, e) {
+            return a("c") + eval;
+        }(o, 28, true));
+        console.log(function f2(a, b, c, d, e) {
+            return a + eval("c");
+        }(14, true, 28));
+        console.log(function f3(a, eval, c, d, e) {
+            return a + eval("c");
+        }(28, o, true));
+    }
+    expect_exact: [
+        "function o(o) {",
+        "    return {",
+        "        cc: 14",
+        '    }[o + "c"];',
+        "}",
+        "",
+        "console.log(function o(c, e, n, r, t) {",
+        '    return c("c") + e;',
+        "}(o, 28, true));",
+        "",
+        "console.log(function f2(a, b, c, d, e) {",
+        '    return a + eval("c");',
+        "}(14, true, 28));",
+        "",
+        "console.log(function f3(a, eval, c, d, e) {",
+        '    return a + eval("c");',
+        "}(28, o, true));",
+    ]
+    expect_stdout: [
+        "42",
+        "42",
+        "42",
+    ]
 }

test/compress/join_vars.js

@@ -790,7 +790,7 @@ issue_3795: {
         dead_code: true,
         evaluate: true,
         join_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         loops: true,
         passes: 2,
         reduce_vars: true,
@@ -1055,3 +1055,75 @@ issue_3916: {
     }
     expect_stdout: "object PASS true PASS"
 }
+
+assign_var: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        b = "foo";
+        var a = [ , "bar" ];
+        console.log(b);
+        for (var b in a)
+            console.log(b, a[b]);
+    }
+    expect: {
+        var b = "foo", a = [ , "bar" ], b;
+        console.log(b);
+        for (b in a)
+            console.log(b, a[b]);
+    }
+    expect_stdout: [
+        "foo",
+        "1 bar",
+    ]
+}
+
+assign_for_var: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        i = "foo",
+        a = new Array(i, "bar");
+        for (var i = 2; --i >= 0;) {
+            console.log(a[i]);
+            for (var a in i);
+        }
+    }
+    expect: {
+        for (var i = "foo", a = new Array(i, "bar"), i = 2; --i >= 0;) {
+            console.log(a[i]);
+            for (var a in i);
+        }
+    }
+    expect_stdout: [
+        "bar",
+        "foo",
+    ]
+}
+
+assign_sequence_var: {
+    options = {
+        join_vars: true,
+    }
+    input: {
+        var a = 0, b = 1;
+        console.log(a),
+        a++,
+        b = 2;
+        var c = 3;
+        console.log(a, b, c);
+    }
+    expect: {
+        var a = 0, b = 1;
+        console.log(a),
+        a++;
+        var b = 2, c = 3;
+        console.log(a, b, c);
+    }
+    expect_stdout: [
+        "0",
+        "1 2 3",
+    ]
+}

test/compress/keep_fargs.js

@@ -18,43 +18,6 @@ keep_fargs_false: {
         function j(e) {}
         console.log(h(), i().length, j.length);
     }
-    expect: {
-        console.log(function f() {
-            return f.length;
-        }(), function g() {
-            return g;
-        }().length);
-        function h() {
-            return h.length;
-        }
-        function i() {
-            return i;
-        }
-        function j() {}
-        console.log(h(), i().length, j.length);
-    }
-}
-
-keep_fargs_strict: {
-    options = {
-        keep_fargs: "strict",
-        unused: true,
-    }
-    input: {
-        console.log(function f(a) {
-            return f.length;
-        }(), function g(b) {
-            return g;
-        }().length);
-        function h(c) {
-            return h.length;
-        }
-        function i(d) {
-            return i;
-        }
-        function j(e) {}
-        console.log(h(), i().length, j.length);
-    }
     expect: {
         console.log(function f(a) {
             return f.length;
@@ -117,61 +80,11 @@ keep_fargs_true: {
     ]
 }
 
-replace_index: {
-    options = {
-        arguments: true,
-        evaluate: true,
-        keep_fargs: "strict",
-        properties: true,
-    }
-    input: {
-        var arguments = [];
-        console.log(arguments[0]);
-        (function() {
-            console.log(arguments[1], arguments["1"], arguments["foo"]);
-        })("bar", 42);
-        (function(a, b) {
-            console.log(arguments[1], arguments["1"], arguments["foo"]);
-        })("bar", 42);
-        (function(arguments) {
-            console.log(arguments[1], arguments["1"], arguments["foo"]);
-        })("bar", 42);
-        (function() {
-            var arguments;
-            console.log(arguments[1], arguments["1"], arguments["foo"]);
-        })("bar", 42);
-    }
-    expect: {
-        var arguments = [];
-        console.log(arguments[0]);
-        (function(argument_0, argument_1) {
-            console.log(argument_1, argument_1, arguments.foo);
-        })("bar", 42);
-        (function(a, b) {
-            console.log(b, b, arguments.foo);
-        })("bar", 42);
-        (function(arguments) {
-            console.log(arguments[1], arguments[1], arguments.foo);
-        })("bar", 42);
-        (function() {
-            var arguments;
-            console.log(arguments[1], arguments[1], arguments.foo);
-        })("bar", 42);
-    }
-    expect_stdout: [
-        "undefined",
-        "42 42 undefined",
-        "42 42 undefined",
-        "a a undefined",
-        "42 42 undefined",
-    ]
-}
-
 replace_index_strict: {
     options = {
         arguments: true,
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         properties: true,
         reduce_vars: true,
     }
@@ -202,7 +115,7 @@ replace_index_strict: {
 issue_1858: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         pure_getters: true,
         unused: true,
     }
@@ -224,7 +137,7 @@ issue_1858: {
 issue_2187_2: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -245,7 +158,7 @@ issue_2187_2: {
 issue_2203_2: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -280,7 +193,7 @@ issue_2203_2: {
 issue_2298: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
@@ -323,7 +236,7 @@ issue_2298: {
 issue_2319_1: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -346,7 +259,7 @@ issue_2319_1: {
 issue_2319_2: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -371,7 +284,7 @@ issue_2319_2: {
 issue_2319_3: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -396,7 +309,7 @@ issue_2319_3: {
 issue_2425_1: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -419,7 +332,7 @@ issue_2425_1: {
 issue_2425_2: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -442,7 +355,7 @@ issue_2425_2: {
 issue_2425_3: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -465,7 +378,7 @@ issue_2425_3: {
 issue_2436_13: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_vars: true,
         unused: true,
@@ -499,7 +412,7 @@ issue_2436_13: {
 issue_2506: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_vars: true,
         unused: true,
@@ -525,7 +438,7 @@ issue_2506: {
         function f0(bar) {
             (function() {
                 (function() {
-                    if (false <= NaN & this >> 1 >= 0)
+                    if (false <= 0/0 & this >> 1 >= 0)
                         c++;
                 })(c++);
             })();
@@ -538,7 +451,7 @@ issue_2506: {
 
 issue_2226_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         side_effects: true,
         unused: true,
     }
@@ -585,7 +498,7 @@ issue_2226_1: {
 issue_2226_2: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         sequences: true,
         side_effects: true,
         unused: true,
@@ -607,7 +520,7 @@ issue_2226_2: {
 issue_2226_3: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         side_effects: true,
         unused: true,
     }
@@ -627,7 +540,7 @@ issue_2226_3: {
 
 issue_3192: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -657,7 +570,7 @@ issue_3192: {
 if_increment: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -679,7 +592,7 @@ if_increment: {
 try_increment: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -703,7 +616,7 @@ try_increment: {
 issue_2630_3: {
     options = {
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -740,7 +653,7 @@ issue_2630_3: {
 issue_3364: {
     options = {
         functions: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         toplevel: true,
         unused: true,
@@ -805,7 +718,7 @@ issue_3364: {
 
 defun_label: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
@@ -837,7 +750,7 @@ defun_label: {
 
 iife_func_side_effects: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
@@ -889,7 +802,7 @@ iife_func_side_effects: {
 issue_1595_1: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
@@ -909,7 +822,7 @@ issue_1595_1: {
 issue_1595_2: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
@@ -929,7 +842,7 @@ issue_1595_2: {
 issue_1595_3: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
@@ -950,7 +863,7 @@ issue_1595_3: {
 issue_1595_4: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_funcs: true,
         reduce_vars: true,
         unused: true,
@@ -972,7 +885,7 @@ issue_1595_4: {
 
 duplicate_lambda_defun_name_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
     }
     input: {
@@ -992,7 +905,7 @@ duplicate_lambda_defun_name_1: {
 
 duplicate_lambda_defun_name_2: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_vars: true,
         unused: true,
@@ -1013,7 +926,7 @@ duplicate_lambda_defun_name_2: {
 
 function_name_mangle: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         keep_fnames: true,
         reduce_vars: true,
         unused: true,
@@ -1031,7 +944,7 @@ function_name_mangle: {
 
 function_name_mangle_ie8: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         keep_fnames: true,
         reduce_vars: true,
         unused: true,
@@ -1052,7 +965,7 @@ function_name_mangle_ie8: {
 
 issue_3420_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1075,7 +988,7 @@ issue_3420_1: {
 issue_3420_2: {
     options = {
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1096,7 +1009,7 @@ issue_3420_2: {
 issue_3420_3: {
     options = {
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -1118,7 +1031,7 @@ issue_3420_3: {
 
 issue_3423_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1138,7 +1051,7 @@ issue_3423_1: {
 
 issue_3423_2: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1165,7 +1078,7 @@ collapse_vars_repeated: {
         hoist_funs: true,
         if_return: true,
         join_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         loops: true,
         properties: true,
         reduce_funcs: true,
@@ -1212,7 +1125,7 @@ collapse_vars_repeated: {
 chained_3: {
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1236,7 +1149,7 @@ replace_all_var_scope: {
     rename = true
     options = {
         collapse_vars: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     mangle = {}
@@ -1265,7 +1178,7 @@ replace_all_var_scope: {
 
 issue_1583: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_funcs: true,
         reduce_vars: true,
@@ -1302,7 +1215,7 @@ issues_3267_1: {
         dead_code: true,
         evaluate: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -1331,7 +1244,7 @@ issues_3267_1: {
 
 trailing_argument_side_effects: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -1355,7 +1268,7 @@ trailing_argument_side_effects: {
 
 recursive_iife_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -1374,7 +1287,7 @@ recursive_iife_1: {
 
 recursive_iife_2: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -1455,7 +1368,7 @@ issue_3619: {
 
 issue_4353_1: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }
@@ -1470,7 +1383,7 @@ issue_4353_1: {
 
 issue_4353_2: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         unused: true,
     }

test/compress/labels.js

@@ -207,3 +207,123 @@ labels_10: {
         }
     }
 }
+
+issue_4466_1: {
+    mangle = {
+        v8: false,
+    }
+    input: {
+        A: if (console.log("PASS"))
+            B:;
+        else
+            C:;
+    }
+    expect: {
+        e: if (console.log("PASS"))
+            l:;
+        else
+            l:;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+issue_4466_1_v8: {
+    mangle = {
+        v8: true,
+    }
+    input: {
+        A: if (console.log("PASS"))
+            B:;
+        else
+            C:;
+    }
+    expect: {
+        e: if (console.log("PASS"))
+            l:;
+        else
+            o:;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=12"
+}
+
+issue_4466_2: {
+    mangle = {
+        toplevel: false,
+        v8: false,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            e:;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4466_2_v8: {
+    mangle = {
+        toplevel: false,
+        v8: true,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            l:;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4466_2_toplevel: {
+    mangle = {
+        toplevel: true,
+        v8: false,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            e:;
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4466_2_toplevel_v8: {
+    mangle = {
+        toplevel: true,
+        v8: true,
+    }
+    input: {
+        if (console.log("PASS"))
+            A:;
+        else
+            B:;
+    }
+    expect: {
+        if (console.log("PASS"))
+            e:;
+        else
+            e:;
+    }
+    expect_stdout: "PASS"
+}

test/compress/let.js

@@ -359,6 +359,28 @@ reduce_block_2_toplevel: {
     node_version: ">=4"
 }
 
+reduce_vars: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        let a = "PASS";
+        console.log(a);
+        a = "FAIL";
+    }
+    expect: {
+        "use strict";
+        console.log("PASS");
+        "FAIL";
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
 hoist_props: {
     options = {
         hoist_props: true,
@@ -1228,3 +1250,157 @@ issue_1753_toplevel: {
     expect_stdout: "0"
     node_version: ">=4"
 }
+
+issue_4438: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        function f() {
+            if (console) {
+                {
+                    let a = console.log;
+                    return void a("PASS");
+                }
+            }
+        }
+        f();
+    }
+    expect: {
+        "use strict";
+        function f() {
+            if (!console)
+                ;
+            else {
+                let a = console.log;
+                a("PASS");
+            }
+        }
+        f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4531_1: {
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        var a;
+        console.log(function a() {
+            let a;
+            var b;
+        }());
+    }
+    expect: {
+        "use strict";
+        var o;
+        console.log(function o() {
+            let o;
+            var t;
+        }());
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_4531_2: {
+    options = {
+        evaluate: true,
+        ie8: true,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        var a = console;
+        console.log(typeof a, function a() {
+            let { [console]: a } = 0 && a;
+            var b = console;
+            while (!b);
+        }());
+    }
+    expect: {
+        var o = console;
+        console.log(typeof o, function o() {
+            let { [console]: o } = 0;
+            var e = console;
+            while (!e);
+        }());
+    }
+    expect_stdout: "object undefined"
+    node_version: ">=6"
+}
+
+issue_4689: {
+    options = {
+        sequences: true,
+    }
+    input: {
+        "use strict";
+        var a = "PASS";
+        console.log(a);
+        for (let a in 42);
+    }
+    expect: {
+        "use strict";
+        var a = "PASS";
+        console.log(a);
+        for (let a in 42);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4691: {
+    options = {
+        if_return: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        function A() {}
+        A.prototype.f = function() {
+            if (!this)
+                return;
+            let a = "PA";
+            function g(b) {
+                h(a + b);
+            }
+            [ "SS" ].forEach(function(c) {
+                g(c);
+            });
+        };
+        function h(d) {
+            console.log(d);
+        }
+        new A().f();
+    }
+    expect: {
+        "use strict";
+        function A() {}
+        A.prototype.f = function() {
+            if (this) {
+                let a = "PA";
+                [ "SS" ].forEach(function(c) {
+                    g(c);
+                });
+                function g(b) {
+                    h(a + b);
+                }
+            }
+        };
+        function h(d) {
+            console.log(d);
+        }
+        new A().f();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/loops.js

@@ -501,14 +501,14 @@ do_switch: {
     }
 }
 
-in_parenthesis_1: {
+in_parentheses_1: {
     input: {
         for (("foo" in {});0;);
     }
     expect_exact: 'for(("foo"in{});0;);'
 }
 
-in_parenthesis_2: {
+in_parentheses_2: {
     input: {
         for ((function(){ "foo" in {}; });0;);
     }
@@ -828,6 +828,21 @@ empty_for_in_prop_init: {
     ]
 }
 
+for_of: {
+    input: {
+        var async = [ "PASS", 42 ];
+        async.p = "FAIL";
+        for (async of (null, async))
+            console.log(async);
+    }
+    expect_exact: 'var async=["PASS",42];async.p="FAIL";for(async of(null,async))console.log(async);'
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=0.12"
+}
+
 issue_3631_1: {
     options = {
         dead_code: true,
@@ -1026,7 +1041,7 @@ issue_4075: {
 
 issue_4082: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         loops: true,
         unused: true,
     }
@@ -1050,9 +1065,8 @@ issue_4082: {
 
 issue_4084: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         loops: true,
-        passes: 2,
         reduce_vars: true,
         unused: true,
     }
@@ -1261,6 +1275,7 @@ issue_4355: {
         dead_code: true,
         evaluate: true,
         loops: true,
+        passes: 2,
         side_effects: true,
         unused: true,
     }
@@ -1280,3 +1295,33 @@ issue_4355: {
     }
     expect_stdout: "PASS"
 }
+
+issue_4564: {
+    options = {
+        loops: true,
+        unused: true,
+    }
+    input: {
+        try {
+            throw null;
+        } catch (a) {
+            var a;
+            (function() {
+                for (a in "foo");
+            })();
+            console.log(a);
+        }
+    }
+    expect: {
+        try {
+            throw null;
+        } catch (a) {
+            var a;
+            (function() {
+                for (a in "foo");
+            })();
+            console.log(a);
+        }
+    }
+    expect_stdout: "2"
+}

test/compress/merge_vars.js

@@ -327,7 +327,7 @@ issue_4103: {
 
 issue_4107: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         merge_vars: true,
         reduce_vars: true,
         unused: true,
@@ -3183,3 +3183,59 @@ issue_4257: {
         "1",
     ]
 }
+
+issue_4628: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function() {
+            try {
+                console;
+            } finally {
+                var b = a;
+            }
+            for (var a in "foo");
+            console.log(b);
+        })();
+    }
+    expect: {
+        (function() {
+            try {
+                console;
+            } finally {
+                var b = a;
+            }
+            for (var a in "foo");
+            console.log(b);
+        })();
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4653: {
+    options = {
+        evaluate: true,
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 1, b;
+        function f(c, d) {
+            c || console.log(d);
+        }
+        f(a++ + (b = b), b |= console.log(a));
+    }
+    expect: {
+        var b = 1;
+        (function(c, d) {
+            c || console.log(d);
+        })(+b + (b = void 0), b |= console.log(2));
+    }
+    expect_stdout: [
+        "2",
+        "0",
+    ]
+}

test/compress/new.js

@@ -85,7 +85,7 @@ new_with_unary_prefix: {
     expect_exact: 'var bar=(+new Date).toString(32);';
 }
 
-dot_parenthesis_1: {
+dot_parentheses_1: {
     input: {
         console.log(new (Math.random().constructor) instanceof Number);
     }
@@ -93,7 +93,7 @@ dot_parenthesis_1: {
     expect_stdout: "true"
 }
 
-dot_parenthesis_2: {
+dot_parentheses_2: {
     input: {
         console.log(typeof new function(){Math.random()}.constructor);
     }

test/compress/nullish.js

@@ -0,0 +1,130 @@
+parentheses: {
+    input: {
+        (console.log("foo") || console.log("bar") ?? console.log("baz")) && console.log("moo");
+    }
+    expect_exact:'((console.log("foo")||console.log("bar"))??console.log("baz"))&&console.log("moo");'
+    expect_stdout: [
+        "foo",
+        "bar",
+        "baz",
+    ]
+    node_version: ">=14"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        void console.log("foo" ?? "bar") ?? console.log("baz");
+    }
+    expect: {
+        console.log("foo"),
+        console.log("baz");
+    }
+    expect_stdout: [
+        "foo",
+        "baz",
+    ]
+    node_version: ">=14"
+}
+
+conditional_assignment_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        console.log(function(a, b) {
+            b ?? (a = "FAIL");
+            return a;
+        }("PASS", !console));
+    }
+    expect: {
+        console.log(function(a, b) {
+            b ?? (a = "FAIL");
+            return a;
+        }("PASS", !console));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+conditional_assignment_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a, b = false;
+        a = "PASS",
+        b ?? (a = "FAIL"),
+        console.log(a);
+    }
+    expect: {
+        var a, b = false;
+        a = "PASS",
+        b ?? (a = "FAIL"),
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+conditional_assignment_3: {
+    options = {
+        conditionals: true,
+        join_vars: true,
+    }
+    input: {
+        var a, b = false;
+        a = "PASS",
+        b ?? (a = "FAIL"),
+        console.log(a);
+    }
+    expect: {
+        var a, b = false, a = "PASS";
+        b ?? (a = "FAIL"),
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+conditional_assignment_4: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        console.log(function(a) {
+            !console ?? (a = "FAIL");
+            return a;
+        }("PASS"));
+    }
+    expect: {
+        console.log(function(a) {
+            !console ?? (a = "FAIL");
+            return a;
+        }("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}
+
+issue_4679: {
+    options = {
+        comparisons: true,
+        ie8: true,
+    }
+    input: {
+        var a;
+        if (void 0 === (undefined ?? a))
+            console.log("PASS");
+    }
+    expect: {
+        var a;
+        if (void 0 === (undefined ?? a))
+            console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=14"
+}

test/compress/numbers.js

@@ -338,7 +338,7 @@ evaluate_3: {
         console.log(1 + Number(x) + 2);
     }
     expect: {
-        console.log(+x + 3);
+        console.log(+("" + x) + 3);
     }
 }
 
@@ -777,7 +777,7 @@ issue_1710: {
     expect_stdout: true
 }
 
-unary_binary_parenthesis: {
+unary_binary_parentheses: {
     options = {
         evaluate: true,
     }
@@ -1386,3 +1386,75 @@ issue_4142: {
     }
     expect_stdout: "0"
 }
+
+issue_4542_1: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a / (1 / (a[0] = 2));
+        }([ 3 ]));
+    }
+    expect: {
+        console.log(function(a) {
+            return a / (1 / (a[0] = 2));
+        }([ 3 ]));
+    }
+    expect_stdout: "4"
+}
+
+issue_4542_2: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a / (1 / --a[0]);
+        }([ 3 ]));
+    }
+    expect: {
+        console.log(function(a) {
+            return a / (1 / --a[0]);
+        }([ 3 ]));
+    }
+    expect_stdout: "4"
+}
+
+issue_4542_3: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a / (0 / (a[0] = 0, 1));
+        }([ 1 ]));
+    }
+    expect: {
+        console.log(function(a) {
+            return a / (0 / (a[0] = 0, 1));
+        }([ 1 ]));
+    }
+    expect_stdout: "NaN"
+}
+
+issue_4542_4: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(function(a) {
+            return a / (1 / (a.length = 1));
+        }([ 2, 3 ]));
+    }
+    expect: {
+        console.log(function(a) {
+            return a / (1 / (a.length = 1));
+        }([ 2, 3 ]));
+    }
+    expect_stdout: "2"
+}

test/compress/objects.js

@@ -280,6 +280,72 @@ shorthand_keywords: {
     node_version: ">=6"
 }
 
+object_super: {
+    input: {
+        var o = {
+            f() {
+                return super.p;
+            },
+            p: "FAIL",
+        };
+        Object.setPrototypeOf(o, { p: "PASS" });
+        console.log(o.f());
+    }
+    expect_exact: 'var o={f(){return super.p},p:"FAIL"};Object.setPrototypeOf(o,{p:"PASS"});console.log(o.f());'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+object_super_async: {
+    input: {
+        var o = {
+            async f() {
+                return super.p;
+            },
+            p: "FAIL",
+        };
+        Object.setPrototypeOf(o, { p: "PASS" });
+        o.f().then(console.log);
+    }
+    expect_exact: 'var o={async f(){return super.p},p:"FAIL"};Object.setPrototypeOf(o,{p:"PASS"});o.f().then(console.log);'
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+object_super_generator: {
+    input: {
+        var o = {
+            *f() {
+                yield super.p;
+            },
+            p: "FAIL",
+        };
+        Object.setPrototypeOf(o, { p: "PASS" });
+        console.log(o.f().next().value);
+    }
+    expect_exact: 'var o={*f(){yield super.p},p:"FAIL"};Object.setPrototypeOf(o,{p:"PASS"});console.log(o.f().next().value);'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+object_super_async_generator: {
+    input: {
+        var o = {
+            async *f() {
+                return super.p;
+            },
+            p: "FAIL",
+        };
+        Object.setPrototypeOf(o, { p: "PASS" });
+        o.f().next().then(function(v) {
+            console.log(v.value, v.done);
+        });
+    }
+    expect_exact: 'var o={async*f(){return super.p},p:"FAIL"};Object.setPrototypeOf(o,{p:"PASS"});o.f().next().then(function(v){console.log(v.value,v.done)});'
+    expect_stdout: "PASS true"
+    node_version: ">=10"
+}
+
 issue_4269_1: {
     options = {
         evaluate: true,

test/compress/properties.js

@@ -1378,3 +1378,25 @@ issue_3389: {
     }
     expect_stdout: "PASS"
 }
+
+object_super: {
+    options = {
+        properties: true,
+    }
+    input: {
+        ({
+            f(a) {
+                return a ? console.log("PASS") : super.log("PASS");
+            },
+        }).f(console);
+    }
+    expect: {
+        ({
+            f(a) {
+                return a ? console.log("PASS") : super.log("PASS");
+            },
+        }).f(console);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/pure_funcs.js

@@ -685,7 +685,7 @@ issue_3858: {
     options = {
         collapse_vars: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -711,7 +711,7 @@ inline_pure_call_1: {
     options = {
         collapse_vars: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -733,7 +733,7 @@ inline_pure_call_2: {
     options = {
         collapse_vars: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         sequences: true,
         side_effects: true,
@@ -756,7 +756,7 @@ inline_pure_call_3: {
         collapse_vars: true,
         evaluate: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         reduce_vars: true,
         toplevel: true,

test/compress/pure_getters.js

@@ -248,6 +248,35 @@ issue_2110_2: {
     expect_stdout: "function"
 }
 
+issue_2110_3: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+    }
+    input: {
+        function g() {
+            return this;
+        }
+        console.log(typeof function() {
+            function f() {}
+            f.g = g;
+            return f.g();
+        }());
+    }
+    expect: {
+        function g() {
+            return this;
+        }
+        console.log(typeof function() {
+            function f() {}
+            f.g = g;
+            return f.g();
+        }());
+    }
+    expect_stdout: "function"
+}
+
 set_immutable_1: {
     options = {
         collapse_vars: true,
@@ -979,6 +1008,7 @@ collapse_vars_2_strict: {
 collapse_rhs_true: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: true,
     }
     input: {
@@ -1015,6 +1045,7 @@ collapse_rhs_true: {
 collapse_rhs_false: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: false,
     }
     input: {
@@ -1051,6 +1082,7 @@ collapse_rhs_false: {
 collapse_rhs_strict: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: "strict",
     }
     input: {
@@ -1087,6 +1119,7 @@ collapse_rhs_strict: {
 collapse_rhs_setter: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         pure_getters: "strict",
     }
     input: {
@@ -1208,3 +1241,32 @@ issue_3427: {
     expect: {}
     expect_stdout: true
 }
+
+issue_4440: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        try {
+            (function() {
+                arguments = null;
+                console.log(arguments.p = "FAIL");
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (function() {
+                arguments = null;
+                console.log(arguments.p = "FAIL");
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/reduce_vars.js

@@ -2373,7 +2373,7 @@ redefine_farg_1: {
         function f(a) {
             return typeof a;
         }
-        function g() {
+        function g(a) {
             return "number";
         }
         function h(a, b) {
@@ -2460,6 +2460,7 @@ delay_def: {
         evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
+        side_effects: true,
         unused: true,
     }
     input: {
@@ -6928,7 +6929,7 @@ issue_3622: {
     options = {
         evaluate: true,
         inline: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         reduce_vars: true,
         sequences: true,
         toplevel: true,
@@ -7196,7 +7197,7 @@ issue_3894: {
 issue_3922: {
     options = {
         evaluate: true,
-        keep_fargs: "strict",
+        keep_fargs: false,
         pure_getters: "strict",
         reduce_vars: true,
         side_effects: true,
@@ -7601,3 +7602,32 @@ issue_4188_2: {
     }
     expect_stdout: "number undefined"
 }
+
+issue_4568: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        passes: 2,
+        reduce_vars: true,
+        sequences: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            a && console.log("FAIL");
+            if (1)
+                do {
+                    if (!console.log("PASS")) break;
+                } while (1);
+        })(!(0 !== delete NaN));
+    }
+    expect: {
+        (function(a) {
+            for (a && console.log("FAIL"), 1; console.log("PASS"); ) 1;
+        })(!(0 !== delete NaN));
+    }
+    expect_stdout: "PASS"
+}

test/compress/rests.js

@@ -0,0 +1,786 @@
+arrow_1: {
+    input: {
+        console.log.apply(console, ((...a) => a)("PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,((...a)=>a)("PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+arrow_2: {
+    input: {
+        console.log.apply(console, ((a, ...b) => b)("FAIL", "PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,((a,...b)=>b)("FAIL","PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+arrow_destructured_array_1: {
+    input: {
+        console.log.apply(console, (([ ...a ]) => a)("PASS"));
+    }
+    expect_exact: 'console.log.apply(console,(([...a])=>a)("PASS"));'
+    expect_stdout: "P A S S"
+    node_version: ">=6"
+}
+
+arrow_destructured_array_2: {
+    input: {
+        console.log.apply(console, (([ a, ...b ]) => b)([ "FAIL", "PASS", 42 ]));
+    }
+    expect_exact: 'console.log.apply(console,(([a,...b])=>b)(["FAIL","PASS",42]));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+arrow_destructured_array_3: {
+    input: {
+        console.log((([ [ ...a ] = "FAIL" ]) => a)([ "PASS" ]).join("|"));
+    }
+    expect_exact: 'console.log((([[...a]="FAIL"])=>a)(["PASS"]).join("|"));'
+    expect_stdout: "P|A|S|S"
+    node_version: ">=6"
+}
+
+arrow_destructured_object_1: {
+    input: {
+        var f = ({ ...a }) => a, o = f({ PASS: 42 });
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_exact: "var f=({...a})=>a,o=f({PASS:42});for(var k in o)console.log(k,o[k]);"
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+arrow_destructured_object_2: {
+    input: {
+        var f = ({ FAIL: a, ...b }) => b, o = f({ PASS: 42, FAIL: null });
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_exact: "var f=({FAIL:a,...b})=>b,o=f({PASS:42,FAIL:null});for(var k in o)console.log(k,o[k]);"
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+arrow_destructured_object_3: {
+    input: {
+        var f = ([ { ...a } = [ "FAIL" ] ]) => a;
+        var o = f([ "PASS" ]);
+        for (var k in o)
+            console.log(k, o[k]);
+    }
+    expect_exact: 'var f=([{...a}=["FAIL"]])=>a;var o=f(["PASS"]);for(var k in o)console.log(k,o[k]);'
+    expect_stdout: [
+        "0 P",
+        "1 A",
+        "2 S",
+        "3 S",
+    ]
+    node_version: ">=8"
+}
+
+funarg_1: {
+    input: {
+        console.log.apply(console, function(...a) {
+            return a;
+        }("PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,function(...a){return a}("PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+funarg_2: {
+    input: {
+        console.log.apply(console, function(a, ...b) {
+            return b;
+        }("FAIL", "PASS", 42));
+    }
+    expect_exact: 'console.log.apply(console,function(a,...b){return b}("FAIL","PASS",42));'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+destructured_array_1: {
+    input: {
+        var [ ...a ] = [ "PASS", 42 ];
+        console.log.apply(console, a);
+    }
+    expect_exact: 'var[...a]=["PASS",42];console.log.apply(console,a);'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+destructured_array_2: {
+    input: {
+        var [ a, ...b ] = [ "FAIL", "PASS", 42 ];
+        console.log.apply(console, b);
+    }
+    expect_exact: 'var[a,...b]=["FAIL","PASS",42];console.log.apply(console,b);'
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+destructured_object_1: {
+    input: {
+        var { ...a } = [ "FAIL", "PASS", 42 ];
+        console.log(a[1], a[2]);
+    }
+    expect_exact: 'var{...a}=["FAIL","PASS",42];console.log(a[1],a[2]);'
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+destructured_object_2: {
+    input: {
+        var { 0: a, ...b } = [ "FAIL", "PASS", 42 ];
+        console.log(b[1], b[2]);
+    }
+    expect_exact: 'var{0:a,...b}=["FAIL","PASS",42];console.log(b[1],b[2]);'
+    expect_stdout: "PASS 42"
+    node_version: ">=8"
+}
+
+drop_fargs: {
+    options = {
+        keep_fargs: false,
+        rests: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a, ...b) {
+            return b[0];
+        }("FAIL", "PASS"));
+    }
+    expect: {
+        console.log(function(b) {
+            return b[0];
+        }([ "PASS" ]));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+inline: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        console.log(function(a, ...[ b, c ]) {
+            return c + b + a;
+        }("SS", "A", "P"));
+    }
+    expect: {
+        console.log(([ a, ...[ b, c ] ] = [ "SS", "A", "P" ], c + b + a));
+        var a, b, c;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+retain_var: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var [ ...a ] = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect: {
+        var [ ...a ] = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+reduce_destructured_array: {
+    options = {
+        reduce_vars: true,
+        rests: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var [ ...a ] = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect: {
+        console.log([ "PASS" ][0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+reduce_destructured_object: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var { ...a } = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect: {
+        var { ...a } = [ "PASS" ];
+        console.log(a[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+retain_destructured_array: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var [ a, ...b ] = [ "FAIL", "PASS", 42 ];
+        console.log.apply(console, b);
+    }
+    expect: {
+        var [ , ...b ] = [ "FAIL", "PASS", 42 ];
+        console.log.apply(console, b);
+    }
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+retain_destructured_object_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var { 0: a, ...b } = [ "FAIL", "PASS", 42 ];
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect: {
+        var { 0: a, ...b } = [ "FAIL", "PASS", 42 ];
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect_stdout: [
+        "1 PASS",
+        "2 42",
+    ]
+    node_version: ">=8"
+}
+
+retain_destructured_object_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var { foo: [ a ], ...b } = { foo: [ "FAIL" ], bar: "PASS", baz: 42 };
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect: {
+        var { foo: [], ...b } = { foo: [ "FAIL" ], bar: "PASS", baz: 42 };
+        for (var k in b)
+            console.log(k, b[k]);
+    }
+    expect_stdout: [
+        "bar PASS",
+        "baz 42",
+    ]
+    node_version: ">=8"
+}
+
+retain_funarg_destructured_array_1: {
+    options = {
+        inline: true,
+        keep_fargs: false,
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        console.log((([ ...a ]) => a)([ "PASS" ])[0]);
+    }
+    expect: {
+        console.log((([ ...a ]) => a)([ "PASS" ])[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+retain_funarg_destructured_array_2: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function([ a, ...b ]) {
+            return b;
+        }("bar")[1]);
+    }
+    expect: {
+        console.log(function([ , ...b ]) {
+            return b;
+        }("bar")[1]);
+    }
+    expect_stdout: "r"
+    node_version: ">=6"
+}
+
+retain_funarg_destructured_object_1: {
+    options = {
+        inline: true,
+        keep_fargs: false,
+        pure_getters: "strict",
+        unused: true,
+    }
+    input: {
+        console.log((({ ...a }) => a)([ "PASS" ])[0]);
+    }
+    expect: {
+        console.log((({ ...a }) => a)([ "PASS" ])[0]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+retain_funarg_destructured_object_2: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function({ p: a, ... b }) {
+            return b;
+        }({ p: "FAIL" }).p || "PASS");
+    }
+    expect: {
+        console.log(function({ p: a, ... b }) {
+            return b;
+        }({ p: "FAIL" }).p || "PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+drop_unused_call_args_1: {
+    options = {
+        rests: true,
+        unused: true,
+    }
+    input: {
+        (function(...a) {
+            console.log(a[0]);
+        })(42, console.log("PASS"));
+    }
+    expect: {
+        (function(a) {
+            console.log(a[0]);
+        })([ 42, console.log("PASS") ]);
+    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=6"
+}
+
+drop_unused_call_args_2: {
+    options = {
+        keep_fargs: false,
+        rests: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a, ...b) {
+            return b;
+        }(console).length);
+    }
+    expect: {
+        console.log(function(b) {
+            return b;
+        }((console, [])).length);
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+merge_funarg: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function(...a) {
+            var b = a.length;
+            console.log(b);
+        })();
+    }
+    expect: {
+        (function(...b) {
+            var b = b.length;
+            console.log(b);
+        })();
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+merge_funarg_destructured_array: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function([ ...a ]) {
+            var b = a.length;
+            console.log(b);
+        })([]);
+    }
+    expect: {
+        (function([ ...b ]) {
+            var b = b.length;
+            console.log(b);
+        })([]);
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+merge_funarg_destructured_object: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        (function({ ...a }) {
+            var b = a[0];
+            console.log(b);
+        })([ "PASS" ]);
+    }
+    expect: {
+        (function({ ...b }) {
+            var b = b[0];
+            console.log(b);
+        })([ "PASS" ]);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+keep_arguments: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        (function(...[ {} ]) {
+            console.log(arguments[0]);
+        })("PASS");
+    }
+    expect: {
+        (function(...[ {} ]) {
+            console.log(arguments[0]);
+        })("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+drop_rest_array: {
+    options = {
+        rests: true,
+    }
+    input: {
+        var [ ...[ a ]] = [ "PASS" ];
+        console.log(a);
+    }
+    expect: {
+        var [ a ] = [ "PASS" ];
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+drop_rest_arrow: {
+    options = {
+        arrows: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        rests: true,
+    }
+    input: {
+        console.log(((...[ a ]) => a)("PASS"));
+    }
+    expect: {
+        console.log((a => a)("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+drop_rest_lambda: {
+    options = {
+        keep_fargs: false,
+        reduce_vars: true,
+        rests: true,
+        toplevel: true,
+    }
+    input: {
+        function f(...[ a ]) {
+            return a;
+        }
+        console.log(f("PASS"), f(42));
+    }
+    expect: {
+        function f(a) {
+            return a;
+        }
+        console.log(f("PASS"), f(42));
+    }
+    expect_stdout: "PASS 42"
+    node_version: ">=6"
+}
+
+issue_4525_1: {
+    options = {
+        arguments: true,
+    }
+    input: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4525_2: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect: {
+        console.log(function(a, ...[]) {
+            a = "FAIL";
+            return arguments[0];
+        }("PASS"));
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4538: {
+    options = {
+        rests: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function f(...a) {
+            return a.p, f;
+        }()());
+    }
+    expect: {
+        console.log(typeof function f(...a) {
+            return a.p, f;
+        }()());
+    }
+    expect_stdout: "function"
+    node_version: ">=6"
+}
+
+issue_4544_1: {
+    options = {
+        keep_fnames: true,
+        side_effects: true,
+    }
+    input: {
+        try {
+            (function f(...[ {} ]) {})();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            [ ...[ {} ] ] = [];
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4544_2: {
+    options = {
+        keep_fnames: true,
+        side_effects: true,
+    }
+    input: {
+        try {
+            (function f(a, ...[ {} ]) {})([]);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            [ , ...[ {} ] ] = [ [] ];
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4562: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        rests: true,
+        unsafe: true,
+    }
+    input: {
+        console.log((([ ...[ a ] ]) => a)("foo"));
+    }
+    expect: {
+        console.log((([ a ]) => a)("foo"));
+    }
+    expect_stdout: "f"
+    node_version: ">=6"
+}
+
+issue_4575: {
+    options = {
+        collapse_vars: true,
+        ie8: true,
+        reduce_vars: true,
+        rests: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            var b = a;
+            var c = function a(...d) {
+                console.log(d.length);
+            }();
+        })();
+    }
+    expect: {
+        (function(a) {
+            (function a(...d) {
+                console.log(d.length);
+            })();
+        })();
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+issue_4621: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (function f(a, ...{
+            [console.log(a)]: b,
+        }) {})("PASS");
+    }
+    expect: {
+        (function f(a, ...{
+            [console.log(a)]: b,
+        }) {})("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4644_1: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function f(b, ...{
+            [a = "PASS"]: c,
+        }) {
+            return b;
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function f(b, ...{
+            [a = "PASS"]: c,
+        }) {
+            return b;
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_4644_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(function(...a) {
+            return a[1];
+        }("FAIL", "PASS"), function(...b) {
+            return b.length;
+        }(), function(c, ...d) {
+            return d[0];
+        }("FAIL"));
+    }
+    expect: {
+        console.log("PASS", 0, function(c, ...d) {
+            return d[0];
+        }("FAIL"));
+    }
+    expect_stdout: "PASS 0 undefined"
+    node_version: ">=6"
+}
+
+issue_4666: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        rests: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var a = 0, b = 0;
+        var o = ((...c) => a++ + c)(b);
+        for (var k in o)
+            b++;
+        console.log(a, b);
+    }
+    expect: {
+        var a = 0, b = 0;
+        var o = (c => +a + c)([ b ]);
+        for(var k in o)
+            b++;
+        console.log(1, b);
+    }
+    expect_stdout: "1 2"
+    node_version: ">=6"
+}

test/compress/sandbox.js

@@ -13,6 +13,23 @@ console_log: {
     ]
 }
 
+console_log_console: {
+    input: {
+        var log = console.log;
+        log(console);
+        log(typeof console.log);
+    }
+    expect: {
+        var log = console.log;
+        log(console);
+        log(typeof console.log);
+    }
+    expect_stdout: [
+        "{ log: 'function(){}' }",
+        "function",
+    ]
+}
+
 typeof_arguments: {
     options = {
         evaluate: true,
@@ -81,6 +98,63 @@ log_global: {
     expect_stdout: "[object global]"
 }
 
+log_nested: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var o = { p: 42 };
+        for (var i = 0; i < 10; i++)
+            o = {
+                p: o,
+                q: function foo() {},
+            };
+        console.log(o);
+    }
+    expect: {
+        var o = { p: 42 };
+        for (var i = 0; i < 10; i++)
+            o = {
+                p: o,
+                q: function() {},
+            };
+        console.log(o);
+    }
+    expect_stdout: true
+}
+
+timers: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var count = 0, interval = 1000, duration = 3210;
+        var timer = setInterval(function() {
+            console.log(++count);
+        }, interval);
+        setTimeout(function() {
+            clearInterval(timer);
+        }, duration);
+    }
+    expect: {
+        var count = 0;
+        var timer = setInterval(function() {
+            console.log(++count);
+        }, 1000);
+        setTimeout(function() {
+            clearInterval(timer);
+        }, 3210);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "3",
+    ]
+    node_version: ">=0.12"
+}
+
 issue_4054: {
     input: {
         console.log({

test/compress/side_effects.js

@@ -348,8 +348,6 @@ issue_3983_1: {
     }
     expect: {
         var a = "PASS";
-        g();
-        function g() {}
         console.log(a);
     }
     expect_stdout: "PASS"
@@ -436,7 +434,7 @@ trim_new: {
 
 issue_4325: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         passes: 2,
         pure_getters: "strict",
         reduce_vars: true,
@@ -458,14 +456,14 @@ issue_4325: {
     }
     expect: {
         (function() {
-            (function() {
+            (function(c) {
                 try {
-                    (void 0).p = 0;
+                    c.p = 0;
                 } catch (e) {
                     console.log("PASS");
                     return;
                 }
-            })();
+            })(void 0);
         })();
     }
     expect_stdout: "PASS"
@@ -506,3 +504,57 @@ issue_4366_2: {
     expect_stdout: "PASS"
     node_version: ">=4"
 }
+
+issue_4668: {
+    options = {
+        conditionals: true,
+        keep_fargs: false,
+        keep_fnames: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var b, c;
+            function g() {
+                return a = 0 + a, !d || (a = 0);
+            }
+            c = g();
+        }
+        console.log(f());
+        var d = 0;
+    }
+    expect: {
+        console.log(function f() {
+            (function g() {
+                0;
+            })();
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+drop_side_effect_free_call: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        function f(a) {
+            return "PA" + a;
+        }
+        f(42);
+        console.log(f("SS"));
+    }
+    expect: {
+        function f(a) {
+            return "PA" + a;
+        }
+        console.log(f("SS"));
+    }
+    expect_stdout: "PASS"
+}

test/compress/spreads.js

@@ -85,6 +85,28 @@ collapse_vars_4: {
     node_version: ">=6"
 }
 
+conditionals_farg: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function log(msg) {
+            console.log(msg);
+        }
+        var a = 42, b = [ "PASS" ], c = [ "FAIL" ];
+        a ? log(...b) : log(...c);
+    }
+    expect: {
+        function log(msg) {
+            console.log(msg);
+        }
+        var a = 42, b = [ "PASS" ], c = [ "FAIL" ];
+        log(...a ? b : c);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
 dont_inline: {
     options = {
         inline: true,
@@ -106,7 +128,7 @@ dont_inline: {
 do_inline: {
     options = {
         inline: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         console.log(function(a) {
@@ -145,7 +167,7 @@ drop_empty_call_1: {
 drop_empty_call_2: {
     options = {
         side_effects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         (function() {})(...[ console.log("PASS") ]);
@@ -159,7 +181,7 @@ drop_empty_call_2: {
 
 convert_hole: {
     options = {
-        spread: true,
+        spreads: true,
     }
     input: {
         console.log(...[ "PASS", , 42 ]);
@@ -192,7 +214,7 @@ keep_property_access: {
 
 keep_fargs: {
     options = {
-        keep_fargs: "strict",
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -253,7 +275,7 @@ reduce_vars_2: {
 convert_setter: {
     options = {
         objects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         var o = {
@@ -397,7 +419,7 @@ keep_getter_4: {
 keep_accessor: {
     options = {
         objects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         var o = {
@@ -445,7 +467,7 @@ keep_accessor: {
 object_key_order_1: {
     options = {
         objects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         var o = {
@@ -475,7 +497,7 @@ object_key_order_1: {
 object_key_order_2: {
     options = {
         objects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         var o = {
@@ -505,7 +527,7 @@ object_key_order_2: {
 object_key_order_3: {
     options = {
         objects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         var o = {
@@ -535,7 +557,7 @@ object_key_order_3: {
 object_key_order_4: {
     options = {
         objects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         var o = {
@@ -565,7 +587,7 @@ object_key_order_4: {
 object_spread_array: {
     options = {
         objects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         var o = {
@@ -591,7 +613,7 @@ object_spread_array: {
 object_spread_string: {
     options = {
         objects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         var o = {
@@ -648,7 +670,7 @@ unused_var_side_effects: {
 issue_4329: {
     options = {
         objects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         console.log({
@@ -727,7 +749,7 @@ issue_4342: {
 issue_4345: {
     options = {
         objects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         console.log({
@@ -787,7 +809,7 @@ issue_4361: {
 issue_4363: {
     options = {
         objects: true,
-        spread: true,
+        spreads: true,
     }
     input: {
         ({
@@ -804,3 +826,124 @@ issue_4363: {
     expect_stdout: "PASS"
     node_version: ">=8"
 }
+
+issue_4556: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = "" + [ a++ ];
+            var b = [ ...a ];
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var a;
+        }());
+    }
+    expect_stdout: "undefined"
+    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",
+        side_effects: true,
+    }
+    input: {
+        try {
+            (function(...[]) {
+                var arguments;
+                arguments[0];
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            (function(...[]) {
+                var arguments;
+                arguments[0];
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}

test/compress/templates.js

@@ -0,0 +1,330 @@
+simple: {
+    input: {
+        console.log(`foo
+        bar\nbaz`);
+    }
+    expect_exact: "console.log(`foo\n        bar\\nbaz`);"
+    expect_stdout: [
+        "foo",
+        "        bar",
+        "baz",
+    ]
+    node_version: ">=4"
+}
+
+placeholder: {
+    input: {
+        console.log(`foo ${ function(a, b) {
+            return a * b;
+        }(6, 7) }`);
+    }
+    expect_exact: "console.log(`foo ${function(a,b){return a*b}(6,7)}`);"
+    expect_stdout: "foo 42"
+    node_version: ">=4"
+}
+
+nested: {
+    input: {
+        console.log(`P${`A${"S"}`}S`);
+    }
+    expect_exact: 'console.log(`P${`A${"S"}`}S`);'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+tagged: {
+    input: {
+        console.log(String.raw`foo\nbar`);
+    }
+    expect_exact: "console.log(String.raw`foo\\nbar`);"
+    expect_stdout: "foo\\nbar"
+    node_version: ">=4"
+}
+
+tagged_chain: {
+    input: {
+        function f(strings) {
+            return strings.join("") || f;
+        }
+        console.log(f```${42}``pass`.toUpperCase());
+    }
+    expect_exact: 'function f(strings){return strings.join("")||f}console.log(f```${42}``pass`.toUpperCase());'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+tag_parentheses_arrow: {
+    input: {
+        console.log((s => s.raw[0])`\tPASS`.slice(2));
+    }
+    expect_exact: "console.log((s=>s.raw[0])`\\tPASS`.slice(2));"
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+tag_parentheses_new: {
+    input: {
+        (new function() {
+            return console.log;
+        })`foo`;
+    }
+    expect_exact: "(new function(){return console.log})`foo`;"
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+malformed_escape: {
+    input: {
+        (function(s) {
+            s.forEach((c, i) => console.log(i, c, s.raw[i]));
+            return () => console.log(arguments);
+        })`\uFo${42}`();
+    }
+    expect_exact: "(function(s){s.forEach((c,i)=>console.log(i,c,s.raw[i]));return()=>console.log(arguments)})`\\uFo${42}`();"
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+        templates: false,
+    }
+    input: {
+        console.log(`foo ${ function(a, b) {
+            return a * b;
+        }(6, 7) }`);
+    }
+    expect: {
+        console.log(`foo ${42}`);
+    }
+    expect_stdout: "foo 42"
+    node_version: ">=4"
+}
+
+evaluate_templates: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`foo ${ function(a, b) {
+            return a * b;
+        }(6, 7) }`);
+    }
+    expect: {
+        console.log("foo 42");
+    }
+    expect_stdout: "foo 42"
+    node_version: ">=4"
+}
+
+partial_evaluate: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${6 * 7} foo ${console ? `PA` + "SS" : `FA` + `IL`}`);
+    }
+    expect: {
+        console.log(`42 foo ${console ? "PASS" : "FAIL"}`);
+    }
+    expect_stdout: "42 foo PASS"
+    node_version: ">=4"
+}
+
+malformed_evaluate_1: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\67 ${6 * 7}`);
+    }
+    expect: {
+        console.log(`\67 42`);
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+malformed_evaluate_2: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\u0${0}b${5}`);
+    }
+    expect: {
+        console.log(`\u0${0}b5`);
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+malformed_evaluate_3: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`\u${0}b${5}`);
+    }
+    expect: {
+        console.log(`\u0b5`);
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+malformed_evaluate_4: {
+    options = {
+        evaluate: true,
+        templates: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(String.raw`\u0${0}b${5}`);
+    }
+    expect: {
+        console.log("\\u00b5");
+    }
+    expect_stdout: "\\u00b5"
+    node_version: ">=8"
+}
+
+unsafe_evaluate: {
+    options = {
+        evaluate: true,
+        templates: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(String.raw`\uFo`);
+    }
+    expect: {
+        console.log("\\uFo");
+    }
+    expect_stdout: "\\uFo"
+    node_version: ">=8"
+}
+
+side_effects: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        `42`;
+        `${console.log("foo")}`;
+        console.log`\nbar`;
+    }
+    expect: {
+        console.log("foo");
+        console.log`\nbar`;
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+unsafe_side_effects: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        `42`;
+        `${console.log("foo")}`;
+        String.raw`\nbar`;
+    }
+    expect: {
+        console.log("foo");
+    }
+    expect_stdout: "foo"
+    node_version: ">=4"
+}
+
+issue_4604: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 0, log = console.log;
+        a = "FAIL";
+        (function() {
+            a = "PASS";
+        })``;
+        log(a);
+    }
+    expect: {
+        var a = 0, log = console.log;
+        a = "FAIL";
+        (function() {
+            a = "PASS";
+        })``;
+        log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4606: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${typeof A} ${"\r"} ${"\\"} ${"`"}`);
+    }
+    expect: {
+        console.log(`${typeof A} \r \\ \``);
+    }
+    expect_stdout: "undefined \r \\ `"
+    node_version: ">=4"
+}
+
+issue_4630: {
+    options = {
+        evaluate: true,
+        templates: true,
+    }
+    input: {
+        console.log(`${/PASS/}`);
+    }
+    expect: {
+        console.log("/PASS/");
+    }
+    expect_stdout: "/PASS/"
+    node_version: ">=4"
+}
+
+issue_4676: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        templates: true,
+        toplevel: true,
+        unsafe:true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            var b = `foo${a = "PASS"}`;
+            for (var c in f && b)
+                b.p;
+            return a;
+        }
+        console.log(f("FAIL"));
+    }
+    expect: {
+        console.log(function f(a) {
+            var b = "fooPASS";
+            for (var c in f, b)
+                b.p;
+            return "PASS";
+        }());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/yields.js

@@ -0,0 +1,952 @@
+binary: {
+    input: {
+        var a = function*() {
+            console.log(6 * (yield "PA" + "SS"));
+        }();
+        console.log(a.next("FAIL").value);
+        console.log(a.next(7).done);
+    }
+    expect_exact: 'var a=function*(){console.log(6*(yield"PA"+"SS"))}();console.log(a.next("FAIL").value);console.log(a.next(7).done);'
+    expect_stdout: [
+        "PASS",
+        "42",
+        "true",
+    ]
+    node_version: ">=4"
+}
+
+empty_yield: {
+    input: {
+        var a = function*() {
+            yield;
+            console.log(yield);
+            yield
+            "FAIL 1";
+        }();
+        console.log(a.next("FAIL 2").value);
+        console.log(a.next("FAIL 3").value);
+        console.log(a.next("PASS").value);
+        console.log(a.next("FAIL 4").done);
+    }
+    expect_exact: 'var a=function*(){yield;console.log(yield);yield;"FAIL 1"}();console.log(a.next("FAIL 2").value);console.log(a.next("FAIL 3").value);console.log(a.next("PASS").value);console.log(a.next("FAIL 4").done);'
+    expect_stdout: [
+        "undefined",
+        "undefined",
+        "PASS",
+        "undefined",
+        "true",
+    ]
+    node_version: ">=4"
+}
+
+empty_yield_conditional: {
+    input: {
+        var a = function*() {
+            console.log((yield) ? yield : yield);
+        }();
+        console.log(a.next("FAIL 1").value);
+        console.log(a.next("FAIL 2").value);
+        console.log(a.next("PASS").value);
+        console.log(a.next("FAIL 3").done);
+    }
+    expect_exact: 'var a=function*(){console.log((yield)?yield:yield)}();console.log(a.next("FAIL 1").value);console.log(a.next("FAIL 2").value);console.log(a.next("PASS").value);console.log(a.next("FAIL 3").done);'
+    expect_stdout: [
+        "undefined",
+        "undefined",
+        "PASS",
+        "undefined",
+        "true",
+    ]
+    node_version: ">=4"
+}
+
+nested_yield: {
+    input: {
+        console.log(function*() {
+            (yield*
+            f())
+            function* f() {
+                return "FAIL";
+            }
+            yield*
+            f();
+            yield *f();
+        }().next().value || "PASS");
+    }
+    expect_exact: 'console.log(function*(){yield*f();function*f(){return"FAIL"}yield*f();yield*f()}().next().value||"PASS");'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+pause_resume: {
+    input: {
+        function* f() {
+            console.log(yield "PASS");
+        }
+        var a = f();
+        console.log(a.next("FAIL").value);
+        console.log(a.next(42).done);
+    }
+    expect_exact: 'function*f(){console.log(yield"PASS")}var a=f();console.log(a.next("FAIL").value);console.log(a.next(42).done);'
+    expect_stdout: [
+        "PASS",
+        "42",
+        "true",
+    ]
+    node_version: ">=4"
+}
+
+arrow_yield: {
+    input: {
+        yield = "PASS";
+        console.log(function*() {
+            return () => yield || "FAIL";
+        }().next().value());
+    }
+    expect_exact: 'yield="PASS";console.log(function*(){return()=>yield||"FAIL"}().next().value());'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+for_of: {
+    input: {
+        function* f() {
+            if (yield "PASS") yield "FAIL 1";
+            yield 42;
+            return "FAIL 2";
+        }
+        for (var a of f())
+            console.log(a);
+    }
+    expect_exact: 'function*f(){if(yield"PASS")yield"FAIL 1";yield 42;return"FAIL 2"}for(var a of f())console.log(a);'
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=4"
+}
+
+for_await_of: {
+    input: {
+        async function* f() {
+            if (yield "PASS") yield "FAIL 1";
+            yield {
+                then: function(r) {
+                    r(42);
+                },
+            };
+            return "FAIL 2";
+        }
+        (async function(a) {
+            for await (a of f())
+                console.log(a);
+        })();
+    }
+    expect_exact: 'async function*f(){if(yield"PASS")yield"FAIL 1";yield{then:function(r){r(42)}};return"FAIL 2"}(async function(a){for await(a of f())console.log(a)})();'
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=10"
+}
+
+collapse_vars_1: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function*() {
+            a = "PASS";
+            yield 42;
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function*() {
+            a = "PASS";
+            yield 42;
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+collapse_vars_2: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function*() {
+            yield (a = "PASS");
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function*() {
+            yield (a = "PASS");
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+collapse_vars_3: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        (function*() {
+            yield (a = "PASS", 42);
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect: {
+        var a = "FAIL";
+        (function*() {
+            yield (a = "PASS", 42);
+            return "PASS";
+        })().next();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+collapse_vars_4: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL";
+        var b = function*(c) {
+            return c;
+        }(a = "PASS");
+        console.log(a, b.next().done);
+    }
+    expect: {
+        var a = "FAIL";
+        var b = function*(c) {
+            return c;
+        }(a = "PASS");
+        console.log(a, b.next().done);
+    }
+    expect_stdout: "PASS true"
+    node_version: ">=4"
+}
+
+collapse_property_lambda: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+    }
+    input: {
+        console.log(function* f() {
+            f.g = () => 42;
+            return f.g();
+        }().next().value);
+    }
+    expect: {
+        console.log(function* f() {
+            return (f.g = () => 42)();
+        }().next().value);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+defun_name: {
+    input: {
+        function* yield() {
+            console.log("PASS");
+        }
+        yield().next();
+    }
+    expect: {
+        function* yield() {
+            console.log("PASS");
+        }
+        yield().next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+drop_fname: {
+    rename = true
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        function* yield() {
+            console.log("PASS");
+        }
+        yield().next();
+    }
+    expect: {
+        (function*() {
+            console.log("PASS");
+        })().next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+keep_fname: {
+    options = {
+        keep_fnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function* yield() {
+            console.log("PASS");
+        }
+        yield().next();
+    }
+    expect: {
+        function* yield() {
+            console.log("PASS");
+        }
+        yield().next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+evaluate: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = function*() {}();
+        console.log(typeof a);
+    }
+    expect: {
+        var a = function*() {}();
+        console.log(typeof a);
+    }
+    expect_stdout: "object"
+    node_version: ">=4"
+}
+
+functions: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        !function*() {
+            var a = function* a() {
+                return a && "a";
+            };
+            var b = function* x() {
+                return !!x;
+            };
+            var c = function*(c) {
+                return c;
+            };
+            if (yield* c(yield* b(yield* a()))) {
+                var d = function*() {};
+                var e = function* y() {
+                    return typeof y;
+                };
+                var f = function*(f) {
+                    return f;
+                };
+                console.log(yield* a(yield* d()), yield* b(yield* e()), yield* c(yield* f(42)), typeof d, yield* e(), typeof f);
+            }
+        }().next();
+    }
+    expect: {
+        !function*() {
+            function* a() {
+                return a && "a";
+            }
+            function* b() {
+                return !!b;
+            }
+            var c = function*(c) {
+                return c;
+            };
+            if (yield* c(yield* b(yield* a()))) {
+                function* d() {}
+                function* e() {
+                    return typeof e;
+                }
+                var f = function*(f) {
+                    return f;
+                };
+                console.log(yield* a(yield* d()), yield* b(yield* e()), yield* c(yield* f(42)), typeof d, yield* e(), typeof f);
+            }
+        }().next();
+    }
+    expect_stdout: "a true 42 function function function"
+    node_version: ">=4"
+}
+
+functions_use_strict: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        !function*() {
+            var a = function* a() {
+                return a && "a";
+            };
+            var b = function* x() {
+                return !!x;
+            };
+            var c = function*(c) {
+                return c;
+            };
+            if (yield* c(yield* b(yield* a()))) {
+                var d = function*() {};
+                var e = function* y() {
+                    return typeof y;
+                };
+                var f = function*(f) {
+                    return f;
+                };
+                console.log(yield* a(yield* d()), yield* b(yield* e()), yield* c(yield* f(42)), typeof d, yield* e(), typeof f);
+            }
+        }().next();
+    }
+    expect: {
+        "use strict";
+        !function*() {
+            function* a() {
+                return a && "a";
+            }
+            function* b() {
+                return !!b;
+            }
+            var c = function*(c) {
+                return c;
+            };
+            if (yield* c(yield* b(yield* a()))) {
+                var d = function*() {};
+                var e = function* y() {
+                    return typeof y;
+                };
+                var f = function*(f) {
+                    return f;
+                };
+                console.log(yield* a(yield* d()), yield* b(yield* e()), yield* c(yield* f(42)), typeof d, yield* e(), typeof f);
+            }
+        }().next();
+    }
+    expect_stdout: "a true 42 function function function"
+    node_version: ">=4"
+}
+
+negate_iife: {
+    options = {
+        negate_iife: true,
+        side_effects: true,
+    }
+    input: {
+        (function*(a) {
+            console.log(a);
+        })("PASS").next();
+    }
+    expect: {
+        !function*(a) {
+            console.log(a);
+        }("PASS").next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+reduce_iife_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function*(a) {
+            yield a;
+        }(42).next().value);
+    }
+    expect: {
+        console.log(function*(a) {
+            yield 42;
+        }().next().value);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+reduce_iife_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        (function*() {
+            a = "FAIL";
+        })();
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (function*() {
+            a = "FAIL";
+        })();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+reduce_single_use_defun: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function* f(a) {
+            console.log(a);
+        }
+        f("PASS").next();
+    }
+    expect: {
+        (function*(a) {
+            console.log(a);
+        })("PASS").next();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+reduce_tagged: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function* f() {
+            function g() {
+                h`foo`;
+            }
+            g();
+            function h(s) {
+                console.log(s[0]);
+            }
+            h([ "bar" ]);
+        }
+        f().next();
+    }
+    expect: {
+        function* f() {
+            (function() {
+                h`foo`;
+            })();
+            function h(s) {
+                console.log(s[0]);
+            }
+            h([ "bar" ]);
+        }
+        f().next();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=4"
+}
+
+reduce_tagged_async: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        async function* f() {
+            function g() {
+                h`foo`;
+            }
+            g();
+            function h(s) {
+                console.log(s[0]);
+            }
+            h([ "bar" ]);
+        }
+        f().next();
+    }
+    expect: {
+        async function* f() {
+            (function() {
+                h`foo`;
+            })();
+            function h(s) {
+                console.log(s[0]);
+            }
+            h([ "bar" ]);
+        }
+        f().next();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=10"
+}
+
+lift_sequence: {
+    options = {
+        sequences: true,
+        yields: true,
+    }
+    input: {
+        console.log(function*() {
+            yield (console, "PASS");
+        }().next().value);
+    }
+    expect: {
+        console.log(function*() {
+            console, yield "PASS";
+        }().next().value);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+inline_nested_yield: {
+    options = {
+        inline: true,
+        sequences: true,
+        yields: true,
+    }
+    input: {
+        var a = function*() {
+            yield* function*() {
+                yield "foo";
+                return "FAIL";
+            }();
+        }(), b;
+        do {
+            b = a.next();
+            console.log(b.value);
+        } while (!b.done);
+    }
+    expect: {
+        var a = function*() {
+            yield "foo",
+            "FAIL";
+        }(), b;
+        do {
+            b = a.next(),
+            console.log(b.value);
+        } while (!b.done);
+    }
+    expect_stdout: [
+        "foo",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+drop_body: {
+    options = {
+        side_effects: true,
+        yields: true,
+    }
+    input: {
+        (function*([ , a = console.log("foo") ]) {
+            console.log("bar");
+        })([ console.log("baz") ]);
+    }
+    expect: {
+        [ [ , [].e = console.log("foo") ] ] = [ [ console.log("baz") ] ];
+    }
+    expect_stdout: [
+        "baz",
+        "foo",
+    ]
+    node_version: ">=6"
+}
+
+drop_unused_call: {
+    options = {
+        inline: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+        yields: true,
+    }
+    input: {
+        var a = function*(){}(console.log("PASS"));
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4454_1: {
+    rename = false
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a) {
+            (function*(b = console.log(a)) {})();
+            var yield = 42..toString();
+            console.log(yield);
+        }
+        f("PASS");
+    }
+    expect: {
+        function f(a) {
+            (function*(b = console.log(a)) {})();
+            var yield = 42..toString();
+            console.log(yield);
+        }
+        f("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=6"
+}
+
+issue_4454_2: {
+    rename = true
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        function f(a) {
+            (function*(b = console.log(a)) {})();
+            var yield = 42..toString();
+            console.log(yield);
+        }
+        f("PASS");
+    }
+    expect: {
+        function f(b) {
+            (function*(c = console.log(b)) {})();
+            var b = 42..toString();
+            console.log(b);
+        }
+        f("PASS");
+    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
+    node_version: ">=6"
+}
+
+issue_4618: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function() {
+            var yield = function* f() {
+                console || f();
+            };
+            console.log;
+            return yield;
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            var yield = function* f() {
+                console || f();
+            };
+            console.log;
+            return yield;
+        }());
+    }
+    expect_stdout: "function"
+    node_version: ">=4"
+}
+
+issue_4623: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        if (console ? function*() {} : 0)
+            console.log("PASS");
+    }
+    expect: {
+        (console ? function*() {} : 0) && console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4633: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        var a = function*() {
+            (function(log) {
+                log(typeof this);
+            })(yield "PASS");
+        }();
+        console.log(a.next().value);
+        a.next(console.log);
+    }
+    expect: {
+        var a = function*() {
+            (function(log) {
+                log(typeof this);
+            })(yield "PASS");
+        }();
+        console.log(a.next().value);
+        a.next(console.log);
+    }
+    expect_stdout: [
+        "PASS",
+        "object",
+    ]
+    node_version: ">=4"
+}
+
+issue_4639_1: {
+    options = {
+        inline: true,
+    }
+    input: {
+        console.log(function*() {
+            return function() {
+                return yield => "PASS";
+            }();
+        }().next().value());
+    }
+    expect: {
+        console.log(function*() {
+            return function() {
+                return yield => "PASS";
+            }();
+        }().next().value());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4639_2: {
+    options = {
+        inline: true,
+    }
+    input: {
+        (function*() {
+            console.log(function() {
+                return typeof yield;
+            }());
+        })().next();
+    }
+    expect: {
+        (function*() {
+            console.log(function() {
+                return typeof yield;
+            }());
+        })().next();
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_4641_1: {
+    options = {
+        sequences: true,
+    }
+    input: {
+        console.log(typeof async function*() {
+            try {
+                console.log("foo");
+                return;
+            } finally {
+                console.log("bar");
+            }
+        }().next().then);
+    }
+    expect: {
+        console.log(typeof async function*() {
+            try {
+                console.log("foo");
+                return;
+            } finally {
+                console.log("bar");
+            }
+        }().next().then);
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+        "function",
+    ]
+    node_version: ">=10"
+}
+
+issue_4641_2: {
+    options = {
+        side_effects: 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 0;
+            } finally {
+                console.log("PASS");
+            }
+        }().next().then);
+    }
+    expect_stdout: [
+        "function",
+        "PASS",
+    ]
+    node_version: ">=10"
+}

test/exports.js

@@ -1,5 +1,6 @@
 exports["Compressor"] = Compressor;
 exports["defaults"] = defaults;
+exports["is_statement"] = is_statement;
 exports["JS_Parse_Error"] = JS_Parse_Error;
 exports["List"] = List;
 exports["mangle_properties"] = mangle_properties;

test/input/invalid/for-of_1.js

@@ -0,0 +1,3 @@
+var a = [ 1 ], b;
+for (b = 2 of a)
+    console.log(b);

test/input/invalid/for-of_2.js

@@ -0,0 +1,3 @@
+var a = [ 1 ];
+for (var b = 2 of a)
+    console.log(b);

test/input/reduce/destructured_assign.js

@@ -0,0 +1,3 @@
+var o = {};
+[ o[1 + .1 + .1] ] = [ 42 ];
+console.log(o[1.2]);

test/input/reduce/destructured_assign.reduced.js

@@ -0,0 +1,17 @@
+// (beautified)
+var o = {};
+
+[ o[1 + .1 + .1] ] = [];
+
+console.log(o);
+// output: { '1.2000000000000002': undefined }
+// 
+// minify: { '1.2': undefined }
+// 
+// options: {
+//   "compress": {
+//     "unsafe_math": true
+//   },
+//   "mangle": false,
+//   "validate": true
+// }

test/input/reduce/destructured_catch.reduced.js

@@ -1,14 +1,12 @@
 // (beautified)
 try {
     1 in 0;
-} catch ({
-    message: message
-}) {
+} catch (message) {
     console.log(message);
 }
-// output: Cannot use 'in' operator to search for '1' in 0
+// output: TypeError: Cannot use 'in' operator to search for '1' in 0
 // 
-// minify: Cannot use 'in' operator to search for '0' in 0
+// minify: TypeError: Cannot use 'in' operator to search for '0' in 0
 // 
 // options: {
 //   "mangle": false

test/input/reduce/diff_error.js

@@ -1,5 +1,5 @@
-(function f(a) {
-    do {
-        console.log(f.length);
-    } while (console.log(f += 0));
-})();
+console.log(function(undefined) {
+    return undefined[function() {
+        {}
+    }] || 1 + .1 + .1;
+}(42));

test/input/reduce/diff_error.reduced.js

@@ -1,19 +1,14 @@
 // (beautified)
-(function f(a) {
-    do {
-        console.log(f.length);
-    } while (console.log(f += 0));
-})();
-// output: 1
-// function(){}0
+console.log(function() {
+    return 1 + .1 + .1;
+}());
+// output: 1.2000000000000002
 // 
-// minify: 0
-// function(){}0
+// minify: 1.2
 // 
 // options: {
 //   "compress": {
-//     "keep_fargs": false,
-//     "unsafe": true
+//     "unsafe_math": true
 //   },
 //   "mangle": false
 // }

test/input/reduce/setter.js

@@ -1,8 +1,5 @@
-console.log(function f(a) {
-    ({
-        set p(v) {
-            f++;
-        }
-    });
-    return f.length;
-}());
+({
+    set p(v) {
+        console.log(+v + .1 + .1);
+    }
+}).p = 1;

test/input/reduce/setter.reduced.js

@@ -1,20 +1,16 @@
 // (beautified)
-console.log(function f(a) {
-    ({
-        set p(v) {
-            f++;
-        }
-    });
-    return f.length;
-}());
-// output: 1
+({
+    set p(v) {
+        console.log(1 + .1 + .1);
+    }
+}).p = 0;
+// output: 1.2000000000000002
 // 
-// minify: 0
+// minify: 1.2
 // 
 // options: {
 //   "compress": {
-//     "keep_fargs": false,
-//     "unsafe": true
+//     "unsafe_math": true
 //   },
 //   "mangle": false
 // }

test/jetstream.js

@@ -5,7 +5,7 @@
 
 var site = "https://browserbench.org/JetStream1.1";
 if (typeof phantom == "undefined") {
-    require("../tools/exit");
+    require("../tools/tty");
     var args = process.argv.slice(2);
     var debug = args.indexOf("--debug");
     if (debug < 0) {

test/mocha/bug-report.js

@@ -0,0 +1,40 @@
+var assert = require("assert");
+var exec = require("child_process").exec;
+
+describe("UGLIFY_BUG_REPORT", function() {
+    var env = Object.create(process.env);
+    env.UGLIFY_BUG_REPORT = 1;
+    it("Should generate bug report via API", function(done) {
+        exec('"' + process.argv[0] + '"', { env: env }, function(err, stdout) {
+            if (err) throw err;
+            assert.strictEqual(stdout, [
+                "// UGLIFY_BUG_REPORT",
+                "// <<undefined>>",
+                "",
+                "//-------------------------------------------------------------",
+                "// INPUT CODE",
+                "...---...",
+                "",
+            ].join("\n"));
+            done();
+        }).stdin.end('console.log(require("./").minify("...---...").code);');
+    });
+    it("Should generate bug report via CLI", function(done) {
+        exec('"' + process.argv[0] + '" bin/uglifyjs -mc', { env: env }, function(err, stdout) {
+            if (err) throw err;
+            assert.strictEqual(stdout, [
+                "// UGLIFY_BUG_REPORT",
+                "// {",
+                '//   "mangle": {},',
+                '//   "compress": {}',
+                "// }",
+                "",
+                "//-------------------------------------------------------------",
+                "// STDIN",
+                "...---...",
+                "",
+            ].join("\n"));
+            done();
+        }).stdin.end("...---...");
+    });
+});

test/mocha/cli.js

@@ -56,7 +56,7 @@ describe("bin/uglifyjs", function() {
             "--source-map", [
                 "names=true",
                 "url=inline",
-            ].join(","),
+            ].join(),
         ].join(" "), function(err, stdout) {
             if (err) throw err;
             var expected = [
@@ -84,7 +84,7 @@ describe("bin/uglifyjs", function() {
             "--source-map", [
                 "names=false",
                 "url=inline",
-            ].join(","),
+            ].join(),
         ].join(" "), function(err, stdout) {
             if (err) throw err;
             var expected = [
@@ -171,7 +171,7 @@ describe("bin/uglifyjs", function() {
                 "content=" + mapFile,
                 "includeSources",
                 "url=inline",
-            ].join(","),
+            ].join(),
         ].join(" ");
 
         var child = exec(command, function(err, stdout) {
@@ -333,11 +333,13 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + " test/input/invalid/simple.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/simple.js:1,12");
-            assert.strictEqual(lines[1], "function f(a{}");
-            assert.strictEqual(lines[2], "            ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: punc «{», expected: punc «,»");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/simple.js:1,12",
+                "function f(a{}",
+                "            ^",
+                "ERROR: Unexpected token: punc «{», expected: punc «,»",
+            ].join("\n"));
             done();
         });
     });
@@ -345,11 +347,13 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + " test/input/invalid/tab.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/tab.js:1,12");
-            assert.strictEqual(lines[1], "\t\tfoo(\txyz, 0abc);");
-            assert.strictEqual(lines[2], "\t\t    \t     ^");
-            assert.strictEqual(lines[3], "ERROR: Invalid syntax: 0abc");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/tab.js:1,12",
+                "\t\tfoo(\txyz, 0abc);",
+                "\t\t    \t     ^",
+                "ERROR: Invalid syntax: 0abc",
+            ].join("\n"));
             done();
         });
     });
@@ -357,11 +361,13 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + " test/input/invalid/eof.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/eof.js:2,0");
-            assert.strictEqual(lines[1], "foo, bar(");
-            assert.strictEqual(lines[2], "         ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: eof");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/eof.js:2,0",
+                "foo, bar(",
+                "         ^",
+                "ERROR: Unexpected token: eof",
+            ].join("\n"));
             done();
         });
     });
@@ -369,11 +375,13 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + " test/input/invalid/loop-no-body.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/loop-no-body.js:2,0");
-            assert.strictEqual(lines[1], "for (var i = 0; i < 1; i++) ");
-            assert.strictEqual(lines[2], "                            ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: eof");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/loop-no-body.js:2,0",
+                "for (var i = 0; i < 1; i++) ",
+                "                            ^",
+                "ERROR: Unexpected token: eof",
+            ].join("\n"));
             done();
         });
     });
@@ -386,7 +394,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/assign_1.js:1,18",
                 "console.log(1 || 5--);",
                 "                  ^",
-                "ERROR: Invalid use of -- operator"
+                "ERROR: Invalid use of -- operator",
             ].join("\n"));
             done();
         });
@@ -400,7 +408,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/assign_2.js:1,32",
                 "console.log(2 || (Math.random() /= 2));",
                 "                                ^",
-                "ERROR: Invalid assignment"
+                "ERROR: Invalid assignment",
             ].join("\n"));
             done();
         });
@@ -414,7 +422,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/assign_3.js:1,17",
                 "console.log(3 || ++this);",
                 "                 ^",
-                "ERROR: Invalid use of ++ operator"
+                "ERROR: Invalid use of ++ operator",
             ].join("\n"));
             done();
         });
@@ -428,7 +436,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/assign_4.js:1,0",
                 "++null",
                 "^",
-                "ERROR: Invalid use of ++ operator"
+                "ERROR: Invalid use of ++ operator",
             ].join("\n"));
             done();
         });
@@ -442,7 +450,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/dot_1.js:1,2",
                 "a.=",
                 "  ^",
-                "ERROR: Unexpected token: operator «=», expected: name"
+                "ERROR: Unexpected token: operator «=», expected: name",
             ].join("\n"));
             done();
         });
@@ -456,7 +464,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/dot_2.js:1,0",
                 "%.a;",
                 "^",
-                "ERROR: Unexpected token: operator «%»"
+                "ERROR: Unexpected token: operator «%»",
             ].join("\n"));
             done();
         });
@@ -470,7 +478,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/dot_3.js:1,2",
                 "a./();",
                 "  ^",
-                "ERROR: Unexpected token: operator «/», expected: name"
+                "ERROR: Unexpected token: operator «/», expected: name",
             ].join("\n"));
             done();
         });
@@ -484,7 +492,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/object.js:1,13",
                 "console.log({%: 1});",
                 "             ^",
-                "ERROR: Unexpected token: operator «%»"
+                "ERROR: Unexpected token: operator «%»",
             ].join("\n"));
             done();
         });
@@ -498,7 +506,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/delete.js:13,11",
                 "    delete x;",
                 "           ^",
-                "ERROR: Calling delete on expression not allowed in strict mode"
+                "ERROR: Calling delete on expression not allowed in strict mode",
             ].join("\n"));
             done();
         });
@@ -512,7 +520,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/function_1.js:4,11",
                 "function g(arguments) {",
                 "           ^",
-                "ERROR: Unexpected arguments in strict mode"
+                "ERROR: Unexpected arguments in strict mode",
             ].join("\n"));
             done();
         });
@@ -526,7 +534,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/function_2.js:4,9",
                 "function eval() {",
                 "         ^",
-                "ERROR: Unexpected eval in strict mode"
+                "ERROR: Unexpected eval in strict mode",
             ].join("\n"));
             done();
         });
@@ -540,7 +548,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/function_3.js:4,10",
                 "!function arguments() {",
                 "          ^",
-                "ERROR: Unexpected arguments in strict mode"
+                "ERROR: Unexpected arguments in strict mode",
             ].join("\n"));
             done();
         });
@@ -554,7 +562,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/try.js:7,18",
                 "    try {} catch (eval) {}",
                 "                  ^",
-                "ERROR: Unexpected eval in strict mode"
+                "ERROR: Unexpected eval in strict mode",
             ].join("\n"));
             done();
         });
@@ -568,7 +576,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/var.js:7,8",
                 "    var eval;",
                 "        ^",
-                "ERROR: Unexpected eval in strict mode"
+                "ERROR: Unexpected eval in strict mode",
             ].join("\n"));
             done();
         });
@@ -582,7 +590,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/destructured_var.js:7,10",
                 "    var { eval } = 42;",
                 "          ^",
-                "ERROR: Unexpected eval in strict mode"
+                "ERROR: Unexpected eval in strict mode",
             ].join("\n"));
             done();
         });
@@ -596,7 +604,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/else.js:1,7",
                 "if (0) else 1;",
                 "       ^",
-                "ERROR: Unexpected token: keyword «else»"
+                "ERROR: Unexpected token: keyword «else»",
             ].join("\n"));
             done();
         });
@@ -610,7 +618,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/return.js:1,0",
                 "return 42;",
                 "^",
-                "ERROR: 'return' outside of function"
+                "ERROR: 'return' outside of function",
             ].join("\n"));
             done();
         });
@@ -624,7 +632,7 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/for-in_1.js:2,5",
                 "for (1, 2, a in b) {",
                 "     ^",
-                "ERROR: Invalid left-hand side in for..in loop"
+                "ERROR: Invalid left-hand side in for..in/of loop",
             ].join("\n"));
             done();
         });
@@ -638,7 +646,35 @@ describe("bin/uglifyjs", function() {
                 "Parse error at test/input/invalid/for-in_2.js:2,5",
                 "for (var a, b in c) {",
                 "     ^",
-                "ERROR: Only one variable declaration allowed in for..in loop"
+                "ERROR: Only one variable declaration allowed in for..in/of loop",
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (for-of init)", function(done) {
+        var command = uglifyjscmd + " test/input/invalid/for-of_1.js";
+        exec(command, function(err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/for-of_1.js:2,5",
+                "for (b = 2 of a)",
+                "     ^",
+                "ERROR: Invalid left-hand side in for..in/of loop",
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (for-of var)", function(done) {
+        var command = uglifyjscmd + " test/input/invalid/for-of_2.js";
+        exec(command, function(err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/for-of_2.js:2,13",
+                "for (var b = 2 of a)",
+                "             ^",
+                "ERROR: No initializers allowed in for..of loop",
             ].join("\n"));
             done();
         });
@@ -647,11 +683,13 @@ describe("bin/uglifyjs", function() {
         var command = uglifyjscmd + " test/input/invalid/switch.js";
         exec(command, function(err, stdout, stderr) {
             assert.ok(err);
-            var lines = stderr.split(/\n/);
-            assert.strictEqual(lines[0], "Parse error at test/input/invalid/switch.js:3,2");
-            assert.strictEqual(lines[1], "  default:");
-            assert.strictEqual(lines[2], "  ^");
-            assert.strictEqual(lines[3], "ERROR: More than one default clause in switch statement");
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/switch.js:3,2",
+                "  default:",
+                "  ^",
+                "ERROR: More than one default clause in switch statement",
+            ].join("\n"));
             done();
         });
     });

test/mocha/comments.js

@@ -259,7 +259,7 @@ describe("comments", function() {
         assert.strictEqual(result.code, code);
     });
 
-    it("Should handle comments around parenthesis correctly", function() {
+    it("Should handle comments around parentheses correctly", function() {
         var code = [
             "a();",
             "/* foo */",

test/mocha/exports.js

@@ -0,0 +1,71 @@
+var assert = require("assert");
+var UglifyJS = require("../node");
+
+describe("export", function() {
+    it("Should reject invalid `export ...` statement syntax", function() {
+        [
+            "export *;",
+            "export A;",
+            "export 42;",
+            "export var;",
+            "export * as A;",
+            "export A as B;",
+            "export const A;",
+            "export function(){};",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject invalid `export { ... }` statement syntax", function() {
+        [
+            "export { * };",
+            "export { * as A };",
+            "export { 42 as A };",
+            "export { A as B-C };",
+            "export { default as A };",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject invalid `export default ...` statement syntax", function() {
+        [
+            "export default *;",
+            "export default var;",
+            "export default A as B;",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject invalid `export ... from ...` statement syntax", function() {
+        [
+            "export from 'path';",
+            "export * from `path`;",
+            "export A as B from 'path';",
+            "export default from 'path';",
+            "export { A }, B from 'path';",
+            "export * as A, B from 'path';",
+            "export * as A, {} from 'path';",
+            "export { * as A } from 'path';",
+            "export { 42 as A } from 'path';",
+            "export { A-B as C } from 'path';",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+});

test/mocha/getter-setter.js

@@ -3,7 +3,7 @@ var UglifyJS = require("../node");
 
 describe("Getters and setters", function() {
     it("Should not accept operator symbols as getter/setter name", function() {
-        var illegalOperators = [
+        [
             "++",
             "--",
             "+",
@@ -42,43 +42,26 @@ describe("Getters and setters", function() {
             "&=",
             "&&",
             "||"
-        ];
-        var generator = function() {
-            var results = [];
-
-            for (var i in illegalOperators) {
-                results.push({
-                    code: "var obj = { get " + illegalOperators[i] + "() { return test; }};",
-                    operator: illegalOperators[i],
-                    method: "get"
-                });
-                results.push({
-                    code: "var obj = { set " + illegalOperators[i] + "(value) { test = value}};",
-                    operator: illegalOperators[i],
-                    method: "set"
-                });
-            }
-
-            return results;
-        };
-        var testCase = function(data) {
-            return function() {
-                UglifyJS.parse(data.code);
-            };
-        };
-        var fail = function(data) {
-            return function(e) {
+        ].reduce(function(tests, illegalOperator) {
+            tests.push({
+                code: "var obj = { get " + illegalOperator + "() { return test; }};",
+                operator: illegalOperator,
+            });
+            tests.push({
+                code: "var obj = { set " + illegalOperator + "(value) { test = value; }};",
+                operator: illegalOperator,
+            });
+            return tests;
+        }, []).forEach(function(test) {
+            assert.throws(function() {
+                UglifyJS.parse(test.code);
+            }, test.operator == "=" ? function(e) {
                 return e instanceof UglifyJS.JS_Parse_Error
-                    && e.message === "Unexpected token: operator «" + data.operator + "»";
-            };
-        };
-        var errorMessage = function(data) {
-            return "Expected but didn't get a syntax error while parsing following line:\n" + data.code;
-        };
-        var tests = generator();
-        for (var i = 0; i < tests.length; i++) {
-            var test = tests[i];
-            assert.throws(testCase(test), fail(test), errorMessage(test));
-        }
+                    && /^Unexpected token: punc «{», expected: punc «.*?»$/.test(e.message);
+            } : function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && e.message === "Unexpected token: operator «" + test.operator + "»";
+            }, "Expected but didn't get a syntax error while parsing following line:\n" + test.code);
+        });
     });
 });

test/mocha/imports.js

@@ -0,0 +1,28 @@
+var assert = require("assert");
+var UglifyJS = require("../node");
+
+describe("import", function() {
+    it("Should reject invalid `import` statement syntax", function() {
+        [
+            "import *;",
+            "import A;",
+            "import {};",
+            "import `path`;",
+            "import from 'path';",
+            "import * from 'path';",
+            "import A as B from 'path';",
+            "import { A }, B from 'path';",
+            "import * as A, B from 'path';",
+            "import * as A, {} from 'path';",
+            "import { * as A } from 'path';",
+            "import { 42 as A } from 'path';",
+            "import { A-B as C } from 'path';",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+});

test/mocha/number-literal.js

@@ -89,4 +89,13 @@ describe("Number literals", function() {
             }, code);
         });
     });
+    it("Should reject invalid syntax under expression=true", function() {
+        assert.throws(function() {
+            UglifyJS.parse("42.g", {
+                expression: true,
+            });
+        }, function(e) {
+            return e instanceof UglifyJS.JS_Parse_Error;
+        });
+    });
 });

test/mocha/parentheses.js

@@ -84,7 +84,7 @@ describe("parentheses", function() {
         }
     });
 
-    it("Should compress leading parenthesis with reasonable performance", function() {
+    it("Should compress leading parentheses with reasonable performance", function() {
         this.timeout(30000);
         var code = [
             "({}?0:1)&&x();",

test/mocha/reduce.js

@@ -37,8 +37,7 @@ describe("test/reduce.js", function() {
     it("Should retain setter arguments", function() {
         var result = reduce_test(read("test/input/reduce/setter.js"), {
             compress: {
-                keep_fargs: false,
-                unsafe: true,
+                unsafe_math: true,
             },
             mangle: false,
         }, {
@@ -110,28 +109,24 @@ describe("test/reduce.js", function() {
     });
     it("Should print correct output for irreducible test case", function() {
         var result = reduce_test([
-            "console.log(function f(a) {",
-            "    return f.length;",
-            "}());",
+            "console.log(1 + .1 + .1);",
         ].join("\n"), {
             compress: {
-                keep_fargs: false,
+                unsafe_math: true,
             },
             mangle: false,
         });
         if (result.error) throw result.error;
         assert.strictEqual(result.code, [
             "// (beautified)",
-            "console.log(function f(a) {",
-            "    return f.length;",
-            "}());",
-            "// output: 1",
+            "console.log(1 + .1 + .1);",
+            "// output: 1.2000000000000002",
             "// ",
-            "// minify: 0",
+            "// minify: 1.2",
             "// ",
             "// options: {",
             '//   "compress": {',
-            '//     "keep_fargs": false',
+            '//     "unsafe_math": true',
             "//   },",
             '//   "mangle": false',
             "// }",
@@ -299,12 +294,45 @@ describe("test/reduce.js", function() {
             "// }",
         ]).join("\n"));
     });
+    it("Should maintain block-scope for const/let", function() {
+        if (semver.satisfies(process.version, "<4")) return;
+        this.timeout(120000);
+        var code = [
+            '"use strict";',
+            "",
+            "L: for (let a = (1 - .8).toString(); ;) {",
+            "    if (!console.log(a)) {",
+            "        break L;",
+            "    }",
+            "}",
+        ].join("\n");
+        var result = reduce_test(code, {
+            compress: {
+                unsafe_math: true,
+            },
+            mangle: false,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "// (beautified)",
+            code,
+            "// output: 0.19999999999999996",
+            "// ",
+            "// minify: 0.2",
+            "// ",
+            "// options: {",
+            '//   "compress": {',
+            '//     "unsafe_math": true',
+            '//   },',
+            '//   "mangle": false',
+            "// }",
+        ].join("\n"));
+    });
     it("Should handle corner cases when intermediate case differs only in Error.message", function() {
         if (semver.satisfies(process.version, "<=0.10")) return;
         var result = reduce_test(read("test/input/reduce/diff_error.js"), {
             compress: {
-                keep_fargs: false,
-                unsafe: true,
+                unsafe_math: true,
             },
             mangle: false,
         }, {
@@ -313,6 +341,18 @@ describe("test/reduce.js", function() {
         if (result.error) throw result.error;
         assert.strictEqual(result.code, read("test/input/reduce/diff_error.reduced.js"));
     });
+    it("Should maintain valid LHS in destructuring assignments", function() {
+        if (semver.satisfies(process.version, "<6")) return;
+        var result = reduce_test(read("test/input/reduce/destructured_assign.js"), {
+            compress: {
+                unsafe_math: true,
+            },
+            mangle: false,
+            validate: true,
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, read("test/input/reduce/destructured_assign.reduced.js"));
+    });
     it("Should handle destructured catch expressions", function() {
         if (semver.satisfies(process.version, "<6")) return;
         var result = reduce_test(read("test/input/reduce/destructured_catch.js"), {

test/mocha/sourcemaps.js

@@ -244,6 +244,39 @@ describe("sourcemaps", function() {
             assert.strictEqual(result.code, '(function(){console.log("hello")}).call(this);');
             assert.strictEqual(result.map, '{"version":3,"sources":["main.coffee"],"names":["console","log"],"mappings":"CAAA,WAAAA,QAAQC,IAAI"}');
         });
+        it("Should not overwrite existing sourcesContent", function() {
+            var result = UglifyJS.minify({
+                "in.js": [
+                    '"use strict";',
+                    "",
+                    "var _window$foo = window.foo,",
+                    "    a = _window$foo[0],",
+                    "    b = _window$foo[1];",
+                ].join("\n"),
+            }, {
+                compress: false,
+                mangle: false,
+                sourceMap: {
+                    content: {
+                        version: 3,
+                        sources: [ "in.js" ],
+                        names: [
+                            "window",
+                            "foo",
+                            "a",
+                            "b",
+                        ],
+                        mappings: ";;kBAAaA,MAAM,CAACC,G;IAAfC,C;IAAGC,C",
+                        file: "in.js",
+                        sourcesContent: [ "let [a, b] = window.foo;\n" ],
+                    },
+                    includeSources: true,
+                },
+            });
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, '"use strict";var _window$foo=window.foo,a=_window$foo[0],b=_window$foo[1];');
+            assert.strictEqual(result.map, '{"version":3,"sources":["in.js"],"sourcesContent":["let [a, b] = window.foo;\\n"],"names":["window","foo","a","b"],"mappings":"6BAAaA,OAAOC,IAAfC,E,eAAGC,E"}');
+        });
     });
 
     describe("sourceMapInline", function() {

test/mocha/string-literal.js

@@ -115,8 +115,8 @@ describe("String literals", function() {
                 UglifyJS.parse(test);
             }, function(e) {
                 return e instanceof UglifyJS.JS_Parse_Error
-                    && e.message === "Invalid hex-character pattern in string";
-            });
+                    && /^Invalid escape sequence: \\u/.test(e.message);
+            }, test);
         });
     });
     it("Should reject invalid code points in Unicode escape sequence", function() {
@@ -130,8 +130,8 @@ describe("String literals", function() {
                 UglifyJS.parse(test);
             }, function(e) {
                 return e instanceof UglifyJS.JS_Parse_Error
-                    && /^Invalid character code: /.test(e.message);
-            });
+                    && /^Invalid escape sequence: \\u{1/.test(e.message);
+            }, test);
         });
     });
 });

test/mocha/templates.js

@@ -0,0 +1,67 @@
+var assert = require("assert");
+var run_code = require("../sandbox").run_code;
+var semver = require("semver");
+var UglifyJS = require("../node");
+
+describe("Template literals", function() {
+    it("Should reject invalid literal", function() {
+        [
+            "`foo\\`",
+            "`foo${bar`",
+            "`foo${bar}",
+        ].forEach(function(input) {
+            assert.throws(function() {
+                UglifyJS.parse(input);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && e.message === "Unterminated template literal";
+            }, input);
+        });
+    });
+    it("Should reject invalid expression", function() {
+        [
+            "`foo${bar;}`",
+            "`foo${42bar}`",
+        ].forEach(function(input) {
+            assert.throws(function() {
+                UglifyJS.parse(input);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, input);
+        });
+    });
+    it("Should process line-break characters correctly", function() {
+        [
+            // native line breaks
+            [ "`foo\nbar`", "`foo\nbar`" ],
+            [ "`foo\rbar`", "`foo\rbar`" ],
+            [ "`foo\r\nbar`", "`foo\nbar`" ],
+            [ "`foo\r\n\rbar`", "`foo\n\rbar`" ],
+            // escaped line breaks
+            [ "`foo\\nbar`", "`foo\\nbar`" ],
+            [ "`foo\\rbar`", "`foo\\rbar`" ],
+            [ "`foo\r\\nbar`", "`foo\r\\nbar`" ],
+            [ "`foo\\r\nbar`", "`foo\\r\nbar`" ],
+            [ "`foo\\r\\nbar`", "`foo\\r\\nbar`" ],
+            // continuation
+            [ "`foo\\\nbar`", "`foo\\\nbar`" ],
+            [ "`foo\\\rbar`", "`foo\\\rbar`" ],
+            [ "`foo\\\r\nbar`", "`foo\\\nbar`" ],
+            [ "`foo\\\r\n\rbar`", "`foo\\\n\rbar`" ],
+            [ "`foo\\\\nbar`", "`foo\\\\nbar`" ],
+            [ "`foo\\\\rbar`", "`foo\\\\rbar`" ],
+            [ "`foo\\\\r\nbar`", "`foo\\\\r\nbar`" ],
+        ].forEach(function(test) {
+            var input = "console.log(" + test[0] + ");";
+            var result = UglifyJS.minify(input, {
+                compress: false,
+                mangle: false,
+            });
+            if (result.error) throw result.error;
+            var expected = "console.log(" + test[1] + ");";
+            assert.strictEqual(result.code, expected, test[0]);
+            if (semver.satisfies(process.version, "<4")) return;
+            assert.strictEqual(run_code(result.code), run_code(input), test[0]);
+        });
+    });
+});

test/mocha/yields.js

@@ -0,0 +1,82 @@
+var assert = require("assert");
+var UglifyJS = require("../node");
+
+describe("generator", function() {
+    it("Should reject `yield` as symbol name within generator functions only", function() {
+        [
+            "function yield() {}",
+            "function(yield) {}",
+            "function() { yield:{} }",
+            "function() { var yield; }",
+            "function() { function yield() {} }",
+            "function() { try {} catch (yield) {} }",
+        ].forEach(function(code) {
+            var ast = UglifyJS.parse("(" + code + ")();");
+            assert.strictEqual(ast.TYPE, "Toplevel");
+            assert.strictEqual(ast.body.length, 1);
+            assert.strictEqual(ast.body[0].TYPE, "SimpleStatement");
+            assert.strictEqual(ast.body[0].body.TYPE, "Call");
+            assert.strictEqual(ast.body[0].body.expression.TYPE, "Function");
+            assert.throws(function() {
+                UglifyJS.parse("(" + code.replace(/^function/, "function*") + ")();");
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject `yield` expression outside of generator functions", function() {
+        [
+            "yield 42;",
+            "function f() { yield 42; }",
+            "function* f() { function g() { yield 42; } }",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should reject `yield` expression directly on computed key of function argument", function() {
+        [
+            "function f({ [yield 42]: a }) {}",
+            "function* f({ [yield 42]: a }) {}",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should accept `yield` expression nested within computed key of function argument", function() {
+        [
+            "function f({ [function*() { yield 42; }()]: a }) {}",
+            "function* f({ [function*() { yield 42; }()]: a }) {}",
+        ].forEach(function(code) {
+            var ast = UglifyJS.parse(code);
+            assert.strictEqual(ast.TYPE, "Toplevel");
+            assert.strictEqual(ast.body.length, 1);
+            assert.strictEqual(ast.body[0].argnames.length, 1);
+            assert.strictEqual(ast.body[0].argnames[0].TYPE, "DestructuredObject");
+        });
+    });
+    it("Should reject `yield*` without an expression", function() {
+        [
+            "yield*",
+            "yield*;",
+            "yield*,",
+            "(yield*)",
+            "[ yield* ]",
+            "42[yield*]",
+            "yield* && 42",
+        ].forEach(function(code) {
+            code = "function* f() { " + code + " }";
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
+});

test/reduce.js

@@ -70,8 +70,8 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
     } else if (differs.error) {
         differs.warnings = warnings;
         return differs;
-    } else if (is_error(differs.unminified_result)
-        && is_error(differs.minified_result)
+    } else if (sandbox.is_error(differs.unminified_result)
+        && sandbox.is_error(differs.minified_result)
         && differs.unminified_result.name == differs.minified_result.name) {
         return {
             code: [
@@ -104,15 +104,14 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
 
             // quick ignores
             if (node instanceof U.AST_Accessor) return;
-            if (node instanceof U.AST_Destructured) return;
             if (node instanceof U.AST_Directive) return;
             if (!in_list && node instanceof U.AST_EmptyStatement) return;
             if (node instanceof U.AST_Label) return;
             if (node instanceof U.AST_LabelRef) return;
-            if (!in_list && node instanceof U.AST_SymbolDeclaration) return;
             if (node instanceof U.AST_Toplevel) return;
             var parent = tt.parent();
             if (node instanceof U.AST_SymbolFunarg && parent instanceof U.AST_Accessor) return;
+            if (!in_list && parent.rest !== node && node instanceof U.AST_SymbolDeclaration) return;
 
             // ensure that the _permute prop is a number.
             // can not use `node.start._permute |= 0;` as it will erase fractional part.
@@ -124,7 +123,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
 
             // ignore lvalues
             if (parent instanceof U.AST_Assign && parent.left === node) return;
-            if (parent instanceof U.AST_DestructuredArray) return;
+            if (parent instanceof U.AST_DefaultValue && parent.name === node) return;
             if (parent instanceof U.AST_DestructuredKeyVal && parent.value === node) return;
             if (parent instanceof U.AST_Unary && parent.expression === node) switch (parent.operator) {
               case "++":
@@ -132,10 +131,16 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
               case "delete":
                 return;
             }
+            if (parent instanceof U.AST_VarDef && parent.name === node) return;
+            // preserve exports
+            if (parent instanceof U.AST_ExportDeclaration) return;
+            if (parent instanceof U.AST_ExportDefault) return;
+            if (parent instanceof U.AST_ExportForeign) return;
+            if (parent instanceof U.AST_ExportReferences) return;
             // preserve for (var xxx; ...)
             if (parent instanceof U.AST_For && parent.init === node && node instanceof U.AST_Definitions) return node;
-            // preserve for (xxx in ...)
-            if (parent instanceof U.AST_ForIn && parent.init === node) return node;
+            // preserve for (xxx in/of ...)
+            if (parent instanceof U.AST_ForEnumeration && parent.init === node) return node;
 
             // node specific permutations with no parent logic
 
@@ -153,6 +158,20 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                     node.left,
                     node.right,
                 ][ permute & 1 ];
+                if (expr instanceof U.AST_Destructured) expr = expr.transform(new U.TreeTransformer(function(node, descend) {
+                    if (node instanceof U.AST_DefaultValue) return new U.AST_Assign({
+                        operator: "=",
+                        left: node.name.transform(this),
+                        right: node.value,
+                        start: {},
+                    });
+                    if (node instanceof U.AST_DestructuredKeyVal) return new U.AST_ObjectKeyVal(node);
+                    if (node instanceof U.AST_Destructured) {
+                        node = new (node instanceof U.AST_DestructuredArray ? U.AST_Array : U.AST_Object)(node);
+                        descend(node, this);
+                    }
+                    return node;
+                }));
                 CHANGED = true;
                 return permute < 2 ? expr : wrap_with_console_log(expr);
             }
@@ -167,7 +186,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             }
             else if (node instanceof U.AST_Call) {
                 var expr = [
-                    node.expression,
+                    !(node.expression instanceof U.AST_Super) && node.expression,
                     node.args[0],
                     null,  // intentional
                 ][ ((node.start._permute += step) * steps | 0) % 3 ];
@@ -188,7 +207,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                     var seq = [];
                     body.forEach(function(node) {
                         var expr = expr instanceof U.AST_Exit ? node.value : node.body;
-                        if (expr instanceof U.AST_Node && !is_statement(expr)) {
+                        if (expr instanceof U.AST_Node && !U.is_statement(expr)) {
                             // collect expressions from each statements' body
                             seq.push(expr);
                         }
@@ -211,6 +230,28 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                     node.alternative,
                 ][ ((node.start._permute += step) * steps | 0) % 3 ];
             }
+            else if (node instanceof U.AST_DefaultValue) {
+                node.start._permute++;
+                CHANGED = true;
+                return node.name;
+            }
+            else if (node instanceof U.AST_DestructuredArray) {
+                var expr = node.elements[0];
+                if (expr && !(expr instanceof U.AST_Hole)) {
+                    node.start._permute++;
+                    CHANGED = true;
+                    return expr;
+                }
+            }
+            else if (node instanceof U.AST_DestructuredObject) {
+                // first property's value
+                var expr = node.properties[0];
+                if (expr) {
+                    node.start._permute++;
+                    CHANGED = true;
+                    return expr.value;
+                }
+            }
             else if (node instanceof U.AST_Defun) {
                 switch (((node.start._permute += step) * steps | 0) % 2) {
                   case 0:
@@ -264,10 +305,10 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 node.start._permute += step;
                 if (expr && (expr !== node.body || !has_loopcontrol(expr, node, parent))) {
                     CHANGED = true;
-                    return to_statement(expr);
+                    return to_statement_init(expr);
                 }
             }
-            else if (node instanceof U.AST_ForIn) {
+            else if (node instanceof U.AST_ForEnumeration) {
                 var expr;
                 switch ((node.start._permute * steps | 0) % 3) {
                   case 0:
@@ -286,7 +327,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                 node.start._permute += step;
                 if (expr) {
                     CHANGED = true;
-                    return to_statement(expr);
+                    return to_statement_init(expr);
                 }
             }
             else if (node instanceof U.AST_If) {
@@ -304,7 +345,16 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             }
             else if (node instanceof U.AST_Object) {
                 // first property's value
-                var expr = node.properties[0] instanceof U.AST_ObjectKeyVal && node.properties[0].value;
+                var expr = node.properties[0];
+                if (expr instanceof U.AST_ObjectKeyVal) {
+                    expr = expr.value;
+                } else if (expr instanceof U.AST_Spread) {
+                    expr = expr.expression;
+                } else if (expr && expr.key instanceof U.AST_Node) {
+                    expr = expr.key;
+                } else {
+                    expr = null;
+                }
                 if (expr) {
                     node.start._permute++;
                     CHANGED = true;
@@ -313,8 +363,8 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             }
             else if (node instanceof U.AST_PropAccess) {
                 var expr = [
-                    node.expression,
-                    node.property instanceof U.AST_Node && node.property,
+                    !(node.expression instanceof U.AST_Super) && node.expression,
+                    node.property instanceof U.AST_Node && !(parent instanceof U.AST_Destructured) && node.property,
                 ][ node.start._permute++ % 2 ];
                 if (expr) {
                     CHANGED = true;
@@ -410,25 +460,27 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                     return List.skip;
                 }
 
+                // preserve sole definition of an export statement
+                if (node instanceof U.AST_VarDef
+                    && parent.definitions.length == 1
+                    && tt.parent(1) instanceof U.AST_ExportDeclaration) {
+                    return node;
+                }
+
                 // remove this node unless its the sole element of a (transient) sequence
                 if (!(parent instanceof U.AST_Sequence) || parent.expressions.length > 1) {
                     node.start._permute++;
                     CHANGED = true;
                     return List.skip;
                 }
-
-                // skip element/property from (destructured) array/object
-                if (parent instanceof U.AST_Array
-                    || parent instanceof U.AST_Destructured
-                    || parent instanceof U.AST_Object) {
-                    node.start._permute++;
-                    CHANGED = true;
-                    return List.skip;
-                }
+            } else if (parent.rest === node) {
+                node.start._permute++;
+                CHANGED = true;
+                return null;
             }
 
             // replace this node
-            var newNode = is_statement(node) ? new U.AST_EmptyStatement({
+            var newNode = U.is_statement(node) ? new U.AST_EmptyStatement({
                 start: {},
             }) : U.parse(REPLACEMENTS[node.start._permute % REPLACEMENTS.length | 0], {
                 expression: true,
@@ -519,8 +571,8 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                         log(code);
                         log(diff.error.stack);
                         log("*** Discarding permutation and continuing.");
-                    } else if (is_error(diff.unminified_result)
-                        && is_error(diff.minified_result)
+                    } else if (sandbox.is_error(diff.unminified_result)
+                        && sandbox.is_error(diff.minified_result)
                         && diff.unminified_result.name == diff.minified_result.name) {
                         // ignore difference in error messages caused by minification
                         diff_error_message = testcase;
@@ -561,10 +613,10 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
         }
         var lines = [ "" ];
         if (isNaN(max_timeout)) {
-            lines.push("// minify error: " + to_comment(strip_color_codes(differs.minified_result.stack)));
+            lines.push("// minify error: " + to_comment(differs.minified_result.stack));
         } else {
-            var unminified_result = strip_color_codes(differs.unminified_result);
-            var minified_result = strip_color_codes(differs.minified_result);
+            var unminified_result = differs.unminified_result;
+            var minified_result = differs.minified_result;
             if (trim_trailing_whitespace(unminified_result) == trim_trailing_whitespace(minified_result)) {
                 lines.push(
                     "// (stringified)",
@@ -585,10 +637,6 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
     }
 };
 
-function strip_color_codes(value) {
-    return ("" + value).replace(/\u001b\[\d+m/g, "");
-}
-
 function to_comment(value) {
     return ("" + value).replace(/\n/g, "\n// ");
 }
@@ -626,17 +674,8 @@ function has_loopcontrol(body, loop, label) {
     return found;
 }
 
-function is_error(result) {
-    return typeof result == "object" && typeof result.name == "string" && typeof result.message == "string";
-}
-
 function is_timed_out(result) {
-    return is_error(result) && /timed out/.test(result.message);
-}
-
-function is_statement(node) {
-    return node instanceof U.AST_Statement
-        && !(node instanceof U.AST_Arrow || node instanceof U.AST_AsyncFunction || node instanceof U.AST_Function);
+    return sandbox.is_error(result) && /timed out/.test(result.message);
 }
 
 function merge_sequence(array, node) {
@@ -658,12 +697,19 @@ function to_sequence(expressions) {
 }
 
 function to_statement(node) {
-    return is_statement(node) ? node : new U.AST_SimpleStatement({
+    return U.is_statement(node) ? node : new U.AST_SimpleStatement({
         body: node,
         start: {},
     });
 }
 
+function to_statement_init(node) {
+    return node instanceof U.AST_Const || node instanceof U.AST_Let ? new U.AST_BlockStatement({
+        body: [ node ],
+        start: {},
+    }) : to_statement(node);;
+}
+
 function wrap_with_console_log(node) {
     // wrap with console.log()
     return new U.AST_Call({
@@ -686,7 +732,7 @@ function run_code(code, toplevel, result_cache, timeout) {
     if (!value) {
         var start = Date.now();
         result_cache[key] = value = {
-            result: sandbox.run_code(code, toplevel, timeout),
+            result: sandbox.run_code(sandbox.patch_module_statements(code), toplevel, timeout),
             elapsed: Date.now() - start,
         };
     }

test/sandbox.js

@@ -1,93 +1,45 @@
+var readFileSync = require("fs").readFileSync;
 var semver = require("semver");
+var spawnSync = require("child_process").spawnSync;
 var vm = require("vm");
 
-var setupContext = new vm.Script([
-    "[ Array, Boolean, Error, Function, Number, Object, RegExp, String ].forEach(function(f) {",
-    "    f.toString = Function.prototype.toString;",
-    "});",
-    "Function.prototype.toString = function() {",
-    "    var id = 100000;",
-    "    return function() {",
-    "        var n = this.name;",
-    "        if (!/^F[0-9]{6}N$/.test(n)) {",
-    '            n = "F" + ++id + "N";',
-].concat(Object.getOwnPropertyDescriptor(Function.prototype, "name").configurable ? [
-    '            Object.defineProperty(this, "name", {',
-    "                get: function() {",
-    "                    return n;",
-    "                }",
-    "            });",
-] : [], [
-    "        }",
-    '        return "function(){}";',
-    "    };",
-    "}();",
-    "this;",
-]).join("\n"));
-
-function createContext() {
-    var ctx = vm.createContext(Object.defineProperties({}, {
-        console: { value: { log: log } },
-        global: { get: self },
-        self: { get: self },
-        window: { get: self },
-    }));
-    var global = setupContext.runInContext(ctx);
-    return ctx;
-
-    function self() {
-        return this;
-    }
-
-    function safe_log(arg, level) {
-        if (arg) switch (typeof arg) {
-          case "function":
-            return arg.toString();
-          case "object":
-            if (arg === global) return "[object global]";
-            if (/Error$/.test(arg.name)) return arg.toString();
-            if (typeof arg.then == "function") return "[object Promise]";
-            arg.constructor.toString();
-            if (level--) for (var key in arg) {
-                var desc = Object.getOwnPropertyDescriptor(arg, key);
-                if (!desc || !desc.get && !desc.set) arg[key] = safe_log(arg[key], level);
-            }
-        }
-        return arg;
-    }
-
-    function log(msg) {
-        if (arguments.length == 1 && typeof msg == "string") return console.log("%s", msg);
-        return console.log.apply(console, [].map.call(arguments, function(arg) {
-            return safe_log(arg, 3);
-        }));
-    }
-}
-
-exports.run_code = function(code, toplevel, timeout) {
-    timeout = timeout || 5000;
-    var stdout = "";
-    var original_write = process.stdout.write;
-    process.stdout.write = function(chunk) {
-        stdout += chunk;
-    };
-    try {
-        vm.runInContext(toplevel ? "(function(){" + code + "})()" : code, createContext(), { timeout: timeout });
-        return stdout;
-    } catch (ex) {
-        return ex;
-    } finally {
-        process.stdout.write = original_write;
+setup_log();
+var setup_code = "(" + setup + ")(" + [
+    "this",
+    find_builtins(),
+    setup_log,
+    "function(process) {" + readFileSync(require.resolve("../tools/tty", "utf8")) + "}",
+].join(",\n") + ");\n";
+exports.has_toplevel = function(options) {
+    return options.toplevel
+        || options.mangle && options.mangle.toplevel
+        || options.compress && options.compress.toplevel;
+};
+exports.is_error = is_error;
+exports.run_code = semver.satisfies(process.version, "0.8") ? function(code, toplevel, timeout) {
+    var stdout = run_code_vm(code, toplevel, timeout);
+    if (typeof stdout != "string" || !/arguments/.test(code)) return stdout;
+    do {
+        var prev = stdout;
+        stdout = run_code_vm(code, toplevel, timeout);
+    } while (prev !== stdout);
+    return stdout;
+} : semver.satisfies(process.version, "<0.12") ? run_code_vm : function(code, toplevel, timeout) {
+    if ([
+        /\basync[ \t]*\([\s\S]*?\)[ \t]*=>/,
+        /\b(async[ \t]+function|setInterval|setTimeout)\b/,
+        /\basync([ \t]+|[ \t]*\*[ \t]*)[^\s()[\]{},.&|!~=*%/+-]+(\s*\(|[ \t]*=>)/,
+    ].some(function(pattern) {
+        return pattern.test(code);
+    })) {
+        return run_code_exec(code, toplevel, timeout);
+    } else {
+        return run_code_vm(code, toplevel, timeout);
     }
 };
-
-function strip_func_ids(text) {
-    return ("" + text).replace(/F[0-9]{6}N/g, "<F<>N>");
-}
-
 exports.same_stdout = semver.satisfies(process.version, "0.12") ? function(expected, actual) {
     if (typeof expected != typeof actual) return false;
-    if (typeof expected == "object" && typeof expected.name == "string" && typeof expected.message == "string") {
+    if (is_error(expected)) {
         if (expected.name !== actual.name) return false;
         if (typeof actual.message != "string") return false;
         expected = expected.message.slice(expected.message.lastIndexOf("\n") + 1);
@@ -97,8 +49,250 @@ exports.same_stdout = semver.satisfies(process.version, "0.12") ? function(expec
 } : function(expected, actual) {
     return typeof expected == typeof actual && strip_func_ids(expected) == strip_func_ids(actual);
 };
-exports.has_toplevel = function(options) {
-    return options.toplevel
-        || options.mangle && options.mangle.toplevel
-        || options.compress && options.compress.toplevel;
+exports.patch_module_statements = function(code) {
+    var count = 0, imports = [];
+    code = code.replace(/\bexport(?:\s*\{[^}]*}\s*?(?:$|\n|;)|\s+default\b(?:\s*(\(|\{|class\s*\{|class\s+(?=extends\b)|(?:async\s+)?function\s*(?:\*\s*)?\())?|\b)/g, function(match, header) {
+        if (!header) return "";
+        if (header.length == 1) return "0, " + header;
+        return header.slice(0, -1) + " _" + ++count + header.slice(-1);
+    }).replace(/\bimport\b(?:\s*([^('"]+)\bfrom\b)?\s*(['"]).*?\2(?:$|\n|;)/g, function(match, symbols) {
+        if (symbols) {
+            if (!/^[{*]/.test(symbols)) symbols = "default:" + symbols;
+            symbols = symbols.replace(/[{}]/g, "").trim().replace(/\s*,\s*/g, ",");
+            symbols = symbols.replace(/\*/, '"*"').replace(/\bas\s+(?!$|,|as\s)/g, ":");
+            imports.push([
+                "const {",
+                symbols,
+                "} = new Proxy(Object.create(null), { get(_, value) { return { value }; } });",
+            ].join(""));
+        }
+        return "";
+    });
+    imports.push("");
+    return imports.join("\n") + code;
 };
+
+function is_error(result) {
+    return result && typeof result.name == "string" && typeof result.message == "string";
+}
+
+function strip_color_codes(value) {
+    return value.replace(/\u001b\[\d+m/g, "");
+}
+
+function strip_func_ids(text) {
+    return ("" + text).replace(/F[0-9]{6}N/g, "<F<>N>");
+}
+
+function setup_log() {
+    var inspect = require("util").inspect;
+    if (inspect.defaultOptions) {
+        var log_options = {
+            breakLength: Infinity,
+            colors: false,
+            compact: true,
+            customInspect: false,
+            depth: Infinity,
+            maxArrayLength: Infinity,
+            maxStringLength: Infinity,
+            showHidden: false,
+        };
+        for (var name in log_options) {
+            if (name in inspect.defaultOptions) inspect.defaultOptions[name] = log_options[name];
+        }
+    }
+    return inspect;
+}
+
+function find_builtins() {
+    setup_code = "console.log(Object.keys(this));";
+    var builtins = run_code_vm("");
+    if (semver.satisfies(process.version, ">=0.12")) builtins += ".concat(" + run_code_exec("") + ")";
+    return builtins;
+}
+
+function setup(global, builtins, setup_log, setup_tty) {
+    [ Array, Boolean, Error, Function, Number, Object, RegExp, String ].forEach(function(f) {
+        f.toString = Function.prototype.toString;
+    });
+    Function.prototype.toString = function() {
+        var configurable = Object.getOwnPropertyDescriptor(Function.prototype, "name").configurable;
+        var id = 100000;
+        return function() {
+            var n = this.name;
+            if (!/^F[0-9]{6}N$/.test(n)) {
+                n = "F" + ++id + "N";
+                if (configurable) Object.defineProperty(this, "name", {
+                    get: function() {
+                        return n;
+                    }
+                });
+            }
+            return "function(){}";
+        };
+    }();
+    var process = global.process;
+    if (process) {
+        setup_tty(process);
+        var inspect = setup_log();
+        process.on("uncaughtException", function(ex) {
+            var value = ex;
+            if (value instanceof Error) {
+                value = {};
+                for (var name in ex) {
+                    value[name] = ex[name];
+                    delete ex[name];
+                }
+            }
+            process.stderr.write(inspect(value) + "\n\n-----===== UNCAUGHT EXCEPTION =====-----\n\n");
+            throw ex;
+        }).on("unhandledRejection", function() {});
+    }
+    var log = console.log;
+    var safe_console = {
+        log: function(msg) {
+            if (arguments.length == 1 && typeof msg == "string") return log("%s", msg);
+            return log.apply(null, [].map.call(arguments, function(arg) {
+                return safe_log(arg, {
+                    level: 5,
+                    original: [],
+                    replaced: [],
+                });
+            }));
+        },
+    };
+    var props = {
+        // for Node.js v8
+        console: {
+            get: function() {
+                return safe_console;
+            },
+        },
+        global: { get: self },
+        self: { get: self },
+        window: { get: self },
+    };
+    [
+        // for Node.js v0.12
+        "Buffer",
+        "clearInterval",
+        "clearTimeout",
+        // for Node.js v0.12
+        "DTRACE_NET_STREAM_END",
+        // for Node.js v8
+        "process",
+        "setInterval",
+        "setTimeout",
+    ].forEach(function(name) {
+        var value = global[name];
+        props[name] = {
+            get: function() {
+                return value;
+            },
+        };
+    });
+    builtins.forEach(function(name) {
+        try {
+            delete global[name];
+        } catch (e) {}
+    });
+    Object.defineProperties(global, props);
+    // for Node.js v8+
+    global.toString = function() {
+        return "[object global]";
+    };
+
+    function self() {
+        return this;
+    }
+
+    function safe_log(arg, cache) {
+        if (arg) switch (typeof arg) {
+          case "function":
+            return arg.toString();
+          case "object":
+            if (arg === global) return "[object global]";
+            if (/Error$/.test(arg.name)) return arg.toString();
+            if (typeof arg.then == "function") return "[object Promise]";
+            arg.constructor.toString();
+            var index = cache.original.indexOf(arg);
+            if (index >= 0) return cache.replaced[index];
+            if (--cache.level < 0) return "[object Object]";
+            var value = {};
+            cache.original.push(arg);
+            cache.replaced.push(value);
+            for (var key in arg) {
+                var desc = Object.getOwnPropertyDescriptor(arg, key);
+                if (desc && (desc.get || desc.set)) {
+                    Object.defineProperty(value, key, desc);
+                } else {
+                    value[key] = safe_log(arg[key], cache);
+                }
+            }
+            return value;
+        }
+        return arg;
+    }
+}
+
+function run_code_vm(code, toplevel, timeout) {
+    timeout = timeout || 5000;
+    var stdout = "";
+    var original_write = process.stdout.write;
+    process.stdout.write = function(chunk) {
+        stdout += chunk;
+    };
+    try {
+        var ctx = vm.createContext({ console: console });
+        // for Node.js v6
+        vm.runInContext(setup_code, ctx);
+        vm.runInContext(toplevel ? "(function(){" + code + "})();" : code, ctx, { timeout: timeout });
+        return strip_color_codes(stdout);
+    } catch (ex) {
+        return ex;
+    } finally {
+        process.stdout.write = original_write;
+    }
+}
+
+function run_code_exec(code, toplevel, timeout) {
+    if (toplevel) {
+        code = setup_code + "(function(){" + code + "})();";
+    } else {
+        code = code.replace(/^((["'])[^"']*\2(;|$))?/, function(directive) {
+            return directive + setup_code;
+        });
+    }
+    var result = spawnSync(process.argv[0], [ '--max-old-space-size=2048' ], {
+        encoding: "utf8",
+        input: code,
+        stdio: "pipe",
+        timeout: timeout || 5000,
+    });
+    if (result.status === 0) return result.stdout;
+    if (result.error && result.error.code == "ETIMEDOUT" || /FATAL ERROR:/.test(msg)) {
+        return new Error("Script execution timed out.");
+    }
+    if (result.error) return result.error;
+    var msg = result.stderr.replace(/\r\n/g, "\n");
+    var end = msg.indexOf("\n\n-----===== UNCAUGHT EXCEPTION =====-----\n\n");
+    var details;
+    if (end >= 0) {
+        details = msg.slice(0, end).replace(/<([1-9][0-9]*) empty items?>/g, function(match, count) {
+            return new Array(+count).join();
+        });
+        try {
+            details = vm.runInNewContext("(" + details + ")");
+        } catch (e) {}
+    }
+    var match = /\n([^:\s]*Error)(?:: ([\s\S]+?))?\n(    at [\s\S]+)\n$/.exec(msg);
+    if (!match) return details;
+    var ex = new global[match[1]](match[2]);
+    ex.stack = ex.stack.slice(0, ex.stack.indexOf("    at ")) + match[3];
+    if (typeof details == "object") {
+        for (var name in details) ex[name] = details[name];
+    } else if (end >= 0) {
+        ex.details = details;
+    }
+    return ex;
+}

test/ufuzz/actions.js

@@ -10,16 +10,17 @@ exports.init = function(url, auth, num) {
 exports.should_stop = function(callback) {
     read(base + "/actions/runs?per_page=100", function(reply) {
         if (!reply || !Array.isArray(reply.workflow_runs)) return;
-        var runs = reply.workflow_runs.filter(function(workflow) {
-            return workflow.status != "completed";
-        }).sort(function(a, b) {
+        var runs = reply.workflow_runs.sort(function(a, b) {
             return b.run_number - a.run_number;
         });
         var found = false, remaining = 20;
         (function next() {
-            if (!runs.length) return;
-            var workflow = runs.pop();
-            if (workflow.event == "schedule" && workflow.run_number == run_number) found = true;
+            var workflow;
+            do {
+                workflow = runs.pop();
+                if (!workflow) return;
+                if (workflow.event == "schedule" && workflow.run_number == run_number) found = true;
+            } while (!found && workflow.status == "completed");
             read(workflow.jobs_url, function(reply) {
                 if (!reply || !Array.isArray(reply.jobs)) return;
                 if (!reply.jobs.every(function(job) {

test/ufuzz/job.js

@@ -70,7 +70,7 @@ function run() {
 
     function trap(data) {
         stderr += data;
-        if (~stderr.indexOf("\nminify(options):\n")) {
+        if (~stderr.indexOf("!!!!!! Failed... round ")) {
             process.exitCode = 1;
             child.stderr.removeListener("data", trap);
         }

test/ufuzz/options.json

@@ -21,14 +21,16 @@
     },
     {
         "compress": {
+            "hoist_vars": true,
+            "keep_infinity": true,
             "passes": 1e6,
             "unsafe": true
         },
+        "keep_fnames": true,
         "toplevel": true
     },
     {
         "compress": {
-            "keep_fargs": false,
             "passes": 1e6,
             "sequences": 1e6,
             "unsafe": true,

tools/exit.js

@@ -1,15 +0,0 @@
-// workaround for tty output truncation upon process.exit()
-var exit = process.exit;
-process.exit = function() {
-    var args = [].slice.call(arguments);
-    process.once("uncaughtException", function() {
-        (function callback() {
-            if (process.stdout.bufferSize || process.stderr.bufferSize) {
-                setTimeout(callback, 1);
-            } else {
-                exit.apply(process, args);
-            }
-        })();
-    });
-    throw exit;
-};

tools/exports.js

@@ -1,4 +1,5 @@
 exports["Dictionary"] = Dictionary;
+exports["is_statement"] = is_statement;
 exports["List"] = List;
 exports["minify"] = minify;
 exports["parse"] = parse;

tools/node.js

@@ -3,11 +3,11 @@ var fs = require("fs");
 exports.FILES = [
     require.resolve("../lib/utils.js"),
     require.resolve("../lib/ast.js"),
-    require.resolve("../lib/parse.js"),
     require.resolve("../lib/transform.js"),
+    require.resolve("../lib/parse.js"),
     require.resolve("../lib/scope.js"),
-    require.resolve("../lib/output.js"),
     require.resolve("../lib/compress.js"),
+    require.resolve("../lib/output.js"),
     require.resolve("../lib/sourcemap.js"),
     require.resolve("../lib/mozilla-ast.js"),
     require.resolve("../lib/propmangle.js"),
@@ -23,6 +23,37 @@ new Function("exports", function() {
     return code.join("\n\n");
 }())(exports);
 
+function to_comment(value) {
+    if (typeof value != "string") value = JSON.stringify(value, function(key, value) {
+        return typeof value == "function" ? "<[ " + value + " ]>" : value;
+    }, 2);
+    return "// " + value.replace(/\n/g, "\n// ");
+}
+
+if (+process.env["UGLIFY_BUG_REPORT"]) exports.minify = function(files, options) {
+    if (typeof options == "undefined") options = "<<undefined>>";
+    var code = [
+        "// UGLIFY_BUG_REPORT",
+        to_comment(options),
+    ];
+    if (typeof files == "string") {
+        code.push("");
+        code.push("//-------------------------------------------------------------")
+        code.push("// INPUT CODE", files);
+    } else for (var name in files) {
+        code.push("");
+        code.push("//-------------------------------------------------------------")
+        code.push(to_comment(name), files[name]);
+    }
+    if (options.sourceMap && options.sourceMap.url) {
+        code.push("");
+        code.push("//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9");
+    }
+    var result = { code: code.join("\n") };
+    if (options.sourceMap) result.map = '{"version":3,"sources":[],"names":[],"mappings":""}';
+    return result;
+};
+
 function describe_ast() {
     var out = OutputStream({ beautify: true });
     function doitem(ctor) {

tools/tty.js

@@ -0,0 +1,22 @@
+// workaround for tty output truncation on Node.js
+try {
+    // prevent buffer overflow and other asynchronous bugs
+    process.stdout._handle.setBlocking(true);
+    process.stderr._handle.setBlocking(true);
+} catch (e) {
+    // ensure output buffers are flushed before process termination
+    var exit = process.exit;
+    process.exit = function() {
+        var args = [].slice.call(arguments);
+        process.once("uncaughtException", function() {
+            (function callback() {
+                if (process.stdout.bufferSize || process.stderr.bufferSize) {
+                    setTimeout(callback, 1);
+                } else {
+                    exit.apply(process, args);
+                }
+            })();
+        });
+        throw exit;
+    };
+}