v3.13.0

fixes #4708

.github/workflows/ufuzz.yml

@@ -32,9 +32,12 @@ jobs:
       - 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: |
-          brew install coreutils
+          while !(brew install coreutils); do echo "'brew install' failed - retrying..."; done
       - name: Perform fuzzing
         shell: bash
         run: |

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).
@@ -667,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
@@ -685,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
@@ -769,6 +773,9 @@ to be `false` and all symbol names will be omitted.
 
 - `switches` (default: `true`) -- de-duplicate and remove unreachable `switch` branches
 
+- `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`)
@@ -808,6 +815,8 @@ 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
@@ -1254,3 +1263,25 @@ To allow for better optimizations, the compiler makes various assumptions:
   }()) => 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

@@ -10,7 +10,7 @@ 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,9 +260,14 @@ 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 = { STDIN: chunks.join("") };
@@ -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/ast.js

@@ -113,7 +113,9 @@ var AST_Node = DEFNODE("Node", "start end", {
     walk: function(visitor) {
         visitor.visit(this);
     },
-    _validate: noop,
+    _validate: function() {
+        if (this.TYPE == "Node") throw new Error("should not instantiate AST_Node");
+    },
     validate: function() {
         var ctor = this.CTOR;
         do {
@@ -187,19 +189,26 @@ AST_Node.disable_validation = function() {
 
 var AST_Statement = DEFNODE("Statement", null, {
     $documentation: "Base class of all statements",
+    _validate: function() {
+        if (this.TYPE == "Statement") throw new Error("should not instantiate AST_Statement");
+    },
 });
 
 var AST_Debugger = DEFNODE("Debugger", null, {
     $documentation: "Represents a debugger statement",
 }, AST_Statement);
 
-var AST_Directive = DEFNODE("Directive", "value quote", {
+var AST_Directive = DEFNODE("Directive", "quote value", {
     $documentation: "Represents a directive, like \"use strict\";",
     $propdoc: {
+        quote: "[string?] the original quote character",
         value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
-        quote: "[string] the original quote character"
     },
     _validate: function() {
+        if (this.quote != null) {
+            if (typeof this.quote != "string") throw new Error("quote must be string");
+            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
+        }
         if (typeof this.value != "string") throw new Error("value must be string");
     },
 }, AST_Statement);
@@ -208,6 +217,12 @@ var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
     $documentation: "The empty statement (empty block or simply a semicolon)"
 }, AST_Statement);
 
+function is_statement(node) {
+    return node instanceof AST_Statement
+        && !(node instanceof AST_ClassExpression)
+        && !(node instanceof AST_LambdaExpression);
+}
+
 function validate_expression(value, prop, multiple, allow_spread, allow_hole) {
     multiple = multiple ? "contain" : "be";
     if (!(value instanceof AST_Node)) throw new Error(prop + " must " + multiple + " AST_Node");
@@ -215,9 +230,7 @@ function validate_expression(value, prop, multiple, allow_spread, allow_hole) {
     if (value instanceof AST_Destructured) throw new Error(prop + " cannot " + multiple + " AST_Destructured");
     if (value instanceof AST_Hole && !allow_hole) throw new Error(prop + " cannot " + multiple + " AST_Hole");
     if (value instanceof AST_Spread && !allow_spread) throw new Error(prop + " cannot " + multiple + " AST_Spread");
-    if (value instanceof AST_Statement && !is_function(value)) {
-        throw new Error(prop + " cannot " + multiple + " AST_Statement");
-    }
+    if (is_statement(value)) throw new Error(prop + " cannot " + multiple + " AST_Statement");
     if (value instanceof AST_SymbolDeclaration) {
         throw new Error(prop + " cannot " + multiple + " AST_SymbolDeclaration");
     }
@@ -230,7 +243,7 @@ function must_be_expression(node, prop) {
 var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
     $documentation: "A statement consisting of an expression, i.e. a = 1 + 2",
     $propdoc: {
-        body: "[AST_Node] an expression node (should not be instanceof AST_Statement)"
+        body: "[AST_Node] an expression node (should not be instanceof AST_Statement)",
     },
     walk: function(visitor) {
         var node = this;
@@ -249,7 +262,7 @@ var AST_BlockScope = DEFNODE("BlockScope", "enclosed functions make_def parent_s
         enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
         functions: "[Object/S] like `variables`, but only lists function declarations",
         parent_scope: "[AST_Scope?/S] link to the parent scope",
-        variables: "[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
+        variables: "[Object/S] a map of name ---> SymbolDef for all variables/functions defined in this scope",
     },
     clone: function(deep) {
         var node = this._clone(deep);
@@ -265,6 +278,7 @@ var AST_BlockScope = DEFNODE("BlockScope", "enclosed functions make_def parent_s
         return this.parent_scope.resolve();
     },
     _validate: function() {
+        if (this.TYPE == "BlockScope") throw new Error("should not instantiate AST_BlockScope");
         if (this.parent_scope == null) return;
         if (!(this.parent_scope instanceof AST_BlockScope)) throw new Error("parent_scope must be AST_BlockScope");
         if (!(this.resolve() instanceof AST_Scope)) throw new Error("must be contained within AST_Scope");
@@ -289,9 +303,9 @@ var AST_Block = DEFNODE("Block", "body", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "Block") throw new Error("should not instantiate AST_Block");
         this.body.forEach(function(node) {
-            if (!(node instanceof AST_Statement)) throw new Error("body must be AST_Statement[]");
-            if (is_function(node)) throw new Error("body cannot contain AST_Function");
+            if (!is_statement(node)) throw new Error("body must contain AST_Statement");
         });
     },
 }, AST_BlockScope);
@@ -306,8 +320,8 @@ var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", {
         body: "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"
     },
     _validate: function() {
-        if (!(this.body instanceof AST_Statement)) throw new Error("body must be AST_Statement");
-        if (is_function(this.body)) throw new Error("body cannot be AST_Function");
+        if (this.TYPE == "StatementWithBody") throw new Error("should not instantiate AST_StatementWithBody");
+        if (!is_statement(this.body)) throw new Error("body must be AST_Statement");
     },
 }, AST_BlockScope);
 
@@ -346,7 +360,10 @@ var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", {
 }, AST_StatementWithBody);
 
 var AST_IterationStatement = DEFNODE("IterationStatement", null, {
-    $documentation: "Internal class.  All loops inherit from it."
+    $documentation: "Internal class.  All loops inherit from it.",
+    _validate: function() {
+        if (this.TYPE == "IterationStatement") throw new Error("should not instantiate AST_IterationStatement");
+    },
 }, AST_StatementWithBody);
 
 var AST_DWLoop = DEFNODE("DWLoop", "condition", {
@@ -355,6 +372,7 @@ var AST_DWLoop = DEFNODE("DWLoop", "condition", {
         condition: "[AST_Node] the loop condition.  Should not be instanceof AST_Statement"
     },
     _validate: function() {
+        if (this.TYPE == "DWLoop") throw new Error("should not instantiate AST_DWLoop");
         must_be_expression(this, "condition");
     },
 }, AST_IterationStatement);
@@ -400,8 +418,7 @@ var AST_For = DEFNODE("For", "init condition step", {
     _validate: function() {
         if (this.init != null) {
             if (!(this.init instanceof AST_Node)) throw new Error("init must be AST_Node");
-            if (this.init instanceof AST_Statement
-                && !(this.init instanceof AST_Definitions || is_function(this.init))) {
+            if (is_statement(this.init) && !(this.init instanceof AST_Definitions)) {
                 throw new Error("init cannot be AST_Statement");
             }
         }
@@ -410,11 +427,11 @@ var AST_For = DEFNODE("For", "init condition step", {
     },
 }, AST_IterationStatement);
 
-var AST_ForIn = DEFNODE("ForIn", "init object", {
-    $documentation: "A `for ... in` statement",
+var AST_ForEnumeration = DEFNODE("ForEnumeration", "init object", {
+    $documentation: "Base class for enumeration loops, i.e. `for ... in`, `for ... of` & `for await ... of`",
     $propdoc: {
-        init: "[AST_Node] the `for/in` initialization code",
-        object: "[AST_Node] the object that we're looping through"
+        init: "[AST_Node] the assignment target during iteration",
+        object: "[AST_Node] the object to iterate over"
     },
     walk: function(visitor) {
         var node = this;
@@ -425,6 +442,7 @@ var AST_ForIn = DEFNODE("ForIn", "init object", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "ForEnumeration") throw new Error("should not instantiate AST_ForEnumeration");
         if (this.init instanceof AST_Definitions) {
             if (this.init.definitions.length != 1) throw new Error("init must have single declaration");
         } else {
@@ -438,6 +456,18 @@ var AST_ForIn = DEFNODE("ForIn", "init object", {
     },
 }, AST_IterationStatement);
 
+var AST_ForIn = DEFNODE("ForIn", null, {
+    $documentation: "A `for ... in` statement",
+}, AST_ForEnumeration);
+
+var AST_ForOf = DEFNODE("ForOf", null, {
+    $documentation: "A `for ... of` statement",
+}, AST_ForEnumeration);
+
+var AST_ForAwaitOf = DEFNODE("ForAwaitOf", null, {
+    $documentation: "A `for await ... of` statement",
+}, AST_ForOf);
+
 var AST_With = DEFNODE("With", "expression", {
     $documentation: "A `with` statement",
     $propdoc: {
@@ -467,12 +497,15 @@ var AST_Scope = DEFNODE("Scope", "uses_eval uses_with", {
         return this.uses_eval || this.uses_with;
     },
     resolve: return_this,
+    _validate: function() {
+        if (this.TYPE == "Scope") throw new Error("should not instantiate AST_Scope");
+    },
 }, AST_Block);
 
 var AST_Toplevel = DEFNODE("Toplevel", "globals", {
     $documentation: "The toplevel scope",
     $propdoc: {
-        globals: "[Object/S] a map of name -> SymbolDef for all undeclared names",
+        globals: "[Object/S] a map of name ---> SymbolDef for all undeclared names",
     },
     wrap: function(name) {
         var body = this.body;
@@ -517,8 +550,9 @@ var AST_Lambda = DEFNODE("Lambda", "argnames length_read rest uses_arguments", {
     $documentation: "Base class for functions",
     $propdoc: {
         argnames: "[(AST_DefaultValue|AST_Destructured|AST_SymbolFunarg)*] array of function arguments and/or destructured literals",
+        length_read: "[boolean/S] whether length property of this function is accessed",
         rest: "[(AST_Destructured|AST_SymbolFunarg)?] rest parameter, or null if absent",
-        uses_arguments: "[boolean/S] tells whether this function accesses the arguments array",
+        uses_arguments: "[boolean/S] whether this function accesses the arguments array",
     },
     each_argname: function(visit) {
         var tw = new TreeWalker(function(node) {
@@ -549,6 +583,7 @@ var AST_Lambda = DEFNODE("Lambda", "argnames length_read rest uses_arguments", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "Lambda") throw new Error("should not instantiate AST_Lambda");
         this.argnames.forEach(function(node) {
             validate_destructured(node, function(node) {
                 if (!(node instanceof AST_SymbolFunarg)) throw new Error("argnames must be AST_SymbolFunarg[]");
@@ -567,12 +602,33 @@ var AST_Accessor = DEFNODE("Accessor", null, {
     },
 }, AST_Lambda);
 
+var AST_LambdaExpression = DEFNODE("LambdaExpression", "inlined", {
+    $documentation: "Base class for function expressions",
+    $propdoc: {
+        inlined: "[boolean/S] whether this function has been inlined",
+    },
+    _validate: function() {
+        if (this.TYPE == "LambdaExpression") throw new Error("should not instantiate AST_LambdaExpression");
+    },
+}, AST_Lambda);
+
 function is_arrow(node) {
-    return node instanceof AST_AsyncArrow || node instanceof AST_Arrow;
+    return node instanceof AST_Arrow || node instanceof AST_AsyncArrow;
 }
 
-function is_function(node) {
-    return is_arrow(node) || node instanceof AST_AsyncFunction || node instanceof AST_Function;
+function is_async(node) {
+    return node instanceof AST_AsyncArrow
+        || node instanceof AST_AsyncDefun
+        || node instanceof AST_AsyncFunction
+        || node instanceof AST_AsyncGeneratorDefun
+        || node instanceof AST_AsyncGeneratorFunction;
+}
+
+function is_generator(node) {
+    return node instanceof AST_AsyncGeneratorDefun
+        || node instanceof AST_AsyncGeneratorFunction
+        || node instanceof AST_GeneratorDefun
+        || node instanceof AST_GeneratorFunction;
 }
 
 function walk_lambda(node, tw) {
@@ -583,7 +639,7 @@ function walk_lambda(node, tw) {
     }
 }
 
-var AST_Arrow = DEFNODE("Arrow", "inlined value", {
+var AST_Arrow = DEFNODE("Arrow", "value", {
     $documentation: "An arrow function expression",
     $propdoc: {
         value: "[AST_Node?] simple return expression, or null if using function body.",
@@ -610,13 +666,9 @@ var AST_Arrow = DEFNODE("Arrow", "inlined value", {
             if (this.body.length) throw new Error("body must be empty if value exists");
         }
     },
-}, AST_Lambda);
+}, AST_LambdaExpression);
 
-function is_async(node) {
-    return node instanceof AST_AsyncArrow || node instanceof AST_AsyncDefun || node instanceof AST_AsyncFunction;
-}
-
-var AST_AsyncArrow = DEFNODE("AsyncArrow", "inlined value", {
+var AST_AsyncArrow = DEFNODE("AsyncArrow", "value", {
     $documentation: "An asynchronous arrow function expression",
     $propdoc: {
         value: "[AST_Node?] simple return expression, or null if using function body.",
@@ -643,60 +695,196 @@ var AST_AsyncArrow = DEFNODE("AsyncArrow", "inlined value", {
             if (this.body.length) throw new Error("body must be empty if value exists");
         }
     },
-}, AST_Lambda);
+}, AST_LambdaExpression);
 
-var AST_AsyncFunction = DEFNODE("AsyncFunction", "inlined name", {
+var AST_AsyncFunction = DEFNODE("AsyncFunction", "name", {
     $documentation: "An asynchronous function expression",
     $propdoc: {
-        name: "[AST_SymbolLambda?] the name of this function",
+        name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
     },
     _validate: function() {
         if (this.name != null) {
             if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
         }
     },
-}, AST_Lambda);
+}, AST_LambdaExpression);
 
-var AST_Function = DEFNODE("Function", "inlined name", {
+var AST_AsyncGeneratorFunction = DEFNODE("AsyncGeneratorFunction", "name", {
+    $documentation: "An asynchronous generator function expression",
+    $propdoc: {
+        name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
+    },
+    _validate: function() {
+        if (this.name != null) {
+            if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
+        }
+    },
+}, AST_LambdaExpression);
+
+var AST_Function = DEFNODE("Function", "name", {
     $documentation: "A function expression",
     $propdoc: {
-        name: "[AST_SymbolLambda?] the name of this function",
+        name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
     },
     _validate: function() {
         if (this.name != null) {
             if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
         }
     },
+}, AST_LambdaExpression);
+
+var AST_GeneratorFunction = DEFNODE("GeneratorFunction", "name", {
+    $documentation: "A generator function expression",
+    $propdoc: {
+        name: "[AST_SymbolLambda?] the name of this function, or null if not specified",
+    },
+    _validate: function() {
+        if (this.name != null) {
+            if (!(this.name instanceof AST_SymbolLambda)) throw new Error("name must be AST_SymbolLambda");
+        }
+    },
+}, AST_LambdaExpression);
+
+var AST_LambdaDefinition = DEFNODE("LambdaDefinition", "inlined name", {
+    $documentation: "Base class for function definitions",
+    $propdoc: {
+        inlined: "[boolean/S] whether this function has been inlined",
+        name: "[AST_SymbolDefun] the name of this function",
+    },
+    _validate: function() {
+        if (this.TYPE == "LambdaDefinition") throw new Error("should not instantiate AST_LambdaDefinition");
+        if (!(this.name instanceof AST_SymbolDefun)) throw new Error("name must be AST_SymbolDefun");
+    },
 }, AST_Lambda);
 
-function is_defun(node) {
-    return node instanceof AST_AsyncDefun || node instanceof AST_Defun;
-}
-
-var AST_AsyncDefun = DEFNODE("AsyncDefun", "inlined name", {
+var AST_AsyncDefun = DEFNODE("AsyncDefun", null, {
     $documentation: "An asynchronous function definition",
-    $propdoc: {
-        name: "[AST_SymbolDefun] the name of this function",
-    },
-    _validate: function() {
-        if (!(this.name instanceof AST_SymbolDefun)) throw new Error("name must be AST_SymbolDefun");
-    },
-}, AST_Lambda);
+}, AST_LambdaDefinition);
 
-var AST_Defun = DEFNODE("Defun", "inlined name", {
+var AST_AsyncGeneratorDefun = DEFNODE("AsyncGeneratorDefun", null, {
+    $documentation: "An asynchronous generator function definition",
+}, AST_LambdaDefinition);
+
+var AST_Defun = DEFNODE("Defun", null, {
     $documentation: "A function definition",
+}, AST_LambdaDefinition);
+
+var AST_GeneratorDefun = DEFNODE("GeneratorDefun", null, {
+    $documentation: "A generator function definition",
+}, AST_LambdaDefinition);
+
+/* -----[ classes ]----- */
+
+var AST_Class = DEFNODE("Class", "extends name properties", {
+    $documentation: "Base class for class literals",
     $propdoc: {
-        name: "[AST_SymbolDefun] the name of this function",
+        extends: "[AST_Node?] the super class, or null if not specified",
+        properties: "[AST_ClassProperty*] array of class properties",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            if (node.name) node.name.walk(visitor);
+            if (node.extends) node.extends.walk(visitor);
+            node.properties.forEach(function(prop) {
+                prop.walk(visitor);
+            });
+        });
     },
     _validate: function() {
-        if (!(this.name instanceof AST_SymbolDefun)) throw new Error("name must be AST_SymbolDefun");
+        if (this.TYPE == "Class") throw new Error("should not instantiate AST_Class");
+        if (this.extends != null) must_be_expression(this, "extends");
+        this.properties.forEach(function(node) {
+            if (!(node instanceof AST_ClassProperty)) throw new Error("properties must contain AST_ClassProperty");
+        });
     },
-}, AST_Lambda);
+}, AST_BlockScope);
+
+var AST_DefClass = DEFNODE("DefClass", null, {
+    $documentation: "A class definition",
+    $propdoc: {
+        name: "[AST_SymbolDefClass] the name of this class",
+    },
+    _validate: function() {
+        if (!(this.name instanceof AST_SymbolDefClass)) throw new Error("name must be AST_SymbolDefClass");
+    },
+}, AST_Class);
+
+var AST_ClassExpression = DEFNODE("ClassExpression", null, {
+    $documentation: "A class expression",
+    $propdoc: {
+        name: "[AST_SymbolClass?] the name of this class, or null if not specified",
+    },
+    _validate: function() {
+        if (this.name != null) {
+            if (!(this.name instanceof AST_SymbolClass)) throw new Error("name must be AST_SymbolClass");
+        }
+    },
+}, AST_Class);
+
+var AST_ClassProperty = DEFNODE("ClassProperty", "key private static value", {
+    $documentation: "Base class for `class` properties",
+    $propdoc: {
+        key: "[string|AST_Node] property name (AST_Node for computed property)",
+        private: "[boolean] whether this is a private property",
+        static: "[boolean] whether this is a static property",
+        value: "[AST_Node?] property value (AST_Accessor for getters/setters, AST_LambdaExpression for methods, null if not specified for fields)",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            if (node.key instanceof AST_Node) node.key.walk(visitor);
+            if (node.value) node.value.walk(visitor);
+        });
+    },
+    _validate: function() {
+        if (this.TYPE == "ClassProperty") throw new Error("should not instantiate AST_ClassProperty");
+        if (typeof this.key != "string") {
+            if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node");
+            must_be_expression(this, "key");
+        }
+        if(this.value != null) {
+            if (!(this.value instanceof AST_Node)) throw new Error("value must be AST_Node");
+        }
+    },
+});
+
+var AST_ClassField = DEFNODE("ClassField", null, {
+    $documentation: "A `class` field",
+    _validate: function() {
+        if(this.value != null) must_be_expression(this, "value");
+    },
+}, AST_ClassProperty);
+
+var AST_ClassGetter = DEFNODE("ClassGetter", null, {
+    $documentation: "A `class` getter",
+    _validate: function() {
+        if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor");
+    },
+}, AST_ClassProperty);
+
+var AST_ClassSetter = DEFNODE("ClassSetter", null, {
+    $documentation: "A `class` setter",
+    _validate: function() {
+        if (!(this.value instanceof AST_Accessor)) throw new Error("value must be AST_Accessor");
+    },
+}, AST_ClassProperty);
+
+var AST_ClassMethod = DEFNODE("ClassMethod", null, {
+    $documentation: "A `class` method",
+    _validate: function() {
+        if (!(this.value instanceof AST_LambdaExpression)) throw new Error("value must be AST_LambdaExpression");
+        if (this.value.name != null) throw new Error("name of class method's lambda must be null");
+    },
+}, AST_ClassProperty);
 
 /* -----[ JUMPS ]----- */
 
 var AST_Jump = DEFNODE("Jump", null, {
-    $documentation: "Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)"
+    $documentation: "Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)",
+    _validate: function() {
+        if (this.TYPE == "Jump") throw new Error("should not instantiate AST_Jump");
+    },
 }, AST_Statement);
 
 var AST_Exit = DEFNODE("Exit", "value", {
@@ -709,7 +897,10 @@ var AST_Exit = DEFNODE("Exit", "value", {
         visitor.visit(node, function() {
             if (node.value) node.value.walk(visitor);
         });
-    }
+    },
+    _validate: function() {
+        if (this.TYPE == "Exit") throw new Error("should not instantiate AST_Exit");
+    },
 }, AST_Jump);
 
 var AST_Return = DEFNODE("Return", null, {
@@ -738,6 +929,7 @@ var AST_LoopControl = DEFNODE("LoopControl", "label", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "LoopControl") throw new Error("should not instantiate AST_LoopControl");
         if (this.label != null) {
             if (!(this.label instanceof AST_LabelRef)) throw new Error("label must be AST_LabelRef");
         }
@@ -771,8 +963,7 @@ var AST_If = DEFNODE("If", "condition alternative", {
     _validate: function() {
         must_be_expression(this, "condition");
         if (this.alternative != null) {
-            if (!(this.alternative instanceof AST_Statement)) throw new Error("alternative must be AST_Statement");
-            if (is_function(this.alternative)) throw new error("alternative cannot be AST_Function");
+            if (!is_statement(this.alternative)) throw new Error("alternative must be AST_Statement");
         }
     },
 }, AST_StatementWithBody);
@@ -801,6 +992,9 @@ var AST_Switch = DEFNODE("Switch", "expression", {
 
 var AST_SwitchBranch = DEFNODE("SwitchBranch", null, {
     $documentation: "Base class for `switch` branches",
+    _validate: function() {
+        if (this.TYPE == "SwitchBranch") throw new Error("should not instantiate AST_SwitchBranch");
+    },
 }, AST_Block);
 
 var AST_Default = DEFNODE("Default", null, {
@@ -889,6 +1083,7 @@ var AST_Definitions = DEFNODE("Definitions", "definitions", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "Definitions") throw new Error("should not instantiate AST_Definitions");
         if (this.definitions.length < 1) throw new Error("must have at least one definition");
     },
 }, AST_Statement);
@@ -949,6 +1144,129 @@ var AST_VarDef = DEFNODE("VarDef", "name value", {
 
 /* -----[ OTHER ]----- */
 
+var AST_ExportDeclaration = DEFNODE("ExportDeclaration", "body", {
+    $documentation: "An `export` statement",
+    $propdoc: {
+        body: "[AST_DefClass|AST_Definitions|AST_LambdaDefinition] the statement to export",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            node.body.walk(visitor);
+        });
+    },
+    _validate: function() {
+        if (!(this.body instanceof AST_DefClass
+            || this.body instanceof AST_Definitions
+            || this.body instanceof AST_LambdaDefinition)) {
+            throw new Error("body must be AST_DefClass, AST_Definitions or AST_LambdaDefinition");
+        }
+    },
+}, AST_Statement);
+
+var AST_ExportDefault = DEFNODE("ExportDefault", "body", {
+    $documentation: "An `export default` statement",
+    $propdoc: {
+        body: "[AST_Node] the default export",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            node.body.walk(visitor);
+        });
+    },
+    _validate: function() {
+        if (!(this.body instanceof AST_DefClass || this.body instanceof AST_LambdaDefinition)) {
+            must_be_expression(this, "body");
+        }
+    },
+}, AST_Statement);
+
+var AST_ExportForeign = DEFNODE("ExportForeign", "aliases keys path quote", {
+    $documentation: "An `export ... from '...'` statement",
+    $propdoc: {
+        aliases: "[string*] array of aliases to export",
+        keys: "[string*] array of keys to import",
+        path: "[string] the path to import module",
+        quote: "[string?] the original quote character",
+    },
+    _validate: function() {
+        if (this.aliases.length != this.keys.length) {
+            throw new Error("aliases:key length mismatch: " + this.aliases.length + " != " + this.keys.length);
+        }
+        this.aliases.forEach(function(name) {
+            if (typeof name != "string") throw new Error("aliases must contain string");
+        });
+        this.keys.forEach(function(name) {
+            if (typeof name != "string") throw new Error("keys must contain string");
+        });
+        if (typeof this.path != "string") throw new Error("path must be string");
+        if (this.quote != null) {
+            if (typeof this.quote != "string") throw new Error("quote must be string");
+            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
+        }
+    },
+}, AST_Statement);
+
+var AST_ExportReferences = DEFNODE("ExportReferences", "properties", {
+    $documentation: "An `export { ... }` statement",
+    $propdoc: {
+        properties: "[AST_SymbolExport*] array of aliases to export",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            node.properties.forEach(function(prop) {
+                prop.walk(visitor);
+            });
+        });
+    },
+    _validate: function() {
+        this.properties.forEach(function(prop) {
+            if (!(prop instanceof AST_SymbolExport)) throw new Error("properties must contain AST_SymbolExport");
+        });
+    },
+}, AST_Statement);
+
+var AST_Import = DEFNODE("Import", "all default path properties quote", {
+    $documentation: "An `import` statement",
+    $propdoc: {
+        all: "[AST_SymbolImport?] the imported namespace, or null if not specified",
+        default: "[AST_SymbolImport?] the alias for default `export`, or null if not specified",
+        path: "[string] the path to import module",
+        properties: "[(AST_SymbolImport*)?] array of aliases, or null if not specified",
+        quote: "[string?] the original quote character",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            if (node.all) node.all.walk(visitor);
+            if (node.default) node.default.walk(visitor);
+            if (node.properties) node.properties.forEach(function(prop) {
+                prop.walk(visitor);
+            });
+        });
+    },
+    _validate: function() {
+        if (this.all != null) {
+            if (!(this.all instanceof AST_SymbolImport)) throw new Error("all must be AST_SymbolImport");
+            if (this.properties != null) throw new Error("cannot import both * and {} in the same statement");
+        }
+        if (this.default != null) {
+            if (!(this.default instanceof AST_SymbolImport)) throw new Error("default must be AST_SymbolImport");
+            if (this.default.key !== "") throw new Error("invalid default key: " + this.default.key);
+        }
+        if (typeof this.path != "string") throw new Error("path must be string");
+        if (this.properties != null) this.properties.forEach(function(node) {
+            if (!(node instanceof AST_SymbolImport)) throw new Error("properties must contain AST_SymbolImport");
+        });
+        if (this.quote != null) {
+            if (typeof this.quote != "string") throw new Error("quote must be string");
+            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
+        }
+    },
+}, AST_Statement);
+
 var AST_DefaultValue = DEFNODE("DefaultValue", "name value", {
     $documentation: "A default value declaration",
     $propdoc: {
@@ -1036,6 +1354,7 @@ var AST_PropAccess = DEFNODE("PropAccess", "expression property", {
         return p;
     },
     _validate: function() {
+        if (this.TYPE == "PropAccess") throw new Error("should not instantiate AST_PropAccess");
         must_be_expression(this, "expression");
     },
 });
@@ -1096,6 +1415,7 @@ var AST_Unary = DEFNODE("Unary", "operator expression", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "Unary") throw new Error("should not instantiate AST_Unary");
         if (typeof this.operator != "string") throw new Error("operator must be string");
         must_be_expression(this, "expression");
     },
@@ -1183,6 +1503,27 @@ var AST_Await = DEFNODE("Await", "expression", {
     },
 });
 
+var AST_Yield = DEFNODE("Yield", "expression nested", {
+    $documentation: "A yield expression",
+    $propdoc: {
+        expression: "[AST_Node?] return value for iterator, or null if undefined",
+        nested: "[boolean] whether to iterate over expression as generator",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            if (node.expression) node.expression.walk(visitor);
+        });
+    },
+    _validate: function() {
+        if (this.expression != null) {
+            must_be_expression(this, "expression");
+        } else if (this.nested) {
+            throw new Error("yield* must contain expression");
+        }
+    },
+});
+
 /* -----[ LITERALS ]----- */
 
 var AST_Array = DEFNODE("Array", "elements", {
@@ -1208,6 +1549,9 @@ var AST_Destructured = DEFNODE("Destructured", "rest", {
     $propdoc: {
         rest: "[(AST_Destructured|AST_SymbolDeclaration|AST_SymbolRef)?] rest parameter, or null if absent",
     },
+    _validate: function() {
+        if (this.TYPE == "Destructured") throw new Error("should not instantiate AST_Destructured");
+    },
 });
 
 function validate_destructured(node, check, allow_default) {
@@ -1319,6 +1663,7 @@ var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
         });
     },
     _validate: function() {
+        if (this.TYPE == "ObjectProperty") throw new Error("should not instantiate AST_ObjectProperty");
         if (typeof this.key != "string") {
             if (!(this.key instanceof AST_Node)) throw new Error("key must be string or AST_Node");
             must_be_expression(this, "key");
@@ -1334,6 +1679,13 @@ var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", null, {
     },
 }, AST_ObjectProperty);
 
+var AST_ObjectMethod = DEFNODE("ObjectMethod", null, {
+    $documentation: "A key(){} object property",
+    _validate: function() {
+        if (!(this.value instanceof AST_LambdaExpression)) throw new Error("value must be AST_LambdaExpression");
+    },
+}, AST_ObjectKeyVal);
+
 var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
     $documentation: "An object setter property",
     _validate: function() {
@@ -1356,6 +1708,7 @@ var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
         thedef: "[SymbolDef/S] the definition of this symbol"
     },
     _validate: function() {
+        if (this.TYPE == "Symbol") throw new Error("should not instantiate AST_Symbol");
         if (typeof this.name != "string") throw new Error("name must be string");
     },
 });
@@ -1368,6 +1721,16 @@ var AST_SymbolConst = DEFNODE("SymbolConst", null, {
     $documentation: "Symbol defining a constant",
 }, AST_SymbolDeclaration);
 
+var AST_SymbolImport = DEFNODE("SymbolImport", "key", {
+    $documentation: "Symbol defined by an `import` statement",
+    $propdoc: {
+        key: "[string] the original `export` name",
+    },
+    _validate: function() {
+        if (typeof this.key != "string") throw new Error("key must be string");
+    },
+}, AST_SymbolConst);
+
 var AST_SymbolLet = DEFNODE("SymbolLet", null, {
     $documentation: "Symbol defining a lexical-scoped variable",
 }, AST_SymbolDeclaration);
@@ -1388,6 +1751,14 @@ var AST_SymbolLambda = DEFNODE("SymbolLambda", null, {
     $documentation: "Symbol naming a function expression",
 }, AST_SymbolDeclaration);
 
+var AST_SymbolDefClass = DEFNODE("SymbolDefClass", null, {
+    $documentation: "Symbol defining a class",
+}, AST_SymbolLet);
+
+var AST_SymbolClass = DEFNODE("SymbolClass", null, {
+    $documentation: "Symbol naming a class expression",
+}, AST_SymbolLet);
+
 var AST_SymbolCatch = DEFNODE("SymbolCatch", null, {
     $documentation: "Symbol naming the exception in catch",
 }, AST_SymbolDeclaration);
@@ -1407,28 +1778,87 @@ var AST_SymbolRef = DEFNODE("SymbolRef", "fixed in_arg redef", {
     $documentation: "Reference to some symbol (not definition/declaration)",
 }, AST_Symbol);
 
+var AST_SymbolExport = DEFNODE("SymbolExport", "alias", {
+    $documentation: "Reference in an `export` statement",
+    $propdoc: {
+        alias: "[string] the `export` alias",
+    },
+    _validate: function() {
+        if (typeof this.alias != "string") throw new Error("alias must be string");
+    },
+}, AST_SymbolRef);
+
 var AST_LabelRef = DEFNODE("LabelRef", null, {
     $documentation: "Reference to a label symbol",
 }, AST_Symbol);
 
+var AST_ObjectIdentity = DEFNODE("ObjectIdentity", null, {
+    $documentation: "Base class for `super` & `this`",
+    _validate: function() {
+        if (this.TYPE == "ObjectIdentity") throw new Error("should not instantiate AST_ObjectIdentity");
+    },
+}, AST_Symbol);
+
+var AST_Super = DEFNODE("Super", null, {
+    $documentation: "The `super` symbol",
+    _validate: function() {
+        if (this.name !== "super") throw new Error('name must be "super"');
+    },
+}, AST_ObjectIdentity);
+
 var AST_This = DEFNODE("This", null, {
     $documentation: "The `this` symbol",
     _validate: function() {
         if (this.name !== "this") throw new Error('name must be "this"');
     },
-}, AST_Symbol);
+}, AST_ObjectIdentity);
+
+var AST_Template = DEFNODE("Template", "expressions strings tag", {
+    $documentation: "A template literal, i.e. tag`str1${expr1}...strN${exprN}strN+1`",
+    $propdoc: {
+        expressions: "[AST_Node*] the placeholder expressions",
+        strings: "[string*] the raw text segments",
+        tag: "[AST_Node] tag function, or null if absent",
+    },
+    walk: function(visitor) {
+        var node = this;
+        visitor.visit(node, function() {
+            if (node.tag) node.tag.walk(visitor);
+            node.expressions.forEach(function(expr) {
+                expr.walk(visitor);
+            });
+        });
+    },
+    _validate: function() {
+        if (this.expressions.length + 1 != this.strings.length) {
+            throw new Error("malformed template with " + this.expressions.length + " placeholder(s) but " + this.strings.length + " text segment(s)");
+        }
+        must_be_expressions(this, "expressions");
+        this.strings.forEach(function(string) {
+            if (typeof string != "string") throw new Error("strings must contain string");
+        });
+        if (this.tag != null) must_be_expression(this, "tag");
+    },
+});
 
 var AST_Constant = DEFNODE("Constant", null, {
     $documentation: "Base class for all constants",
+    _validate: function() {
+        if (this.TYPE == "Constant") throw new Error("should not instantiate AST_Constant");
+    },
 });
 
-var AST_String = DEFNODE("String", "value quote", {
+var AST_String = DEFNODE("String", "quote value", {
     $documentation: "A string literal",
     $propdoc: {
+        quote: "[string?] the original quote character",
         value: "[string] the contents of this string",
-        quote: "[string] the original quote character"
     },
     _validate: function() {
+        if (this.quote != null) {
+            if (typeof this.quote != "string") throw new Error("quote must be string");
+            if (!/^["']$/.test(this.quote)) throw new Error("invalid quote: " + this.quote);
+        }
         if (typeof this.value != "string") throw new Error("value must be string");
     },
 }, AST_Constant);
@@ -1440,6 +1870,19 @@ var AST_Number = DEFNODE("Number", "value", {
     },
     _validate: function() {
         if (typeof this.value != "number") throw new Error("value must be number");
+        if (!isFinite(this.value)) throw new Error("value must be finite");
+        if (this.value < 0) throw new Error("value cannot be negative");
+    },
+}, AST_Constant);
+
+var AST_BigInt = DEFNODE("BigInt", "value", {
+    $documentation: "A BigInt literal",
+    $propdoc: {
+        value: "[string] the numeric representation",
+    },
+    _validate: function() {
+        if (typeof this.value != "string") throw new Error("value must be string");
+        if (this.value[0] == "-") throw new Error("value cannot be negative");
     },
 }, AST_Constant);
 
@@ -1455,6 +1898,9 @@ var AST_RegExp = DEFNODE("RegExp", "value", {
 
 var AST_Atom = DEFNODE("Atom", null, {
     $documentation: "Base class for atoms",
+    _validate: function() {
+        if (this.TYPE == "Atom") throw new Error("should not instantiate AST_Atom");
+    },
 }, AST_Constant);
 
 var AST_Null = DEFNODE("Null", null, {
@@ -1484,6 +1930,9 @@ var AST_Infinity = DEFNODE("Infinity", null, {
 
 var AST_Boolean = DEFNODE("Boolean", null, {
     $documentation: "Base class for booleans",
+    _validate: function() {
+        if (this.TYPE == "Boolean") throw new Error("should not instantiate AST_Boolean");
+    },
 }, AST_Atom);
 
 var AST_False = DEFNODE("False", null, {
@@ -1522,7 +1971,8 @@ TreeWalker.prototype = {
         this.stack.push(node);
     },
     pop: function() {
-        if (this.stack.pop() instanceof AST_Lambda) {
+        var node = this.stack.pop();
+        if (node instanceof AST_Lambda) {
             this.directives = Object.getPrototypeOf(this.directives);
         }
     },

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,54 +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)
+            // () ---> (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
-            // [ a = (1, 2) ] = [] ==> a == 2
+            // [ a = (1, 2) ] = [] ---> a == 2
             || p instanceof AST_DefaultValue
-            // { [(1, 2)]: 3 }[2] ==> 3
-            // { foo: (1, 2) }.foo ==> 2
+            // { [(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)
@@ -773,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) {
@@ -795,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;
     }
@@ -807,8 +849,8 @@ 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);
@@ -819,15 +861,8 @@ function OutputStream(options) {
     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 ]----- */
@@ -879,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("");
@@ -969,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");
@@ -993,6 +1029,94 @@ 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 ]----- */
     function print_funargs(self, output) {
@@ -1052,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) {
@@ -1203,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"));
@@ -1230,7 +1421,7 @@ 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);
         }
     });
@@ -1351,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) {
@@ -1415,12 +1613,12 @@ function OutputStream(options) {
         });
         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();
@@ -1428,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) {
@@ -1443,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 {
@@ -1462,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);
@@ -1473,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/parse.js

@@ -44,10 +44,10 @@
 
 "use strict";
 
-var KEYWORDS = "break case catch const continue debugger default delete do else finally for function if in instanceof let new return switch throw try typeof var void while with";
+var KEYWORDS = "break case catch class const continue debugger default delete do else extends finally for function if in instanceof let new return switch throw try typeof var void while with";
 var KEYWORDS_ATOM = "false null true";
 var RESERVED_WORDS = [
-    "await abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized this throws transient volatile yield",
+    "abstract async await boolean byte char double enum export final float goto implements import int interface long native package private protected public short static super synchronized this throws transient volatile yield",
     KEYWORDS_ATOM,
     KEYWORDS,
 ].join(" ");
@@ -81,6 +81,7 @@ var OPERATORS = makePredicate([
     "*",
     "/",
     "%",
+    "**",
     ">>",
     "<<",
     ">>>",
@@ -106,18 +107,24 @@ var OPERATORS = makePredicate([
     "^=",
     "&=",
     "&&",
-    "||"
+    "||",
+    "??",
 ]);
 
 var NEWLINE_CHARS = "\n\r\u2028\u2029";
 var OPERATOR_CHARS = "+-*&%=<>!?|~^";
-var PUNC_BEFORE_EXPRESSION = "[{(,;:";
-var PUNC_CHARS = PUNC_BEFORE_EXPRESSION + ")}]";
+var PUNC_OPENERS = "[{(";
+var PUNC_SEPARATORS = ",;:";
+var PUNC_CLOSERS = ")}]";
+var PUNC_AFTER_EXPRESSION = PUNC_SEPARATORS + PUNC_CLOSERS;
+var PUNC_BEFORE_EXPRESSION = PUNC_OPENERS + PUNC_SEPARATORS;
+var PUNC_CHARS = PUNC_BEFORE_EXPRESSION + "`" + PUNC_CLOSERS;
 var WHITESPACE_CHARS = NEWLINE_CHARS + " \u00a0\t\f\u000b\u200b\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\uFEFF";
 var NON_IDENTIFIER_CHARS = makePredicate(characters("./'\"" + OPERATOR_CHARS + PUNC_CHARS + WHITESPACE_CHARS));
 
 NEWLINE_CHARS = makePredicate(characters(NEWLINE_CHARS));
 OPERATOR_CHARS = makePredicate(characters(OPERATOR_CHARS));
+PUNC_AFTER_EXPRESSION = makePredicate(characters(PUNC_AFTER_EXPRESSION));
 PUNC_BEFORE_EXPRESSION = makePredicate(characters(PUNC_BEFORE_EXPRESSION));
 PUNC_CHARS = makePredicate(characters(PUNC_CHARS));
 WHITESPACE_CHARS = makePredicate(characters(WHITESPACE_CHARS));
@@ -144,6 +151,43 @@ function is_identifier_string(str) {
     return /^[a-z_$][a-z0-9_$]*$/i.test(str);
 }
 
+function decode_escape_sequence(seq) {
+    switch (seq[0]) {
+      case "b": return "\b";
+      case "f": return "\f";
+      case "n": return "\n";
+      case "r": return "\r";
+      case "t": return "\t";
+      case "u":
+        var code;
+        if (seq.length == 5) {
+            code = seq.slice(1);
+        } else if (seq[1] == "{" && seq.slice(-1) == "}") {
+            code = seq.slice(2, -1);
+        } else {
+            return;
+        }
+        var num = parseInt(code, 16);
+        if (num < 0 || isNaN(num)) return;
+        if (num < 0x10000) return String.fromCharCode(num);
+        if (num > 0x10ffff) return;
+        return String.fromCharCode((num >> 10) + 0xd7c0) + String.fromCharCode((num & 0x03ff) + 0xdc00);
+      case "v": return "\u000b";
+      case "x":
+        if (seq.length != 3) return;
+        var num = parseInt(seq.slice(1), 16);
+        if (num < 0 || isNaN(num)) return;
+        return String.fromCharCode(num);
+      case "\r":
+      case "\n":
+        return "";
+      default:
+        if (seq == "0") return "\0";
+        if (seq[0] >= "0" && seq[0] <= "9") return;
+        return seq;
+    }
+}
+
 function parse_js_number(num) {
     var match;
     if (match = RE_BIN_NUMBER.exec(num)) return parseInt(match[1], 2);
@@ -190,7 +234,29 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         regex_allowed   : false,
         comments_before : [],
         directives      : {},
-        directive_stack : []
+        directive_stack : [],
+        read_template   : with_eof_error("Unterminated template literal", function(strings) {
+            var s = "";
+            for (;;) {
+                var ch = next(true, true);
+                switch (ch) {
+                  case "\\":
+                    ch += next(true, true);
+                    break;
+                  case "`":
+                    strings.push(s);
+                    return;
+                  case "$":
+                    if (peek() == "{") {
+                        next();
+                        strings.push(s);
+                        S.regex_allowed = true;
+                        return true;
+                    }
+                }
+                s += ch;
+            }
+        }),
     };
     var prev_was_dot = false;
 
@@ -280,9 +346,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     }
 
     function read_while(pred) {
-        var ret = "", ch, i = 0;
-        while ((ch = peek()) && pred(ch, i++))
-            ret += next();
+        var ret = "", ch;
+        while ((ch = peek()) && pred(ch)) ret += next();
         return ret;
     }
 
@@ -292,16 +357,14 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     function read_num(prefix) {
         var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".";
-        var num = read_while(function(ch, i) {
+        var num = read_while(function(ch) {
             var code = ch.charCodeAt(0);
             switch (code) {
               case 120: case 88: // xX
                 return has_x ? false : (has_x = true);
               case 101: case 69: // eE
                 return has_x ? true : has_e ? false : (has_e = after_e = true);
-              case 45: // -
-                return after_e || (i == 0 && !prefix);
-              case 43: // +
+              case 43: case 45: // +-
                 return after_e;
               case (after_e = false, 46): // .
                 return (!has_dot && !has_x && !has_e) ? (has_dot = true) : false;
@@ -315,41 +378,29 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             num = num.replace(has_x ? /([1-9a-f]|.0)_(?=[0-9a-f])/gi : /([1-9]|.0)_(?=[0-9])/gi, "$1");
         }
         var valid = parse_js_number(num);
-        if (!isNaN(valid)) return token("num", valid);
-        parse_error("Invalid syntax: " + num);
+        if (isNaN(valid)) parse_error("Invalid syntax: " + num);
+        if (has_dot || has_e || peek() != "n") return token("num", valid);
+        return token("bigint", num.toLowerCase() + next());
     }
 
     function read_escaped_char(in_string) {
-        var ch = next(true, in_string);
-        switch (ch.charCodeAt(0)) {
-          case 110: return "\n";
-          case 114: return "\r";
-          case 116: return "\t";
-          case 98:  return "\b";
-          case 118: return "\u000b";                            // \v
-          case 102: return "\f";
-          case 120: return String.fromCharCode(hex_bytes(2));   // \x
-          case 117:                                             // \u
-            if (peek() != "{") return String.fromCharCode(hex_bytes(4));
-            next();
-            var num = 0;
-            do {
-                var digit = parseInt(next(true), 16);
-                if (isNaN(digit)) parse_error("Invalid hex-character pattern in string");
-                num = num * 16 + digit;
-            } while (peek() != "}");
-            next();
-            if (num < 0x10000) return String.fromCharCode(num);
-            if (num > 0x10ffff) parse_error("Invalid character code: " + num);
-            return String.fromCharCode((num >> 10) + 0xd7c0) + String.fromCharCode((num & 0x03ff) + 0xdc00);
-          case 13:                                              // \r
-            // DOS newline
-            if (peek() == "\n") next(true, in_string);
-          case 10:  return "";                                  // \n
+        var seq = next(true, in_string);
+        if (seq >= "0" && seq <= "7") return read_octal_escape_sequence(seq);
+        if (seq == "u") {
+            var ch = next(true, in_string);
+            seq += ch;
+            if (ch != "{") {
+                seq += next(true, in_string) + next(true, in_string) + next(true, in_string);
+            } else do {
+                ch = next(true, in_string);
+                seq += ch;
+            } while (ch != "}");
+        } else if (seq == "x") {
+            seq += next(true, in_string) + next(true, in_string);
         }
-        if (ch >= "0" && ch <= "7")
-            return read_octal_escape_sequence(ch);
-        return ch;
+        var str = decode_escape_sequence(seq);
+        if (typeof str != "string") parse_error("Invalid escape sequence: \\" + seq);
+        return str;
     }
 
     function read_octal_escape_sequence(ch) {
@@ -368,17 +419,6 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         return String.fromCharCode(parseInt(ch, 8));
     }
 
-    function hex_bytes(n) {
-        var num = 0;
-        for (; n > 0; --n) {
-            var digit = parseInt(next(true), 16);
-            if (isNaN(digit))
-                parse_error("Invalid hex-character pattern in string");
-            num = (num << 4) | digit;
-        }
-        return num;
-    }
-
     var read_string = with_eof_error("Unterminated string constant", function(quote_char) {
         var quote = next(), ret = "";
         for (;;) {
@@ -623,6 +663,7 @@ var PRECEDENCE = function(a, ret) {
     }
     return ret;
 }([
+    ["??"],
     ["||"],
     ["&&"],
     ["|"],
@@ -632,10 +673,11 @@ var PRECEDENCE = function(a, ret) {
     ["<", ">", "<=", ">=", "in", "instanceof"],
     [">>", "<<", ">>>"],
     ["+", "-"],
-    ["*", "/", "%"]
+    ["*", "/", "%"],
+    ["**"],
 ], {});
 
-var ATOMIC_START_TOKEN = makePredicate("atom num regexp string");
+var ATOMIC_START_TOKEN = makePredicate("atom bigint num regexp string");
 
 /* -----[ Parser ]----- */
 
@@ -658,6 +700,7 @@ function parse($TEXT, options) {
         in_directives : true,
         in_funarg     : -1,
         in_function   : 0,
+        in_generator  : false,
         in_loop       : 0,
         labels        : [],
         peeked        : null,
@@ -783,6 +826,7 @@ function parse($TEXT, options) {
             semicolon();
             return dir ? new AST_Directive(body) : new AST_SimpleStatement({ body: body });
           case "num":
+          case "bigint":
           case "regexp":
           case "operator":
           case "atom":
@@ -794,12 +838,25 @@ function parse($TEXT, options) {
                 if (is_token(peek(), "keyword", "function")) {
                     next();
                     next();
-                    return function_(AST_AsyncDefun);
+                    if (!is("operator", "*")) return function_(AST_AsyncDefun);
+                    next();
+                    return function_(AST_AsyncGeneratorDefun);
                 }
                 break;
               case "await":
                 if (S.in_async) return simple_statement();
                 break;
+              case "export":
+                next();
+                return export_();
+              case "import":
+                if (!is_token(peek(), "punc", "(")) {
+                    next();
+                    return import_();
+                }
+              case "yield":
+                if (S.in_generator) return simple_statement();
+                break;
             }
             return is_token(peek(), "punc", ":")
                 ? labeled_statement()
@@ -815,6 +872,7 @@ function parse($TEXT, options) {
                 });
               case "[":
               case "(":
+              case "`":
                 return simple_statement();
               case ";":
                 S.in_directives = false;
@@ -830,6 +888,10 @@ function parse($TEXT, options) {
                 next();
                 return break_cont(AST_Break);
 
+              case "class":
+                next();
+                return class_(AST_DefClass);
+
               case "const":
                 next();
                 var node = const_();
@@ -869,7 +931,9 @@ function parse($TEXT, options) {
 
               case "function":
                 next();
-                return function_(AST_Defun);
+                if (!is("operator", "*")) return function_(AST_Defun);
+                next();
+                return function_(AST_GeneratorDefun);
 
               case "if":
                 next();
@@ -989,7 +1053,130 @@ function parse($TEXT, options) {
         return stat;
     }
 
+    function class_(ctor) {
+        var was_async = S.in_async;
+        var was_gen = S.in_generator;
+        S.input.push_directives_stack();
+        S.input.add_directive("use strict");
+        var name;
+        if (ctor === AST_DefClass) {
+            name = as_symbol(AST_SymbolDefClass);
+        } else {
+            name = as_symbol(AST_SymbolClass, true);
+        }
+        var parent = null;
+        if (is("keyword", "extends")) {
+            next();
+            handle_regexp();
+            parent = expr_atom(true);
+        }
+        expect("{");
+        var props = [];
+        while (!is("punc", "}")) {
+            if (is("punc", ";")) {
+                next();
+                continue;
+            }
+            var start = S.token;
+            var fixed = is("name", "static");
+            if (fixed) next();
+            var async = is("name", "async") && peek();
+            if (async) {
+                if (async.type == "punc" && /^[(=;}]$/.test(async.value) || has_newline_before(async)) {
+                    async = false;
+                } else {
+                    async = next();
+                }
+            }
+            if (is("operator", "*")) {
+                next();
+                var internal = is("name") && /^#/.test(S.token.value);
+                var key = as_property_key();
+                var gen_start = S.token;
+                var gen = function_(async ? AST_AsyncGeneratorFunction : AST_GeneratorFunction);
+                gen.start = gen_start;
+                gen.end = prev();
+                props.push(new AST_ClassMethod({
+                    start: start,
+                    static: fixed,
+                    private: internal,
+                    key: key,
+                    value: gen,
+                    end: prev(),
+                }));
+                continue;
+            }
+            var internal = is("name") && /^#/.test(S.token.value);
+            var key = as_property_key();
+            if (is("punc", "(")) {
+                var func_start = S.token;
+                var func = function_(async ? AST_AsyncFunction : AST_Function);
+                func.start = func_start;
+                func.end = prev();
+                props.push(new AST_ClassMethod({
+                    start: start,
+                    static: fixed,
+                    private: internal,
+                    key: key,
+                    value: func,
+                    end: prev(),
+                }));
+                continue;
+            }
+            if (async) unexpected(async);
+            var value = null;
+            if (is("operator", "=")) {
+                next();
+                S.in_async = false;
+                S.in_generator = false;
+                value = maybe_assign();
+                S.in_generator = was_gen;
+                S.in_async = was_async;
+            } else if (!(is("punc", ";") || is("punc", "}"))) {
+                var type = null;
+                switch (key) {
+                  case "get":
+                    type = AST_ClassGetter;
+                    break;
+                  case "set":
+                    type = AST_ClassSetter;
+                    break;
+                }
+                if (type) {
+                    props.push(new type({
+                        start: start,
+                        static: fixed,
+                        private: is("name") && /^#/.test(S.token.value),
+                        key: as_property_key(),
+                        value: create_accessor(),
+                        end: prev(),
+                    }));
+                    continue;
+                }
+            }
+            semicolon();
+            props.push(new AST_ClassField({
+                start: start,
+                static: fixed,
+                private: internal,
+                key: key,
+                value: value,
+                end: prev(),
+            }));
+        }
+        next();
+        S.input.pop_directives_stack();
+        S.in_generator = was_gen;
+        S.in_async = was_async;
+        return new ctor({
+            extends: parent,
+            name: name,
+            properties: props,
+        });
+    }
+
     function for_() {
+        var await = is("name", "await") && next();
         expect("(");
         var init = null;
         if (!is("punc", ";")) {
@@ -1000,16 +1187,29 @@ function parse($TEXT, options) {
                 : is("keyword", "var")
                 ? (next(), var_(true))
                 : expression(true);
-            if (is("operator", "in")) {
+            var ctor;
+            if (await) {
+                expect_token("name", "of");
+                ctor = AST_ForAwaitOf;
+            } else if (is("operator", "in")) {
+                next();
+                ctor = AST_ForIn;
+            } else if (is("name", "of")) {
+                next();
+                ctor = AST_ForOf;
+            }
+            if (ctor) {
                 if (init instanceof AST_Definitions) {
                     if (init.definitions.length > 1) {
-                        token_error(init.start, "Only one variable declaration allowed in for..in loop");
+                        token_error(init.start, "Only one variable declaration allowed in for..in/of loop");
+                    }
+                    if (ctor !== AST_ForIn && init.definitions[0].value) {
+                        token_error(init.definitions[0].value.start, "No initializers allowed in for..of loop");
                     }
                 } else if (!(is_assignable(init) || (init = to_destructured(init)) instanceof AST_Destructured)) {
-                    token_error(init.start, "Invalid left-hand side in for..in loop");
+                    token_error(init.start, "Invalid left-hand side in for..in/of loop");
                 }
-                next();
-                return for_in(init);
+                return for_enum(ctor, init);
             }
         }
         return regular_for(init);
@@ -1029,10 +1229,10 @@ function parse($TEXT, options) {
         });
     }
 
-    function for_in(init) {
+    function for_enum(ctor, init) {
         var obj = expression();
         expect(")");
-        return new AST_ForIn({
+        return new ctor({
             init   : init,
             object : obj,
             body   : in_loop(statement)
@@ -1102,7 +1302,9 @@ function parse($TEXT, options) {
 
     function arrow(exprs, start, async) {
         var was_async = S.in_async;
+        var was_gen = S.in_generator;
         S.in_async = async;
+        S.in_generator = false;
         var was_funarg = S.in_funarg;
         S.in_funarg = S.in_function;
         var argnames = exprs.map(to_funarg);
@@ -1126,12 +1328,14 @@ function parse($TEXT, options) {
             }
         } else {
             body = [];
+            handle_regexp();
             value = maybe_assign();
         }
         S.input.pop_directives_stack();
         --S.in_function;
         S.in_loop = loop;
         S.labels = labels;
+        S.in_generator = was_gen;
         S.in_async = was_async;
         return new (async ? AST_AsyncArrow : AST_Arrow)({
             start: start,
@@ -1145,15 +1349,15 @@ function parse($TEXT, options) {
 
     var function_ = function(ctor) {
         var was_async = S.in_async;
+        var was_gen = S.in_generator;
         var name;
-        if (ctor === AST_AsyncDefun) {
+        if (/Defun$/.test(ctor.TYPE)) {
             name = as_symbol(AST_SymbolDefun);
-            S.in_async = true;
-        } else if (ctor === AST_Defun) {
-            name = as_symbol(AST_SymbolDefun);
-            S.in_async = false;
+            S.in_async = /^Async/.test(ctor.TYPE);
+            S.in_generator = /Generator/.test(ctor.TYPE);
         } else {
-            S.in_async = ctor === AST_AsyncFunction;
+            S.in_async = /^Async/.test(ctor.TYPE);
+            S.in_generator = /Generator/.test(ctor.TYPE);
             name = as_symbol(AST_SymbolLambda, true);
         }
         if (name && ctor !== AST_Accessor && !(name instanceof AST_SymbolDeclaration))
@@ -1182,6 +1386,7 @@ function parse($TEXT, options) {
         --S.in_function;
         S.in_loop = loop;
         S.labels = labels;
+        S.in_generator = was_gen;
         S.in_async = was_async;
         return new ctor({
             name: name,
@@ -1204,6 +1409,197 @@ function parse($TEXT, options) {
         });
     }
 
+    function is_alias() {
+        return is("name") || is_identifier_string(S.token.value);
+    }
+
+    function export_() {
+        if (is("operator", "*")) {
+            next();
+            var alias = "*";
+            if (is("name", "as")) {
+                next();
+                if (!is_alias()) expect_token("name");
+                alias = S.token.value;
+                next();
+            }
+            expect_token("name", "from");
+            var path = S.token;
+            expect_token("string");
+            semicolon();
+            return new AST_ExportForeign({
+                aliases: [ alias ],
+                keys: [ "*" ],
+                path: path.value,
+                quote: path.quote,
+            });
+        }
+        if (is("punc", "{")) {
+            next();
+            var aliases = [];
+            var keys = [];
+            while (is_alias()) {
+                var key = S.token;
+                next();
+                keys.push(key);
+                if (is("name", "as")) {
+                    next();
+                    if (!is_alias()) expect_token("name");
+                    aliases.push(S.token.value);
+                    next();
+                } else {
+                    aliases.push(key.value);
+                }
+                if (!is("punc", "}")) expect(",");
+            }
+            expect("}");
+            if (is("name", "from")) {
+                next();
+                var path = S.token;
+                expect_token("string");
+                semicolon();
+                return new AST_ExportForeign({
+                    aliases: aliases,
+                    keys: keys.map(function(token) {
+                        return token.value;
+                    }),
+                    path: path.value,
+                    quote: path.quote,
+                });
+            }
+            semicolon();
+            return new AST_ExportReferences({
+                properties: keys.map(function(token, index) {
+                    if (!is_token(token, "name")) token_error(token, "Name expected");
+                    var sym = _make_symbol(AST_SymbolExport, token);
+                    sym.alias = aliases[index];
+                    return sym;
+                }),
+            });
+        }
+        if (is("keyword", "default")) {
+            next();
+            var start = S.token;
+            var body = export_default_decl();
+            if (body) {
+                body.start = start;
+                body.end = prev();
+            } else {
+                body = expression();
+                semicolon();
+            }
+            return new AST_ExportDefault({ body: body });
+        }
+        return new AST_ExportDeclaration({ body: export_decl() });
+    }
+
+    function maybe_named(def, expr) {
+        if (expr.name) {
+            expr = new def(expr);
+            expr.name = new (def === AST_DefClass ? AST_SymbolDefClass : AST_SymbolDefun)(expr.name);
+        }
+        return expr;
+    }
+
+    function export_default_decl() {
+        switch (S.token.value) {
+          case "async":
+            if (!is_token(peek(), "keyword", "function")) return;
+            next();
+            next();
+            if (!is("operator", "*")) return maybe_named(AST_AsyncDefun, function_(AST_AsyncFunction));
+            next();
+            return maybe_named(AST_AsyncGeneratorDefun, function_(AST_AsyncGeneratorFunction));
+          case "class":
+            next();
+            return maybe_named(AST_DefClass, class_(AST_ClassExpression));
+          case "function":
+            next();
+            if (!is("operator", "*")) return maybe_named(AST_Defun, function_(AST_Function));
+            next();
+            return maybe_named(AST_GeneratorDefun, function_(AST_GeneratorFunction));
+        }
+    }
+
+    var export_decl = embed_tokens(function() {
+        switch (S.token.value) {
+          case "async":
+            next();
+            expect_token("keyword", "function");
+            if (!is("operator", "*")) return function_(AST_AsyncDefun);
+            next();
+            return function_(AST_AsyncGeneratorDefun);
+          case "class":
+            next();
+            return class_(AST_DefClass);
+          case "const":
+            next();
+            var node = const_();
+            semicolon();
+            return node;
+          case "function":
+            next();
+            if (!is("operator", "*")) return function_(AST_Defun);
+            next();
+            return function_(AST_GeneratorDefun);
+          case "let":
+            next();
+            var node = let_();
+            semicolon();
+            return node;
+          case "var":
+            next();
+            var node = var_();
+            semicolon();
+            return node;
+        }
+        unexpected();
+    });
+
+    function import_() {
+        var all = null;
+        var def = as_symbol(AST_SymbolImport, true);
+        var props = null;
+        if (def ? (def.key = "", is("punc", ",") && next()) : !is("string")) {
+            if (is("operator", "*")) {
+                next();
+                expect_token("name", "as");
+                all = as_symbol(AST_SymbolImport);
+                all.key = "*";
+            } else {
+                expect("{");
+                props = [];
+                while (is_alias()) {
+                    var alias;
+                    if (is_token(peek(), "name", "as")) {
+                        var key = S.token.value;
+                        next();
+                        next();
+                        alias = as_symbol(AST_SymbolImport);
+                        alias.key = key;
+                    } else {
+                        alias = as_symbol(AST_SymbolImport);
+                        alias.key = alias.name;
+                    }
+                    props.push(alias);
+                    if (!is("punc", "}")) expect(",");
+                }
+                expect("}");
+            }
+        }
+        if (all || def || props) expect_token("name", "from");
+        var path = S.token;
+        expect_token("string");
+        semicolon();
+        return new AST_Import({
+            all: all,
+            default: def,
+            path: path.value,
+            properties: props,
+            quote: path.quote,
+        });
+    }
+
     function block_() {
         expect("{");
         var a = [];
@@ -1361,6 +1757,9 @@ function parse($TEXT, options) {
           case "num":
             ret = new AST_Number({ start: tok, end: tok, value: tok.value });
             break;
+          case "bigint":
+            ret = new AST_BigInt({ start: tok, end: tok, value: tok.value });
+            break;
           case "string":
             ret = new AST_String({
                 start : tok,
@@ -1397,6 +1796,11 @@ function parse($TEXT, options) {
         var start = S.token;
         if (is("punc")) {
             switch (start.value) {
+              case "`":
+                var tmpl = template(null);
+                tmpl.start = start;
+                tmpl.end = prev();
+                return subscripts(tmpl, allow_calls);
               case "(":
                 next();
                 if (is("punc", ")")) {
@@ -1435,9 +1839,22 @@ function parse($TEXT, options) {
             }
             unexpected();
         }
-        if (is("keyword", "function")) {
+        if (is("keyword")) switch (start.value) {
+          case "class":
             next();
-            var func = function_(AST_Function);
+            var clazz = class_(AST_ClassExpression);
+            clazz.start = start;
+            clazz.end = prev();
+            return subscripts(clazz, allow_calls);
+          case "function":
+            next();
+            var func;
+            if (is("operator", "*")) {
+                next();
+                func = function_(AST_GeneratorFunction);
+            } else {
+                func = function_(AST_Function);
+            }
             func.start = start;
             func.end = prev();
             return subscripts(func, allow_calls);
@@ -1448,12 +1865,18 @@ function parse($TEXT, options) {
             if (sym.name == "async") {
                 if (is("keyword", "function")) {
                     next();
-                    var func = function_(AST_AsyncFunction);
+                    var func;
+                    if (is("operator", "*")) {
+                        next();
+                        func = function_(AST_AsyncGeneratorFunction);
+                    } else {
+                        func = function_(AST_AsyncFunction);
+                    }
                     func.start = start;
                     func.end = prev();
                     return subscripts(func, allow_calls);
                 }
-                if (is("name")) {
+                if (is("name") && is_token(peek(), "punc", "=>")) {
                     start = S.token;
                     sym = _make_symbol(AST_SymbolRef, start);
                     next();
@@ -1523,6 +1946,21 @@ function parse($TEXT, options) {
             // allow trailing comma
             if (!options.strict && is("punc", "}")) break;
             var start = S.token;
+            if (is("operator", "*")) {
+                next();
+                var key = as_property_key();
+                var gen_start = S.token;
+                var gen = function_(AST_GeneratorFunction);
+                gen.start = gen_start;
+                gen.end = prev();
+                a.push(new AST_ObjectMethod({
+                    start: start,
+                    key: key,
+                    value: gen,
+                    end: prev(),
+                }));
+                continue;
+            }
             if (is("operator", "...")) {
                 next();
                 a.push(new AST_Spread({
@@ -1564,7 +2002,7 @@ function parse($TEXT, options) {
                 var func = function_(AST_Function);
                 func.start = func_start;
                 func.end = prev();
-                a.push(new AST_ObjectKeyVal({
+                a.push(new AST_ObjectMethod({
                     start: start,
                     key: key,
                     value: func,
@@ -1584,12 +2022,13 @@ function parse($TEXT, options) {
             }
             if (start.type == "name") switch (key) {
               case "async":
+                var is_gen = is("operator", "*") && next();
                 key = as_property_key();
                 var func_start = S.token;
-                var func = function_(AST_AsyncFunction);
+                var func = function_(is_gen ? AST_AsyncGeneratorFunction : AST_AsyncFunction);
                 func.start = func_start;
                 func.end = prev();
-                a.push(new AST_ObjectKeyVal({
+                a.push(new AST_ObjectMethod({
                     start: start,
                     key: key,
                     value: func,
@@ -1649,8 +2088,21 @@ function parse($TEXT, options) {
 
     function _make_symbol(type, token) {
         var name = token.value;
-        if (name === "await" && S.in_async) unexpected(token);
-        return new (name === "this" ? AST_This : type)({
+        switch (name) {
+          case "await":
+            if (S.in_async) unexpected(token);
+            break;
+          case "super":
+            type = AST_Super;
+            break;
+          case "this":
+            type = AST_This;
+            break;
+          case "yield":
+            if (S.in_generator) unexpected(token);
+            break;
+        }
+        return new type({
             name: "" + name,
             start: token,
             end: token,
@@ -1767,6 +2219,23 @@ function parse($TEXT, options) {
         }
     }
 
+    function template(tag) {
+        var read = S.input.context().read_template;
+        var strings = [];
+        var expressions = [];
+        while (read(strings)) {
+            next();
+            expressions.push(expression());
+            if (!is("punc", "}")) unexpected();
+        }
+        next();
+        return new AST_Template({
+            expressions: expressions,
+            strings: strings,
+            tag: tag,
+        });
+    }
+
     var subscripts = function(expr, allow_calls) {
         var start = expr.start;
         if (is("punc", ".")) {
@@ -1800,15 +2269,51 @@ function parse($TEXT, options) {
             mark_pure(call);
             return subscripts(call, true);
         }
+        if (is("punc", "`")) {
+            var tmpl = template(expr);
+            tmpl.start = expr.start;
+            tmpl.end = prev();
+            return subscripts(tmpl, allow_calls);
+        }
         return expr;
     };
 
-    function maybe_unary() {
+    function maybe_unary(no_in) {
         var start = S.token;
+        if (S.in_async && is("name", "await")) {
+            if (S.in_funarg === S.in_function) croak("Invalid use of await in function argument");
+            S.input.context().regex_allowed = true;
+            next();
+            return new AST_Await({
+                start: start,
+                expression: maybe_unary(no_in),
+                end: prev(),
+            });
+        }
+        if (S.in_generator && is("name", "yield")) {
+            if (S.in_funarg === S.in_function) croak("Invalid use of yield in function argument");
+            S.input.context().regex_allowed = true;
+            next();
+            var exp = null;
+            var nested = false;
+            if (is("operator", "*")) {
+                next();
+                exp = maybe_assign(no_in);
+                nested = true;
+            } else if (is("punc") ? !PUNC_AFTER_EXPRESSION[S.token.value] : !can_insert_semicolon()) {
+                exp = maybe_assign(no_in);
+            }
+            return new AST_Yield({
+                start: start,
+                expression: exp,
+                nested: nested,
+                end: prev(),
+            });
+        }
         if (is("operator") && UNARY_PREFIX[start.value]) {
             next();
             handle_regexp();
-            var ex = make_unary(AST_UnaryPrefix, start, maybe_await());
+            var ex = make_unary(AST_UnaryPrefix, start, maybe_unary(no_in));
             ex.start = start;
             ex.end = prev();
             return ex;
@@ -1839,26 +2344,13 @@ function parse($TEXT, options) {
         return new ctor({ operator: op, expression: expr });
     }
 
-    function maybe_await() {
-        var start = S.token;
-        if (!(S.in_async && is("name", "await"))) return maybe_unary();
-        if (S.in_funarg === S.in_function) croak("Invalid use of await in function argument");
-        S.input.context().regex_allowed = true;
-        next();
-        return new AST_Await({
-            start: start,
-            expression: maybe_await(),
-            end: prev(),
-        });
-    }
-
     var expr_op = function(left, min_prec, no_in) {
         var op = is("operator") ? S.token.value : null;
         if (op == "in" && no_in) op = null;
         var prec = op != null ? PRECEDENCE[op] : null;
         if (prec != null && prec > min_prec) {
             next();
-            var right = expr_op(maybe_await(), prec, no_in);
+            var right = expr_op(maybe_unary(no_in), op == "**" ? prec - 1 : prec, no_in);
             return expr_op(new AST_Binary({
                 start    : left.start,
                 left     : left,
@@ -1871,7 +2363,7 @@ function parse($TEXT, options) {
     };
 
     function expr_ops(no_in) {
-        return expr_op(maybe_await(), 0, no_in);
+        return expr_op(maybe_unary(no_in), 0, no_in);
     }
 
     var maybe_conditional = function(no_in) {

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,6 +45,7 @@
 
 function SymbolDef(id, scope, orig, init) {
     this.eliminated = 0;
+    this.exported = false;
     this.global = false;
     this.id = id;
     this.init = init;
@@ -91,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
@@ -101,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,
@@ -110,11 +121,35 @@ 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);
@@ -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);
         }
 
@@ -269,8 +306,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
                 sym = self.def_global(node);
             } 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)) {
@@ -292,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;
@@ -411,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);
             });
@@ -432,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;
 });
@@ -441,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);

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);
@@ -147,6 +147,15 @@ TreeTransformer.prototype = new TreeWalker;
     }
     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);
         self.args = do_list(self.args, tw);
@@ -157,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);
     });
@@ -201,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,7 +238,7 @@ 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 (is_arrow(p)) {
@@ -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.5",
+  "version": "3.13.0",
   "engines": {
     "node": ">=0.8.0"
   },

test/compress.js

@@ -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

@@ -977,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;
@@ -434,6 +434,62 @@ 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,
@@ -638,3 +694,112 @@ issue_4476: {
     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/awaits.js

@@ -519,6 +519,160 @@ collapse_vars_3: {
     node_version: ">=8"
 }
 
+collapse_property_lambda: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+    }
+    input: {
+        (async function f() {
+            f.g = () => 42;
+            return f.g();
+        })().then(console.log);
+    }
+    expect: {
+        (async function f() {
+            return (f.g = () => 42)();
+        })().then(console.log);
+    }
+    expect_stdout: "42"
+    node_version: ">=8"
+}
+
+drop_return: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (async function(a) {
+            while (!console);
+            return console.log(a);
+        })(42);
+    }
+    expect: {
+        (async function(a) {
+            while (!console);
+            console.log(a);
+        })(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=8"
+}
+
+functions: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        !async function() {
+            var a = async function a() {
+                return a && "a";
+            };
+            var b = async function x() {
+                return !!x;
+            };
+            var c = async function(c) {
+                return c;
+            };
+            if (await c(await b(await a()))) {
+                var d = async function() {};
+                var e = async function y() {
+                    return typeof y;
+                };
+                var f = async function(f) {
+                    return f;
+                };
+                console.log(await a(await d()), await b(await e()), await c(await f(42)), typeof d, await e(), typeof f);
+            }
+        }();
+    }
+    expect: {
+        !async function() {
+            async function a() {
+                return a && "a";
+            }
+            async function b() {
+                return !!b;
+            }
+            var c = async function(c) {
+                return c;
+            };
+            if (await c(await b(await a()))) {
+                async function d() {}
+                async function e() {
+                    return typeof e;
+                }
+                var f = async function(f) {
+                    return f;
+                };
+                console.log(await a(await d()), await b(await e()), await c(await f(42)), typeof d, await e(), typeof f);
+            }
+        }();
+    }
+    expect_stdout: "a true 42 function function function"
+    node_version: ">=8"
+}
+
+functions_use_strict: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        !async function() {
+            var a = async function a() {
+                return a && "a";
+            };
+            var b = async function x() {
+                return !!x;
+            };
+            var c = async function(c) {
+                return c;
+            };
+            if (await c(await b(await a()))) {
+                var d = async function() {};
+                var e = async function y() {
+                    return typeof y;
+                };
+                var f = async function(f) {
+                    return f;
+                };
+                console.log(await a(await d()), await b(await e()), await c(await f(42)), typeof d, await e(), typeof f);
+            }
+        }();
+    }
+    expect: {
+        "use strict";
+        !async function() {
+            async function a() {
+                return a && "a";
+            }
+            async function b() {
+                return !!b;
+            }
+            var c = async function(c) {
+                return c;
+            };
+            if (await c(await b(await a()))) {
+                var d = async function() {};
+                var e = async function y() {
+                    return typeof y;
+                };
+                var f = async function(f) {
+                    return f;
+                };
+                console.log(await a(await d()), await b(await e()), await c(await f(42)), typeof d, await e(), typeof f);
+            }
+        }();
+    }
+    expect_stdout: "a true 42 function function function"
+    node_version: ">=8"
+}
+
 issue_4335_1: {
     options = {
         inline: true,
@@ -612,22 +766,32 @@ issue_4340: {
 call_expression: {
     input: {
         console.log(typeof async function(log) {
-            (await log)("FAIL");
+            (await log)("foo");
         }(console.log).then);
+        console.log("bar");
     }
-    expect_exact: 'console.log(typeof async function(log){(await log)("FAIL")}(console.log).then);'
-    expect_stdout: "function"
+    expect_exact: 'console.log(typeof async function(log){(await log)("foo")}(console.log).then);console.log("bar");'
+    expect_stdout: [
+        "function",
+        "bar",
+        "foo",
+    ]
     node_version: ">=8"
 }
 
 property_access_expression: {
     input: {
         console.log(typeof async function(con) {
-            (await con).log("FAIL");
+            (await con).log("foo");
         }(console).then);
+        console.log("bar");
     }
-    expect_exact: 'console.log(typeof async function(con){(await con).log("FAIL")}(console).then);'
-    expect_stdout: "function"
+    expect_exact: 'console.log(typeof async function(con){(await con).log("foo")}(console).then);console.log("bar");'
+    expect_stdout: [
+        "function",
+        "bar",
+        "foo",
+    ]
     node_version: ">=8"
 }
 
@@ -685,20 +849,18 @@ reduce_iife_3: {
     input: {
         var a = "foo";
         (async function() {
-            console.log(a);
-            console.log(await a);
+            console.log(a, await a, a, await a);
         })();
         a = "bar";
     }
     expect: {
         var a = "foo";
         (async function() {
-            console.log(a);
-            console.log(await a);
+            console.log(a, await a, a, await a);
         })();
         a = "bar";
     }
-    expect_stdout: "foo"
+    expect_stdout: "foo foo bar bar"
     node_version: ">=8"
 }
 
@@ -995,3 +1157,92 @@ issue_4534: {
     expect_stdout: "PASS"
     node_version: ">=8"
 }
+
+issue_4581: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        (async () => (A, a = "FAIL"))();
+        console.log(a);
+    }
+    expect: {
+        var a = "PASS";
+        (async () => (A, a = "FAIL"))();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4595: {
+    options = {
+        awaits: true,
+        inline: true,
+    }
+    input: {
+        (async function() {
+            await async function f() {
+                console.log(f.length);
+            }();
+        })();
+    }
+    expect: {
+        (async function() {
+            await async function f() {
+                console.log(f.length);
+            }();
+        })();
+    }
+    expect_stdout: "0"
+    node_version: ">=8"
+}
+
+issue_4598: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        if (console.log("PASS")) {
+            async function f() {}
+        }
+    }
+    expect: {
+        async function f() {}
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+issue_4618: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function() {
+            var await = async function f() {
+                console || f();
+            };
+            console.log;
+            return await;
+        }());
+    }
+    expect: {
+        console.log(typeof function() {
+            var await = async function f() {
+                console || f();
+            };
+            console.log;
+            return await;
+        }());
+    }
+    expect_stdout: "function"
+    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

@@ -5608,6 +5608,7 @@ collapse_rhs_array: {
 collapse_rhs_boolean_1: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5633,6 +5634,7 @@ collapse_rhs_boolean_1: {
 collapse_rhs_boolean_2: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a;
@@ -5667,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;
@@ -5720,6 +5723,7 @@ collapse_rhs_function: {
 collapse_rhs_number: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5799,6 +5803,7 @@ collapse_rhs_regexp: {
 collapse_rhs_string: {
     options = {
         collapse_vars: true,
+        evaluate: true,
     }
     input: {
         var a, b;
@@ -5874,6 +5879,7 @@ collapse_rhs_this: {
 collapse_rhs_undefined: {
     options = {
         collapse_vars: true,
+        side_effects: true,
     }
     input: {
         var a, b;
@@ -8705,3 +8711,48 @@ collapse_or_assign: {
     }
     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

@@ -1434,3 +1434,67 @@ issue_4527: {
     }
     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;

test/compress/default-values.js

@@ -161,6 +161,7 @@ process_boolean_returns: {
 collapse_value_1: {
     options = {
         collapse_vars: true,
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -169,7 +170,7 @@ collapse_value_1: {
         }());
     }
     expect: {
-        console.log(function(a) {
+        console.log(function() {
             return "PASS";
         }());
     }
@@ -180,6 +181,7 @@ collapse_value_1: {
 collapse_value_2: {
     options = {
         collapse_vars: true,
+        keep_fargs: false,
         unused: true,
     }
     input: {
@@ -188,7 +190,7 @@ collapse_value_2: {
         })().log("PASS");
     }
     expect: {
-        (function(a) {
+        (function() {
             return console;
         })().log("PASS");
     }
@@ -471,7 +473,7 @@ inline_side_effects_2: {
     }
     expect: {
         var a = 42;
-        [ 0[0] = --a ] = [ console ];
+        [ [].e = --a ] = [ console ];
         console.log(a);
     }
     expect_stdout: "42"
@@ -554,8 +556,9 @@ drop_fargs: {
         "bar",
     ]
     expect_warnings: [
-        "WARN: Dropping unused function argument c [test/compress/default-values.js:1,61]",
+        "WARN: Dropping unused default argument c [test/compress/default-values.js:1,61]",
         "WARN: Side effects in default value of unused variable b [test/compress/default-values.js:1,37]",
+        "WARN: Dropping unused default argument assignment a [test/compress/default-values.js:1,29]",
     ]
     node_version: ">=6"
 }
@@ -1474,7 +1477,7 @@ issue_4502_4: {
         (function(a, b = console.log("FAIL")) {})(..."" + console.log(42));
     }
     expect: {
-        [ , 0[0] = console.log("FAIL") ] = [ ..."" + console.log(42) ];
+        [ , [].e = console.log("FAIL") ] = [ ..."" + console.log(42) ];
     }
     expect_stdout: "42"
     node_version: ">=6"
@@ -1596,3 +1599,65 @@ issue_4548: {
     ]
     node_version: ">=6"
 }
+
+issue_4588_1_unused: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function(a = 42) {}.length);
+    }
+    expect: {
+        console.log(function(a = 0) {}.length);
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+issue_4588_2_unused: {
+    options = {
+        unused: true,
+    }
+    input: {
+        console.log(function(a, b = void 0, c, d = "foo") {}.length);
+    }
+    expect: {
+        console.log(function(a, b = 0, c, d) {}.length);
+    }
+    expect_stdout: "1"
+    expect_warnings: [
+        "WARN: Dropping unused default argument assignment d [test/compress/default-values.js:1,47]",
+        "WARN: Dropping unused default argument value b [test/compress/default-values.js:1,32]",
+    ]
+    node_version: ">=6"
+}
+
+issue_4588_1_evaluate: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(function(a = 42) {}.length);
+    }
+    expect: {
+        console.log(0);
+    }
+    expect_stdout: "0"
+    node_version: ">=6"
+}
+
+issue_4588_2_evaluate: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(function(a, b = void 0, c, d = "foo") {}.length);
+    }
+    expect: {
+        console.log(1);
+    }
+    expect_stdout: "1"
+    node_version: ">=6"
+}

test/compress/destructured.js

@@ -2487,3 +2487,72 @@ issue_4554: {
     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

@@ -2138,6 +2138,7 @@ issue_3497: {
 issue_3515_1: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         reduce_vars: true,
         unused: true,
     }
@@ -2189,6 +2190,7 @@ issue_3515_2: {
 issue_3515_3: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         unused: true,
     }
     input: {
@@ -2256,6 +2258,7 @@ function_assign: {
 issue_3598: {
     options = {
         collapse_vars: true,
+        evaluate: true,
         reduce_vars: true,
         unused: true,
     }
@@ -3248,3 +3251,26 @@ issue_4558_2: {
     }
     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",

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

@@ -2053,7 +2053,7 @@ issue_2898: {
     expect_stdout: "2"
 }
 
-deduplicate_parenthesis: {
+deduplicate_parentheses: {
     input: {
         ({}).a = b;
         (({}).a = b)();
@@ -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"
@@ -5016,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",
@@ -5283,3 +5288,413 @@ issue_4471: {
         "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/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/join_vars.js

@@ -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

@@ -438,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++);
             })();

test/compress/let.js

@@ -1319,7 +1319,6 @@ issue_4531_2: {
         toplevel: true,
     }
     input: {
-        "use strict";
         var a = console;
         console.log(typeof a, function a() {
             let { [console]: a } = 0 && a;
@@ -1328,7 +1327,6 @@ issue_4531_2: {
         }());
     }
     expect: {
-        "use strict";
         var o = console;
         console.log(typeof o, function o() {
             let { [console]: o } = 0;
@@ -1339,3 +1337,70 @@ issue_4531_2: {
     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,
@@ -1052,7 +1067,6 @@ issue_4084: {
     options = {
         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,
     }

test/compress/merge_vars.js

@@ -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,
     }

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_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: {

test/compress/reduce_vars.js

@@ -2460,6 +2460,7 @@ delay_def: {
         evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
+        side_effects: true,
         unused: true,
     }
     input: {

test/compress/rests.js

@@ -663,3 +663,124 @@ issue_4562: {
     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"
@@ -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

@@ -918,3 +918,32 @@ issue_4560_3: {
     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/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/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/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

@@ -294,6 +294,40 @@ 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"), {

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: [
@@ -131,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
 
@@ -180,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 ];
@@ -201,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);
                         }
@@ -299,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:
@@ -321,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) {
@@ -357,7 +363,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             }
             else if (node instanceof U.AST_PropAccess) {
                 var expr = [
-                    node.expression,
+                    !(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) {
@@ -454,6 +460,13 @@ 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++;
@@ -467,7 +480,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
             }
 
             // 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,
@@ -558,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;
@@ -600,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)",
@@ -624,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// ");
 }
@@ -665,20 +674,8 @@ function has_loopcontrol(body, loop, label) {
     return found;
 }
 
-function is_error(result) {
-    return result && 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_AsyncArrow
-            || 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) {
@@ -700,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({
@@ -728,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,103 +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);
-        }));
-    }
-}
-
-function run_code(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(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(code, toplevel, timeout);
+        stdout = run_code_vm(code, toplevel, timeout);
     } while (prev !== stdout);
     return stdout;
-} : run_code;
-
-function strip_func_ids(text) {
-    return ("" + text).replace(/F[0-9]{6}N/g, "<F<>N>");
-}
-
+} : 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);
+    }
+};
 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);
@@ -107,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) {

tools/exports.js

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