harmony-v3.3.3

fixes #2678

README.md

@@ -1,14 +1,11 @@
-UglifyJS 3
-==========
+uglify-es
+=========
 
-UglifyJS is a JavaScript parser, minifier, compressor and beautifier toolkit.
+A JavaScript parser, mangler/compressor and beautifier toolkit for ES6+.
 
 #### 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/UglifyJS2/tree/v2.x)**.
-- **Documentation for UglifyJS `2.x` releases can be found [here](https://github.com/mishoo/UglifyJS2/tree/v2.x)**.
-- `uglify-js` only supports ECMAScript 5 (ES5).
-- Those wishing to minify
-ES2015+ (ES6+) should use the `npm` package [**uglify-es**](https://github.com/mishoo/UglifyJS2/tree/harmony).
+- **`uglify-es` is API/CLI compatible with `uglify-js@3`.**
+- **`uglify-es` is not backwards compatible with `uglify-js@2`.**
 
 Install
 -------
@@ -18,11 +15,11 @@ First make sure you have installed the latest version of [node.js](http://nodejs
 
 From NPM for use as a command line app:
 
-    npm install uglify-js -g
+    npm install uglify-es -g
 
 From NPM for programmatic use:
 
-    npm install uglify-js
+    npm install uglify-es
 
 # Command line usage
 
@@ -105,13 +102,20 @@ a double dash to prevent input files being used as option arguments:
                                 sequences.
     --config-file <file>        Read `minify()` options from JSON file.
     -d, --define <expr>[=value] Global definitions.
+    --ecma <version>            Specify ECMAScript release: 5, 6, 7 or 8.
     --ie8                       Support non-standard Internet Explorer 8.
                                 Equivalent to setting `ie8: true` in `minify()`
                                 for `compress`, `mangle` and `output` options.
                                 By default UglifyJS will not try to be IE-proof.
+    --keep-classnames           Do not mangle/drop class names.
     --keep-fnames               Do not mangle/drop function names.  Useful for
                                 code relying on Function.prototype.name.
     --name-cache <file>         File to hold mangled name mappings.
+    --safari10                  Support non-standard Safari 10/11.
+                                Equivalent to setting `safari10: true` in `minify()`
+                                for `mangle` and `output` options.
+                                By default `uglify-es` will not work around
+                                Safari 10/11 bugs.
     --self                      Build UglifyJS as a library (implies --wrap UglifyJS)
     --source-map [options]      Enable source map/specify source map options:
                                 `base`  Path to compute relative paths from input files.
@@ -345,7 +349,7 @@ identify mistakes like writing mangled keys to storage.
 Assuming installation via NPM, you can load UglifyJS in your application
 like this:
 ```javascript
-var UglifyJS = require("uglify-js");
+var UglifyJS = require("uglify-es");
 ```
 
 There is a single high level function, **`minify(code, options)`**,
@@ -474,6 +478,9 @@ if (result.error) throw result.error;
 
 ## Minify options
 
+- `ecma` (default `undefined`) - pass `5`, `6`, `7` or `8` to override `parse`,
+  `compress` and `output` options.
+
 - `warnings` (default `false`) — pass `true` to return compressor warnings
   in `result.warnings`. Use the value `"verbose"` for more detailed warnings.
 
@@ -508,8 +515,17 @@ if (result.error) throw result.error;
 
 - `ie8` (default `false`) - set to `true` to support IE8.
 
+- `keep_classnames` (default: `undefined`) - pass `true` to prevent discarding or mangling
+  of class names.
+
 - `keep_fnames` (default: `false`) - pass `true` to prevent discarding or mangling
-  of function names.  Useful for code relying on `Function.prototype.name`.
+  of function names.  Useful for code relying on `Function.prototype.name`. If the
+  top level minify option `keep_classnames` is `undefined` it will be overriden with
+  the value of the top level minify option `keep_fnames`.
+
+- `safari10` (default: `false`) - pass `true` to work around Safari 10/11 bugs in
+  loop scoping and `await`. See `safari10` options in [`mangle`](#mangle-options)
+  and [`output`](#output-options) for details.
 
 ## Minify options structure
 
@@ -534,9 +550,13 @@ if (result.error) throw result.error;
     sourceMap: {
         // source map options
     },
-    nameCache: null, // or specify a name cache object
-    toplevel: false,
+    ecma: 5, // specify one of: 5, 6, 7 or 8
+    keep_classnames: false,
+    keep_fnames: false,
     ie8: false,
+    nameCache: null, // or specify a name cache object
+    safari10: false,
+    toplevel: false,
     warnings: false,
 }
 ```
@@ -592,18 +612,24 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 
 - `bare_returns` (default `false`) -- support top level `return` statements
 
+- `ecma` (default: `8`) -- specify one of `5`, `6`, `7` or `8`. Note: this setting
+  is not presently enforced except for ES8 optional trailing commas in function
+  parameter lists and calls with `ecma` `8`.
+
 - `html5_comments` (default `true`)
 
 - `shebang` (default `true`) -- support `#!command` as the first line
 
 ## Compress options
 
+- `arrows` (default: `true`) -- Converts `()=>{return x}` to `()=>x`. Class
+  and object literal methods will also be converted to arrow expressions if
+  the resultant code is shorter: `m(){return x}` becomes `m:()=>x`.
+  This transform requires that the `ecma` compress option is set to `6` or greater.
+
 - `booleans` (default: `true`) -- various optimizations for boolean context,
   for example `!!a ? b : c → a ? b : c`
 
-- `cascade` (default: `true`) -- small optimization for sequences, transform
-  `x, x` into `x` and `x = something(), x` into `x = something()`
-
 - `collapse_vars` (default: `true`) -- Collapse single-use non-constant variables,
   side effects permitting.
 
@@ -611,6 +637,9 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
   e.g. `!(a <= b) → a > b` (only when `unsafe_comps`), attempts to negate binary
   nodes, e.g. `a = !b && !c && !d && !e → a=!(b||c||d||e)` etc.
 
+- `computed_props` (default: `true`) -- Transforms constant computed properties
+  into regular ones: `{["computed"]: 1}` is converted to `{computed: 1}`.
+
 - `conditionals` (default: `true`) -- apply optimizations for `if`-s and conditional
   expressions
 
@@ -623,6 +652,9 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 
 - `drop_debugger` (default: `true`) -- remove `debugger;` statements
 
+- `ecma` (default: `5`) -- Pass `6` or greater to enable `compress` options that
+  will transform ES5 code into smaller ES6+ equivalent forms.
+
 - `evaluate` (default: `true`) -- attempt to evaluate constant expressions
 
 - `expression` (default: `false`) -- Pass `true` to preserve completion values
@@ -630,7 +662,7 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 
 - `global_defs` (default: `{}`) -- see [conditional compilation](#conditional-compilation)
 
-- `hoist_funs` (default: `true`) -- hoist function declarations
+- `hoist_funs` (default: `false`) -- hoist function declarations
 
 - `hoist_props` (default: `true`) -- hoist properties from constant object and
   array literals into regular variables subject to a set of constraints. For example:
@@ -647,6 +679,10 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 
 - `join_vars` (default: `true`) -- join consecutive `var` statements
 
+- `keep_classnames` (default: `false`) -- Pass `true` to prevent the
+  compressor from discarding class names.  See also: the `keep_classnames`
+  [mangle option](#mangle).
+
 - `keep_fargs` (default: `true`) -- Prevents the compressor from discarding unused
   function arguments.  You need this for code which relies on `Function.length`.
 
@@ -727,6 +763,12 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 
 - `unsafe` (default: `false`) -- apply "unsafe" transformations (discussion below)
 
+- `unsafe_arrows` (default: `false`) -- Convert ES5 style anonymous function
+  expressions to arrow functions if the function body does not reference `this`.
+  Note: it is not always safe to perform this conversion if code relies on the
+  the function having a `prototype`, which arrow functions lack.
+  This transform requires that the `ecma` compress option is set to `6` or greater.
+
 - `unsafe_comps` (default: `false`) -- Reverse `<` and `<=` to `>` and `>=` to
   allow improved compression. This might be unsafe when an at least one of two
   operands is an object with computed values due the use of methods like `get`,
@@ -740,6 +782,13 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 - `unsafe_math` (default: `false`) -- optimize numerical expressions like
   `2 * x * 3` into `6 * x`, which may give imprecise floating point results.
 
+- `unsafe_methods` (default: false) -- Converts `{ m: function(){} }` to
+  `{ m(){} }`. `ecma` must be set to `6` or greater to enable this transform.
+  If `unsafe_methods` is a RegExp then key/value pairs with keys matching the
+  RegExp will be converted to concise methods.
+  Note: if enabled there is a risk of getting a "`<method name>` is not a
+  constructor" TypeError should any code try to `new` the former function.
+
 - `unsafe_proto` (default: `false`) -- optimize expressions like
   `Array.prototype.slice.call(a)` into `[].slice.call(a)`
 
@@ -757,6 +806,9 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 - `eval` (default `false`) -- Pass `true` to mangle names visible in scopes
   where `eval` or `with` are used.
 
+- `keep_classnames` (default `false`) -- Pass `true` to not mangle class names.
+  See also: the `keep_classnames` [compress option](#compress-options).
+
 - `keep_fnames` (default `false`) -- Pass `true` to not mangle function names.
   Useful for code relying on `Function.prototype.name`. See also: the `keep_fnames`
   [compress option](#compress-options).
@@ -767,6 +819,11 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 - `toplevel` (default `false`) -- Pass `true` to mangle names declared in the
   top level scope.
 
+- `safari10` (default `false`) -- Pass `true` to work around the Safari 10 loop
+  iterator [bug](https://bugs.webkit.org/show_bug.cgi?id=171041)
+  "Cannot declare a let variable twice".
+  See also: the `safari10` [output option](#output-options).
+
 Examples:
 
 ```javascript
@@ -827,6 +884,13 @@ can pass additional arguments that control the code output:
   comments, `"some"` to preserve some comments, a regular expression string
   (e.g. `/^!/`) or a function.
 
+- `ecma` (default `5`) -- set output printing mode. Set `ecma` to `6` or
+  greater to emit shorthand object properties - i.e.: `{a}` instead of `{a: a}`.
+  The `ecma` option will only change the output in direct control of the
+  beautifier. Non-compatible features in the abstract syntax tree will still
+  be output as is. For example: an `ecma` setting of `5` will **not** convert
+  ES6+ code to ES5.
+
 - `indent_level` (default `4`)
 
 - `indent_start` (default `0`) -- prefix all lines by that many spaces
@@ -858,6 +922,10 @@ can pass additional arguments that control the code output:
   - `2` -- always use double quotes
   - `3` -- always use the original quotes
 
+- `safari10` (default `false`) -- set this option to `true` to work around
+  the [Safari 10/11 await bug](https://bugs.webkit.org/show_bug.cgi?id=176685).
+  See also: the `safari10` [mangle option](#mangle-options).
+
 - `semicolons` (default `true`) -- separate statements with semicolons.  If
   you pass `false` then whenever possible we will use a newline instead of a
   semicolon, leading to more readable output of uglified code (size before

bin/uglifyjs

@@ -44,10 +44,13 @@ program.option("-o, --output <file>", "Output file (default STDOUT).");
 program.option("--comments [filter]", "Preserve copyright comments in the output.");
 program.option("--config-file <file>", "Read minify() options from JSON file.");
 program.option("-d, --define <expr>[=value]", "Global definitions.", parse_js("define"));
+program.option("--ecma <version>", "Specify ECMAScript release: 5, 6, 7 or 8.");
 program.option("--ie8", "Support non-standard Internet Explorer 8.");
+program.option("--keep-classnames", "Do not mangle/drop class names.");
 program.option("--keep-fnames", "Do not mangle/drop function names. Useful for code relying on Function.prototype.name.");
 program.option("--name-cache <file>", "File to hold mangled name mappings.");
 program.option("--no-rename", "Disable symbol expansion.");
+program.option("--safari10", "Support non-standard Safari 10.");
 program.option("--self", "Build UglifyJS as a library (implies --wrap UglifyJS)");
 program.option("--source-map [options]", "Enable source map/specify source map options.", parse_source_map());
 program.option("--timings", "Display operations run time on STDERR.")
@@ -67,6 +70,7 @@ if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
     "ie8",
     "mangle",
     "rename",
+    "safari10",
     "sourceMap",
     "toplevel",
     "wrap"
@@ -76,6 +80,10 @@ if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
         options[name] = program[name];
     }
 });
+if ("ecma" in program) {
+    if (program.ecma != (program.ecma | 0)) fatal("ERROR: ecma must be an integer");
+    options.ecma = program.ecma | 0;
+}
 if (program.beautify) {
     options.output = typeof program.beautify == "object" ? program.beautify : {};
     if (!("beautify" in options.output)) {
@@ -93,6 +101,9 @@ if (program.define) {
         options.compress.global_defs[expr] = program.define[expr];
     }
 }
+if (program.keepClassnames) {
+    options.keep_classnames = true;
+}
 if (program.keepFnames) {
     options.keep_fnames = true;
 }

lib/ast.js

@@ -87,7 +87,7 @@ function DEFNODE(type, props, methods, base) {
     return ctor;
 };
 
-var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before file raw", {
+var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before comments_after file raw", {
 }, null);
 
 var AST_Node = DEFNODE("Node", "start end", {
@@ -156,7 +156,7 @@ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
 
 function walk_body(node, visitor) {
     var body = node.body;
-    if (body instanceof AST_Statement) {
+    if (body instanceof AST_Node) {
         body._walk(visitor);
     }
     else for (var i = 0, len = body.length; i < len; i++) {
@@ -283,6 +283,10 @@ var AST_ForIn = DEFNODE("ForIn", "init name object", {
     }
 }, AST_IterationStatement);
 
+var AST_ForOf = DEFNODE("ForOf", null, {
+    $documentation: "A `for ... of` statement",
+}, AST_ForIn);
+
 var AST_With = DEFNODE("With", "expression", {
     $documentation: "A `with` statement",
     $propdoc: {
@@ -309,6 +313,13 @@ var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent
         enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
         cname: "[integer/S] current index for mangling variables (used internally by the mangler)",
     },
+    get_defun_scope: function() {
+        var self = this;
+        while (self.is_block_scope()) {
+            self = self.parent_scope;
+        }
+        return self;
+    }
 }, AST_Block);
 
 var AST_Toplevel = DEFNODE("Toplevel", "globals", {
@@ -329,12 +340,38 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
     }
 }, AST_Scope);
 
-var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments", {
+var AST_Expansion = DEFNODE("Expansion", "expression", {
+    $documentation: "An expandible argument, such as ...rest, a splat, such as [1,2,...all], or an expansion in a variable declaration, such as var [first, ...rest] = list",
+    $propdoc: {
+        expression: "[AST_Node] the thing to be expanded"
+    },
+    _walk: function(visitor) {
+        var self = this;
+        return visitor._visit(this, function(){
+            self.expression.walk(visitor);
+        });
+    }
+});
+
+var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator async", {
     $documentation: "Base class for functions",
     $propdoc: {
         name: "[AST_SymbolDeclaration?] the name of this function",
-        argnames: "[AST_SymbolFunarg*] array of function arguments",
-        uses_arguments: "[boolean/S] tells whether this function accesses the arguments array"
+        argnames: "[AST_SymbolFunarg|AST_Destructuring|AST_Expansion|AST_DefaultAssign*] array of function arguments, destructurings, or expanding arguments",
+        uses_arguments: "[boolean/S] tells whether this function accesses the arguments array",
+        is_generator: "[boolean] is this a generator method",
+        async: "[boolean] is this method async",
+    },
+    args_as_names: function () {
+        var out = [];
+        for (var i = 0; i < this.argnames.length; i++) {
+            if (this.argnames[i] instanceof AST_Destructuring) {
+                out = out.concat(this.argnames[i].all_symbols());
+            } else {
+                out.push(this.argnames[i]);
+            }
+        }
+        return out;
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
@@ -356,10 +393,76 @@ var AST_Function = DEFNODE("Function", "inlined", {
     $documentation: "A function expression"
 }, AST_Lambda);
 
+var AST_Arrow = DEFNODE("Arrow", "inlined", {
+    $documentation: "An ES6 Arrow function ((a) => b)"
+}, AST_Lambda);
+
 var AST_Defun = DEFNODE("Defun", "inlined", {
     $documentation: "A function definition"
 }, AST_Lambda);
 
+/* -----[ DESTRUCTURING ]----- */
+var AST_Destructuring = DEFNODE("Destructuring", "names is_array", {
+    $documentation: "A destructuring of several names. Used in destructuring assignment and with destructuring function argument names",
+    $propdoc: {
+        "names": "[AST_Node*] Array of properties or elements",
+        "is_array": "[Boolean] Whether the destructuring represents an object or array"
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.names.forEach(function(name){
+                name._walk(visitor);
+            });
+        });
+    },
+    all_symbols: function() {
+        var out = [];
+        this.walk(new TreeWalker(function (node) {
+            if (node instanceof AST_Symbol) {
+                out.push(node);
+            }
+            if (node instanceof AST_Expansion) {
+                out.push(node.expression);
+            }
+        }));
+        return out;
+    }
+});
+
+var AST_PrefixedTemplateString = DEFNODE("PrefixedTemplateString", "template_string prefix", {
+    $documentation: "A templatestring with a prefix, such as String.raw`foobarbaz`",
+    $propdoc: {
+        template_string: "[AST_TemplateString] The template string",
+        prefix: "[AST_SymbolRef|AST_PropAccess] The prefix, which can be a symbol such as `foo` or a dotted expression such as `String.raw`."
+    },
+    _walk: function(visitor) {
+        this.prefix._walk(visitor);
+        this.template_string._walk(visitor);
+    }
+})
+
+var AST_TemplateString = DEFNODE("TemplateString", "segments", {
+    $documentation: "A template string literal",
+    $propdoc: {
+        segments: "[AST_Node*] One or more segments, starting with AST_TemplateSegment. AST_Node may follow AST_TemplateSegment, but each AST_Node must be followed by AST_TemplateSegment."
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.segments.forEach(function(seg){
+                seg._walk(visitor);
+            });
+        });
+    }
+});
+
+var AST_TemplateSegment = DEFNODE("TemplateSegment", "value raw", {
+    $documentation: "A segment of a template string literal",
+    $propdoc: {
+        value: "Content of the segment",
+        raw: "Raw content of the segment"
+    }
+});
+
 /* -----[ JUMPS ]----- */
 
 var AST_Jump = DEFNODE("Jump", null, {
@@ -479,7 +582,7 @@ var AST_Try = DEFNODE("Try", "bcatch bfinally", {
 var AST_Catch = DEFNODE("Catch", "argname", {
     $documentation: "A `catch` node; only makes sense as part of a `try` statement",
     $propdoc: {
-        argname: "[AST_SymbolCatch] symbol for the exception"
+        argname: "[AST_SymbolCatch|AST_Destructuring|AST_Expansion|AST_DefaultAssign] symbol for the exception"
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
@@ -493,10 +596,10 @@ var AST_Finally = DEFNODE("Finally", null, {
     $documentation: "A `finally` node; only makes sense as part of a `try` statement"
 }, AST_Block);
 
-/* -----[ VAR ]----- */
+/* -----[ VAR/CONST ]----- */
 
 var AST_Definitions = DEFNODE("Definitions", "definitions", {
-    $documentation: "Base class for `var` nodes (variable declarations/initializations)",
+    $documentation: "Base class for `var` or `const` nodes (variable declarations/initializations)",
     $propdoc: {
         definitions: "[AST_VarDef*] array of variable definitions"
     },
@@ -514,10 +617,83 @@ var AST_Var = DEFNODE("Var", null, {
     $documentation: "A `var` statement"
 }, AST_Definitions);
 
+var AST_Let = DEFNODE("Let", null, {
+    $documentation: "A `let` statement"
+}, AST_Definitions);
+
+var AST_Const = DEFNODE("Const", null, {
+    $documentation: "A `const` statement"
+}, AST_Definitions);
+
+var AST_NameMapping = DEFNODE("NameMapping", "foreign_name name", {
+    $documentation: "The part of the export/import statement that declare names from a module.",
+    $propdoc: {
+        foreign_name: "[AST_SymbolExportForeign|AST_SymbolImportForeign] The name being exported/imported (as specified in the module)",
+        name: "[AST_SymbolExport|AST_SymbolImport] The name as it is visible to this module."
+    },
+    _walk: function (visitor) {
+        return visitor._visit(this, function() {
+            this.foreign_name._walk(visitor);
+            this.name._walk(visitor);
+        });
+    }
+})
+
+var AST_Import = DEFNODE("Import", "imported_name imported_names module_name", {
+    $documentation: "An `import` statement",
+    $propdoc: {
+        imported_name: "[AST_SymbolImport] The name of the variable holding the module's default export.",
+        imported_names: "[AST_NameMapping*] The names of non-default imported variables",
+        module_name: "[AST_String] String literal describing where this module came from",
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, function() {
+            if (this.imported_name) {
+                this.imported_name._walk(visitor);
+            }
+            if (this.imported_names) {
+                this.imported_names.forEach(function(name_import) {
+                    name_import._walk(visitor);
+                });
+            }
+            this.module_name._walk(visitor);
+        });
+    }
+});
+
+var AST_Export = DEFNODE("Export", "exported_definition exported_value is_default exported_names module_name", {
+    $documentation: "An `export` statement",
+    $propdoc: {
+        exported_definition: "[AST_Defun|AST_Definitions|AST_DefClass?] An exported definition",
+        exported_value: "[AST_Node?] An exported value",
+        exported_names: "[AST_NameMapping*?] List of exported names",
+        module_name: "[AST_String?] Name of the file to load exports from",
+        is_default: "[Boolean] Whether this is the default exported value of this module"
+    },
+    _walk: function (visitor) {
+        visitor._visit(this, function () {
+            if (this.exported_definition) {
+                this.exported_definition._walk(visitor);
+            }
+            if (this.exported_value) {
+                this.exported_value._walk(visitor);
+            }
+            if (this.exported_names) {
+                this.exported_names.forEach(function(name_export) {
+                    name_export._walk(visitor);
+                });
+            }
+            if (this.module_name) {
+                this.module_name._walk(visitor);
+            }
+        });
+    }
+}, AST_Statement);
+
 var AST_VarDef = DEFNODE("VarDef", "name value", {
     $documentation: "A variable declaration; only appears in a AST_Definitions node",
     $propdoc: {
-        name: "[AST_SymbolVar] name of the variable",
+        name: "[AST_Destructuring|AST_SymbolConst|AST_SymbolLet|AST_SymbolVar] name of the variable",
         value: "[AST_Node?] initializer, or null of there's no initializer"
     },
     _walk: function(visitor) {
@@ -648,6 +824,10 @@ var AST_Assign = DEFNODE("Assign", null, {
     $documentation: "An assignment expression — `a = b + 5`",
 }, AST_Binary);
 
+var AST_DefaultAssign = DEFNODE("DefaultAssign", null, {
+    $documentation: "A default assignment expression like in `(a = 3) => a`"
+}, AST_Binary);
+
 /* -----[ LITERALS ]----- */
 
 var AST_Array = DEFNODE("Array", "elements", {
@@ -683,11 +863,13 @@ var AST_Object = DEFNODE("Object", "properties", {
 var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
     $documentation: "Base class for literal object properties",
     $propdoc: {
-        key: "[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an AST_SymbolAccessor.",
+        key: "[string|AST_Node] the property name converted to a string for ObjectKeyVal. For setters, getters and computed property this is an arbitrary AST_Node",
         value: "[AST_Node] property value.  For setters and getters this is an AST_Accessor."
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
+            if (this.key instanceof AST_Node)
+                this.key._walk(visitor);
             this.value._walk(visitor);
         });
     }
@@ -700,35 +882,95 @@ var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", {
     }
 }, AST_ObjectProperty);
 
-var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
+var AST_ObjectSetter = DEFNODE("ObjectSetter", "quote static", {
+    $propdoc: {
+        quote: "[string|undefined] the original quote character, if any",
+        static: "[boolean] whether this is a static setter (classes only)"
+    },
     $documentation: "An object setter property",
 }, AST_ObjectProperty);
 
-var AST_ObjectGetter = DEFNODE("ObjectGetter", null, {
+var AST_ObjectGetter = DEFNODE("ObjectGetter", "quote static", {
+    $propdoc: {
+        quote: "[string|undefined] the original quote character, if any",
+        static: "[boolean] whether this is a static getter (classes only)"
+    },
     $documentation: "An object getter property",
 }, AST_ObjectProperty);
 
+var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator async", {
+    $propdoc: {
+        quote: "[string|undefined] the original quote character, if any",
+        static: "[boolean] is this method static (classes only)",
+        is_generator: "[boolean] is this a generator method",
+        async: "[boolean] is this method async",
+    },
+    $documentation: "An ES6 concise method inside an object or class"
+}, AST_ObjectProperty);
+
+var AST_Class = DEFNODE("Class", "name extends properties inlined", {
+    $propdoc: {
+        name: "[AST_SymbolClass|AST_SymbolDefClass?] optional class name.",
+        extends: "[AST_Node]? optional parent class",
+        properties: "[AST_ObjectProperty*] array of properties"
+    },
+    $documentation: "An ES6 class",
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            if (this.name) {
+                this.name._walk(visitor);
+            }
+            if (this.extends) {
+                this.extends._walk(visitor);
+            }
+            this.properties.forEach(function(prop){
+                prop._walk(visitor);
+            });
+        });
+    },
+}, AST_Scope);
+
+var AST_DefClass = DEFNODE("DefClass", null, {
+    $documentation: "A class definition",
+}, AST_Class);
+
+var AST_ClassExpression = DEFNODE("ClassExpression", null, {
+    $documentation: "A class expression."
+}, AST_Class);
+
 var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
     $propdoc: {
         name: "[string] name of this symbol",
         scope: "[AST_Scope/S] the current scope (not necessarily the definition scope)",
         thedef: "[SymbolDef/S] the definition of this symbol"
     },
-    $documentation: "Base class for all symbols",
+    $documentation: "Base class for all symbols"
 });
 
-var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
-    $documentation: "The name of a property accessor (setter/getter function)"
-}, AST_Symbol);
+var AST_NewTarget = DEFNODE("NewTarget", null, {
+    $documentation: "A reference to new.target"
+});
 
 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
-    $documentation: "A declaration symbol (symbol in var, function name or argument, symbol in catch)",
+    $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
 }, AST_Symbol);
 
 var AST_SymbolVar = DEFNODE("SymbolVar", null, {
     $documentation: "Symbol defining a variable",
 }, AST_SymbolDeclaration);
 
+var AST_SymbolBlockDeclaration = DEFNODE("SymbolBlockDeclaration", null, {
+    $documentation: "Base class for block-scoped declaration symbols"
+}, AST_SymbolDeclaration);
+
+var AST_SymbolConst = DEFNODE("SymbolConst", null, {
+    $documentation: "A constant declaration"
+}, AST_SymbolBlockDeclaration);
+
+var AST_SymbolLet = DEFNODE("SymbolLet", null, {
+    $documentation: "A block-scoped `let` declaration"
+}, AST_SymbolBlockDeclaration);
+
 var AST_SymbolFunarg = DEFNODE("SymbolFunarg", null, {
     $documentation: "Symbol naming a function argument",
 }, AST_SymbolVar);
@@ -737,13 +979,33 @@ var AST_SymbolDefun = DEFNODE("SymbolDefun", null, {
     $documentation: "Symbol defining a function",
 }, AST_SymbolDeclaration);
 
+var AST_SymbolMethod = DEFNODE("SymbolMethod", null, {
+    $documentation: "Symbol in an object defining a method",
+}, AST_Symbol);
+
 var AST_SymbolLambda = DEFNODE("SymbolLambda", null, {
     $documentation: "Symbol naming a function expression",
 }, AST_SymbolDeclaration);
 
+var AST_SymbolDefClass = DEFNODE("SymbolDefClass", null, {
+    $documentation: "Symbol naming a class's name in a class declaration. Lexically scoped to its containing scope, and accessible within the class."
+}, AST_SymbolBlockDeclaration);
+
+var AST_SymbolClass = DEFNODE("SymbolClass", null, {
+    $documentation: "Symbol naming a class's name. Lexically scoped to the class."
+}, AST_SymbolDeclaration);
+
 var AST_SymbolCatch = DEFNODE("SymbolCatch", null, {
     $documentation: "Symbol naming the exception in catch",
-}, AST_SymbolDeclaration);
+}, AST_SymbolBlockDeclaration);
+
+var AST_SymbolImport = DEFNODE("SymbolImport", null, {
+    $documentation: "Symbol referring to an imported name",
+}, AST_SymbolBlockDeclaration);
+
+var AST_SymbolImportForeign = DEFNODE("SymbolImportForeign", null, {
+    $documentation: "A symbol imported from a module, but it is defined in the other module, and its real name is irrelevant for this module's purposes",
+}, AST_Symbol);
 
 var AST_Label = DEFNODE("Label", "references", {
     $documentation: "Symbol naming a label (declaration)",
@@ -760,6 +1022,14 @@ var AST_SymbolRef = DEFNODE("SymbolRef", null, {
     $documentation: "Reference to some symbol (not definition/declaration)",
 }, AST_Symbol);
 
+var AST_SymbolExport = DEFNODE("SymbolExport", null, {
+    $documentation: "Symbol referring to a name to export",
+}, AST_SymbolRef);
+
+var AST_SymbolExportForeign = DEFNODE("SymbolExportForeign", null, {
+    $documentation: "A symbol exported from this module, but it is used in the other module, and its real name is irrelevant for this module's purposes",
+}, AST_Symbol);
+
 var AST_LabelRef = DEFNODE("LabelRef", null, {
     $documentation: "Reference to a label symbol",
 }, AST_Symbol);
@@ -768,6 +1038,10 @@ var AST_This = DEFNODE("This", null, {
     $documentation: "The `this` symbol",
 }, AST_Symbol);
 
+var AST_Super = DEFNODE("Super", null, {
+    $documentation: "The `super` symbol",
+}, AST_This);
+
 var AST_Constant = DEFNODE("Constant", null, {
     $documentation: "Base class for all constants",
     getValue: function() {
@@ -841,6 +1115,31 @@ var AST_True = DEFNODE("True", null, {
     value: true
 }, AST_Boolean);
 
+var AST_Await = DEFNODE("Await", "expression", {
+    $documentation: "An `await` statement",
+    $propdoc: {
+        expression: "[AST_Node] the mandatory expression being awaited",
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.expression._walk(visitor);
+        });
+    }
+});
+
+var AST_Yield = DEFNODE("Yield", "expression is_star", {
+    $documentation: "A `yield` statement",
+    $propdoc: {
+        expression: "[AST_Node?] the value returned or thrown by this statement; could be null (representing undefined) but only when is_star is set to false",
+        is_star: "[Boolean] Whether this is a yield or yield* statement"
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, this.expression && function(){
+            this.expression._walk(visitor);
+        });
+    }
+});
+
 /* -----[ TreeWalker ]----- */
 
 function TreeWalker(callback) {
@@ -868,11 +1167,17 @@ TreeWalker.prototype = {
             this.directives = Object.create(this.directives);
         } else if (node instanceof AST_Directive && !this.directives[node.value]) {
             this.directives[node.value] = node;
+        } else if (node instanceof AST_Class) {
+            this.directives = Object.create(this.directives);
+            if (!this.directives["use strict"]) {
+                this.directives["use strict"] = node;
+            }
         }
         this.stack.push(node);
     },
     pop: function() {
-        if (this.stack.pop() instanceof AST_Lambda) {
+        var node = this.stack.pop();
+        if (node instanceof AST_Lambda || node instanceof AST_Class) {
             this.directives = Object.getPrototypeOf(this.directives);
         }
     },
@@ -890,7 +1195,7 @@ TreeWalker.prototype = {
         var dir = this.directives[type];
         if (dir) return dir;
         var node = this.stack[this.stack.length - 1];
-        if (node instanceof AST_Scope) {
+        if (node instanceof AST_Scope && node.body) {
             for (var i = 0; i < node.body.length; ++i) {
                 var st = node.body[i];
                 if (!(st instanceof AST_Directive)) break;

lib/minify.js

@@ -49,13 +49,16 @@ function minify(files, options) {
     try {
         options = defaults(options, {
             compress: {},
+            ecma: undefined,
             ie8: false,
+            keep_classnames: undefined,
             keep_fnames: false,
             mangle: {},
             nameCache: null,
             output: {},
             parse: {},
             rename: undefined,
+            safari10: false,
             sourceMap: false,
             timings: false,
             toplevel: false,
@@ -65,11 +68,17 @@ function minify(files, options) {
         var timings = options.timings && {
             start: Date.now()
         };
+        if (options.keep_classnames === undefined) {
+            options.keep_classnames = options.keep_fnames;
+        }
         if (options.rename === undefined) {
             options.rename = options.compress && options.mangle;
         }
+        set_shorthand("ecma", options, [ "parse", "compress", "output" ]);
         set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
+        set_shorthand("keep_classnames", options, [ "compress", "mangle" ]);
         set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
+        set_shorthand("safari10", options, [ "mangle", "output" ]);
         set_shorthand("toplevel", options, [ "compress", "mangle" ]);
         set_shorthand("warnings", options, [ "compress" ]);
         var quoted_props;
@@ -78,9 +87,11 @@ function minify(files, options) {
                 cache: options.nameCache && (options.nameCache.vars || {}),
                 eval: false,
                 ie8: false,
+                keep_classnames: false,
                 keep_fnames: false,
                 properties: false,
                 reserved: [],
+                safari10: false,
                 toplevel: false,
             }, true);
             if (options.mangle.properties) {

lib/mozilla-ast.js

@@ -118,7 +118,7 @@
                 value    : from_moz(M.value)
             };
             if (M.kind == "init") return new AST_ObjectKeyVal(args);
-            args.key = new AST_SymbolAccessor({
+            args.key = new AST_SymbolMethod({
                 name: args.key
             });
             args.value = new AST_Accessor(args.value);
@@ -168,7 +168,7 @@
             });
         },
         VariableDeclaration: function(M) {
-            return new AST_Var({
+            return new (M.kind === "const" ? AST_Const : AST_Var)({
                 start       : my_start_token(M),
                 end         : my_end_token(M),
                 definitions : M.declarations.map(from_moz)
@@ -204,7 +204,7 @@
         Identifier: function(M) {
             var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
             return new (  p.type == "LabeledStatement" ? AST_Label
-                        : p.type == "VariableDeclarator" && p.id === M ? AST_SymbolVar
+                        : p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : AST_SymbolVar)
                         : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
                         : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
                         : p.type == "CatchClause" ? AST_SymbolCatch
@@ -324,7 +324,7 @@
     def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
         return {
             type: "VariableDeclaration",
-            kind: "var",
+            kind: M instanceof AST_Const ? "const" : "var",
             declarations: M.definitions.map(to_moz)
         };
     });
@@ -381,7 +381,7 @@
     def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
         var key = {
             type: "Literal",
-            value: M.key instanceof AST_SymbolAccessor ? M.key.name : M.key
+            value: M.key instanceof AST_SymbolMethod ? M.key.name : M.key
         };
         var kind;
         if (M instanceof AST_ObjectKeyVal) {

lib/output.js

@@ -52,11 +52,13 @@ function is_some_comments(comment) {
 
 function OutputStream(options) {
 
+    var readonly = !options;
     options = defaults(options, {
         ascii_only       : false,
         beautify         : false,
         bracketize       : false,
         comments         : false,
+        ecma             : 5,
         ie8              : false,
         indent_level     : 4,
         indent_start     : 0,
@@ -67,14 +69,19 @@ function OutputStream(options) {
         preserve_line    : false,
         quote_keys       : false,
         quote_style      : 0,
+        safari10         : false,
         semicolons       : true,
         shebang          : true,
+        shorthand        : undefined,
         source_map       : null,
         webkit           : false,
         width            : 80,
         wrap_iife        : false,
     }, true);
 
+    if (options.shorthand === undefined)
+        options.shorthand = options.ecma > 5;
+
     // Convert comment option to RegExp if neccessary and set up comments filter
     var comment_filter = return_false; // Default case, throw all comments away
     if (options.comments) {
@@ -110,6 +117,12 @@ function OutputStream(options) {
     var OUTPUT = "";
 
     var to_utf8 = options.ascii_only ? function(str, identifier) {
+        if (options.ecma >= 6) {
+            str = str.replace(/[\ud800-\udbff][\udc00-\udfff]/g, function(ch) {
+                var code = get_full_char_code(ch, 0).toString(16);
+                return "\\u{" + code + "}";
+            });
+        }
         return str.replace(/[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
             var code = ch.charCodeAt(0).toString(16);
             if (code.length <= 2 && !identifier) {
@@ -121,11 +134,16 @@ function OutputStream(options) {
             }
         });
     } : function(str) {
-        return str.replace(/[\ud800-\udbff](?![\udc00-\udfff])/g, function(ch) {
-            return "\\u" + ch.charCodeAt(0).toString(16);
-        }).replace(/(^|[^\ud800-\udbff])([\udc00-\udfff])/g, function(match, prefix, ch) {
-            return prefix + "\\u" + ch.charCodeAt(0).toString(16);
-        });
+        var s = "";
+        for (var i = 0, len = str.length; i < len; i++) {
+            if (is_surrogate_pair_head(str[i]) && !is_surrogate_pair_tail(str[i + 1])
+                || is_surrogate_pair_tail(str[i]) && !is_surrogate_pair_head(str[i - 1])) {
+                s += "\\u" + str.charCodeAt(i).toString(16);
+            } else {
+                s += str[i];
+            }
+        }
+        return s;
     };
 
     function make_string(str, quote) {
@@ -146,7 +164,7 @@ function OutputStream(options) {
               case "\u2029": return "\\u2029";
               case "\ufeff": return "\\ufeff";
               case "\0":
-                  return /[0-9]/.test(str.charAt(i+1)) ? "\\x00" : "\\0";
+                  return /[0-9]/.test(get_full_char(str, i+1)) ? "\\x00" : "\\0";
             }
             return s;
         });
@@ -156,7 +174,11 @@ function OutputStream(options) {
         function quote_double() {
             return '"' + str.replace(/\x22/g, '\\"') + '"';
         }
+        function quote_template() {
+            return '`' + str.replace(/`/g, '\\`') + '`';
+        }
         str = to_utf8(str);
+        if (quote === "`") return quote_template();
         switch (options.quote_style) {
           case 1:
             return quote_single();
@@ -194,6 +216,9 @@ function OutputStream(options) {
     var might_need_space = false;
     var might_need_semicolon = false;
     var might_add_newline = 0;
+    var need_newline_indented = false;
+    var need_space = false;
+    var newline_insert = -1;
     var last = "";
     var mapping_token, mapping_name, mappings = options.source_map && [];
 
@@ -247,11 +272,26 @@ function OutputStream(options) {
         }
     } : noop;
 
-    var requireSemicolonChars = makePredicate("( [ + * / - , .");
+    var requireSemicolonChars = makePredicate("( [ + * / - , . `");
 
     function print(str) {
         str = String(str);
-        var ch = str.charAt(0);
+        var ch = get_full_char(str, 0);
+        var prev = get_full_char(last, last.length - 1);
+        if (need_newline_indented && ch) {
+            need_newline_indented = false;
+            if (ch != "\n") {
+                print("\n");
+                indent();
+            }
+        }
+        if (need_space && ch) {
+            need_space = false;
+            if (!/[\s;})]/.test(ch)) {
+                space();
+            }
+        }
+        newline_insert = -1;
         var prev = last.charAt(last.length - 1);
         if (might_need_semicolon) {
             might_need_semicolon = false;
@@ -328,6 +368,10 @@ function OutputStream(options) {
         last = str;
     };
 
+    var star = function(){
+        print("*");
+    }
+
     var space = options.beautify ? function() {
         print(" ");
     } : function() {
@@ -350,7 +394,13 @@ function OutputStream(options) {
     } : function(col, cont) { return cont() };
 
     var newline = options.beautify ? function() {
-        print("\n");
+        if (newline_insert < 0) return print("\n");
+        if (OUTPUT[newline_insert] != "\n") {
+            OUTPUT = OUTPUT.slice(0, newline_insert) + "\n" + OUTPUT.slice(newline_insert);
+            current_pos++;
+            current_line++;
+        }
+        newline_insert++;
     } : options.max_line_len ? function() {
         ensure_line_len();
         might_add_newline = OUTPUT.length;
@@ -422,6 +472,118 @@ function OutputStream(options) {
         return OUTPUT;
     };
 
+    function prepend_comments(node) {
+        var self = this;
+        var start = node.start;
+        if (!start) return;
+        if (!(start.comments_before && start.comments_before._dumped === self)) {
+            var comments = start.comments_before;
+            if (!comments) {
+                comments = start.comments_before = [];
+            }
+            comments._dumped = self;
+
+            if (node instanceof AST_Exit && node.value) {
+                var tw = new TreeWalker(function(node) {
+                    var parent = tw.parent();
+                    if (parent instanceof AST_Exit
+                        || parent instanceof AST_Binary && parent.left === node
+                        || parent.TYPE == "Call" && parent.expression === node
+                        || parent instanceof AST_Conditional && parent.condition === node
+                        || parent instanceof AST_Dot && parent.expression === node
+                        || parent instanceof AST_Sequence && parent.expressions[0] === node
+                        || parent instanceof AST_Sub && parent.expression === node
+                        || parent instanceof AST_UnaryPostfix) {
+                        if (!node.start) return;
+                        var text = node.start.comments_before;
+                        if (text && text._dumped !== self) {
+                            text._dumped = self;
+                            comments = comments.concat(text);
+                        }
+                    } else {
+                        return true;
+                    }
+                });
+                tw.push(node);
+                node.value.walk(tw);
+            }
+
+            if (current_pos == 0) {
+                if (comments.length > 0 && options.shebang && comments[0].type == "comment5") {
+                    print("#!" + comments.shift().value + "\n");
+                    indent();
+                }
+                var preamble = options.preamble;
+                if (preamble) {
+                    print(preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
+                }
+            }
+
+            comments = comments.filter(comment_filter, node);
+            if (comments.length == 0) return;
+            var last_nlb = /(^|\n) *$/.test(OUTPUT);
+            comments.forEach(function(c, i) {
+                if (!last_nlb) {
+                    if (c.nlb) {
+                        print("\n");
+                        indent();
+                        last_nlb = true;
+                    } else if (i > 0) {
+                        space();
+                    }
+                }
+                if (/comment[134]/.test(c.type)) {
+                    print("//" + c.value.replace(/[@#]__PURE__/g, ' ') + "\n");
+                    indent();
+                    last_nlb = true;
+                } else if (c.type == "comment2") {
+                    print("/*" + c.value.replace(/[@#]__PURE__/g, ' ') + "*/");
+                    last_nlb = false;
+                }
+            });
+            if (!last_nlb) {
+                if (start.nlb) {
+                    print("\n");
+                    indent();
+                } else {
+                    space();
+                }
+            }
+        }
+    }
+
+    function append_comments(node, tail) {
+        var self = this;
+        var token = node.end;
+        if (!token) return;
+        var comments = token[tail ? "comments_before" : "comments_after"];
+        if (comments && comments._dumped !== self) {
+            comments._dumped = self;
+            var insert = OUTPUT.length;
+            comments.filter(comment_filter, node).forEach(function(c, i) {
+                need_space = false;
+                if (need_newline_indented) {
+                    print("\n");
+                    indent();
+                    need_newline_indented = false;
+                } else if (c.nlb && (i > 0 || !/(^|\n) *$/.test(OUTPUT))) {
+                    print("\n");
+                    indent();
+                } else if (i > 0 || !tail) {
+                    space();
+                }
+                if (/comment[134]/.test(c.type)) {
+                    print("//" + c.value.replace(/[@#]__PURE__/g, ' '));
+                    need_newline_indented = true;
+                } else if (c.type == "comment2") {
+                    print("/*" + c.value.replace(/[@#]__PURE__/g, ' ') + "*/");
+                    need_space = true;
+                }
+            });
+            if (OUTPUT.length > insert) newline_insert = insert;
+        }
+    }
+
     var stack = [];
     return {
         get             : get,
@@ -432,6 +594,7 @@ function OutputStream(options) {
         should_break    : function() { return options.width && this.current_width() >= options.width },
         newline         : newline,
         print           : print,
+        star            : star,
         space           : space,
         comma           : comma,
         colon           : colon,
@@ -451,6 +614,10 @@ function OutputStream(options) {
             }
             print(encoded);
         },
+        print_template_string_chars: function(str) {
+            var encoded = encode_string(str, '`').replace(/\${/g, "\\${");
+            return print(encoded.substr(1, encoded.length - 2));
+        },
         encode_string   : encode_string,
         next_indent     : next_indent,
         with_indent     : with_indent,
@@ -459,7 +626,8 @@ function OutputStream(options) {
         with_square     : with_square,
         add_mapping     : add_mapping,
         option          : function(opt) { return options[opt] },
-        comment_filter  : comment_filter,
+        prepend_comments: readonly ? noop : prepend_comments,
+        append_comments : readonly ? noop : append_comments,
         line            : function() { return current_line },
         col             : function() { return current_col },
         pos             : function() { return current_pos },
@@ -495,9 +663,10 @@ function OutputStream(options) {
             use_asm = active_scope;
         }
         function doit() {
-            self.add_comments(stream);
+            stream.prepend_comments(self);
             self.add_source_map(stream);
             generator(self, stream);
+            stream.append_comments(self);
         }
         stream.push_node(self);
         if (force_parens || self.needs_parens(stream)) {
@@ -514,77 +683,10 @@ function OutputStream(options) {
 
     AST_Node.DEFMETHOD("print_to_string", function(options){
         var s = OutputStream(options);
-        if (!options) s._readonly = true;
         this.print(s);
         return s.get();
     });
 
-    /* -----[ comments ]----- */
-
-    AST_Node.DEFMETHOD("add_comments", function(output){
-        if (output._readonly) return;
-        var self = this;
-        var start = self.start;
-        if (start && !start._comments_dumped) {
-            start._comments_dumped = true;
-            var comments = start.comments_before || [];
-
-            // XXX: ugly fix for https://github.com/mishoo/UglifyJS2/issues/112
-            //               and https://github.com/mishoo/UglifyJS2/issues/372
-            if (self instanceof AST_Exit && self.value) {
-                self.value.walk(new TreeWalker(function(node){
-                    if (node.start && node.start.comments_before) {
-                        comments = comments.concat(node.start.comments_before);
-                        node.start.comments_before = [];
-                    }
-                    if (node instanceof AST_Function ||
-                        node instanceof AST_Array ||
-                        node instanceof AST_Object)
-                    {
-                        return true; // don't go inside.
-                    }
-                }));
-            }
-
-            if (output.pos() == 0) {
-                if (comments.length > 0 && output.option("shebang") && comments[0].type == "comment5") {
-                    output.print("#!" + comments.shift().value + "\n");
-                    output.indent();
-                }
-                var preamble = output.option("preamble");
-                if (preamble) {
-                    output.print(preamble.replace(/\r\n?|[\n\u2028\u2029]|\s*$/g, "\n"));
-                }
-            }
-
-            comments = comments.filter(output.comment_filter, self);
-
-            // Keep single line comments after nlb, after nlb
-            if (!output.option("beautify") && comments.length > 0 &&
-                /comment[134]/.test(comments[0].type) &&
-                output.col() !== 0 && comments[0].nlb)
-            {
-                output.print("\n");
-            }
-
-            comments.forEach(function(c){
-                if (/comment[134]/.test(c.type)) {
-                    output.print("//" + c.value + "\n");
-                    output.indent();
-                }
-                else if (c.type == "comment2") {
-                    output.print("/*" + c.value + "*/");
-                    if (start.nlb) {
-                        output.print("\n");
-                        output.indent();
-                    } else {
-                        output.space();
-                    }
-                }
-            });
-        }
-    });
-
     /* -----[ PARENTHESES ]----- */
 
     function PARENS(nodetype, func) {
@@ -623,29 +725,48 @@ function OutputStream(options) {
         return false;
     });
 
+    PARENS(AST_Arrow, function(output){
+        var p = output.parent();
+        return p instanceof AST_PropAccess && p.expression === this;
+    });
+
     // same goes for an object literal, because otherwise it would be
     // interpreted as a block of code.
-    PARENS(AST_Object, function(output){
-        return first_in_statement(output);
-    });
+    PARENS([ AST_ClassExpression, AST_Object ], first_in_statement);
 
     PARENS(AST_Unary, function(output){
         var p = output.parent();
         return p instanceof AST_PropAccess && p.expression === this
-            || p instanceof AST_Call && p.expression === this;
+            || p instanceof AST_Call && p.expression === this
+            || p instanceof AST_Binary
+                && p.operator === "**"
+                && this instanceof AST_UnaryPrefix
+                && p.left === this
+                && this.operator !== "++"
+                && this.operator !== "--";
+    });
+
+    PARENS(AST_Await, function(output){
+        var p = output.parent();
+        return p instanceof AST_PropAccess && p.expression === this
+            || p instanceof AST_Call && p.expression === this
+            || output.option("safari10") && p instanceof AST_UnaryPrefix;
     });
 
     PARENS(AST_Sequence, function(output){
         var p = output.parent();
-        return p instanceof AST_Call             // (foo, bar)() or foo(1, (2, 3), 4)
-            || p instanceof AST_Unary            // !(foo, bar, baz)
-            || p instanceof AST_Binary           // 1 + (2, 3) + 4 ==> 8
-            || p instanceof AST_VarDef           // var a = (1, 2), b = a + a; ==> b == 4
-            || p instanceof AST_PropAccess       // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
-            || p instanceof AST_Array            // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
-            || p instanceof AST_ObjectProperty   // { foo: (1, 2) }.foo ==> 2
-            || p instanceof AST_Conditional      /* (false, true) ? (a = 10, b = 20) : (c = 30)
-                                                  * ==> 20 (side effect, set a := 10 and b := 20) */
+        return p instanceof AST_Call                          // (foo, bar)() or foo(1, (2, 3), 4)
+            || p instanceof AST_Unary                         // !(foo, bar, baz)
+            || p instanceof AST_Binary                        // 1 + (2, 3) + 4 ==> 8
+            || p instanceof AST_VarDef                        // var a = (1, 2), b = a + a; ==> b == 4
+            || p instanceof AST_PropAccess                    // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
+            || p instanceof AST_Array                         // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
+            || p instanceof AST_ObjectProperty                // { foo: (1, 2) }.foo ==> 2
+            || p instanceof AST_Conditional                   /* (false, true) ? (a = 10, b = 20) : (c = 30)
+                                                               * ==> 20 (side effect, set a := 10 and b := 20) */
+            || p instanceof AST_Arrow                         // x => (x, x)
+            || p instanceof AST_DefaultAssign                 // x => (x = (0, function(){}))
+            || p instanceof AST_Expansion                     // [...(a, b)]
         ;
     });
 
@@ -672,6 +793,24 @@ function OutputStream(options) {
         }
     });
 
+    PARENS(AST_Yield, function(output){
+        var p = output.parent();
+        // (yield 1) + (yield 2)
+        // a = yield 3
+        if (p instanceof AST_Binary && p.operator !== "=")
+            return true;
+        // (yield 1) ? yield 2 : yield 3
+        if (p instanceof AST_Conditional && p.condition === this)
+            return true;
+        // -(yield 4)
+        if (p instanceof AST_Unary)
+            return true;
+        // (yield x).foo
+        // (yield x)['foo']
+        if (p instanceof AST_PropAccess && p.expression === this)
+            return true;
+    });
+
     PARENS(AST_PropAccess, function(output){
         var p = output.parent();
         if (p instanceof AST_New && p.expression === this) {
@@ -742,6 +881,9 @@ function OutputStream(options) {
         // (a = foo)["prop"] —or— (a = foo).prop
         if (p instanceof AST_PropAccess && p.expression === this)
             return true;
+        // ({a, b} = {a: 1, b: 2}), a destructuring assignment
+        if (this instanceof AST_Assign && this.left instanceof AST_Destructuring && this.left.is_array === false)
+            return true;
     });
 
     /* -----[ PRINTERS ]----- */
@@ -750,6 +892,26 @@ function OutputStream(options) {
         output.print_string(self.value, self.quote);
         output.semicolon();
     });
+
+    DEFPRINT(AST_Expansion, function (self, output) {
+        output.print('...');
+        self.expression.print(output);
+    });
+
+    DEFPRINT(AST_Destructuring, function (self, output) {
+        output.print(self.is_array ? "[" : "{");
+        var len = self.names.length;
+        self.names.forEach(function (name, i) {
+            if (i > 0) output.comma();
+            name.print(output);
+            // If the final element is a hole, we need to make sure it
+            // doesn't look like a trailing comma, by inserting an actual
+            // trailing comma.
+            if (i == len - 1 && name instanceof AST_Hole) output.comma();
+        });
+        output.print(self.is_array ? "]" : "}");
+    });
+
     DEFPRINT(AST_Debugger, function(self, output){
         output.print("debugger");
         output.semicolon();
@@ -806,14 +968,21 @@ function OutputStream(options) {
         self.body.print(output);
         output.semicolon();
     });
-    function print_bracketed(body, output, allow_directives) {
-        if (body.length > 0) output.with_block(function(){
-            display_body(body, false, output, allow_directives);
-        });
-        else output.print("{}");
+    function print_bracketed(self, output, allow_directives) {
+        if (self.body.length > 0) {
+            output.with_block(function() {
+                display_body(self.body, false, output, allow_directives);
+            });
+        } else {
+            output.print("{");
+            output.with_indent(output.next_indent(), function() {
+                output.append_comments(self, true);
+            });
+            output.print("}");
+        }
     };
     DEFPRINT(AST_BlockStatement, function(self, output){
-        print_bracketed(self.body, output);
+        print_bracketed(self, output);
     });
     DEFPRINT(AST_EmptyStatement, function(self, output){
         output.semicolon();
@@ -874,7 +1043,11 @@ function OutputStream(options) {
         output.with_parens(function(){
             self.init.print(output);
             output.space();
-            output.print("in");
+            if (self instanceof AST_ForOf) {
+                output.print("of");
+            } else {
+                output.print("in");
+            }
             output.space();
             self.object.print(output);
         });
@@ -895,11 +1068,24 @@ function OutputStream(options) {
     AST_Lambda.DEFMETHOD("_do_print", function(output, nokeyword){
         var self = this;
         if (!nokeyword) {
+            if (self.async) {
+                output.print("async");
+                output.space();
+            }
             output.print("function");
+            if (self.is_generator) {
+                output.star();
+            }
+            if (self.name) {
+                output.space();
+            }
         }
-        if (self.name) {
-            output.space();
+        if (self.name instanceof AST_Symbol) {
             self.name.print(output);
+        } else if (nokeyword && self.name instanceof AST_Node) {
+            output.with_square(function() {
+                self.name.print(output); // Computed method name
+            });
         }
         output.with_parens(function(){
             self.argnames.forEach(function(arg, i){
@@ -908,12 +1094,66 @@ function OutputStream(options) {
             });
         });
         output.space();
-        print_bracketed(self.body, output, true);
+        print_bracketed(self, output, true);
     });
     DEFPRINT(AST_Lambda, function(self, output){
         self._do_print(output);
     });
 
+    DEFPRINT(AST_PrefixedTemplateString, function(self, output) {
+        self.prefix.print(output);
+        self.template_string.print(output);
+    });
+    DEFPRINT(AST_TemplateString, function(self, output) {
+        var is_tagged = output.parent() instanceof AST_PrefixedTemplateString;
+
+        output.print("`");
+        for (var i = 0; i < self.segments.length; i++) {
+            if (!(self.segments[i] instanceof AST_TemplateSegment)) {
+                output.print("${");
+                self.segments[i].print(output);
+                output.print("}");
+            } else if (is_tagged) {
+                output.print(self.segments[i].raw);
+            } else {
+                output.print_template_string_chars(self.segments[i].value);
+            }
+        }
+        output.print("`");
+    });
+
+    AST_Arrow.DEFMETHOD("_do_print", function(output){
+        var self = this;
+        var parent = output.parent();
+        var needs_parens = parent instanceof AST_Binary ||
+            parent instanceof AST_Unary ||
+            (parent instanceof AST_Call && self === parent.expression);
+        if (needs_parens) { output.print("(") }
+        if (self.async) {
+            output.print("async");
+            output.space();
+        }
+        if (self.argnames.length === 1 && self.argnames[0] instanceof AST_Symbol) {
+            self.argnames[0].print(output);
+        } else {
+            output.with_parens(function(){
+                self.argnames.forEach(function(arg, i){
+                    if (i) output.comma();
+                    arg.print(output);
+                });
+            });
+        }
+        output.space();
+        output.print('=>');
+        output.space();
+        if (self.body instanceof AST_Node) {
+            self.body.print(output);
+        } else {
+            print_bracketed(self, output);
+        }
+        if (needs_parens) { output.print(")") }
+    });
+
     /* -----[ exits ]----- */
     AST_Exit.DEFMETHOD("_do_print", function(output, kind){
         output.print(kind);
@@ -930,6 +1170,33 @@ function OutputStream(options) {
         self._do_print(output, "throw");
     });
 
+    /* -----[ yield ]----- */
+
+    DEFPRINT(AST_Yield, function(self, output){
+        var star = self.is_star ? "*" : "";
+        output.print("yield" + star);
+        if (self.expression) {
+            output.space();
+            self.expression.print(output);
+        }
+    });
+
+    DEFPRINT(AST_Await, function(self, output){
+        output.print("await");
+        output.space();
+        var e = self.expression;
+        var parens = !(
+               e instanceof AST_Call
+            || e instanceof AST_SymbolRef
+            || e instanceof AST_PropAccess
+            || e instanceof AST_Unary
+            || e instanceof AST_Constant
+        );
+        if (parens) output.print("(");
+        self.expression.print(output);
+        if (parens) output.print(")");
+    });
+
     /* -----[ loop control ]----- */
     AST_LoopControl.DEFMETHOD("_do_print", function(output, kind){
         output.print(kind);
@@ -1039,7 +1306,7 @@ function OutputStream(options) {
     DEFPRINT(AST_Try, function(self, output){
         output.print("try");
         output.space();
-        print_bracketed(self.body, output);
+        print_bracketed(self, output);
         if (self.bcatch) {
             output.space();
             self.bcatch.print(output);
@@ -1056,12 +1323,12 @@ function OutputStream(options) {
             self.argname.print(output);
         });
         output.space();
-        print_bracketed(self.body, output);
+        print_bracketed(self, output);
     });
     DEFPRINT(AST_Finally, function(self, output){
         output.print("finally");
         output.space();
-        print_bracketed(self.body, output);
+        print_bracketed(self, output);
     });
 
     /* -----[ var/const ]----- */
@@ -1078,9 +1345,112 @@ function OutputStream(options) {
         if (!avoid_semicolon)
             output.semicolon();
     });
+    DEFPRINT(AST_Let, function(self, output){
+        self._do_print(output, "let");
+    });
     DEFPRINT(AST_Var, function(self, output){
         self._do_print(output, "var");
     });
+    DEFPRINT(AST_Const, function(self, output){
+        self._do_print(output, "const");
+    });
+    DEFPRINT(AST_Import, function(self, output) {
+        output.print("import");
+        output.space();
+        if (self.imported_name) {
+            self.imported_name.print(output);
+        }
+        if (self.imported_name && self.imported_names) {
+            output.print(",");
+            output.space();
+        }
+        if (self.imported_names) {
+            if (self.imported_names.length === 1 && self.imported_names[0].foreign_name.name === "*") {
+                self.imported_names[0].print(output);
+            } else {
+                output.print("{");
+                self.imported_names.forEach(function (name_import, i) {
+                    output.space();
+                    name_import.print(output);
+                    if (i < self.imported_names.length - 1) {
+                        output.print(",");
+                    }
+                });
+                output.space();
+                output.print("}");
+            }
+        }
+        if (self.imported_name || self.imported_names) {
+            output.space();
+            output.print("from")
+            output.space();
+        }
+        self.module_name.print(output);
+        output.semicolon();
+    });
+
+    DEFPRINT(AST_NameMapping, function(self, output) {
+        var is_import = output.parent() instanceof AST_Import;
+        var definition = self.name.definition();
+        var names_are_different =
+            (definition && definition.mangled_name || self.name.name) !==
+            self.foreign_name.name;
+        if (names_are_different) {
+            if (is_import) {
+                output.print(self.foreign_name.name);
+            } else {
+                self.name.print(output);
+            }
+            output.space();
+            output.print("as");
+            output.space();
+            if (is_import) {
+                self.name.print(output);
+            } else {
+                output.print(self.foreign_name.name);
+            }
+        } else {
+            self.name.print(output);
+        }
+    });
+
+    DEFPRINT(AST_Export, function(self, output) {
+        output.print("export");
+        output.space();
+        if (self.is_default) {
+            output.print("default");
+            output.space();
+        }
+        if (self.exported_names) {
+            if (self.exported_names.length === 1 && self.exported_names[0].name.name === "*") {
+                self.exported_names[0].print(output);
+            } else {
+                output.print("{");
+                self.exported_names.forEach(function(name_export, i) {
+                    output.space();
+                    name_export.print(output);
+                    if (i < self.exported_names.length - 1) {
+                        output.print(",");
+                    }
+                });
+                output.space();
+                output.print("}");
+            }
+        }
+        else if (self.exported_value) {
+            self.exported_value.print(output);
+        } else if (self.exported_definition) {
+            self.exported_definition.print(output);
+            if (self.exported_definition instanceof AST_Definitions) return;
+        }
+        if (self.module_name) {
+            output.space();
+            output.print("from");
+            output.space();
+            self.module_name.print(output);
+        }
+        output.semicolon();
+    });
 
     function parenthesize_for_noin(node, output, noin) {
         var parens = false;
@@ -1262,6 +1632,48 @@ function OutputStream(options) {
         });
         else output.print("{}");
     });
+    DEFPRINT(AST_Class, function(self, output){
+        output.print("class");
+        output.space();
+        if (self.name) {
+            self.name.print(output);
+            output.space();
+        }
+        if (self.extends) {
+            var parens = (
+                   !(self.extends instanceof AST_SymbolRef)
+                && !(self.extends instanceof AST_PropAccess)
+                && !(self.extends instanceof AST_ClassExpression)
+                && !(self.extends instanceof AST_Function)
+            );
+            output.print("extends");
+            if (parens) {
+                output.print("(");
+            } else {
+                output.space();
+            }
+            self.extends.print(output);
+            if (parens) {
+                output.print(")");
+            } else {
+                output.space();
+            }
+        }
+        if (self.properties.length > 0) output.with_block(function(){
+            self.properties.forEach(function(prop, i){
+                if (i) {
+                    output.newline();
+                }
+                output.indent();
+                prop.print(output);
+            });
+            output.newline();
+        });
+        else output.print("{}");
+    });
+    DEFPRINT(AST_NewTarget, function(self, output) {
+        output.print("new.target");
+    });
 
     function print_property_name(key, quote, output) {
         if (output.option("quote_keys")) {
@@ -1283,15 +1695,61 @@ function OutputStream(options) {
     }
 
     DEFPRINT(AST_ObjectKeyVal, function(self, output){
-        print_property_name(self.key, self.quote, output);
-        output.colon();
-        self.value.print(output);
+        function get_name(self) {
+            var def = self.definition();
+            return def ? def.mangled_name || def.name : self.name;
+        }
+
+        var allowShortHand = output.option("shorthand");
+        if (allowShortHand &&
+            self.value instanceof AST_Symbol &&
+            is_identifier_string(self.key) &&
+            get_name(self.value) === self.key &&
+            is_identifier(self.key)
+        ) {
+            print_property_name(self.key, self.quote, output);
+
+        } else if (allowShortHand &&
+            self.value instanceof AST_DefaultAssign &&
+            self.value.left instanceof AST_Symbol &&
+            is_identifier_string(self.key) &&
+            get_name(self.value.left) === self.key
+        ) {
+            print_property_name(self.key, self.quote, output);
+            output.space();
+            output.print("=");
+            output.space();
+            self.value.right.print(output);
+        } else {
+            if (!(self.key instanceof AST_Node)) {
+                print_property_name(self.key, self.quote, output);
+            } else {
+                output.with_square(function() {
+                    self.key.print(output);
+                });
+            }
+            output.colon();
+            self.value.print(output);
+        }
     });
     AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, output) {
-        output.print(type);
-        output.space();
-        print_property_name(this.key.name, this.quote, output);
-        this.value._do_print(output, true);
+        var self = this;
+        if (self.static) {
+            output.print("static");
+            output.space();
+        }
+        if (type) {
+            output.print(type);
+            output.space();
+        }
+        if (self.key instanceof AST_SymbolMethod) {
+            print_property_name(self.key.name, self.quote, output);
+        } else {
+            output.with_square(function() {
+                self.key.print(output);
+            });
+        }
+        self.value._do_print(output, true);
     });
     DEFPRINT(AST_ObjectSetter, function(self, output){
         self._print_getter_setter("set", output);
@@ -1299,14 +1757,23 @@ function OutputStream(options) {
     DEFPRINT(AST_ObjectGetter, function(self, output){
         self._print_getter_setter("get", output);
     });
-    DEFPRINT(AST_Symbol, function(self, output){
-        var def = self.definition();
-        output.print_name(def ? def.mangled_name || def.name : self.name);
+    DEFPRINT(AST_ConciseMethod, function(self, output){
+        self._print_getter_setter(self.is_generator && "*" || self.async && "async", output);
+    });
+    AST_Symbol.DEFMETHOD("_do_print", function(output){
+        var def = this.definition();
+        output.print_name(def ? def.mangled_name || def.name : this.name);
+    });
+    DEFPRINT(AST_Symbol, function (self, output) {
+        self._do_print(output);
     });
     DEFPRINT(AST_Hole, noop);
     DEFPRINT(AST_This, function(self, output){
         output.print("this");
     });
+    DEFPRINT(AST_Super, function(self, output){
+        output.print("super");
+    });
     DEFPRINT(AST_Constant, function(self, output){
         output.print(self.getValue());
     });

lib/propmangle.js

@@ -44,6 +44,16 @@
 "use strict";
 
 function find_builtins(reserved) {
+
+    // Compatibility fix for some standard defined globals not defined on every js environment
+    var new_globals = ["Symbol", "Map", "Promise", "Proxy", "Reflect", "Set", "WeakMap", "WeakSet"];
+    var objects = {};
+    var global_ref = typeof global === "object" ? global : self;
+
+    new_globals.forEach(function (new_global) {
+        objects[new_global] = global_ref[new_global] || new Function();
+    });
+
     // NaN will be included due to Number.NaN
     [
         "null",
@@ -55,7 +65,15 @@ function find_builtins(reserved) {
     ].forEach(add);
     [ Object, Array, Function, Number,
       String, Boolean, Error, Math,
-      Date, RegExp
+      Date, RegExp, objects.Symbol, ArrayBuffer,
+      DataView, decodeURI, decodeURIComponent,
+      encodeURI, encodeURIComponent, eval, EvalError,
+      Float32Array, Float64Array, Int8Array, Int16Array,
+      Int32Array, isFinite, isNaN, JSON, objects.Map, parseFloat,
+      parseInt, objects.Promise, objects.Proxy, RangeError, ReferenceError,
+      objects.Reflect, objects.Set, SyntaxError, TypeError, Uint8Array,
+      Uint8ClampedArray, Uint16Array, Uint32Array, URIError,
+      objects.WeakMap, objects.WeakSet
     ].forEach(function(ctor){
         Object.getOwnPropertyNames(ctor).map(add);
         if (ctor.prototype) {
@@ -75,6 +93,8 @@ function reserve_quoted_keys(ast, reserved) {
     ast.walk(new TreeWalker(function(node) {
         if (node instanceof AST_ObjectKeyVal && node.quote) {
             add(node.key);
+        } else if (node instanceof AST_ObjectProperty && node.quote) {
+            add(node.key.name);
         } else if (node instanceof AST_Sub) {
             addStrings(node.property, add);
         }

lib/scope.js

@@ -51,6 +51,7 @@ function SymbolDef(scope, orig) {
     this.references = [];
     this.replaced = 0;
     this.global = false;
+    this.export = false;
     this.mangled_name = null;
     this.undeclared = false;
     this.id = SymbolDef.next_id++;
@@ -63,11 +64,16 @@ SymbolDef.prototype = {
         if (!options) options = {};
 
         return (this.global && !options.toplevel)
+            || this.export
             || this.undeclared
             || (!options.eval && (this.scope.uses_eval || this.scope.uses_with))
             || (options.keep_fnames
                 && (this.orig[0] instanceof AST_SymbolLambda
-                    || this.orig[0] instanceof AST_SymbolDefun));
+                    || this.orig[0] instanceof AST_SymbolDefun))
+            || this.orig[0] instanceof AST_SymbolMethod
+            || (options.keep_classnames
+                && (this.orig[0] instanceof AST_SymbolClass
+                    || this.orig[0] instanceof AST_SymbolDefClass));
     },
     mangle: function(options) {
         var cache = options.cache && options.cache.props;
@@ -98,6 +104,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     options = defaults(options, {
         cache: null,
         ie8: false,
+        safari10: false,
     });
 
     // pass 1: setup scope chaining and handle definitions
@@ -105,15 +112,33 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     var scope = self.parent_scope = null;
     var labels = new Dictionary();
     var defun = null;
+    var in_destructuring = null;
+    var for_scopes = [];
     var tw = new TreeWalker(function(node, descend){
-        if (node instanceof AST_Catch) {
+        if (node.is_block_scope()) {
             var save_scope = scope;
-            scope = new AST_Scope(node);
+            node.block_scope = scope = new AST_Scope(node);
             scope.init_scope_vars(save_scope);
+            if (!(node instanceof AST_Scope)) {
+                scope.uses_with = save_scope.uses_with;
+                scope.uses_eval = save_scope.uses_eval;
+                scope.directives = save_scope.directives;
+            }
+            if (options.safari10) {
+                if (node instanceof AST_For || node instanceof AST_ForIn) {
+                    for_scopes.push(scope);
+                }
+            }
             descend();
             scope = save_scope;
             return true;
         }
+        if (node instanceof AST_Destructuring) {
+            in_destructuring = node;  // These don't nest
+            descend();
+            in_destructuring = null;
+            return true;
+        }
         if (node instanceof AST_Scope) {
             node.init_scope_vars(scope);
             var save_scope = scope;
@@ -158,10 +183,40 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             // scope when we encounter the AST_Defun node (which is
             // instanceof AST_Scope) but we get to the symbol a bit
             // later.
-            (node.scope = defun.parent_scope).def_function(node);
+            mark_export((node.scope = defun.parent_scope.get_defun_scope()).def_function(node), 1);
         }
-        else if (node instanceof AST_SymbolVar) {
-            defun.def_variable(node);
+        else if (node instanceof AST_SymbolClass) {
+            mark_export(defun.def_variable(node), 1);
+        }
+        else if (node instanceof AST_SymbolImport) {
+            scope.def_variable(node);
+        }
+        else if (node instanceof AST_SymbolDefClass) {
+            // This deals with the name of the class being available
+            // inside the class.
+            mark_export((node.scope = defun.parent_scope).def_function(node), 1);
+        }
+        else if (node instanceof AST_SymbolVar
+            || node instanceof AST_SymbolLet
+            || node instanceof AST_SymbolConst) {
+            var def = ((node instanceof AST_SymbolBlockDeclaration) ? scope : defun).def_variable(node);
+            if (!all(def.orig, function(sym) {
+                if (sym === node) return true;
+                if (node instanceof AST_SymbolBlockDeclaration) {
+                    return sym instanceof AST_SymbolLambda;
+                }
+                return !(sym instanceof AST_SymbolLet || sym instanceof AST_SymbolConst);
+            })) {
+                js_error(
+                    node.name + " redeclared",
+                    node.start.file,
+                    node.start.line,
+                    node.start.col,
+                    node.start.pos
+                );
+            }
+            if (!(node instanceof AST_SymbolFunarg)) mark_export(def, 2);
+            def.destructuring = in_destructuring;
             if (defun !== scope) {
                 node.mark_enclosed(options);
                 var def = scope.find_variable(node);
@@ -183,6 +238,26 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             }));
             node.thedef = sym;
         }
+        if (!(scope instanceof AST_Toplevel) && (node instanceof AST_Export || node instanceof AST_Import)) {
+            js_error(
+                node.TYPE + " statement may only appear at top level",
+                node.start.file,
+                node.start.line,
+                node.start.col,
+                node.start.pos
+            );
+        }
+
+        function mark_export(def, level) {
+            if (in_destructuring) {
+                var i = 0;
+                do {
+                    level++;
+                } while (tw.parent(i++) !== in_destructuring);
+            }
+            var node = tw.parent(level);
+            def.export = node instanceof AST_Export;
+        }
     });
     self.walk(tw);
 
@@ -200,8 +275,9 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
                     s.uses_eval = true;
                 }
             }
-            var sym = node.scope.find_variable(name);
-            if (!sym) {
+            var sym;
+            if (tw.parent() instanceof AST_NameMapping && tw.parent(1).module_name
+                || !(sym = node.scope.find_variable(name))) {
                 sym = self.def_global(node);
             } else if (sym.scope instanceof AST_Lambda && name == "arguments") {
                 sym.scope.uses_arguments = true;
@@ -242,6 +318,19 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
         }));
     }
 
+    // pass 4: add symbol definitions to loop scopes
+    // Safari/Webkit bug workaround - loop init let variable shadowing argument.
+    // https://github.com/mishoo/UglifyJS2/issues/1753
+    // https://bugs.webkit.org/show_bug.cgi?id=171041
+    if (options.safari10) {
+        for (var i = 0; i < for_scopes.length; i++) {
+            var scope = for_scopes[i];
+            scope.parent_scope.variables.each(function(def) {
+                push_uniq(scope.enclosed, def);
+            });
+        }
+    }
+
     if (options.cache) {
         this.cname = options.cache.cname;
     }
@@ -270,6 +359,14 @@ AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
     this.cname = -1;                    // the current index for mangling functions/variables
 });
 
+AST_Node.DEFMETHOD("is_block_scope", return_false);
+AST_Class.DEFMETHOD("is_block_scope", return_false);
+AST_Lambda.DEFMETHOD("is_block_scope", return_false);
+AST_Toplevel.DEFMETHOD("is_block_scope", return_false);
+AST_SwitchBranch.DEFMETHOD("is_block_scope", return_false);
+AST_Block.DEFMETHOD("is_block_scope", return_true);
+AST_IterationStatement.DEFMETHOD("is_block_scope", return_true);
+
 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
     AST_Scope.prototype.init_scope_vars.apply(this, arguments);
     this.uses_arguments = false;
@@ -307,7 +404,9 @@ AST_Scope.DEFMETHOD("find_variable", function(name){
 });
 
 AST_Scope.DEFMETHOD("def_function", function(symbol){
-    this.functions.set(symbol.name, this.def_variable(symbol));
+    var def = this.def_variable(symbol);
+    this.functions.set(symbol.name, def);
+    return def;
 });
 
 AST_Scope.DEFMETHOD("def_variable", function(symbol){
@@ -387,6 +486,7 @@ AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options) {
     options = defaults(options, {
         eval        : false,
         ie8         : false,
+        keep_classnames: false,
         keep_fnames : false,
         reserved    : [],
         toplevel    : false,
@@ -429,13 +529,18 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
             node.mangled_name = name;
             return true;
         }
-        if (!options.ie8 && node instanceof AST_SymbolCatch) {
+        var mangle_with_block_scope =
+            (!options.ie8 && node instanceof AST_SymbolCatch) ||
+            node instanceof AST_SymbolBlockDeclaration;
+        if (mangle_with_block_scope && options.reserved.indexOf(node.name) < 0) {
             to_mangle.push(node.definition());
             return;
         }
     });
     this.walk(tw);
-    to_mangle.forEach(function(def){ def.mangle(options) });
+    to_mangle.forEach(function(def){
+        def.mangle(options);
+    });
 
     if (options.cache) {
         options.cache.cname = this.cname;

lib/transform.js

@@ -60,12 +60,9 @@ TreeTransformer.prototype = new TreeWalker;
             tw.push(this);
             if (tw.before) x = tw.before(this, descend, in_list);
             if (x === undefined) {
-                if (!tw.after) {
-                    x = this;
-                    descend(x, tw);
-                } else {
-                    tw.stack[tw.stack.length - 1] = x = this;
-                    descend(x, tw);
+                x = this;
+                descend(x, tw);
+                if (tw.after) {
                     y = tw.after(x, in_list);
                     if (y !== undefined) x = y;
                 }
@@ -163,10 +160,18 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.value) self.value = self.value.transform(tw);
     });
 
+    _(AST_Destructuring, function(self, tw) {
+        self.names = do_list(self.names, tw);
+    });
+
     _(AST_Lambda, function(self, tw){
         if (self.name) self.name = self.name.transform(tw);
         self.argnames = do_list(self.argnames, tw);
-        self.body = do_list(self.body, tw);
+        if (self.body instanceof AST_Node) {
+            self.body = self.body.transform(tw);
+        } else {
+            self.body = do_list(self.body, tw);
+        }
     });
 
     _(AST_Call, function(self, tw){
@@ -187,6 +192,14 @@ TreeTransformer.prototype = new TreeWalker;
         self.property = self.property.transform(tw);
     });
 
+    _(AST_Yield, function(self, tw){
+        if (self.expression) self.expression = self.expression.transform(tw);
+    });
+
+    _(AST_Await, function(self, tw){
+        self.expression = self.expression.transform(tw);
+    });
+
     _(AST_Unary, function(self, tw){
         self.expression = self.expression.transform(tw);
     });
@@ -211,7 +224,46 @@ TreeTransformer.prototype = new TreeWalker;
     });
 
     _(AST_ObjectProperty, function(self, tw){
+        if (self.key instanceof AST_Node) {
+            self.key = self.key.transform(tw);
+        }
         self.value = self.value.transform(tw);
     });
 
+    _(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);
+    });
+
+    _(AST_Expansion, function(self, tw){
+        self.expression = self.expression.transform(tw);
+    });
+
+    _(AST_NameMapping, function(self, tw) {
+        self.foreign_name = self.foreign_name.transform(tw);
+        self.name = self.name.transform(tw);
+    });
+
+    _(AST_Import, function(self, tw) {
+        if (self.imported_name) self.imported_name = self.imported_name.transform(tw);
+        if (self.imported_names) do_list(self.imported_names, tw);
+        self.module_name = self.module_name.transform(tw);
+    });
+
+    _(AST_Export, function(self, tw) {
+        if (self.exported_definition) self.exported_definition = self.exported_definition.transform(tw);
+        if (self.exported_value) self.exported_value = self.exported_value.transform(tw);
+        if (self.exported_names) do_list(self.exported_names, tw);
+        if (self.module_name) self.module_name = self.module_name.transform(tw);
+    });
+
+    _(AST_TemplateString, function(self, tw) {
+        self.segments = do_list(self.segments, tw);
+    });
+
+    _(AST_PrefixedTemplateString, function(self, tw) {
+        self.template_string = self.template_string.transform(tw);
+    });
+
 })();

lib/utils.js

@@ -43,10 +43,6 @@
 
 "use strict";
 
-function slice(a, start) {
-    return Array.prototype.slice.call(a, start || 0);
-};
-
 function characters(str) {
     return str.split("");
 };
@@ -214,18 +210,6 @@ function mergeSort(array, cmp) {
     return _ms(array);
 };
 
-function set_difference(a, b) {
-    return a.filter(function(el){
-        return b.indexOf(el) < 0;
-    });
-};
-
-function set_intersection(a, b) {
-    return a.filter(function(el){
-        return b.indexOf(el) >= 0;
-    });
-};
-
 // this function is taken from Acorn [1], written by Marijn Haverbeke
 // [1] https://github.com/marijnh/acorn
 function makePredicate(words) {
@@ -340,7 +324,7 @@ function first_in_statement(stack) {
         if (p instanceof AST_Statement && p.body === node)
             return true;
         if ((p instanceof AST_Sequence      && p.expressions[0] === node) ||
-            (p instanceof AST_Call          && p.expression === node && !(p instanceof AST_New) ) ||
+            (p.TYPE == "Call"               && p.expression === node ) ||
             (p instanceof AST_Dot           && p.expression === node ) ||
             (p instanceof AST_Sub           && p.expression === node ) ||
             (p instanceof AST_Conditional   && p.condition === node  ) ||

package.json

@@ -1,20 +1,17 @@
 {
-  "name": "uglify-js",
-  "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
-  "homepage": "http://lisperator.net/uglifyjs",
+  "name": "uglify-es",
+  "description": "JavaScript parser, mangler/compressor and beautifier toolkit for ES6+",
+  "homepage": "https://github.com/mishoo/UglifyJS2/tree/harmony",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.2.2",
+  "version": "3.3.3",
   "engines": {
     "node": ">=0.8.0"
   },
   "maintainers": [
     "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)"
   ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/mishoo/UglifyJS2.git"
-  },
+  "repository": "git+https://github.com/mishoo/UglifyJS2.git#harmony",
   "bugs": {
     "url": "https://github.com/mishoo/UglifyJS2/issues"
   },
@@ -40,5 +37,22 @@
   "scripts": {
     "test": "node test/run-tests.js"
   },
-  "keywords": ["uglify", "uglify-js", "minify", "minifier", "es5"]
+  "keywords": [
+    "uglify",
+    "uglify-es",
+    "uglify-js",
+    "minify",
+    "minifier",
+    "javascript",
+    "ecmascript",
+    "es5",
+    "es6",
+    "es7",
+    "es8",
+    "es2015",
+    "es2016",
+    "es2017",
+    "async",
+    "await"
+  ]
 }

test/benchmark.js

@@ -21,6 +21,7 @@ var urls = [
     "http://builds.emberjs.com/tags/v2.11.0/ember.prod.js",
     "https://cdn.jsdelivr.net/lodash/4.17.4/lodash.js",
     "https://cdnjs.cloudflare.com/ajax/libs/d3/4.5.0/d3.js",
+    "https://raw.githubusercontent.com/kangax/html-minifier/v3.5.7/dist/htmlminifier.js",
 ];
 var results = {};
 var remaining = 2 * urls.length;

test/compress/arrays.js

@@ -1,3 +1,5 @@
+// NOTE trailing comma doesn't contribute to length of an array
+// That also means the array changes length if previous element is a hole too and got cut off
 holes_and_undefined: {
     input: {
         w = [1,,];
@@ -91,6 +93,79 @@ constant_join_2: {
     }
 }
 
+spread_with_variable_as_last_element: {
+    input: {
+        var values = [4, 5, 6];
+        var a = [1, 2, 3, ...values];
+    }
+    expect: {
+        var values = [4, 5, 6];
+        var a = [1, 2, 3, ...values];
+    }
+}
+
+spread_with_variable_in_middle: {
+    input: {
+        var values = [4, 5, 6];
+        var a = [1, 2, 3, ...values, 7,,,];
+    }
+    expect: {
+        var values = [4, 5, 6];
+        var a = [1, 2, 3, ...values, 7,,,];
+    }
+}
+
+spread_with_variable_at_front: {
+    input: {
+        var values = [1, 2, 3];
+        var a = [...values, 4, 5, 6];
+    }
+    expect: {
+        var values = [1, 2, 3];
+        var a = [...values, 4, 5, 6];
+    }
+}
+
+spread_with_variable_at_front_after_elisions: {
+    input: {
+        var values = [1, 2, 3];
+        var a = [,,,...values, 4, 5, 6];
+    }
+    expect: {
+        var values = [1, 2, 3];
+        var a = [,,,...values, 4, 5, 6];
+    }
+}
+
+spread_with_array_at_end: {
+    input: {
+        var a = [1, 2, ...[4, 5, 6]];
+    }
+    expect: {
+        var a = [1, 2, ...[4, 5, 6]];
+    }
+}
+
+spread_with_logical_expression_at_end: {
+    options = { evaluate: true }
+    input: {
+        var a = [1, 2, 3, ...[2+2]]
+    }
+    expect: {
+        var a = [1, 2, 3, ...[4]]
+    }
+}
+
+spread_with_logical_expression_at_middle: {
+    options = { evaluate: true }
+    input: {
+        var a = [1, 1, ...[1+1, 1+2, 2+3], 8]
+    }
+    expect: {
+        var a = [1, 1, ...[2, 3, 5], 8]
+    }
+}
+
 constant_join_3: {
     options = {
         unsafe: true,

test/compress/arrow.js

@@ -0,0 +1,656 @@
+arrow_functions_without_body: {
+    input: {
+        var a1 = () => 42;
+        var a2 = (p) => p;
+        var a3 = p => p;
+        var a4 = (...p) => p;
+        var a5 = (b, c) => b + c;
+        var a6 = (b, ...c) => b + c[0];
+        var a7 = (...b) => b.join();
+    }
+    expect: {
+        var a1 = () => 42;
+        var a2 = (p) => p;
+        var a3 = p => p;
+        var a4 = (...p) => p;
+        var a5 = (b, c) => b + c;
+        var a6 = (b, ...c) => b + c[0];
+        var a7 = (...b) => b.join();
+    }
+}
+
+arrow_functions_with_body: {
+    input: {
+        var a1 = () => {
+            var a = 42 * Math.random();
+            return a;
+        };
+        var a2 = (p) => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a3 = p => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a4 = (...p) => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a5 = (b, c) => {
+            var result = b * c + b / c;
+            return result
+        };
+        var a6 = (b, ...c) => {
+            var result = b;
+            for (var i = 0; i < c.length; i++)
+                result += c[i];
+            return result
+        };
+        var a7 = (...b) => {
+            b.join();
+        }
+    }
+    expect: {
+        var a1 = () => {
+            var a = 42 * Math.random();
+            return a;
+        };
+        var a2 = (p) => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a3 = p => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a4 = (...p) => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a5 = (b, c) => {
+            var result = b * c + b / c;
+            return result
+        };
+        var a6 = (b, ...c) => {
+            var result = b;
+            for (var i = 0; i < c.length; i++)
+                result += c[i];
+            return result
+        };
+        var a7 = (...b) => {
+            b.join();
+        };
+    }
+}
+
+arrow_function_with_single_parameter_with_default: {
+    input: {
+        var foo = (a = 0) => doSomething(a);
+    }
+    expect_exact: "var foo=(a=0)=>doSomething(a);"
+}
+
+arrow_binding_pattern: {
+    input: {
+        var foo = ([]) => "foo";
+        var bar = ({}) => "bar";
+        var with_default = (foo = "default") => foo;
+        var object_with_default = ({foo = "default", bar: baz = "default"}) => foo;
+        var array_after_spread = (...[foo]) => foo;
+        var array_after_spread = (...{foo}) => foo;
+        var computed = ({ [compute()]: x }) => {};
+        var array_hole = ([, , ...x] = [1, 2]) => {};
+        var object_trailing_elision = ({foo,}) => {};
+        var spread_empty_array = (...[]) => "foo";
+        var spread_empty_object = (...{}) => "foo";
+    }
+    expect: {
+        var foo = ([]) => "foo";
+        var bar = ({}) => "bar";
+        var with_default = (foo = "default") => foo;
+        var object_with_default = ({foo = "default", bar: baz = "default"}) => foo;
+        var array_after_spread = (...[foo]) => foo;
+        var array_after_spread = (...{foo}) => foo;
+        var computed = ({ [compute()]: x }) => {};
+        var array_hole = ([, , ...x] = [1, 2]) => {};
+        var object_trailing_elision = ({foo,}) => {};
+        var spread_empty_array = (...[]) => "foo";
+        var spread_empty_object = (...{}) => "foo";
+    }
+}
+
+arrow_binding_pattern_strict: {
+    input: {
+        var foo = ([,]) => "foo";
+    }
+    expect_exact: 'var foo=([,])=>"foo";'
+}
+
+arrow_with_regexp: {
+    input: {
+        num => /\d{11,14}/.test( num )
+    }
+    expect: {
+        num => /\d{11,14}/.test( num )
+    }
+}
+
+arrow_unused: {
+    options = {
+        toplevel: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        top => dog;
+        let fn = a => { console.log(a * a); };
+        let u = (x, y) => x - y + g;
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let unused = x => { console.log(x); };
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect: {
+        let fn = a => { console.log(a * a); };
+        let u = (x, y) => x - y + g;
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect_stdout: [ "0", "1", "2", "9" ]
+    node_version: ">=6"
+}
+
+arrow_unused_toplevel: {
+    options = {
+        toplevel: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        top => dog;
+        let fn = a => { console.log(a * a); };
+        let u = (x, y) => x - y + g;
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let unused = x => { console.log(x); };
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect: {
+        let fn = a => { console.log(a * a); };
+        (() => { console.log("0"); })();
+        !function(x) {
+            (() => { console.log("1"); })();
+            let baz = e => e + e;
+            console.log(baz(x));
+        }(1);
+        fn(3);
+    }
+    expect_stdout: [ "0", "1", "2", "9" ]
+    node_version: ">=6"
+}
+
+no_leading_parentheses: {
+    input: {
+        (x,y) => x(y);
+        async (x,y) => await x(y);
+    }
+    expect_exact: "(x,y)=>x(y);async(x,y)=>await x(y);"
+}
+
+async_identifiers: {
+    options = {
+        unsafe_arrows: true,
+        ecma: 6,
+    }
+    input: {
+        var async = function(x){ console.log("async", x); };
+        var await = function(x){ console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect: {
+        var async = x => { console.log("async", x); };
+        var await = x => { console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect_stdout: [
+        "async 1",
+        "await 2",
+    ]
+    node_version: ">=4"
+}
+
+async_function_expression: {
+    options = {
+        unsafe_arrows: true,
+        ecma: 6,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        var named = async function foo() {
+            await bar(1 + 0) + (2 + 0);
+        }
+        var anon = async function() {
+            await (1 + 0) + bar(2 + 0);
+        }
+    }
+    expect: {
+        var named = async function foo() {
+            await bar(1);
+        };
+        var anon = async () => {
+            await 1, bar(2);
+        };
+    }
+}
+
+issue_27: {
+    options = {
+        unsafe_arrows: true,
+        collapse_vars: true,
+        ecma: 6,
+        unused: true,
+    }
+    input: {
+        (function(jQuery) {
+            var $;
+            $ = jQuery;
+            $("body").addClass("foo");
+        })(jQuery);
+    }
+    expect: {
+        (jQuery => {
+            jQuery("body").addClass("foo");
+        })(jQuery);
+    }
+}
+
+issue_2105_1: {
+    options = {
+        unsafe_arrows: true,
+        collapse_vars: true,
+        ecma: 6,
+        inline: true,
+        passes: 3,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unsafe_methods: true,
+        unused: true,
+    }
+    input: {
+        !function(factory) {
+            factory();
+        }( function() {
+            return function(fn) {
+                fn()().prop();
+            }( function() {
+                function bar() {
+                    var quux = function() {
+                        console.log("PASS");
+                    }, foo = function() {
+                        console.log;
+                        quux();
+                    };
+                    return { prop: foo };
+                }
+                return bar;
+            } );
+        });
+    }
+    expect: {
+        ({
+            prop() {
+                console.log;
+                console.log("PASS");
+            }
+        }).prop();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_2105_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        ((factory) => {
+            factory();
+        })( () => {
+            return ((fn) => {
+                fn()().prop();
+            })( () => {
+                let bar = () => {
+                    var quux = () => {
+                        console.log("PASS");
+                    }, foo = () => {
+                        console.log;
+                        quux();
+                    };
+                    return { prop: foo };
+                };
+                return bar;
+            } );
+        });
+    }
+    expect: {
+        ({
+            prop: () => {
+                console.log;
+                console.log("PASS");
+            }
+        }).prop();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_2136_2: {
+    options = {
+        arrows: true,
+        collapse_vars: true,
+        ecma: 6,
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f(x) {
+            console.log(x);
+        }
+        !function(a, ...b) {
+            f(b[0]);
+        }(1, 2, 3);
+    }
+    expect: {
+        function f(x) {
+            console.log(x);
+        }
+        f([2,3][0]);
+    }
+    expect_stdout: "2"
+    node_version: ">=6"
+}
+
+issue_2136_3: {
+    options = {
+        arrows: true,
+        collapse_vars: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        passes: 3,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        function f(x) {
+            console.log(x);
+        }
+        !function(a, ...b) {
+            f(b[0]);
+        }(1, 2, 3);
+    }
+    expect: {
+        console.log(2);
+    }
+    expect_stdout: "2"
+    node_version: ">=6"
+}
+
+call_args: {
+    options = {
+        arrows: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+    }
+    input: {
+        const a = 1;
+        console.log(a);
+        +function(a) {
+            return a;
+        }(a);
+    }
+    expect: {
+        const a = 1;
+        console.log(1);
+        +(1, 1);
+    }
+    expect_stdout: true
+}
+
+call_args_drop_param: {
+    options = {
+        arrows: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        keep_fargs: false,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        const a = 1;
+        console.log(a);
+        +function(a) {
+            return a;
+        }(a, b);
+    }
+    expect: {
+        const a = 1;
+        console.log(1);
+        +(b, 1);
+    }
+    expect_stdout: true
+}
+
+issue_485_crashing_1530: {
+    options = {
+        arrows: true,
+        conditionals: true,
+        dead_code: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        (function(a) {
+            if (true) return;
+            var b = 42;
+        })(this);
+    }
+    expect: {}
+}
+
+issue_2084: {
+    options = {
+        unsafe_arrows: true,
+        collapse_vars: true,
+        conditionals: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        !function() {
+            !function(c) {
+                c = 1 + c;
+                var c = 0;
+                function f14(a_1) {
+                    if (c = 1 + c, 0 !== 23..toString())
+                        c = 1 + c, a_1 && (a_1[0] = 0);
+                }
+                f14();
+            }(-1);
+        }();
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        ((c) => {
+            c = 1 + c,
+            c = 1 + (c = 0),
+            0 !== 23..toString() && (c = 1 + c);
+        })(-1),
+        console.log(c);
+    }
+    expect_stdout: "0"
+    node_version: ">=4"
+}
+
+export_default_object_expression: {
+    options = {
+        arrows: true,
+        evaluate: true,
+    }
+    input: {
+        export default {
+            foo: 1 + 2,
+            bar() { return 4; },
+            get baz() { return this.foo; },
+        };
+    }
+    expect_exact: "export default{foo:3,bar:()=>4,get baz(){return this.foo}};"
+}
+
+concise_methods_with_computed_property2: {
+    options = {
+        arrows: true,
+        evaluate: true,
+    }
+    input: {
+        var foo = {
+            [[1]](v) {
+                return v;
+            }
+        };
+        console.log(foo[[1]]("PASS"));
+    }
+    expect_exact: 'var foo={[[1]]:v=>v};console.log(foo[[1]]("PASS"));'
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+async_object_literal: {
+    options = {
+        arrows: true,
+        unsafe_arrows: true,
+        ecma: 6,
+        evaluate: true,
+    }
+    input: {
+        var obj = {
+            async a() {
+                return await foo(1 + 0);
+            },
+            anon: async function() {
+                return await foo(2 + 0);
+            }
+        };
+    }
+    expect: {
+        var obj = {
+            a: async () => await foo(1),
+            anon: async () => await foo(2)
+        };
+    }
+}
+
+issue_2271: {
+    options = {
+        arrows: true,
+        ecma: 6,
+        evaluate: true,
+        unsafe_arrows: false,
+    }
+    input: {
+        var Foo = function() {};
+        Foo.prototype.set = function(value) {
+            this.value = value;
+            return this;
+        }
+        Foo.prototype.print = function() {
+            console.log(this.value);
+        }
+        new Foo().set("PASS").print();
+    }
+    expect: {
+        var Foo = function() {};
+        Foo.prototype.set = function(value) {
+            this.value = value;
+            return this;
+        }
+        Foo.prototype.print = function() {
+            console.log(this.value);
+        }
+        new Foo().set("PASS").print();
+    }
+    expect_stdout: "PASS"
+}
+
+concise_method_with_super: {
+    options = {
+        arrows: true,
+    }
+    input: {
+        var o = {
+            f: "FAIL",
+            g() {
+                return super.f;
+            }
+        }
+        Object.setPrototypeOf(o, { f: "PASS" });
+        console.log(o.g());
+    }
+    expect: {
+        var o = {
+            f: "FAIL",
+            g() {
+                return super.f;
+            }
+        }
+        Object.setPrototypeOf(o, { f: "PASS" });
+        console.log(o.g());
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}

test/compress/asm.js

@@ -16,7 +16,6 @@ asm_mixed: {
         hoist_vars    : true,
         if_return     : true,
         join_vars     : true,
-        cascade       : true,
         side_effects  : true,
         negate_iife   : true
     };

test/compress/async.js

@@ -0,0 +1,323 @@
+await_precedence: {
+    input: {
+        async function f1() { await x + y; }
+        async function f2() { await (x + y); }
+    }
+    expect_exact: "async function f1(){await x+y}async function f2(){await(x+y)}"
+}
+
+await_precedence_prop: {
+    input: {
+        async function f1(){ return (await foo()).bar; }
+        async function f2(){ return (await foo().bar); }
+    }
+    expect_exact: "async function f1(){return(await foo()).bar}async function f2(){return await foo().bar}"
+}
+
+await_precedence_call: {
+    input: {
+        async function f3(){ return (await foo())(); }
+        async function f4(){ return await (foo()()); }
+    }
+    expect_exact: "async function f3(){return(await foo())()}async function f4(){return await foo()()}"
+}
+
+async_function_declaration: {
+    options = {
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        async function f0() {}
+        async function f1() { await x + y; }
+        async function f2() { await (x + y); }
+        async function f3() { await x + await y; }
+        async function f4() { await (x + await y); }
+        async function f5() { await x; await y; }
+        async function f6() { await x, await y; }
+    }
+    expect: {
+        async function f0() {}
+        async function f1() { await x, y; }
+        async function f2() { await (x + y); }
+        async function f3() { await x, await y; }
+        async function f4() { await (x + await y); }
+        async function f5() { await x; await y; }
+        async function f6() { await x, await y; }
+    }
+}
+
+async_function_expression: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var named = async function foo() {
+            await bar(1 + 0) + (2 + 0);
+        }
+        var anon = async function() {
+            await (1 + 0) + bar(2 + 0);
+        }
+    }
+    expect: {
+        var named = async function() {
+            await bar(1);
+        };
+        var anon = async function() {
+            await 1, bar(2);
+        };
+    }
+}
+
+async_class: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        class Foo {
+            async m1() {
+                return await foo(1 + 2);
+            }
+            static async m2() {
+                return await foo(3 + 4);
+            }
+        }
+    }
+    expect: {
+        class Foo {
+            async m1() {
+                return await foo(3);
+            }
+            static async m2() {
+                return await foo(7);
+            }
+        }
+    }
+}
+
+async_object_literal: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var obj = {
+            async a() {
+                await foo(1 + 0);
+            },
+            anon: async function(){
+                await foo(2 + 0);
+            }
+        };
+    }
+    expect: {
+        var obj = {
+            async a() {
+                await foo(1);
+            },
+            anon: async function() {
+                await foo(2);
+            }
+        };
+    }
+}
+
+async_export: {
+    input: {
+        export async function run() {};
+        export default async function def() {};
+    }
+    expect: {
+        export async function run() {};
+        export default async function def() {};
+    }
+}
+
+async_inline: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        negate_iife: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        (async function(){ return await 3; })();
+        (async function(x){ await console.log(x); })(4);
+
+        function echo(x) { return x; }
+        echo( async function(){ return await 1; }() );
+        echo( async function(x){ await console.log(x); }(2) );
+
+        function top() { console.log("top"); }
+        top();
+
+        async function async_top() { console.log("async_top"); }
+        async_top();
+    }
+    expect: {
+        !async function(){await 3}();
+        !async function(x){await console.log(4)}();
+
+        function echo(x){return x}
+        echo(async function(){return await 1}());
+        echo(async function(x){await console.log(2)}());
+
+        console.log("top");
+
+        !async function(){console.log("async_top")}();
+    }
+    expect_stdout: [
+        "4",
+        "2",
+        "top",
+        "async_top",
+    ]
+    node_version: ">=8"
+}
+
+async_identifiers: {
+    input: {
+        var async = function(x){ console.log("async", x); };
+        var await = function(x){ console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect: {
+        var async = function(x){ console.log("async", x); };
+        var await = function(x){ console.log("await", x); };
+        async(1);
+        await(2);
+    }
+    expect_stdout: [
+        "async 1",
+        "await 2",
+    ]
+}
+
+async_shorthand_property: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        function print(o) { console.log(o.async + " " + o.await); }
+        var async = "Async", await = "Await";
+
+        print({ async });
+        print({ await });
+        print({ async, await });
+        print({ await, async });
+
+        print({ async: async });
+        print({ await: await });
+        print({ async: async, await: await });
+        print({ await: await, async: async });
+    }
+    expect: {
+        function a(a) { console.log(a.async + " " + a.await); }
+        var n = "Async", c = "Await";
+
+        a({ async: n });
+        a({ await: c });
+        a({ async: n, await: c });
+        a({ await: c, async: n });
+
+        a({ async: n });
+        a({ await: c });
+        a({ async: n, await: c });
+        a({ await: c, async: n });
+    }
+    expect_stdout: [
+        "Async undefined",
+        "undefined Await",
+        "Async Await",
+        "Async Await",
+        "Async undefined",
+        "undefined Await",
+        "Async Await",
+        "Async Await",
+    ]
+    node_version: ">=4"
+}
+
+async_arrow: {
+    input: {
+        let a1 = async x => await foo(x);
+        let a2 = async () => await bar();
+        let a3 = async (x) => await baz(x);
+        let a4 = async (x, y) => { await far(x, y); }
+        let a5 = async ({x = [1], y: z = 2}) => { await wow(x, z); }
+    }
+    expect: {
+        let a1 = async x => await foo(x);
+        let a2 = async () => await bar();
+        let a3 = async (x) => await baz(x);
+        let a4 = async (x, y) => { await far(x, y); }
+        let a5 = async ({x = [1], y: z = 2}) => { await wow(x, z); }
+    }
+}
+
+async_arrow_wait: {
+    input: {
+        var a = async (x, y) => await x(y);
+    }
+    expect_exact: "var a=async(x,y)=>await x(y);"
+}
+
+async_arrow_iife: {
+    input: {
+        (async () => {
+            await fetch({});
+        })();
+    }
+    expect_exact: "(async()=>{await fetch({})})();"
+}
+
+async_arrow_iife_negate_iife: {
+    options = {
+        negate_iife: true,
+    }
+    input: {
+        (async () => {
+            await fetch();
+        })();
+        (() => {
+            plain();
+        })();
+    }
+    expect_exact: "(async()=>{await fetch()})();(()=>{plain()})();"
+}
+
+issue_2344_1: {
+    beautify = {
+        safari10: false,
+    }
+    input: {
+        async () => {
+            +await x;
+            await y;
+            return await z;
+        };
+    }
+    expect_exact: "async()=>{+await x;await y;return await z};"
+}
+
+issue_2344_2: {
+    beautify = {
+        safari10: true,
+    }
+    input: {
+        async () => {
+            +await x;
+            await y;
+            return await z;
+        };
+    }
+    expect_exact: "async()=>{+(await x);await y;return await z};"
+}

test/compress/block-scope.js

@@ -0,0 +1,191 @@
+
+let_statement: {
+    input: {
+        let x = 6;
+    }
+    expect_exact: "let x=6;"
+}
+
+do_not_hoist_let: {
+    options = {
+        hoist_vars: true,
+    };
+    input: {
+        function x() {
+            if (FOO) {
+                let let1;
+                let let2;
+                var var1;
+                var var2;
+            }
+        }
+    }
+    expect: {
+        function x() {
+            var var1, var2;
+            if (FOO) {
+                let let1;
+                let let2;
+            }
+        }
+    }
+}
+
+do_not_remove_anon_blocks_if_they_have_decls: {
+    input: {
+        function x() {
+            {
+                let x;
+            }
+            {
+                var x;
+            }
+            {
+                const y;
+                class Zee {};
+            }
+        }
+        {
+            let y;
+        }
+        {
+            var y;
+        }
+    }
+    expect: {
+        function x(){
+            {
+                let x
+            }
+            var x;
+            {
+                const y;
+                class Zee {}
+            }
+        }
+        {
+            let y
+        }
+        var y;
+    }
+}
+
+remove_unused_in_global_block: {
+    options = {
+        unused: true,
+    }
+    input: {
+        {
+            let x;
+            const y;
+            class Zee {};
+            var w;
+        }
+        let ex;
+        const why;
+        class Zed {};
+        var wut;
+        console.log(x, y, Zee);
+    }
+    expect: {
+        var w;
+        let ex;
+        const why;
+        class Zed {};
+        var wut;
+        console.log(x, y, Zee);
+    }
+}
+
+regression_block_scope_resolves: {
+    mangle = { };
+    options = {
+        dead_code: false
+    };
+    input: {
+        (function () {
+            if (1) {
+                let x;
+                const y = 1;
+                class Zee {};
+            }
+            if (1) {
+                let ex;
+                const why = 2;
+                class Zi {};
+            }
+            console.log(typeof x, typeof y, typeof Zee, typeof ex, typeof why, typeof Zi);
+        }());
+    }
+    expect: {
+        (function () {
+            if (1) {
+                let e;
+                const o = 1;
+                class t {};
+            }
+            if (1) {
+                let e;
+                const o = 2;
+                class t {};
+            }
+            console.log(typeof x, typeof y, typeof Zee, typeof ex, typeof why, typeof Zi);
+        }());
+    }
+    expect_stdout: "undefined undefined undefined undefined undefined undefined"
+    node_version: ">=6"
+}
+
+switch_block_scope_mangler: {
+    mangle = {}
+    input: {
+        var fn = function(code) {
+            switch (code) {
+                case 1:
+                    let apple = code + 1;
+                    let dog = code + 4;
+                    console.log(apple, dog);
+                    break;
+                case 2:
+                    let banana = code + 2;
+                    console.log(banana);
+                    break;
+                default:
+                    let cat = code + 3;
+                    console.log(cat);
+            }
+        };
+        fn(1);
+        fn(2);
+        fn(3);
+    }
+    expect: {
+        var fn = function(e) {
+            switch (e) {
+              case 1:
+                let l = e + 1
+                let o = e + 4;
+                console.log(l, o);
+                break;
+
+              case 2:
+                let n = e + 2;
+                console.log(n);
+                break;
+
+              default:
+                let c = e + 3;
+                console.log(c);
+            }
+        };
+        fn(1);
+        fn(2);
+        fn(3);
+    }
+    expect_stdout: [
+        "2 5",
+        "4",
+        "6",
+    ]
+    node_version: ">=6"
+}

test/compress/blocks.js

@@ -47,3 +47,142 @@ keep_some_blocks: {
         } else stuff();
     }
 }
+
+issue_1664: {
+    input: {
+        var a = 1;
+        function f() {
+            if (undefined) a = 2;
+            {
+                function undefined() {}
+                undefined();
+            }
+        }
+        f();
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        function f() {
+            if (undefined) a = 2;
+            {
+                function undefined() {}
+                undefined();
+            }
+        }
+        f();
+        console.log(a);
+    }
+    expect_stdout: "1"
+    node_version: ">=6"
+}
+
+issue_1672_for: {
+    input: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_1672_for_strict: {
+    input: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            for (; console.log("FAIL");) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_1672_if: {
+    input: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) function xxx() {}
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+issue_1672_if_strict: {
+    input: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect: {
+        "use strict";
+        switch (function() {
+            return xxx;
+        }) {
+          case xxx:
+            if (console.log("FAIL")) {
+                function xxx() {}
+            }
+            break;
+        }
+    }
+    expect_stdout: true
+    node_version: ">=6"
+}

test/compress/conditionals.js

@@ -649,7 +649,7 @@ ternary_boolean_consequent: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
     }
     input: {
         function f1() { return a == b ? true : x; }
@@ -677,7 +677,7 @@ ternary_boolean_alternative: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
     }
     input: {
         function f1() { return a == b ? x : true; }

test/compress/const.js

@@ -0,0 +1,170 @@
+issue_1191: {
+    options = {
+        evaluate      : true,
+        booleans      : true,
+        comparisons   : true,
+        dead_code     : true,
+        conditionals  : true,
+        side_effects  : true,
+        unused        : true,
+        hoist_funs    : true,
+        if_return     : true,
+        join_vars     : true,
+        sequences     : false,
+        collapse_vars : false,
+        reduce_funcs  : true,
+        reduce_vars   : true,
+    }
+    input: {
+        function foo(rot) {
+            const rotTol = 5;
+            if (rot < -rotTol || rot > rotTol)
+                bar();
+            baz();
+        }
+    }
+    expect: {
+        function foo(rot) {
+            (rot < -5 || rot > 5) && bar();
+            baz();
+        }
+    }
+}
+
+issue_1194: {
+    options = {
+        evaluate      : true,
+        booleans      : true,
+        comparisons   : true,
+        dead_code     : true,
+        conditionals  : true,
+        side_effects  : true,
+        unused        : true,
+        hoist_funs    : true,
+        if_return     : true,
+        join_vars     : true,
+        sequences     : false,
+        collapse_vars : false,
+        reduce_funcs  : true,
+        reduce_vars   : true,
+    }
+    input: {
+        function f1() {const a = "X"; return a + a;}
+        function f2() {const aa = "X"; return aa + aa;}
+        function f3() {const aaa = "X"; return aaa + aaa;}
+    }
+    expect: {
+        function f1(){return"XX"}
+        function f2(){return"XX"}
+        function f3(){return"XX"}
+    }
+}
+
+issue_1396: {
+    options = {
+        evaluate      : true,
+        booleans      : true,
+        comparisons   : true,
+        dead_code     : true,
+        conditionals  : true,
+        side_effects  : true,
+        unused        : true,
+        hoist_funs    : true,
+        if_return     : true,
+        join_vars     : true,
+        sequences     : false,
+        collapse_vars : false,
+        reduce_funcs  : true,
+        reduce_vars   : true,
+    }
+    input: {
+        function foo(a) {
+            const VALUE = 1;
+            console.log(2 | VALUE);
+            console.log(VALUE + 1);
+            console.log(VALUE);
+            console.log(a & VALUE);
+        }
+        function bar() {
+            const s = "01234567890123456789";
+            console.log(s + s + s + s + s);
+
+            const CONSTANT = "abc";
+            console.log(CONSTANT + CONSTANT + CONSTANT + CONSTANT + CONSTANT);
+        }
+    }
+    expect: {
+        function foo(a) {
+            console.log(3);
+            console.log(2);
+            console.log(1);
+            console.log(1 & a);
+        }
+        function bar() {
+            const s = "01234567890123456789";
+            console.log(s + s + s + s + s);
+
+            console.log("abcabcabcabcabc");
+        }
+    }
+}
+
+unused_regexp_literal: {
+    options = {
+        evaluate      : true,
+        booleans      : true,
+        comparisons   : true,
+        dead_code     : true,
+        conditionals  : true,
+        side_effects  : true,
+        unused        : true,
+        hoist_funs    : true,
+        if_return     : true,
+        join_vars     : true,
+        sequences     : false,
+        collapse_vars : false,
+    }
+    input: {
+        function f(){ var a = /b/; }
+    }
+    expect: {
+        function f(){}
+    }
+}
+
+regexp_literal_not_const: {
+    options = {
+        evaluate      : true,
+        booleans      : true,
+        comparisons   : true,
+        dead_code     : true,
+        conditionals  : true,
+        side_effects  : true,
+        unused        : true,
+        hoist_funs    : true,
+        if_return     : true,
+        join_vars     : true,
+        sequences     : false,
+        collapse_vars : false,
+        reduce_funcs  : true,
+        reduce_vars   : true,
+    }
+    input: {
+        (function(){
+            var result;
+            const s = 'acdabcdeabbb';
+            const REGEXP_LITERAL = /ab*/g;
+            while (result = REGEXP_LITERAL.exec(s)) {
+                console.log(result[0]);
+            }
+        })();
+    }
+    expect: {
+        (function() {
+            var result;
+            const REGEXP_LITERAL = /ab*/g;
+            while (result = REGEXP_LITERAL.exec("acdabcdeabbb")) console.log(result[0]);
+        })();
+    }
+    expect_stdout: true
+}

test/compress/dead-code.js

@@ -54,12 +54,12 @@ dead_code_2_should_warn: {
             x = 10;
             throw new Error("foo");
             var x;
-            function g(){};
+            var g;
         }
         f();
     }
     expect_stdout: true
-    node_version: "<=4"
+    node_version: ">=6"
 }
 
 dead_code_2_should_warn_strict: {
@@ -126,7 +126,7 @@ dead_code_constant_boolean_should_warn_more: {
     }
     expect: {
         var foo;
-        function bar() {}
+        var bar;
         // nothing for the while
         // as for the for, it should keep:
         var moo;
@@ -134,7 +134,7 @@ dead_code_constant_boolean_should_warn_more: {
         bar();
     }
     expect_stdout: true
-    node_version: "<=4"
+    node_version: ">=6"
 }
 
 dead_code_constant_boolean_should_warn_more_strict: {
@@ -173,6 +173,161 @@ dead_code_constant_boolean_should_warn_more_strict: {
     node_version: ">=4"
 }
 
+dead_code_block_decls_die: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+    };
+    input: {
+        if (0) {
+            let foo = 6;
+            const bar = 12;
+            class Baz {};
+            var qux;
+        }
+        console.log(foo, bar, Baz);
+    }
+    expect: {
+        var qux;
+        console.log(foo, bar, Baz);
+    }
+}
+
+dead_code_const_declaration: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+    };
+    input: {
+        var unused;
+        const CONST_FOO = false;
+        if (CONST_FOO) {
+            console.log("unreachable");
+            var moo;
+            function bar() {}
+        }
+    }
+    expect: {
+        var unused;
+        const CONST_FOO = !1;
+        var moo;
+        var bar;
+    }
+    expect_stdout: true
+}
+
+dead_code_const_annotation: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    };
+    input: {
+        var unused;
+        /** @const */ var CONST_FOO_ANN = false;
+        if (CONST_FOO_ANN) {
+            console.log("unreachable");
+            var moo;
+            function bar() {}
+        }
+    }
+    expect: {
+        var unused;
+        var CONST_FOO_ANN = !1;
+        var moo;
+        var bar;
+    }
+    expect_stdout: true
+}
+
+dead_code_const_annotation_regex: {
+    options = {
+        dead_code    : true,
+        loops        : true,
+        booleans     : true,
+        conditionals : true,
+        evaluate     : true
+    };
+    input: {
+        var unused;
+        // @constraint this shouldn't be a constant
+        var CONST_FOO_ANN = false;
+        if (CONST_FOO_ANN) {
+            console.log("reachable");
+        }
+    }
+    expect: {
+        var unused;
+        var CONST_FOO_ANN = !1;
+        CONST_FOO_ANN && console.log('reachable');
+    }
+    expect_stdout: true
+}
+
+dead_code_const_annotation_complex_scope: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+    };
+    input: {
+        var unused_var;
+        /** @const */ var test = 'test';
+        // @const
+        var CONST_FOO_ANN = false;
+        var unused_var_2;
+        if (CONST_FOO_ANN) {
+            console.log("unreachable");
+            var moo;
+            function bar() {}
+        }
+        if (test === 'test') {
+            var beef = 'good';
+            /** @const */ var meat = 'beef';
+            var pork = 'bad';
+            if (meat === 'pork') {
+                console.log('also unreachable');
+            } else if (pork === 'good') {
+                console.log('reached, not const');
+            }
+        }
+    }
+    expect: {
+        var unused_var;
+        var test = 'test';
+        var CONST_FOO_ANN = !1;
+        var unused_var_2;
+        var moo;
+        var bar;
+        var beef = 'good';
+        var meat = 'beef';
+        var pork = 'bad';
+    }
+    expect_stdout: true
+}
+
 try_catch_finally: {
     options = {
         conditionals: true,
@@ -417,3 +572,505 @@ global_fns: {
         "RangeError",
     ]
 }
+
+issue_2383_1: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        if (0) {
+            var {x, y} = foo();
+        }
+    }
+    expect: {
+        var x, y;
+    }
+}
+
+issue_2383_2: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        if (0) {
+            var {
+                x = 0,
+                y: [ w, , { z, p: q = 7 } ] = [ 1, 2, { z: 3 } ]
+            } = {};
+        }
+        console.log(x, q, w, z);
+    }
+    expect: {
+        var x, w, z, q;
+        console.log(x, q, w, z);
+    }
+    expect_stdout: "undefined undefined undefined undefined"
+    node_version: ">=6"
+}
+
+issue_2383_3: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        var b = 7, y = 8;
+        if (0) {
+            var a = 1, [ x, y, z ] = [ 2, 3, 4 ], b = 5;
+        }
+        console.log(a, x, y, z, b);
+    }
+    expect: {
+        var b = 7, y = 8;
+        var a, x, y, z, b;
+        console.log(a, x, y, z, b);
+    }
+    expect_stdout: "undefined undefined 8 undefined 7"
+    node_version: ">=6"
+}
+
+collapse_vars_assignment: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        passes: 2,
+        unused: true,
+    }
+    input: {
+        function f0(c) {
+            var a = 3 / c;
+            return a = a;
+        }
+    }
+    expect: {
+        function f0(c) {
+            return 3 / c;
+        }
+    }
+}
+
+collapse_vars_lvalues_drop_assign: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        unused: true,
+    }
+    input: {
+        function f0(x) { var i = ++x; return x += i; }
+        function f1(x) { var a = (x -= 3); return x += a; }
+        function f2(x) { var z = x, a = ++z; return z += a; }
+    }
+    expect: {
+        function f0(x) { var i = ++x; return x + i; }
+        function f1(x) { var a = (x -= 3); return x + a; }
+        function f2(x) { var z = x, a = ++z; return z + a; }
+    }
+}
+
+collapse_vars_misc1: {
+    options = {
+        collapse_vars: true,
+        dead_code: true,
+        unused: true,
+    }
+    input: {
+        function f10(x) { var a = 5, b = 3; return a += b; }
+        function f11(x) { var a = 5, b = 3; return a += --b; }
+    }
+    expect: {
+        function f10(x) { return 5 + 3; }
+        function f11(x) { var b = 3; return 5 + --b; }
+    }
+}
+
+return_assignment: {
+    options = {
+        dead_code: true,
+        unused: true,
+    }
+    input: {
+        function f1(a, b, c) {
+            return a = x(), b = y(), b = a && (c >>= 5);
+        }
+        function f2() {
+            return e = x();
+        }
+        function f3(e) {
+            return e = x();
+        }
+        function f4() {
+            var e;
+            return e = x();
+        }
+        function f5(a) {
+            try {
+                return a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f6(a) {
+            try {
+                return a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function y() {
+            console.log("y");
+        }
+        function test(inc) {
+            var counter = 0;
+            x = function() {
+                counter += inc;
+                if (inc < 0) throw counter;
+                return counter;
+            };
+            [ f1, f2, f3, f4, f5, f6 ].forEach(function(f, i) {
+                e = null;
+                try {
+                    i += 1;
+                    console.log("result " + f(10 * i, 100 * i, 1000 * i));
+                } catch (x) {
+                    console.log("caught " + x);
+                }
+                if (null !== e) console.log("e: " + e);
+            });
+        }
+        var x, e;
+        test(1);
+        test(-1);
+    }
+    expect: {
+        function f1(a, b, c) {
+            return a = x(), y(), a && (c >> 5);
+        }
+        function f2() {
+            return e = x();
+        }
+        function f3(e) {
+            return x();
+        }
+        function f4() {
+            return x();
+        }
+        function f5(a) {
+            try {
+                return x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f6(a) {
+            try {
+                return a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function y() {
+            console.log("y");
+        }
+        function test(inc) {
+            var counter = 0;
+            x = function() {
+                counter += inc;
+                if (inc < 0) throw counter;
+                return counter;
+            };
+            [ f1, f2, f3, f4, f5, f6 ].forEach(function(f, i) {
+                e = null;
+                try {
+                    i += 1;
+                    console.log("result " + f(10 * i, 100 * i, 1000 * i));
+                } catch (x) {
+                    console.log("caught " + x);
+                }
+                if (null !== e) console.log("e: " + e);
+            });
+        }
+        var x, e;
+        test(1);
+        test(-1);
+    }
+    expect_stdout: [
+        "y",
+        "result 31",
+        "result 2",
+        "e: 2",
+        "result 3",
+        "result 4",
+        "result 5",
+        "6",
+        "result 6",
+        "caught -1",
+        "caught -2",
+        "caught -3",
+        "caught -4",
+        "50",
+        "result undefined",
+        "60",
+        "caught -6",
+    ]
+}
+
+throw_assignment: {
+    options = {
+        dead_code: true,
+        unused: true,
+    }
+    input: {
+        function f1() {
+            throw a = x();
+        }
+        function f2(a) {
+            throw a = x();
+        }
+        function f3() {
+            var a;
+            throw a = x();
+        }
+        function f4() {
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f5(a) {
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f6() {
+            var a;
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f7() {
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function f8(a) {
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function f9() {
+            var a;
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function test(inc) {
+            var counter = 0;
+            x = function() {
+                counter += inc;
+                if (inc < 0) throw counter;
+                return counter;
+            };
+            [ f1, f2, f3, f4, f5, f6, f7, f8, f9 ].forEach(function(f, i) {
+                a = null;
+                try {
+                    f(10 * (1 + i));
+                } catch (x) {
+                    console.log("caught " + x);
+                }
+                if (null !== a) console.log("a: " + a);
+            });
+        }
+        var x, a;
+        test(1);
+        test(-1);
+    }
+    expect: {
+        function f1() {
+            throw a = x();
+        }
+        function f2(a) {
+            throw x();
+        }
+        function f3() {
+            throw x();
+        }
+        function f4() {
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f5(a) {
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f6() {
+            var a;
+            try {
+                throw a = x();
+            } catch (b) {
+                console.log(a);
+            }
+        }
+        function f7() {
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function f8(a) {
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function f9() {
+            var a;
+            try {
+                throw a = x();
+            } finally {
+                console.log(a);
+            }
+        }
+        function test(inc) {
+            var counter = 0;
+            x = function() {
+                counter += inc;
+                if (inc < 0) throw counter;
+                return counter;
+            };
+            [ f1, f2, f3, f4, f5, f6, f7, f8, f9 ].forEach(function(f, i) {
+                a = null;
+                try {
+                    f(10 * (1 + i));
+                } catch (x) {
+                    console.log("caught " + x);
+                }
+                if (null !== a) console.log("a: " + a);
+            });
+        }
+        var x, a;
+        test(1);
+        test(-1);
+    }
+    expect_stdout: [
+        "caught 1",
+        "a: 1",
+        "caught 2",
+        "caught 3",
+        "4",
+        "a: 4",
+        "5",
+        "6",
+        "7",
+        "caught 7",
+        "a: 7",
+        "8",
+        "caught 8",
+        "9",
+        "caught 9",
+        "caught -1",
+        "caught -2",
+        "caught -3",
+        "null",
+        "50",
+        "undefined",
+        "null",
+        "caught -7",
+        "80",
+        "caught -8",
+        "undefined",
+        "caught -9",
+    ]
+}
+
+issue_2597: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        function f(b) {
+            try {
+                try {
+                    throw "foo";
+                } catch (e) {
+                    return b = true;
+                }
+            } finally {
+                b && (a = "PASS");
+            }
+        }
+        var a = "FAIL";
+        f();
+        console.log(a);
+    }
+    expect: {
+        function f(b) {
+            try {
+                try {
+                    throw "foo";
+                } catch (e) {
+                    return b = true;
+                }
+            } finally {
+                b && (a = "PASS");
+            }
+        }
+        var a = "FAIL";
+        f();
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2666: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        function f(a) {
+            return a = {
+                p: function() {
+                    return a;
+                }
+            };
+        }
+        console.log(typeof f().p());
+    }
+    expect: {
+        function f(a) {
+            return a = {
+                p: function() {
+                    return a;
+                }
+            };
+        }
+        console.log(typeof f().p());
+    }
+    expect_stdout: "object"
+}

test/compress/destructuring.js

@@ -0,0 +1,662 @@
+destructuring_arrays: {
+    input: {
+        {const [aa, bb] = cc;}
+        {const [aa, [bb, cc]] = dd;}
+        {let [aa, bb] = cc;}
+        {let [aa, [bb, cc]] = dd;}
+        var [aa, bb] = cc;
+        var [aa, [bb, cc]] = dd;
+        var [,[,,,,,],,,zz,] = xx; // Trailing comma
+        var [,,zzz,,] = xxx; // Trailing comma after hole
+    }
+    expect: {
+        {const [aa, bb] = cc;}
+        {const [aa, [bb, cc]] = dd;}
+        {let [aa, bb] = cc;}
+        {let [aa, [bb, cc]] = dd;}
+        var [aa, bb] = cc;
+        var [aa, [bb, cc]] = dd;
+        var [,[,,,,,],,,zz] = xx;
+        var [,,zzz,,] = xxx;
+    }
+}
+
+destructuring_arrays_holes: {
+    input: {
+        var [,,,,] = a;
+        var [,,b,] = c;
+        var [d,,]  = e;
+    }
+    expect_exact: "var[,,,,]=a;var[,,b]=c;var[d,,]=e;"
+}
+
+destructuring_objects: {
+    input: {
+        {const {aa, bb} = {aa:1, bb:2};}
+        {const {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        {let {aa, bb} = {aa:1, bb:2};}
+        {let {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        var {aa, bb} = {aa:1, bb:2};
+        var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
+    }
+    expect: {
+        {const {aa, bb} = {aa:1, bb:2};}
+        {const {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        {let {aa, bb} = {aa:1, bb:2};}
+        {let {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        var {aa, bb} = {aa:1, bb:2};
+        var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
+    }
+}
+
+destructuring_objects_trailing_elision: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        var {cc,} = foo;
+    }
+    expect_exact: "var{cc}=foo;"
+}
+
+nested_destructuring_objects: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        const [{a},b] = c;
+        let [{d},e] = f;
+        var [{g},h] = i;
+    }
+    expect_exact: 'const[{a},b]=c;let[{d},e]=f;var[{g},h]=i;';
+}
+
+destructuring_constdef_in_loops: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        for (const [x,y] in pairs);
+        for (const [a] = 0;;);
+        for (const {c} of cees);
+    }
+    expect_exact: "for(const[x,y]in pairs);for(const[a]=0;;);for(const{c}of cees);"
+}
+
+destructuring_letdef_in_loops: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        for (let [x,y] in pairs);
+        for (let [a] = 0;;);
+        for (let {c} of cees);
+    }
+    expect_exact: "for(let[x,y]in pairs);for(let[a]=0;;);for(let{c}of cees);"
+}
+
+destructuring_vardef_in_loops: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        for (var [x,y] in pairs);
+        for (var [a] = 0;;);
+        for (var {c} of cees);
+    }
+    expect_exact: "for(var[x,y]in pairs);for(var[a]=0;;);for(var{c}of cees);"
+}
+
+destructuring_expressions: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        ({a, b});
+        [{a}];
+        f({x});
+    }
+    expect_exact: "({a,b});[{a}];f({x});"
+}
+
+destructuring_remove_unused_1: {
+    options = {
+        unused: true
+    }
+    input: {
+        function a() {
+            var unused = "foo";
+            var a = [1];
+            var [b] = a;
+            f(b);
+        }
+        function b() {
+            var unused = "foo";
+            var a = {b: 1};
+            var {b} = a;
+            f(b);
+        }
+        function c() {
+            var unused = "foo";
+            var a = [[1]];
+            var [[b]] = a;
+            f(b);
+        }
+        function d() {
+            var unused = "foo";
+            var a = {b: {b:1}};
+            var {b:{b}} = a;
+            f(b);
+        }
+        function e() {
+            var unused = "foo";
+            var a = [1, 2, 3, 4, 5];
+            var x = [[1, 2, 3]];
+            var y = {h: 1};
+            var [b, ...c] = a;
+            var [...[e, f]] = x;
+            var [...{g: h}] = y;
+            f(b, c, e, f, g);
+        }
+    }
+    expect: {
+        function a() {
+            var a = [1];
+            var [b] = a;
+            f(b);
+        }
+        function b() {
+            var a = {b: 1};
+            var {b} = a;
+            f(b);
+        }
+        function c() {
+            var a = [[1]];
+            var [[b]] = a;
+            f(b);
+        }
+        function d() {
+            var a = {b: {b:1}};
+            var {b:{b}} = a;
+            f(b);
+        }
+        function e() {
+            var a = [1, 2, 3, 4, 5];
+            var x = [[1, 2, 3]];
+            var y = {h: 1};
+            var [b, ...c] = a;
+            var [...[e, f]] = x;
+            var [...{g: h}] = y;
+            f(b, c, e, f, g);
+        }
+    }
+}
+
+destructuring_remove_unused_2: {
+    options = {
+        unused: true
+    }
+    input: {
+        function a() {
+            var unused = "foo";
+            var a = [,,1];
+            var [b] = a;
+            f(b);
+        }
+        function b() {
+            var unused = "foo";
+            var a = [{a: [1]}];
+            var [{b: a}] = a;
+            f(b);
+        }
+    }
+    expect: {
+        function a() {
+            var a = [,,1];
+            var [b] = a;
+            f(b);
+        }
+        function b() {
+            var a = [{a: [1]}];
+            var [{b: a}] = a;
+            f(b);
+        }
+    }
+}
+
+object_destructuring_may_need_parentheses: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        ({a, b} = {a: 1, b: 2});
+    }
+    expect_exact: "({a,b}={a:1,b:2});"
+}
+
+destructuring_with_undefined_as_default_assignment: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        [foo = undefined] = bar;
+        [foo = void 0] = bar;
+    }
+    expect: {
+        [foo] = bar;
+        [foo] = bar;
+    }
+}
+
+destructuring_dont_evaluate_with_undefined_as_default_assignment: {
+    options = {
+        evaluate: false
+    }
+    input: {
+        [foo = undefined] = bar;
+    }
+    expect: {
+        [foo = void 0] = bar;
+    }
+}
+
+reduce_vars: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+    }
+    input: {
+        {const [aa, [bb, cc]] = dd;}
+        {let [aa, [bb, cc]] = dd;}
+        var [aa, [bb, cc]] = dd;
+        [aa, [bb, cc]] = dd;
+        {const {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        {let {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
+        ({aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}});
+        const [{a},b] = c;
+        let [{d},e] = f;
+        var [{g},h] = i;
+        [{a},b] = c;
+        for (const [x,y] in pairs);
+        for (let [x,y] in pairs);
+        for (var [x,y] in pairs);
+        for ([x,y] in pairs);
+    }
+    expect: {
+        {const [aa, [bb, cc]] = dd;}
+        {let [aa, [bb, cc]] = dd;}
+        var [aa, [bb, cc]] = dd;
+        [aa, [bb, cc]] = dd;
+        {const {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        {let {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
+        ({aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}});
+        const [{a},b] = c;
+        let [{d},e] = f;
+        var [{g},h] = i;
+        [{a},b] = c;
+        for (const [x,y] in pairs);
+        for (let [x,y] in pairs);
+        for (var [x,y] in pairs);
+        for ([x,y] in pairs);
+    }
+}
+
+unused: {
+    options = {
+        unused: true,
+    }
+    input: {
+        let { foo: [, , ...a] } = { foo: [1, 2, 3, 4], bar: 5 };
+        console.log(a);
+    }
+    expect: {
+        let { foo: [, , ...a] } = { foo: [1, 2, 3, 4], bar: 5 };
+        console.log(a);
+    }
+}
+
+issue_1886: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        let [a] = [1];
+        console.log(a);
+    }
+    expect: {
+        let [a] = [1];
+        console.log(a);
+    }
+}
+
+destructuring_decl_of_numeric_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let { 3: x } = { [1 + 2]: 42 };
+        console.log(x);
+    }
+    expect: {
+        let { 3: x } = { [3]: 42 };
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+destructuring_decl_of_computed_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let four = 4;
+        let { [7 - four]: x } = { [1 + 2]: 42 };
+        console.log(x);
+    }
+    expect: {
+        let four = 4;
+        let { [7 - four]: x } = { [3]: 42 };
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+destructuring_assign_of_numeric_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let x;
+        ({ 3: x } = { [1 + 2]: 42 });
+        console.log(x);
+    }
+    expect: {
+        let x;
+        ({ 3: x } = { [3]: 42 });
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+destructuring_assign_of_computed_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let x;
+        let four = 4;
+        ({ [(5 + 2) - four]: x } = { [1 + 2]: 42 });
+        console.log(x);
+    }
+    expect: {
+        let x;
+        let four = 4;
+        ({ [7 - four]: x } = { [3]: 42 });
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+mangle_destructuring_decl: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    mangle = {
+    }
+    input: {
+        function test(opts) {
+            let a = opts.a || { e: 7, n: 8 };
+            let { t, e, n, s =  5 + 4, o, r } = a;
+            console.log(t, e, n, s, o, r);
+        }
+        test({a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 }});
+        test({});
+    }
+    expect: {
+        function test(t) {
+            let e = t.a || { e: 7, n: 8 };
+            let {t: n,  e: o,  n: s,  s: l = 9,  o: a,  r: c} = e;
+            console.log(n, o, s, l, a, c);
+        }
+        test({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
+        test({});
+    }
+    expect_stdout: [
+        "1 2 3 4 5 6",
+        "undefined 7 8 9 undefined undefined",
+    ]
+    node_version: ">=6"
+}
+
+mangle_destructuring_assign_toplevel_true: {
+    options = {
+        toplevel: true,
+        evaluate: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        function test(opts) {
+            let s, o, r;
+            let a = opts.a || { e: 7, n: 8 };
+            ({ t, e, n, s =  5 + 4, o, r } = a);
+            console.log(t, e, n, s, o, r);
+        }
+        let t, e, n;
+        test({a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 }});
+        test({});
+    }
+    expect: {
+        function e(e) {
+            let l, s, a;
+            let c = e.a || { e: 7, n: 8 };
+            ({t: n,  e: o,  n: t,  s: l = 9,  o: s,  r: a} = c);
+            console.log(n, o, t, l, s, a);
+        }
+        let n, o, t;
+        e({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
+        e({});
+    }
+    expect_stdout: [
+        "1 2 3 4 5 6",
+        "undefined 7 8 9 undefined undefined",
+    ]
+    node_version: ">=6"
+}
+
+mangle_destructuring_assign_toplevel_false: {
+    options = {
+        toplevel: false,
+        evaluate: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: false,
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        function test(opts) {
+            let s, o, r;
+            let a = opts.a || { e: 7, n: 8 };
+            ({ t, e, n, s = 9, o, r } = a);
+            console.log(t, e, n, s, o, r);
+        }
+        let t, e, n;
+        test({a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 }});
+        test({});
+    }
+    expect: {
+        function test(o) {
+            let s, l, a;
+            let c = o.a || { e: 7, n: 8 };
+            ({t,  e,  n,  s = 9,  o: l,  r: a} = c);
+            console.log(t, e, n, s, l, a);
+        }
+        let t, e, n;
+        test({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
+        test({});
+    }
+    expect_stdout: [
+        "1 2 3 4 5 6",
+        "undefined 7 8 9 undefined undefined",
+    ]
+    node_version: ">=6"
+}
+
+mangle_destructuring_decl_array: {
+    options = {
+        evaluate: true,
+        unused: true,
+        toplevel: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        var [, t, e, n, s, o = 2, r = [ 1 + 2 ]] = [ 9, 8, 7, 6 ];
+        console.log(t, e, n, s, o, r);
+    }
+    expect: {
+        var [, o,  l,  a,  c,  e = 2,  g = [ 3 ]] = [ 9, 8, 7, 6 ];
+        console.log(o, l, a, c, e, g);
+    }
+    expect_stdout: "8 7 6 undefined 2 [ 3 ]"
+    node_version: ">=6"
+}
+
+anon_func_with_destructuring_args: {
+    options = {
+        evaluate: true,
+        unused: true,
+        toplevel: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 5,
+    }
+    input: {
+        (function({foo = 1 + 0, bar = 2}, [car = 3, far = 4]) {
+            console.log(foo, bar, car, far);
+        })({bar: 5 - 0}, [, 6]);
+    }
+    expect: {
+        (function({foo: o = 1, bar: n = 2}, [a = 3, b = 4]) {
+            console.log(o, n, a, b);
+        })({bar: 5}, [, 6]);
+    }
+    expect_stdout: "1 5 3 6"
+    node_version: ">=6"
+}
+
+arrow_func_with_destructuring_args: {
+    options = {
+        evaluate: true,
+        unused: true,
+        toplevel: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 5,
+    }
+    input: {
+        (({foo = 1 + 0, bar = 2}, [car = 3, far = 4]) => {
+            console.log(foo, bar, car, far);
+        })({bar: 5 - 0}, [, 6]);
+    }
+    expect: {
+        (({foo: o = 1, bar: a = 2}, [b = 3, l = 4]) => {
+            console.log(o, a, b, l);
+        })({bar: 5}, [, 6]);
+    }
+    expect_stdout: "1 5 3 6"
+    node_version: ">=6"
+}
+
+issue_2044_ecma_5: {
+    beautify = {
+        beautify: false,
+        ecma: 5,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x:a=1,y:y=2+b,z:z=3-c}=obj);"
+}
+
+issue_2044_ecma_6: {
+    beautify = {
+        beautify: false,
+        ecma: 6,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x:a=1,y=2+b,z=3-c}=obj);"
+}
+
+issue_2044_ecma_5_beautify: {
+    beautify = {
+        beautify: true,
+        ecma: 5,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x: a = 1, y: y = 2 + b, z: z = 3 - c} = obj);"
+}
+
+issue_2044_ecma_6_beautify: {
+    beautify = {
+        beautify: true,
+        ecma: 6,
+    }
+    input: {
+        ({x : a = 1, y = 2 + b, z = 3 - c} = obj);
+    }
+    expect_exact: "({x: a = 1, y = 2 + b, z = 3 - c} = obj);"
+}
+
+issue_2140: {
+    options = {
+        unused: true,
+    }
+    input: {
+        !function() {
+            var t = {};
+            console.log(([t.a] = [42])[0]);
+        }();
+    }
+    expect: {
+        !function() {
+            var t = {};
+            console.log(([t.a] = [42])[0]);
+        }();
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}

test/compress/directives.js

@@ -0,0 +1,10 @@
+class_directives_compression: {
+    input: {
+        class foo {
+            foo() {
+                "use strict";
+            }
+        }
+    }
+    expect_exact: "class foo{foo(){}}"
+}

test/compress/drop-unused.js

@@ -164,6 +164,87 @@ used_var_in_catch: {
     }
 }
 
+unused_block_decls_in_catch: {
+    options = { unused: true };
+    input: {
+        function foo() {
+            try {
+                foo();
+            } catch(ex) {
+                let x = 10;
+                const y = 10;
+                class Zee {};
+            }
+        }
+    }
+    expect: {
+        function foo() {
+            try {
+                foo();
+            } catch(ex) {}
+        }
+    }
+}
+
+used_block_decls_in_catch: {
+    options = { unused: true };
+    input: {
+        function foo() {
+            try {
+                foo();
+            } catch(ex) {
+                let x = 10;
+                const y = 10;
+                class Zee {};
+            }
+            console.log(x, y, Zee);
+        }
+    }
+    expect: {
+        function foo() {
+            try {
+                foo();
+            } catch(ex) {}
+            console.log(x, y, Zee);
+        }
+    }
+}
+
+unused_block_decls: {
+    options = { unused: true };
+    input: {
+        function foo() {
+            {
+                const x;
+            }
+            {
+                let y;
+            }
+            console.log(x, y);
+        }
+    }
+    expect: {
+        function foo() {
+            console.log(x, y);
+        }
+    }
+}
+
+unused_keep_harmony_destructuring: {
+    options = { unused: true };
+    input: {
+        function foo() {
+            var {x, y} = foo;
+            var a = foo;
+        }
+    }
+    expect:  {
+        function foo() {
+            var {x, y} = foo;
+        }
+    }
+}
+
 keep_fnames: {
     options = { unused: true, keep_fnames: true, unsafe: true };
     input: {
@@ -683,9 +764,41 @@ drop_value: {
     }
 }
 
+const_assign: {
+    options = {
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            const b = 2;
+            return 1 + b;
+        }
+
+        function g() {
+            const b = 2;
+            b = 3;
+            return 1 + b;
+        }
+    }
+    expect: {
+        function f() {
+            return 3;
+        }
+
+        function g() {
+            const b = 2;
+            b = 3;
+            return 1 + b;
+        }
+    }
+}
+
 issue_1539: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         sequences: true,
         side_effects: true,
         unused: true,
@@ -732,7 +845,7 @@ vardef_value: {
 
 assign_binding: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
         unused: true,
     }
@@ -821,6 +934,10 @@ issue_1709: {
                 var x = 1;
                 return x;
             }(),
+            function y() {
+                const y = 2;
+                return y;
+            }(),
             function z() {
                 function z() {}
                 return z;
@@ -833,6 +950,10 @@ issue_1709: {
                 var x = 1;
                 return x;
             }(),
+            function() {
+                const y = 2;
+                return y;
+            }(),
             function() {
                 function z() {}
                 return z;
@@ -1146,6 +1267,71 @@ var_catch_toplevel: {
     }
 }
 
+reassign_const: {
+    options = {
+        collapse_vars: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            const a = 1;
+            a = 2;
+            return a;
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            const a = 1;
+            return a = 2, a;
+        }
+        console.log(f());
+    }
+    expect_stdout: true
+}
+
+issue_1968: {
+    options = {
+        unused: true,
+    }
+    input: {
+        function f(c) {
+            var a;
+            if (c) {
+                let b;
+                return (a = 2) + (b = 3);
+            }
+        }
+        console.log(f(1));
+    }
+    expect: {
+        function f(c) {
+            if (c) {
+                let b;
+                return 2 + (b = 3);
+            }
+        }
+        console.log(f(1));
+    }
+    expect_stdout: "5"
+    node_version: ">=6"
+}
+
+issue_2063: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var a;
+        var a;
+    }
+    expect: {
+        var a;
+    }
+}
+
 issue_2105_1: {
     options = {
         collapse_vars: true,
@@ -1226,6 +1412,95 @@ issue_2105_2: {
     expect_stdout: "PASS"
 }
 
+issue_2136_1: {
+    options = {
+        inline: true,
+        unused: true,
+    }
+    input: {
+        !function(a, ...b) {
+            console.log(b);
+        }();
+    }
+    expect: {
+        !function(a, ...b) {
+            console.log(b);
+        }();
+    }
+    expect_stdout: "[]"
+    node_version: ">=6"
+}
+
+issue_2136_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f(x) {
+            console.log(x);
+        }
+        !function(a, ...b) {
+            f(b[0]);
+        }(1, 2, 3);
+    }
+    expect: {
+        function f(x) {
+            console.log(x);
+        }
+        f([2,3][0]);
+    }
+    expect_stdout: "2"
+    node_version: ">=6"
+}
+
+issue_2136_3: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        passes: 3,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        function f(x) {
+            console.log(x);
+        }
+        !function(a, ...b) {
+            f(b[0]);
+        }(1, 2, 3);
+    }
+    expect: {
+        console.log(2);
+    }
+    expect_stdout: "2"
+    node_version: ">=6"
+}
+
+issue_2163: {
+    options = {
+        pure_funcs: [ "pure" ],
+        side_effects: true,
+    }
+    input: {
+        var c;
+        /*@__PURE__*/f(...a);
+        pure(b, ...c);
+    }
+    expect: {
+        var c;
+        a;
+        b;
+    }
+}
+
 issue_2226_1: {
     options = {
         side_effects: true,
@@ -1273,7 +1548,7 @@ issue_2226_1: {
 
 issue_2226_2: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         sequences: true,
         side_effects: true,
         unused: true,
@@ -1286,8 +1561,8 @@ issue_2226_2: {
     }
     expect: {
         console.log(function(a, b) {
-            return a += b;
-        }(1, 2));
+            return a += 2;
+        }(1));
     }
     expect_stdout: "3"
 }
@@ -1413,3 +1688,210 @@ issue_2516_2: {
         Baz(2);
     }
 }
+
+issue_2418_1: {
+    options = {
+        unused: true,
+    }
+    input: {
+        class C {}
+        function F() {}
+        (class c {});
+        (function f() {});
+    }
+    expect: {
+        class C {}
+        function F() {}
+        (class {});
+        (function() {});
+    }
+}
+
+issue_2418_2: {
+    options = {
+        keep_classnames: false,
+        keep_fnames: false,
+        unused: true,
+    }
+    input: {
+        class C {}
+        function F() {}
+        (class c {});
+        (function f() {});
+    }
+    expect: {
+        class C {}
+        function F() {}
+        (class {});
+        (function() {});
+    }
+}
+
+issue_2418_3: {
+    options = {
+        keep_classnames: false,
+        keep_fnames: true,
+        unused: true,
+    }
+    input: {
+        class C {}
+        function F() {}
+        (class c {});
+        (function f() {});
+    }
+    expect: {
+        class C {}
+        function F() {}
+        (class {});
+        (function f() {});
+    }
+}
+
+issue_2418_4: {
+    options = {
+        keep_classnames: true,
+        keep_fnames: false,
+        unused: true,
+    }
+    input: {
+        class C {}
+        function F() {}
+        (class c {});
+        (function f() {});
+    }
+    expect: {
+        class C {}
+        function F() {}
+        (class c {});
+        (function() {});
+    }
+}
+
+issue_2418_5: {
+    options = {
+        keep_classnames: true,
+        keep_fnames: true,
+        unused: true,
+    }
+    input: {
+        class C {}
+        function F() {}
+        (class c {});
+        (function f() {});
+    }
+    expect: {
+        class C {}
+        function F() {}
+        (class c {});
+        (function f() {});
+    }
+}
+
+defun_lambda_same_name: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(n) {
+            return n ? n * f(n - 1) : 1;
+        }
+        console.log(function f(n) {
+            return n ? n * f(n - 1) : 1;
+        }(5));
+    }
+    expect: {
+        console.log(function f(n) {
+            return n ? n * f(n - 1) : 1;
+        }(5));
+    }
+    expect_stdout: "120"
+}
+
+issue_2660_1: {
+    options = {
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 2;
+        function f(b) {
+            return b && f() || a--;
+        }
+        f(1);
+        console.log(a);
+    }
+    expect: {
+        var a = 2;
+        (function f(b) {
+            return b && f() || a--;
+        })(1);
+        console.log(a);
+    }
+    expect_stdout: "1"
+}
+
+issue_2660_2: {
+    options = {
+        collapse_vars: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        function f(b) {
+            b && f();
+            --a, a.toString();
+        }
+        f();
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        (function f(b) {
+            b && f(),
+            (--a).toString();
+        })(),
+        console.log(a);
+    }
+    expect_stdout: "0"
+}
+
+issue_2665: {
+    options = {
+        evaluate: true,
+        inline: true,
+        keep_fargs: false,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        typeofs: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        function g() {
+            a-- && g();
+        }
+        typeof h == "function" && h();
+        function h() {
+            typeof g == "function" && g();
+        }
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        !function g() {
+            a-- && g();
+        }();
+        console.log(a);
+    }
+    expect_stdout: "-1"
+}

test/compress/evaluate.js

@@ -227,6 +227,100 @@ positive_zero: {
     expect_stdout: true
 }
 
+pow: {
+    options = { evaluate: true }
+    input: {
+        var a = 5 ** 3;
+    }
+    expect: {
+        var a = 125;
+    }
+}
+
+pow_sequence: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var a = 2 ** 3 ** 2;
+    }
+    expect: {
+        var a = 512;
+    }
+}
+
+pow_mixed: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var a = 5 + 2 ** 3 + 5;
+        var b = 5 * 3 ** 2;
+        var c = 5 ** 3 * 2;
+        var d = 5 ** +3;
+    }
+    expect: {
+        var a = 18;
+        var b = 45;
+        var c = 250;
+        var d = 125;
+    }
+}
+
+pow_with_right_side_evaluating_to_unary: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var a = (4 - 7) ** foo;
+        var b = ++bar ** 3;
+        var c = --baz ** 2;
+    }
+    expect_exact: "var a=(-3)**foo;var b=++bar**3;var c=--baz**2;"
+}
+
+pow_with_number_constants: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var a = 5 ** NaN;
+        /* NaN exponent results to NaN */
+        var b = 42 ** +0;
+        /* +0 exponent results to NaN */
+        var c = 42 ** -0;
+        /* -0 exponent results to NaN */
+        var d = NaN ** 1;
+        /* NaN with non-zero exponent is NaN */
+        var e = 2 ** Infinity;
+        /* abs(base) > 1 with Infinity as exponent is Infinity */
+        var f = 2 ** -Infinity;
+        /* abs(base) > 1 with -Infinity as exponent is +0 */
+        var g = (-7) ** (0.5);
+        var h = 2324334 ** 34343443;
+        var i = (-2324334) ** 34343443;
+        var j = 2 ** (-3);
+        var k = 2.0 ** -3;
+        var l = 2.0 ** (5 - 7);
+        var m = 3 ** -10;  // Result will be 0.000016935087808430286, which is too long
+    }
+    expect: {
+        var a = NaN;
+        var b = 1;
+        var c = 1;
+        var d = NaN;
+        var e = 1/0;
+        var f = 0;
+        var g = NaN;
+        var h = 1/0;
+        var i = -1/0;
+        var j = .125;
+        var k = .125;
+        var l = .25;
+        var m = 3 ** -10;
+    }
+}
+
 unsafe_constant: {
     options = {
         evaluate  : true,
@@ -673,17 +767,16 @@ call_args: {
         inline: true,
         reduce_funcs: true,
         reduce_vars: true,
-        toplevel: true,
     }
     input: {
-        var a = 1;
+        const a = 1;
         console.log(a);
         +function(a) {
             return a;
         }(a);
     }
     expect: {
-        var a = 1;
+        const a = 1;
         console.log(1);
         +(1, 1);
     }
@@ -697,17 +790,17 @@ call_args_drop_param: {
         keep_fargs: false,
         reduce_funcs: true,
         reduce_vars: true,
-        toplevel: true,
         unused: true,
     }
     input: {
-        var a = 1;
+        const a = 1;
         console.log(a);
         +function(a) {
             return a;
         }(a, b);
     }
     expect: {
+        const a = 1;
         console.log(1);
         +(b, 1);
     }
@@ -1330,13 +1423,13 @@ issue_2535_3: {
     }
     expect_stdout: true
     expect_warnings: [
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1316,20]",
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1317,20]",
-        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1318,20]",
-        "WARN: Condition left of && always false [test/compress/evaluate.js:1318,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1319,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1320,20]",
-        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1321,20]",
-        "WARN: Condition left of || always true [test/compress/evaluate.js:1321,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1409,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1410,20]",
+        "WARN: Dropping side-effect-free && [test/compress/evaluate.js:1411,20]",
+        "WARN: Condition left of && always false [test/compress/evaluate.js:1411,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1412,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1413,20]",
+        "WARN: Dropping side-effect-free || [test/compress/evaluate.js:1414,20]",
+        "WARN: Condition left of || always true [test/compress/evaluate.js:1414,20]",
     ]
 }

test/compress/expansions.js

@@ -0,0 +1,71 @@
+
+expand_arguments: {
+    input: {
+        func(a, ...rest);
+        func(...all);
+    }
+    expect_exact: "func(a,...rest);func(...all);"
+}
+
+expand_expression_arguments: {
+    input: {
+        f(...a.b);
+        f(...a.b());
+        f(...(a));
+        f(...(a.b));
+        f(...a[i]);
+    }
+    expect_exact: "f(...a.b);f(...a.b());f(...a);f(...a.b);f(...a[i]);"
+}
+
+expand_parameters: {
+    input: {
+        (function (a, ...b){});
+        (function (...args){});
+    }
+    expect_exact: "(function(a,...b){});(function(...args){});"
+}
+
+avoid_spread_in_ternary: {
+    options = {
+        comparisons: true,
+        conditionals: true,
+        evaluate: true,
+    }
+    input: {
+        function print(...x) {
+            console.log(...x);
+        }
+        var a = [1, 2], b = [3, 4], m = Math;
+
+        if (m)
+            print(a);
+        else
+            print(b);
+
+        if (m)
+            print(...a);
+        else
+            print(b);
+
+        if (m.no_such_property)
+            print(a);
+        else
+            print(...b);
+    }
+    expect: {
+        function print(...x) {
+            console.log(...x);
+        }
+        var a = [ 1, 2 ], b = [ 3, 4 ], m = Math;
+        print(m ? a : b);
+        m ? print(...a) : print(b);
+        m.no_such_property ? print(a) : print(...b);
+    }
+    expect_stdout: [
+        "[ 1, 2 ]",
+        "1 2",
+        "3 4",
+    ]
+    node_version: ">=6"
+}

test/compress/export.js

@@ -0,0 +1,446 @@
+issue_2038_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export var V = 1;
+        export let L = 2;
+        export const C = 3;
+    }
+    expect: {
+        export var V = 1;
+        export let L = 2;
+        export const C = 3;
+    }
+}
+
+issue_2038_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        let LET = 1;
+        const CONST = 2;
+        var VAR = 3;
+        export { LET, CONST, VAR };
+    }
+    expect: {
+        let t = 1;
+        const e = 2;
+        var o = 3;
+        export { t as LET, e as CONST, o as VAR };
+    }
+}
+
+issue_2126: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        import { foo as bar, cat as dog } from "stuff";
+        console.log(bar, dog);
+        export { bar as qux };
+        export { dog };
+    }
+    expect: {
+        import { foo as o, cat as s } from "stuff";
+        console.log(o, s);
+        export { o as qux };
+        export { s as dog };
+    }
+}
+
+beautify: {
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        export { A as B, C as D };
+    }
+    expect_exact: "export { A as B, C as D };"
+}
+
+issue_2131: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function no() {
+            console.log(42);
+        }
+        function go() {
+            console.log(42);
+        }
+        var X = 1, Y = 2;
+        export function main() {
+            go(X);
+        };
+    }
+    expect: {
+        function go() {
+            console.log(42);
+        }
+        var X = 1;
+        export function main() {
+            go(X);
+        };
+    }
+}
+
+issue_2129: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export const { keys } = Object;
+    }
+    expect: {
+        export const { keys } = Object;
+    }
+}
+
+async_func: {
+    options = {
+        keep_fargs: false,
+        unused: true,
+    }
+    input: {
+        export async function Foo(x){};
+    }
+    expect: {
+        export async function Foo(){};
+    }
+}
+
+issue_2134_1: {
+    options = {
+        keep_fargs: false,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function Foo(x){};
+        Foo.prototype = {};
+    }
+    expect: {
+        export function Foo(){};
+        Foo.prototype = {};
+    }
+}
+
+issue_2134_2: {
+    options = {
+        keep_fargs: false,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export async function Foo(x){};
+        Foo.prototype = {};
+    }
+    expect: {
+        export async function Foo(){};
+        Foo.prototype = {};
+    }
+}
+
+redirection: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        let foo = 1, bar = 2;
+        export { foo as delete };
+        export { bar as default };
+        export { foo as var } from "module.js";
+    }
+    expect: {
+        let e = 1, o = 2;
+        export { e as delete };
+        export { o as default };
+        export { foo as var } from "module.js";
+    }
+}
+
+keyword_invalid_1: {
+    input: {
+        export { default };
+    }
+    expect: {
+        export { default };
+    }
+}
+
+keyword_invalid_2: {
+    input: {
+        export { default as Alias };
+    }
+    expect: {
+        export { default as Alias };
+    }
+}
+
+keyword_invalid_3: {
+    input: {
+        export { default as default };
+    }
+    expect: {
+        export { default as default };
+    }
+}
+
+keyword_valid_1: {
+    input: {
+        export { default } from "module.js";
+    }
+    expect: {
+        export { default } from "module.js";
+    }
+}
+
+keyword_valid_2: {
+    input: {
+        export { default as Alias } from "module.js";
+    }
+    expect: {
+        export { default as Alias } from "module.js";
+    }
+}
+
+keyword_valid_3: {
+    input: {
+        export { default as default } from "module.js";
+    }
+    expect: {
+        export { default as default } from "module.js";
+    }
+}
+
+dynamic_import: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        import traditional from './traditional.js';
+        function imp(x) {
+            return import(x);
+        }
+        import("module_for_side_effects.js");
+        let dynamic = import("some/module.js");
+        dynamic.foo();
+    }
+    expect: {
+        import o from "./traditional.js";
+        function t(o) {
+            return import(o);
+        }
+        import("module_for_side_effects.js");
+        let r = import("some/module.js");
+        r.foo();
+    }
+}
+
+trailing_comma: {
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        export const a = 1;
+    }
+    expect_exact: "export const a = 1;"
+}
+
+export_default_anonymous_function: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function () {
+            foo();
+        }
+    }
+    expect_exact: "export default function(){foo()};"
+}
+
+export_default_arrow: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default () => foo();
+    }
+    expect_exact: "export default()=>foo();"
+}
+
+export_default_anonymous_generator: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function * () {
+            yield foo();
+        }
+    }
+    expect_exact: "export default function*(){yield foo()};"
+}
+
+export_default_anonymous_async_function: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default async function() {
+            return await foo();
+        }
+    }
+    expect_exact: "export default async function(){return await foo()};"
+}
+
+export_default_async_arrow_function: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default async () => await foo();
+    }
+    expect_exact: "export default async()=>await foo();"
+}
+
+export_default_named_generator: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function * gen() {
+            yield foo();
+        }
+    }
+    expect_exact: "export default function*gen(){yield foo()};"
+}
+
+export_default_named_async_function: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default async function bar() {
+            return await foo();
+        }
+    }
+    expect_exact: "export default async function bar(){return await foo()};"
+}
+
+export_default_anonymous_class: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default class {
+            constructor() {
+                foo();
+            }
+        };
+    }
+    expect_exact: "export default class{constructor(){foo()}};"
+}
+
+export_default_anonymous_function_not_call: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function(){}(foo);
+    }
+    // FIXME: should be `export default function(){};foo;`
+    expect_exact: "export default function(){}(foo);"
+}
+
+export_default_anonymous_generator_not_call: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function*(){}(foo);
+    }
+    // agrees with `acorn` and `babylon 7`
+    expect_exact: "export default function*(){};foo;"
+}
+
+export_default_anonymous_async_function_not_call: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default async function(){}(foo);
+    }
+    // agrees with `acorn` and `babylon 7`
+    expect_exact: "export default async function(){};foo;"
+}

test/compress/expression.js

@@ -0,0 +1,52 @@
+pow: {
+    input: {
+        var a = 2 ** 7;
+        var b = 3;
+        b **= 2;
+    }
+    expect: {
+        var a = 2 ** 7;
+        var b = 3;
+        b **= 2;
+    }
+}
+
+pow_with_number_constants: {
+    input: {
+        var a = 5 ** NaN;
+        var b = 42 ** +0;
+        var c = 42 ** -0;
+        var d = NaN ** 1;
+        var e = 2 ** Infinity;
+        var f = 2 ** -Infinity;
+    }
+    expect: {
+        var a = 5 ** NaN;
+        var b = 42 ** +0;
+        var c = 42 ** -0;
+        var d = NaN ** 1;
+        var e = 2 ** (1/0);
+        var f = 2 ** (-1/0);
+    }
+}
+
+pow_with_parentheses: {
+    input: {
+        var g = (-7) ** (0.5);
+        var h = 2324334 ** 34343443;
+        var i = (-2324334) ** 34343443;
+        var j = 2 ** (-3);
+        var k = 2.0 ** -3;
+        var l = 2.0 ** (5 - 7);
+    }
+    expect_exact: "var g=(-7)**.5;var h=2324334**34343443;var i=(-2324334)**34343443;var j=2**-3;var k=2**-3;var l=2**(5-7);"
+}
+
+pow_with_unary_between_brackets: {
+    input: {
+        var a = (-(+5)) ** 3;
+    }
+    expect: {
+        var a = (-+5)**3;
+    }
+}

test/compress/global_defs.js

@@ -121,7 +121,7 @@ mixed: {
         properties: true,
     }
     input: {
-        var FOO = { BAR: 0 };
+        const FOO = { BAR: 0 };
         console.log(FOO.BAR);
         console.log(++CONFIG.DEBUG);
         console.log(++CONFIG.VALUE);
@@ -131,7 +131,7 @@ mixed: {
         console.log(CONFIG);
     }
     expect: {
-        var FOO = { BAR: 0 };
+        const FOO = { BAR: 0 };
         console.log("moo");
         console.log(++CONFIG.DEBUG);
         console.log(++CONFIG.VALUE);

test/compress/hoist.js

@@ -0,0 +1,85 @@
+
+hoist_vars: {
+    options = {
+        hoist_vars: true
+    }
+    input: {
+        function a() {
+            bar();
+            var var1;
+            var var2;
+        }
+        function b(anArg) {
+            bar();
+            var var1;
+            var anArg;
+        }
+    }
+    expect: {
+        function a() {
+            var var1, var2;  // Vars go up and are joined
+            bar();
+        }
+        function b(anArg) {
+            var var1;
+            bar();
+            // But vars named like arguments go away!
+        }
+    }
+}
+
+hoist_funs: {
+    options = {
+        hoist_funs: true
+    }
+    input: {
+        function a() {
+            bar();
+            function foo() {}
+        }
+    }
+    expect: {
+        function a() {
+            function foo() {}  // Funs go up
+            bar();
+        }
+    }
+}
+
+hoist_no_destructurings: {
+    options = {
+        hoist_vars: true,
+        hoist_funs: true
+    }
+    input: {
+        function a([anArg]) {
+            bar();
+            var var1;
+            var anArg;  // Because anArg is already declared, this goes away!
+        }
+    }
+    expect: {
+        function a([anArg]) {
+            var var1;
+            bar();
+        }
+    }
+}
+
+dont_hoist_var_destructurings: {
+    options = {
+        hoist_vars: true,
+        hoist_funs: true
+    }
+    input: {
+        function x() {
+            // If foo is null or undefined, this should be an exception
+            var {x,y} = foo;
+        }
+    }
+    expect: {
+        function x() {
+            var {x,y} = foo;
+        }
+    }
+}

test/compress/hoist_props.js

@@ -55,9 +55,8 @@ issue_2377_2: {
         console.log(obj.foo, obj.cube(3));
     }
     expect: {
-        console.log(1, function(x) {
-            return x * x * x;
-        }(3));
+        console.log(1, (x = 3, x * x * x));
+        var x;
     }
     expect_stdout: "1 27"
 }
@@ -67,9 +66,10 @@ issue_2377_3: {
         evaluate: true,
         inline: true,
         hoist_props: true,
-        passes: 3,
+        passes: 4,
         reduce_funcs: true,
         reduce_vars: true,
+        side_effects: true,
         toplevel: true,
         unused: true,
     }
@@ -383,6 +383,124 @@ contains_this_3: {
     expect_stdout: "1 1 true"
 }
 
+hoist_class: {
+    options = {
+        comparisons: true,
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        keep_classnames: true,
+        keep_fnames: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function run(c, v) {
+            return new c(v).value;
+        }
+        var o = {
+            p: class Foo {
+                constructor(value) {
+                    this.value = value * 10;
+                }
+            },
+            x: 1,
+            y: 2,
+        };
+        console.log(o.p.name, o.p === o.p, run(o.p, o.x), run(o.p, o.y));
+    }
+    expect: {
+        function run(c, v) {
+            return new c(v).value;
+        }
+        var o_p = class Foo {
+            constructor(value) {
+                this.value = 10 * value;
+            }
+        };
+        console.log(o_p.name, true, run(o_p, 1), run(o_p, 2));
+    }
+    node_version: ">=6"
+    expect_stdout: "Foo true 10 20"
+}
+
+hoist_class_with_new: {
+    options = {
+        comparisons: true,
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        keep_classnames: true,
+        keep_fnames: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            p: class Foo {
+                constructor(value) {
+                    this.value = value * 10;
+                }
+            },
+            x: 1,
+            y: 2,
+        };
+        console.log(o.p.name, o.p === o.p, new o.p(o.x).value, new o.p(o.y).value);
+    }
+    expect: {
+        var o_p = class Foo {
+            constructor(value) {
+                this.value = 10 * value;
+            }
+        };
+        console.log(o_p.name, true, new o_p(1).value, new o_p(2).value);
+    }
+    node_version: ">=6"
+    expect_stdout: "Foo true 10 20"
+}
+
+hoist_function_with_call: {
+    options = {
+        comparisons: true,
+        evaluate: true,
+        hoist_props: true,
+        inline: true,
+        keep_fnames: true,
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            p: function Foo(value) {
+                return 10 * value;
+            },
+            x: 1,
+            y: 2
+        };
+        console.log(o.p.name, o.p === o.p, o.p(o.x), o.p(o.y));
+    }
+    expect: {
+        var o = {
+            p: function Foo(value) {
+                return 10 * value;
+            },
+            x: 1,
+            y: 2
+        };
+        console.log(o.p.name, o.p == o.p, o.p(o.x), o.p(o.y));
+    }
+    expect_stdout: "Foo true 10 20"
+}
+
 new_this: {
     options = {
         evaluate: true,
@@ -412,6 +530,26 @@ new_this: {
     expect_stdout: "1 2"
 }
 
+issue_2462: {
+    options = {
+        hoist_props: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+    }
+    input: {
+        export const Foo = {
+            a: 1,
+            b: () => 2
+        };
+    }
+    expect: {
+        export const Foo = {
+            a: 1,
+            b: () => 2
+        };
+    }
+}
+
 issue_2473_1: {
     options = {
         hoist_props: false,
@@ -634,6 +772,31 @@ issue_2508_5: {
     expect_stdout: true
 }
 
+issue_2508_6: {
+    options = {
+        collapse_vars: true,
+        hoist_props: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            f: x => {
+                console.log(x);
+            }
+        };
+        o.f(o.f);
+    }
+    expect: {
+        var o_f = x => {
+            console.log(x);
+        };
+        o_f(o_f);
+    }
+    expect_stdout: true
+}
+
 issue_2519: {
     options = {
         collapse_vars: true,

test/compress/html_comments.js

@@ -53,3 +53,12 @@ html_comment_in_string_literal: {
     }
     expect_exact: 'function f(){return"\\x3c!--HTML--\\x3ecomment in\\x3c!--string literal--\\x3e"}';
 }
+
+html_comment_after_multiline_comment: {
+    input: {
+        var foo; /*
+*/-->   var bar;
+        var foobar;
+    }
+    expect_exact: "var foo;var foobar;"
+}

test/compress/if_return.js

@@ -326,3 +326,61 @@ issue_512: {
         }
     }
 }
+
+issue_1317: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect: {
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect_stdout: "1"
+    node_version: ">=6"
+}
+
+issue_1317_strict: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect: {
+        "use strict";
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect_stdout: "1"
+    node_version: ">=4"
+}

test/compress/issue-1001.js

@@ -0,0 +1,8 @@
+parenthesis_strings_in_parenthesis: {
+    input: {
+        var foo = ('(');
+        a(')');
+
+    }
+    expect_exact: 'var foo="(";a(")");'
+}

test/compress/issue-1034.js

@@ -2,7 +2,7 @@ non_hoisted_function_after_return: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true
+        if_return: true, join_vars: true, side_effects: true
     }
     input: {
         function foo(x) {
@@ -38,7 +38,7 @@ non_hoisted_function_after_return_2a: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        if_return: true, join_vars: true, side_effects: true,
         collapse_vars: false, passes: 2, warnings: "verbose"
     }
     input: {
@@ -85,7 +85,7 @@ non_hoisted_function_after_return_2b: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        if_return: true, join_vars: true, side_effects: true,
         collapse_vars: false
     }
     input: {
@@ -123,7 +123,7 @@ non_hoisted_function_after_return_strict: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true
+        if_return: true, join_vars: true, side_effects: true
     }
     input: {
         "use strict";
@@ -164,7 +164,7 @@ non_hoisted_function_after_return_2a_strict: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        if_return: true, join_vars: true, side_effects: true,
         collapse_vars: false, passes: 2, warnings: "verbose"
     }
     input: {
@@ -216,7 +216,7 @@ non_hoisted_function_after_return_2b_strict: {
     options = {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        if_return: true, join_vars: true, side_effects: true,
         collapse_vars: false
     }
     input: {

test/compress/issue-1041.js

@@ -1,3 +1,16 @@
+const_declaration: {
+    options = {
+        evaluate: true
+    };
+
+    input: {
+        const goog = goog || {};
+    }
+    expect: {
+        const goog = goog || {};
+    }
+}
+
 const_pragma: {
     options = {
         evaluate: true,

test/compress/issue-1043.js

@@ -0,0 +1,30 @@
+issue_1043: {
+    options = {
+        side_effects: true
+    };
+
+    input: {
+        function* range(start = 0, end = null, step = 1) {
+            if (end == null) {
+                end = start;
+                start = 0;
+            }
+
+            for (let i = start; i < end; i += step) {
+                yield i;
+            }
+        }
+    }
+
+    expect: {
+        function* range(start = 0, end = null, step = 1) {
+            if (null == end) {
+                end = start;
+                start = 0;
+            }
+
+            for (let i = start; i < end; i += step)
+                yield i;
+        }
+    }
+}

test/compress/issue-1044.js

@@ -0,0 +1,9 @@
+issue_1044: {
+    options = { evaluate: true, conditionals: true };
+    input: {
+        const mixed = Base ? class extends Base {} : class {}
+    }
+    expect: {
+        const mixed = Base ? class extends Base {} : class {}
+    }
+}

test/compress/issue-1052.js

@@ -134,9 +134,8 @@ defun_hoist_funs: {
     expect: {
         function e() {
             function f() {}
-            function g() {}
             function h() {}
-            if (window);
+            if (window) function g() {}
         }
     }
 }

test/compress/issue-1105.js

@@ -190,7 +190,6 @@ assorted_Infinity_NaN_undefined_in_with_scope: {
         keep_fargs:    true,
         if_return:     true,
         join_vars:     true,
-        cascade:       true,
         side_effects:  true,
         sequences:     false,
         keep_infinity: false,
@@ -253,7 +252,6 @@ assorted_Infinity_NaN_undefined_in_with_scope_keep_infinity: {
         keep_fargs:    true,
         if_return:     true,
         join_vars:     true,
-        cascade:       true,
         side_effects:  true,
         sequences:     false,
         keep_infinity: true,

test/compress/issue-1212.js

@@ -0,0 +1,76 @@
+issue_1212_debug_false: {
+    options = {
+        global_defs   : { DEBUG: false },
+        sequences     : true,
+        properties    : true,
+        dead_code     : true,
+        conditionals  : true,
+        comparisons   : true,
+        evaluate      : true,
+        booleans      : true,
+        loops         : true,
+        unused        : true,
+        hoist_funs    : true,
+        keep_fargs    : true,
+        if_return     : true,
+        join_vars     : true,
+        collapse_vars : true,
+        side_effects  : true,
+    }
+    input: {
+        class foo {
+            bar() {
+                if (DEBUG)
+                    console.log("DEV");
+                else
+                    console.log("PROD");
+            }
+        }
+        new foo().bar();
+    }
+    expect: {
+        class foo{
+            bar() { console.log("PROD") }
+        }
+        (new foo).bar();
+    }
+}
+
+issue_1212_debug_true: {
+    options = {
+        global_defs   : { DEBUG: true },
+        sequences     : true,
+        properties    : true,
+        dead_code     : true,
+        conditionals  : true,
+        comparisons   : true,
+        evaluate      : true,
+        booleans      : true,
+        loops         : true,
+        unused        : true,
+        hoist_funs    : true,
+        keep_fargs    : true,
+        if_return     : true,
+        join_vars     : true,
+        collapse_vars : true,
+        side_effects  : true,
+    }
+    input: {
+        class foo {
+            bar() {
+                if (DEBUG)
+                    console.log("DEV");
+                else
+                    console.log("PROD");
+            }
+        }
+        new foo().bar();
+    }
+    expect: {
+        class foo{
+            bar() { console.log("DEV") }
+        }
+        (new foo).bar();
+    }
+}
+

test/compress/issue-1261.js

@@ -8,7 +8,6 @@ pure_function_calls: {
         unused       : true,
         if_return    : true,
         join_vars    : true,
-        cascade      : true,
         negate_iife  : true,
     }
     input: {
@@ -49,13 +48,13 @@ pure_function_calls: {
         a.b(), f.g();
     }
     expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:17,8]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:17,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:30,37]",
-        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:30,16]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:28,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:38,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:39,31]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:16,8]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:16,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:29,37]",
+        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:29,16]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:27,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:37,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:38,31]",
     ]
 }
 
@@ -69,7 +68,6 @@ pure_function_calls_toplevel: {
         unused       : true,
         if_return    : true,
         join_vars    : true,
-        cascade      : true,
         negate_iife  : true,
         toplevel     : true,
     }
@@ -112,17 +110,17 @@ pure_function_calls_toplevel: {
         a.b(), f.g();
     }
     expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:79,8]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:79,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:92,37]",
-        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:92,16]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:90,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:107,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:108,31]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:84,33]",
-        "WARN: Dropping unused variable iife1 [test/compress/issue-1261.js:84,12]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:100,45]",
-        "WARN: Dropping unused variable MyClass [test/compress/issue-1261.js:100,12]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:77,8]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:77,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:90,37]",
+        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:90,16]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:88,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:105,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:106,31]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:82,33]",
+        "WARN: Dropping unused variable iife1 [test/compress/issue-1261.js:82,12]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:98,45]",
+        "WARN: Dropping unused variable MyClass [test/compress/issue-1261.js:98,12]",
     ]
 }
 
@@ -157,29 +155,29 @@ should_warn: {
         baz();
     }
     expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:137,61]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:137,23]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:137,23]",
-        "WARN: Boolean || always true [test/compress/issue-1261.js:138,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:135,61]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:135,23]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:135,23]",
+        "WARN: Boolean || always true [test/compress/issue-1261.js:136,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:136,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:136,23]",
+        "WARN: Condition left of || always true [test/compress/issue-1261.js:137,8]",
+        "WARN: Condition always true [test/compress/issue-1261.js:137,8]",
+        "WARN: Boolean && always false [test/compress/issue-1261.js:138,23]",
         "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:138,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:138,23]",
-        "WARN: Condition left of || always true [test/compress/issue-1261.js:139,8]",
-        "WARN: Condition always true [test/compress/issue-1261.js:139,8]",
-        "WARN: Boolean && always false [test/compress/issue-1261.js:140,23]",
+        "WARN: Condition always false [test/compress/issue-1261.js:138,23]",
+        "WARN: Condition left of && always false [test/compress/issue-1261.js:139,8]",
+        "WARN: Condition always false [test/compress/issue-1261.js:139,8]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:140,23]",
         "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:140,23]",
-        "WARN: Condition always false [test/compress/issue-1261.js:140,23]",
-        "WARN: Condition left of && always false [test/compress/issue-1261.js:141,8]",
-        "WARN: Condition always false [test/compress/issue-1261.js:141,8]",
-        "WARN: + in boolean context always true [test/compress/issue-1261.js:142,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:140,23]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:141,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:141,31]",
+        "WARN: Condition always true [test/compress/issue-1261.js:141,8]",
         "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:142,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:142,23]",
-        "WARN: + in boolean context always true [test/compress/issue-1261.js:143,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:143,31]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:143,24]",
         "WARN: Condition always true [test/compress/issue-1261.js:143,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:144,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:145,24]",
-        "WARN: Condition always true [test/compress/issue-1261.js:145,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:146,31]",
-        "WARN: Condition always false [test/compress/issue-1261.js:146,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:144,31]",
+        "WARN: Condition always false [test/compress/issue-1261.js:144,8]",
     ]
 }

test/compress/issue-1275.js

@@ -9,7 +9,6 @@ string_plus_optimization: {
         unused        : true,
         if_return     : true,
         join_vars     : true,
-        cascade       : true,
         hoist_funs    : true,
     };
     input: {

test/compress/issue-1447.js

@@ -32,7 +32,6 @@ conditional_false_stray_else_in_loop: {
         hoist_vars   : true,
         join_vars    : true,
         if_return    : true,
-        cascade      : true,
         conditionals : false,
     }
     input: {

test/compress/issue-1466.js

@@ -0,0 +1,284 @@
+same_variable_in_multiple_for_loop: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: true,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        for (let i = 0; i < 3; i++) {
+            let a = 100;
+            console.log(i, a);
+            for (let i = 0; i < 2; i++) {
+                console.log(i, a);
+                let c = 2;
+                console.log(c);
+            }
+        }
+    }
+    expect: {
+        for (let o = 0; o < 3; o++) {
+            let l = 100;
+            console.log(o, l);
+            for (let o = 0; o < 2; o++) {
+                console.log(o, l);
+                let e = 2;
+                console.log(e);
+            }
+        }
+    }
+    expect_stdout: true
+}
+
+same_variable_in_multiple_forOf: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: true,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (let tmp of test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (let tmp of dd) {
+                console.log(tmp);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (let o of test) {
+            console.log(o);
+            let e;
+            e = [ "e", "f", "g" ];
+            for (let o of e)
+                console.log(o);
+        }
+    }
+    expect_stdout: true
+}
+
+same_variable_in_multiple_forIn: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: false,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (let tmp in test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (let tmp in test) {
+                console.log(tmp);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (let e in test) {
+            console.log(e);
+            let t;
+            t = [ "e", "f", "g" ];
+            for (let e in test)
+                console.log(e);
+        }
+    }
+    expect_stdout: true
+}
+
+different_variable_in_multiple_for_loop: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: true,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        for (let i = 0; i < 3; i++) {
+            let a = 100;
+            console.log(i, a);
+            for (let j = 0; j < 2; j++) {
+                console.log(j, a);
+                let c = 2;
+                console.log(c);
+            }
+        }
+    }
+    expect: {
+        for (let o = 0; o < 3; o++) {
+            let l = 100;
+            console.log(o, l);
+            for (let o = 0; o < 2; o++) {
+                console.log(o, l);
+                let e = 2;
+                console.log(e);
+            }
+        }
+    }
+    expect_stdout: true
+}
+
+different_variable_in_multiple_forOf: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: true,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (let tmp of test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (let t of dd) {
+                console.log(t);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (let o of test) {
+            console.log(o);
+            let e;
+            e = [ "e", "f", "g" ];
+            for (let o of e)
+                console.log(o);
+        }
+    }
+    expect_stdout: true
+}
+
+different_variable_in_multiple_forIn: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: false,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        var test = [ "a", "b", "c" ];
+        for (let tmp in test) {
+            console.log(tmp);
+            let dd;
+            dd = [ "e", "f", "g" ];
+            for (let t in test) {
+                console.log(t);
+            }
+        }
+    }
+    expect: {
+        var test = [ "a", "b", "c" ];
+        for (let e in test) {
+            console.log(e);
+            let t;
+            t = [ "e", "f", "g" ];
+            for (let e in test)
+                console.log(e);
+        }
+    }
+    expect_stdout: true
+}
+
+more_variable_in_multiple_for: {
+    options = {
+        hoist_funs: true,
+        dead_code: true,
+        conditionals: true,
+        comparisons: true,
+        evaluate: true,
+        booleans: true,
+        loops: true,
+        unused: false,
+        keep_fargs: true,
+        if_return: true,
+        join_vars: true,
+        side_effects: true,
+        collapse_vars: true,
+    }
+    mangle = {}
+    input: {
+        for (let a = 9, i = 0; i < 20; i += a) {
+            let b = a++ + i;
+            console.log(a, b, i);
+            for (let k = b, m = b*b, i = 0; i < 10; i++) {
+                console.log(a, b, m, k, i);
+            }
+        }
+    }
+    expect: {
+        for (let o = 9, l = 0; l < 20; l += o) {
+            let e = o++ + l;
+            console.log(o, e, l);
+            for (let l = e, t = e * e, c = 0; c < 10; c++)
+                console.log(o, e, t, l, c);
+        }
+    }
+    expect_stdout: true
+}

test/compress/issue-1588.js

@@ -85,3 +85,15 @@ unsafe_undefined: {
     }
     expect_stdout: true
 }
+
+runtime_error: {
+    input: {
+        const a = 1;
+        console.log(a++);
+    }
+    expect: {
+        const a = 1;
+        console.log(a++);
+    }
+    expect_stdout: true
+}

test/compress/issue-1639.js

@@ -2,7 +2,7 @@
 issue_1639_1: {
     options = {
         booleans: true,
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         evaluate: true,
         join_vars: true,
@@ -35,7 +35,7 @@ issue_1639_1: {
 issue_1639_2: {
     options = {
         booleans: true,
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         evaluate: true,
         join_vars: true,
@@ -68,7 +68,7 @@ issue_1639_2: {
 issue_1639_3: {
     options = {
         booleans: true,
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         evaluate: true,
         sequences: true,

test/compress/issue-1656.js

@@ -1,7 +1,6 @@
 f7: {
     options = {
         booleans: true,
-        cascade: true,
         collapse_vars: true,
         comparisons: true,
         conditionals: true,

test/compress/issue-1770.js

@@ -107,139 +107,3 @@ numeric_literal: {
         "8 7 8",
     ]
 }
-
-identifier: {
-    mangle = {
-        properties: true,
-    }
-    input: {
-        var obj = {
-            abstract: 1,
-            boolean: 2,
-            byte: 3,
-            char: 4,
-            class: 5,
-            double: 6,
-            enum: 7,
-            export: 8,
-            extends: 9,
-            final: 10,
-            float: 11,
-            goto: 12,
-            implements: 13,
-            import: 14,
-            int: 15,
-            interface: 16,
-            let: 17,
-            long: 18,
-            native: 19,
-            package: 20,
-            private: 21,
-            protected: 22,
-            public: 23,
-            short: 24,
-            static: 25,
-            super: 26,
-            synchronized: 27,
-            this: 28,
-            throws: 29,
-            transient: 30,
-            volatile: 31,
-            yield: 32,
-            false: 33,
-            null: 34,
-            true: 35,
-            break: 36,
-            case: 37,
-            catch: 38,
-            const: 39,
-            continue: 40,
-            debugger: 41,
-            default: 42,
-            delete: 43,
-            do: 44,
-            else: 45,
-            finally: 46,
-            for: 47,
-            function: 48,
-            if: 49,
-            in: 50,
-            instanceof: 51,
-            new: 52,
-            return: 53,
-            switch: 54,
-            throw: 55,
-            try: 56,
-            typeof: 57,
-            var: 58,
-            void: 59,
-            while: 60,
-            with: 61,
-        };
-    }
-    expect: {
-        var obj = {
-            e: 1,
-            t: 2,
-            n: 3,
-            a: 4,
-            i: 5,
-            o: 6,
-            r: 7,
-            l: 8,
-            s: 9,
-            c: 10,
-            f: 11,
-            u: 12,
-            d: 13,
-            h: 14,
-            p: 15,
-            b: 16,
-            v: 17,
-            w: 18,
-            y: 19,
-            g: 20,
-            m: 21,
-            k: 22,
-            x: 23,
-            j: 24,
-            z: 25,
-            q: 26,
-            A: 27,
-            B: 28,
-            C: 29,
-            D: 30,
-            F: 31,
-            G: 32,
-            false: 33,
-            null: 34,
-            true: 35,
-            H: 36,
-            I: 37,
-            J: 38,
-            K: 39,
-            L: 40,
-            M: 41,
-            N: 42,
-            O: 43,
-            P: 44,
-            Q: 45,
-            R: 46,
-            S: 47,
-            T: 48,
-            U: 49,
-            V: 50,
-            W: 51,
-            X: 52,
-            Y: 53,
-            Z: 54,
-            $: 55,
-            _: 56,
-            ee: 57,
-            te: 58,
-            ne: 59,
-            ae: 60,
-            ie: 61,
-        };
-    }
-}

test/compress/issue-2001.js

@@ -0,0 +1,283 @@
+export_func_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f(){};
+    }
+    expect_exact: "export function f(){};"
+}
+
+export_func_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f(){}(1);
+    }
+    expect_exact: "export function f(){};1;"
+}
+
+export_func_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f(){}(1);
+    }
+    expect_exact: "export function f(){};"
+}
+
+export_default_func_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){};
+    }
+    expect_exact: "export default function f(){};"
+}
+
+export_default_func_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){}(1);
+    }
+    expect_exact: "export default function f(){};1;"
+}
+
+export_default_func_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){}(1);
+    }
+    expect_exact: "export default function f(){};"
+}
+
+export_class_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export class C {};
+    }
+    expect_exact: "export class C{};"
+}
+
+export_class_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export class C {}(1);
+    }
+    expect_exact: "export class C{};1;"
+}
+
+export_class_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export class C {}(1);
+    }
+    expect_exact: "export class C{};"
+}
+
+export_default_class_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class C {};
+    }
+    expect_exact: "export default class C{};"
+}
+
+export_default_class_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class C {}(1);
+    }
+    expect_exact: "export default class C{};1;"
+}
+
+export_default_class_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class C {}(1);
+    }
+    expect_exact: "export default class C{};"
+}
+
+export_mangle_1: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export function foo(one, two) {
+            return one - two;
+        };
+    }
+    expect_exact: "export function foo(o,n){return o-n};"
+}
+
+export_mangle_2: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function foo(one, two) {
+            return one - two;
+        };
+    }
+    expect_exact: "export default function foo(o,t){return o-t};"
+}
+
+export_mangle_3: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export class C {
+            go(one, two) {
+                var z = one;
+                return one - two + z;
+            }
+        };
+    }
+    expect_exact: "export class C{go(r,e){return r-e+r}};"
+}
+
+export_mangle_4: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default class C {
+            go(one, two) {
+                var z = one;
+                return one - two + z;
+            }
+        };
+    }
+    expect_exact: "export default class C{go(e,r){return e-r+e}};"
+}
+
+export_mangle_5: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default {
+            prop: function(one, two) {
+                return one - two;
+            }
+        };
+    }
+    expect_exact: "export default{prop:function(r,t){return r-t}};"
+}
+
+export_mangle_6: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var baz = 2;
+        export let foo = 1, bar = baz;
+    }
+    expect_exact: "var o=2;export let foo=1,bar=o;"
+}
+
+export_toplevel_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(){}
+        export function g(){};
+        export default function h(){};
+    }
+    expect: {
+        export function g(){};
+        export default function h(){};
+    }
+}
+
+export_toplevel_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        class A {}
+        export class B {};
+        export default class C {};
+    }
+    expect: {
+        export class B {};
+        export default class C {};
+    }
+}
+
+export_default_func_ref: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){};
+        f();
+    }
+    expect_exact: "export default function f(){};f();"
+}

test/compress/issue-203.js

@@ -0,0 +1,57 @@
+
+compress_new_function: {
+    options = {
+        unsafe: true,
+        unsafe_Func: true,
+    }
+    input: {
+        new Function("aa, bb", 'return aa;');
+    }
+    expect: {
+        Function("n,r", "return n");
+    }
+}
+
+compress_new_function_with_destruct: {
+    options = {
+        unsafe: true,
+        unsafe_Func: true,
+        ecma: 6
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        new Function("aa, [bb]", 'return aa;');
+        new Function("aa, {bb}", 'return aa;');
+        new Function("[[aa]], [{bb}]", 'return aa;');
+    }
+    expect: {
+        Function("n,[r]", "return n");
+        Function("n,{bb:b}", "return n");
+        Function("[[n]],[{bb:b}]", "return n");
+    }
+}
+
+compress_new_function_with_destruct_arrows: {
+    options = {
+        arrows: true,
+        unsafe_arrows: true,
+        unsafe: true,
+        unsafe_Func: true,
+        ecma: 6,
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        new Function("aa, [bb]", 'return aa;');
+        new Function("aa, {bb}", 'return aa;');
+        new Function("[[aa]], [{bb}]", 'return aa;');
+    }
+    expect: {
+        Function("n,[a]", "return n");
+        Function("b,{bb:n}", "return b");
+        Function("[[b]],[{bb:n}]", "return b");
+    }
+}

test/compress/issue-208.js

@@ -38,7 +38,7 @@ mixed: {
         }
     }
     input: {
-        var ENV = 3;
+        const ENV = 3;
         var FOO = 4;
         f(ENV * 10);
         --FOO;
@@ -49,7 +49,7 @@ mixed: {
         x = DEBUG;
     }
     expect: {
-        var ENV = 3;
+        const ENV = 3;
         var FOO = 4;
         f(10);
         --FOO;
@@ -60,7 +60,7 @@ mixed: {
         x = 0;
     }
     expect_warnings: [
-        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,12]',
+        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,14]',
         'WARN: global_defs FOO redefined [test/compress/issue-208.js:42,12]',
         'WARN: global_defs FOO redefined [test/compress/issue-208.js:44,10]',
         'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:45,8]',

test/compress/issue-2652.js

@@ -0,0 +1,33 @@
+insert_semicolon: {
+    beautify = {
+        beautify: true,
+        comments: "all",
+    }
+    input: {
+        var a
+        /* foo */ var b
+    }
+    expect_exact: [
+        "var a",
+        "/* foo */;",
+        "",
+        "var b;",
+    ]
+}
+
+unary_postfix: {
+    beautify = {
+        beautify: true,
+        comments: "all",
+    }
+    input: {
+        a
+        /* foo */++b
+    }
+    expect_exact: [
+        "a",
+        "/* foo */;",
+        "",
+        "++b;",
+    ]
+}

test/compress/issue-281.js

@@ -453,7 +453,7 @@ pure_annotation_2: {
 
 drop_fargs: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         inline: true,
         keep_fargs: false,
         side_effects: true,
@@ -476,7 +476,7 @@ drop_fargs: {
 
 keep_fargs: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         inline: true,
         keep_fargs: true,
         side_effects: true,

test/compress/issue-368.js

@@ -1,6 +1,6 @@
 collapse: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         sequences: true,
         side_effects: true,
         unused: true,
@@ -41,7 +41,7 @@ collapse: {
             return void 0 !== ('function' === typeof b ? b() : b) && c();
         }
         function f2(b) {
-            return b = c(), 'stirng' == typeof ('function' === typeof b ? b() : b) && d();
+            return 'stirng' == typeof ('function' === typeof (b = c()) ? b() : b) && d();
         }
         function f3(c) {
             var a;

test/compress/issue-892.js

@@ -18,7 +18,6 @@ dont_mangle_arguments: {
         hoist_vars    : true,
         if_return     : true,
         join_vars     : true,
-        cascade       : true,
         side_effects  : true,
         negate_iife   : false
     };

test/compress/issue-926.js

@@ -0,0 +1,9 @@
+template_strings: {
+    input: {
+        foo(
+            `<span>${contents}</span>`,
+            `<a href="${url}">${text}</a>`
+        );
+    }
+    expect_exact: "foo(`<span>${contents}</span>`,`<a href=\"${url}\">${text}</a>`);"
+}

test/compress/issue-976.js

@@ -2,7 +2,7 @@ eval_collapse_vars: {
     options = {
         collapse_vars:true, sequences:false, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
     };
     input: {
         function f1() {

test/compress/issue-979.js

@@ -2,7 +2,7 @@ issue979_reported: {
     options = {
         sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
     }
     input: {
         function f1() {
@@ -32,7 +32,7 @@ issue979_test_negated_is_best: {
     options = {
         sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+        keep_fargs:true, if_return:true, join_vars:true, side_effects:true
     }
     input: {
         function f3() {

test/compress/join-vars.js

@@ -0,0 +1,40 @@
+only_vars: {
+    options = { join_vars: true };
+    input: {
+        let netmaskBinary = '';
+        for (let i = 0; i < netmaskBits; ++i) {
+            netmaskBinary += '1';
+        }
+    }
+    expect: {
+        let netmaskBinary = '';
+        for (let i = 0; i < netmaskBits; ++i) netmaskBinary += '1';
+    }
+}
+
+issue_1079_with_vars: {
+    options = { join_vars: true };
+    input: {
+        var netmaskBinary = '';
+        for (var i = 0; i < netmaskBits; ++i) {
+            netmaskBinary += '1';
+        }
+    }
+    expect: {
+        for (var netmaskBinary = '', i = 0; i < netmaskBits; ++i) netmaskBinary += '1';
+    }
+}
+
+issue_1079_with_mixed: {
+    options = { join_vars: true };
+    input: {
+        var netmaskBinary = '';
+        for (let i = 0; i < netmaskBits; ++i) {
+            netmaskBinary += '1';
+        }
+    }
+    expect: {
+        var netmaskBinary = ''
+        for (let i = 0; i < netmaskBits; ++i) netmaskBinary += '1';
+    }
+}

test/compress/loops.js

@@ -146,6 +146,50 @@ parse_do_while_without_semicolon: {
     }
 }
 
+
+keep_collapse_const_in_own_block_scope: {
+    options = {
+        join_vars: true,
+        loops: true
+    }
+    input: {
+        var i=2;
+        const c=5;
+        while(i--)
+            console.log(i);
+        console.log(c);
+    }
+    expect: {
+        var i=2;
+        const c=5;
+        for(;i--;)
+            console.log(i);
+        console.log(c);
+    }
+    expect_stdout: true
+}
+
+keep_collapse_const_in_own_block_scope_2: {
+    options = {
+        join_vars: true,
+        loops: true
+    }
+    input: {
+        const c=5;
+        var i=2; // Moves to loop, while it did not in previous test
+        while(i--)
+            console.log(i);
+        console.log(c);
+    }
+    expect: {
+        const c=5;
+        for(var i=2;i--;)
+            console.log(i);
+        console.log(c);
+    }
+    expect_stdout: true
+}
+
 evaluate: {
     options = {
         dead_code: true,

test/compress/new.js

@@ -83,6 +83,22 @@ new_with_unary_prefix: {
     expect_exact: 'var bar=(+new Date).toString(32);';
 }
 
+new_with_assignement_expression: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var a;
+        new x(a = 5 * 2, b = [1, 2, 3], c = {a: "a", b: "b", cd: "c" + "d"});
+        new y([a, b] = [3, 4]);
+    }
+    expect: {
+        var a;
+        new x(a = 10, b = [1, 2, 3], c = {a: "a", b: "b", cd: "cd"});
+        new y([a, b] = [3, 4]);
+    }
+}
+
 dot_parenthesis_1: {
     input: {
         console.log(new (Math.random().constructor) instanceof Number);

test/compress/parameters.js

@@ -0,0 +1,186 @@
+arrow_functions: {
+    options = {
+        arrows: true,
+    }
+    input: {
+        (a) => b;  // 1 args
+        (a, b) => c;  // n args
+        () => b;  // 0 args
+        (a) => (b) => c;  // func returns func returns func
+        (a) => ((b) => c);  // So these parens are dropped
+        () => (b,c) => d;  // func returns func returns func
+        a=>{return b;}
+        a => 'lel';  // Dropping the parens
+    }
+    expect_exact: "a=>b;(a,b)=>c;()=>b;a=>b=>c;a=>b=>c;()=>(b,c)=>d;a=>b;a=>\"lel\";"
+}
+
+arrow_return: {
+    options = {
+        arrows: true,
+    }
+    input: {
+        () => {};
+        () => { return; };
+        a => { return 1; }
+        a => { return -b }
+        a => { return b; var b; }
+        (x, y) => { return x - y; }
+    }
+    expect_exact: "()=>{};()=>{};a=>1;a=>-b;a=>{return b;var b};(x,y)=>x-y;"
+}
+
+regression_arrow_functions_and_hoist: {
+    options = {
+        hoist_vars: true,
+        hoist_funs: true
+    }
+    input: {
+        (a) => b;
+    }
+    expect_exact: "a=>b;"
+}
+
+regression_assign_arrow_functions: {
+    input: {
+        oninstall = e => false;
+        oninstall = () => false;
+    }
+    expect: {
+        oninstall=e=>false;
+        oninstall=()=>false;
+    }
+}
+
+destructuring_arguments_1: {
+    input: {
+        (function ( a ) { });
+        (function ( [ a ] ) { });
+        (function ( [ a, b ] ) { });
+        (function ( [ [ a ] ] ) { });
+        (function ( [ [ a, b ] ] ) { });
+        (function ( [ a, [ b ] ] ) { });
+        (function ( [ [ b ], a ] ) { });
+
+        (function ( { a } ) { });
+        (function ( { a, b } ) { });
+
+        (function ( [ { a } ] ) { });
+        (function ( [ { a, b } ] ) { });
+        (function ( [ a, { b } ] ) { });
+        (function ( [ { b }, a ] ) { });
+
+        ( [ a ] ) => { };
+        ( [ a, b ] ) => { };
+
+        ( { a } ) => { };
+        ( { a, b, c, d, e } ) => { };
+
+        ( [ a ] ) => b;
+        ( [ a, b ] ) => c;
+
+        ( { a } ) => b;
+        ( { a, b } ) => c;
+    }
+    expect: {
+        (function(a){});
+        (function([a]){});
+        (function([a,b]){});
+        (function([[a]]){});
+        (function([[a,b]]){});
+        (function([a,[b]]){});
+        (function([[b],a]){});
+
+        (function({a}){});
+        (function({a,b}){});
+
+        (function([{a}]){});
+        (function([{a,b}]){});
+        (function([a,{b}]){});
+        (function([{b},a]){});
+
+        ([a])=>{};
+        ([a,b])=>{};
+
+        ({a})=>{};
+        ({a,b,c,d,e})=>{};
+
+        ([a])=>b;
+        ([a,b])=>c;
+
+        ({a})=>b;
+        ({a,b})=>c;
+    }
+}
+
+destructuring_arguments_2: {
+    input: {
+        (function([]) {});
+        (function({}) {});
+        (function([,,,,,]) {});
+        (function ([a, {b: c}]) {});
+        (function ([...args]) {});
+        (function ({x,}) {});
+        class a { *method({ [thrower()]: x } = {}) {}};
+        (function(a, b, c, d, [{e: [...f]}]){})(1, 2, 3, 4, [{e: [1, 2, 3]}]);
+    }
+    expect: {
+        (function([]) {});
+        (function({}) {});
+        (function([,,,,,]) {});
+        (function ([a, {b: c}]) {});
+        (function ([...args]) {});
+        (function ({x,}) {});
+        class a { *method({ [thrower()]: x } = {}) {}};
+        (function(a, b, c, d, [{e: [...f]}]){})(1, 2, 3, 4, [{e: [1, 2, 3]}]);
+    }
+}
+
+destructuring_arguments_3: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        function fn3({x: {y: {z: {} = 42}}}) {}
+        const { a = (function () {}), b = (0, function() {})  } = {};
+        let { c = (function () {}), d = (0, function() {})  } = {};
+        var { e = (function () {}), f = (0, function() {})  } = {};
+    }
+    expect_exact: "function fn3({x:{y:{z:{}=42}}}){}const{a=function(){},b=(0,function(){})}={};let{c=function(){},d=(0,function(){})}={};var{e=function(){},f=(0,function(){})}={};"
+}
+
+default_arguments: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        function x(a = 6) { }
+        function x(a = (6 + 5)) { }
+        function x({ foo } = {}, [ bar ] = [ 1 ]) { }
+    }
+    expect_exact: "function x(a=6){}function x(a=6+5){}function x({foo}={},[bar]=[1]){}"
+}
+
+default_values_in_destructurings: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        function x({a=(4), b}) {}
+        function x([b, c=(12)]) {}
+        var { x = (6), y } = x;
+        var [ x, y = (6) ] = x;
+    }
+    expect_exact: "function x({a=4,b}){}function x([b,c=12]){}var{x=6,y}=x;var[x,y=6]=x;"
+}
+
+accept_duplicated_parameters_in_non_strict_without_spread_or_default_assignment: {
+    input: {
+        function a(b, b){}
+        function b({c: test, c: test}){}
+    }
+    expect: {
+        function a(b, b){}
+        function b({c: test, c: test}){}
+    }
+}

test/compress/properties.js

@@ -159,6 +159,7 @@ mangle_unquoted_properties: {
     }
     mangle = {
         properties: {
+            builtins: true,
             keep_quoted: true,
         },
     }
@@ -258,6 +259,7 @@ mangle_debug_suffix_keep_quoted: {
     }
     mangle = {
         properties: {
+            builtins: true,
             debug: "XYZ",
             keep_quoted: true,
             reserved: [],
@@ -792,6 +794,172 @@ issue_2208_5: {
     expect_stdout: "42"
 }
 
+issue_2208_6: {
+    options = {
+        inline: true,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log({
+            p: () => 42
+        }.p());
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+issue_2208_7: {
+    options = {
+        ecma: 6,
+        inline: true,
+        properties: true,
+        side_effects: true,
+        unsafe_arrows: true,
+    }
+    input: {
+        console.log({
+            p() {
+                return 42;
+            }
+        }.p());
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+issue_2208_8: {
+    options = {
+        ecma: 6,
+        inline: true,
+        properties: true,
+        side_effects: true,
+        unsafe_arrows: true,
+    }
+    input: {
+        console.log({
+            *p() {
+                return x();
+            }
+        }.p());
+        console.log({
+            async p() {
+                return await x();
+            }
+        }.p());
+    }
+    expect: {
+        console.log({
+            *p() {
+                return x();
+            }
+        }.p());
+        console.log((async () => {
+            return await x();
+        })());
+    }
+}
+
+issue_2208_9: {
+    options = {
+        inline: true,
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        a = 42;
+        console.log({
+            p: () => {
+                return function() {
+                    return this.a;
+                }();
+            }
+        }.p());
+    }
+    expect: {
+        a = 42;
+        console.log(function() {
+            return this.a;
+        }());
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+methods_keep_quoted_true: {
+    options = {
+        arrows: true,
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    mangle = {
+        properties: {
+            keep_quoted: true,
+        },
+    }
+    input: {
+        class C { "Quoted"(){} Unquoted(){} }
+        f1({ "Quoted"(){}, Unquoted(){}, "Prop": 3 });
+        f2({ "Quoted": function(){} });
+        f3({ "Quoted": ()=>{} });
+    }
+    expect_exact: "class C{Quoted(){}o(){}}f1({Quoted(){},o(){},Prop:3});f2({Quoted(){}});f3({Quoted(){}});"
+}
+
+methods_keep_quoted_false: {
+    options = {
+        arrows: true,
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    mangle = {
+        properties: {
+            keep_quoted: false,
+        },
+    }
+    input: {
+        class C { "Quoted"(){} Unquoted(){} }
+        f1({ "Quoted"(){}, Unquoted(){}, "Prop": 3 });
+        f2({ "Quoted": function(){} });
+        f3({ "Quoted": ()=>{} });
+    }
+    expect_exact: "class C{o(){}d(){}}f1({o(){},d(){},e:3});f2({o(){}});f3({o(){}});"
+}
+
+methods_keep_quoted_from_dead_code: {
+    options = {
+        arrows: true,
+        booleans: true,
+        conditionals: true,
+        dead_code: true,
+        ecma: 6,
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        unsafe_methods: true,
+    }
+    mangle = {
+        properties: {
+            keep_quoted: true,
+        },
+    }
+    input: {
+        class C { Quoted(){} Unquoted(){} }
+        f1({ Quoted(){}, Unquoted(){}, "Prop": 3 });
+        f2({ Quoted: function(){} });
+        f3({ Quoted: ()=>{} });
+        0 && obj["Quoted"];
+    }
+    expect_exact: "class C{Quoted(){}o(){}}f1({Quoted(){},o(){},Prop:3});f2({Quoted(){}});f3({Quoted(){}});"
+}
+
 issue_2256: {
     options = {
         side_effects: true,
@@ -810,6 +978,91 @@ issue_2256: {
     }
 }
 
+issue_2321: {
+    options = {
+        ecma: 6,
+        unsafe_methods: false,
+    }
+    input: {
+        var f = {
+            foo: function(){ console.log("foo") },
+            bar() { console.log("bar") }
+        };
+        var foo = new f.foo();
+        var bar =     f.bar();
+    }
+    expect: {
+        var f = {
+            foo: function() {
+                console.log("foo");
+            },
+            bar() {
+                console.log("bar");
+            }
+        };
+        var foo = new f.foo();
+        var bar = f.bar();
+    }
+    expect_stdout: [
+        "foo",
+        "bar",
+    ]
+    node_version: ">=6"
+}
+
+unsafe_methods_regex: {
+    options = {
+        ecma: 6,
+        unsafe_methods: /^[A-Z1]/,
+    }
+    input: {
+        var f = {
+            123: function(){ console.log("123") },
+            foo: function(){ console.log("foo") },
+            bar() { console.log("bar") },
+            Baz: function(){ console.log("baz") },
+            BOO: function(){ console.log("boo") },
+            null: function(){ console.log("null") },
+            undefined: function(){ console.log("undefined") },
+        };
+        f[123]();
+        new f.foo();
+        f.bar();
+        f.Baz();
+        f.BOO();
+        new f.null();
+        new f.undefined();
+    }
+    expect: {
+        var f = {
+            123() { console.log("123") },
+            foo: function(){ console.log("foo") },
+            bar() { console.log("bar"); },
+            Baz() { console.log("baz") },
+            BOO() { console.log("boo") },
+            null: function(){ console.log("null") },
+            undefined: function(){ console.log("undefined") },
+        };
+        f[123]();
+        new f.foo();
+        f.bar();
+        f.Baz();
+        f.BOO();
+        new f.null();
+        new f.undefined();
+    }
+    expect_stdout: [
+        "123",
+        "foo",
+        "bar",
+        "baz",
+        "boo",
+        "null",
+        "undefined",
+    ]
+    node_version: ">=6"
+}
+
 lhs_prop_1: {
     options = {
         evaluate: true,
@@ -1010,6 +1263,30 @@ array_hole: {
     expect_stdout: "2 undefined 3"
 }
 
+computed_property: {
+    options = {
+        properties: true,
+        side_effects: true,
+    }
+    input: {
+        console.log({
+            a: "bar",
+            [console.log("foo")]: 42,
+        }.a);
+    }
+    expect: {
+        console.log([
+            "bar",
+            console.log("foo")
+        ][0]);
+    }
+    expect_stdout: [
+        "foo",
+        "bar"
+    ]
+    node_version: ">=4"
+}
+
 new_this: {
     options = {
         properties: true,
@@ -1054,3 +1331,43 @@ issue_2513: {
         "undefined undefined",
     ]
 }
+
+const_prop_assign_strict: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        function Simulator() {
+            /abc/.index = 1;
+            this._aircraft = [];
+        }
+        (function() {}).prototype.destroy = x();
+    }
+    expect: {
+        function Simulator() {
+            this._aircraft = [];
+        }
+        x();
+    }
+}
+
+const_prop_assign_pure: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        function Simulator() {
+            /abc/.index = 1;
+            this._aircraft = [];
+        }
+        (function() {}).prototype.destroy = x();
+    }
+    expect: {
+        function Simulator() {
+            this._aircraft = [];
+        }
+        x();
+    }
+}

test/compress/pure_funcs.js

@@ -293,3 +293,124 @@ unary: {
         bar();
     }
 }
+
+issue_2629_1: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ a();
+        /*@__PURE__*/ (b());
+        (/*@__PURE__*/ c)();
+        (/*@__PURE__*/ d());
+    }
+    expect_exact: [
+        "/* */c();",
+    ]
+}
+
+issue_2629_2: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ a(1)(2)(3);
+        /*@__PURE__*/ (b(1))(2)(3);
+        /*@__PURE__*/ (c(1)(2))(3);
+        /*@__PURE__*/ (d(1)(2)(3));
+        (/*@__PURE__*/ e)(1)(2)(3);
+        (/*@__PURE__*/ f(1))(2)(3);
+        (/*@__PURE__*/ g(1)(2))(3);
+        (/*@__PURE__*/ h(1)(2)(3));
+    }
+    expect_exact: [
+        "/* */e(1)(2)(3);",
+        "/* */f(1)(2)(3);",
+        "/* */g(1)(2)(3);",
+    ]
+}
+
+issue_2629_3: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/ a.x(1).y(2).z(3);
+        /*@__PURE__*/ (b.x)(1).y(2).z(3);
+        /*@__PURE__*/ (c.x(1)).y(2).z(3);
+        /*@__PURE__*/ (d.x(1).y)(2).z(3);
+        /*@__PURE__*/ (e.x(1).y(2)).z(3);
+        /*@__PURE__*/ (f.x(1).y(2).z)(3);
+        /*@__PURE__*/ (g.x(1).y(2).z(3));
+        (/*@__PURE__*/ h).x(1).y(2).z(3);
+        (/*@__PURE__*/ i.x)(1).y(2).z(3);
+        (/*@__PURE__*/ j.x(1)).y(2).z(3);
+        (/*@__PURE__*/ k.x(1).y)(2).z(3);
+        (/*@__PURE__*/ l.x(1).y(2)).z(3);
+        (/*@__PURE__*/ m.x(1).y(2).z)(3);
+        (/*@__PURE__*/ n.x(1).y(2).z(3));
+    }
+    expect_exact: [
+        "/* */h.x(1).y(2).z(3);",
+        "/* */i.x(1).y(2).z(3);",
+        "/* */j.x(1).y(2).z(3);",
+        "/* */k.x(1).y(2).z(3);",
+        "/* */l.x(1).y(2).z(3);",
+        "/* */m.x(1).y(2).z(3);",
+    ]
+}
+
+issue_2629_4: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        (/*@__PURE__*/ x(), y());
+        (w(), /*@__PURE__*/ x(), y());
+    }
+    expect: {
+        y();
+        w(), y();
+    }
+}
+
+issue_2629_5: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        [ /*@__PURE__*/ x() ];
+        [ /*@__PURE__*/ x(), y() ];
+        [ w(), /*@__PURE__*/ x(), y() ];
+    }
+    expect: {
+        y();
+        w(), y();
+    }
+}
+
+issue_2638: {
+    options = {
+        side_effects: true,
+    }
+    beautify = {
+        comments: "all",
+    }
+    input: {
+        /*@__PURE__*/(g() || h())(x(), y());
+        (/*@__PURE__*/ (a() || b()))(c(), d());
+    }
+    expect_exact: [
+        "/* */x(),y();",
+        "/* */(a()||b())(c(),d());",
+    ]
+}

test/compress/pure_getters.js

@@ -185,7 +185,7 @@ impure_getter_2: {
 
 issue_2110_1: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         pure_getters: "strict",
         sequences: true,
         side_effects: true,
@@ -274,7 +274,7 @@ set_immutable_1: {
 
 set_immutable_2: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         pure_getters: "strict",
         reduce_funcs: true,
@@ -324,7 +324,7 @@ set_immutable_3: {
 
 set_immutable_4: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         pure_getters: "strict",
         reduce_funcs: true,
@@ -375,7 +375,7 @@ set_mutable_1: {
 
 set_mutable_2: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         pure_getters: "strict",
         reduce_funcs: true,
@@ -398,9 +398,85 @@ set_mutable_2: {
     expect_stdout: "PASS"
 }
 
+issue_2265_1: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        ({ ...{} }).p;
+        ({ ...g }).p;
+    }
+    expect: {
+        ({ ...g }).p;
+    }
+}
+
+issue_2265_2: {
+    options = {
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = {
+            get b() {
+                throw 0;
+            }
+        };
+        ({...a}).b;
+    }
+    expect: {
+        var a = {
+            get b() {
+                throw 0;
+            }
+        };
+        ({...a}).b;
+    }
+}
+
+issue_2265_3: {
+    options = {
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = {
+            set b() {
+                throw 0;
+            }
+        };
+        ({...a}).b;
+    }
+    expect: {}
+}
+
+issue_2265_4: {
+    options = {
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = { b: 1 };
+        ({...a}).b;
+    }
+    expect: {}
+}
+
 issue_2313_1: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         pure_getters: "strict",
         sequences: true,
@@ -446,7 +522,7 @@ issue_2313_1: {
 
 issue_2313_2: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         pure_getters: true,
         sequences: true,
@@ -611,3 +687,83 @@ issue_2313_6: {
         x();
     }
 }
+
+issue_2313_7: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: true,
+    }
+    input: {
+        var a = 0, b = 0;
+        class foo {
+            get c() {
+                a++;
+                return 42;
+            }
+            set c(c) {
+                b++;
+            }
+        }
+        class bar extends foo {
+            d() {
+                super.c++;
+                if (super.c) console.log(a, b);
+            }
+        }
+        new bar().d();
+    }
+    expect: {
+        var a = 0, b = 0;
+        class foo {
+            get c() {
+                a++;
+                return 42;
+            }
+            set c(c) {
+                b++;
+            }
+        }
+        class bar extends foo {
+            d() {
+                super.c++;
+                super.c && console.log(a, b);
+            }
+        }
+        new bar().d();
+    }
+    expect_stdout: "2 1"
+    node_version: ">=6"
+}
+
+issue_2678: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        var a = 1, c = "FAIL";
+        (function f() {
+            (a-- && f()).p;
+            return {
+                get p() {
+                    c = "PASS";
+                }
+            };
+        })();
+        console.log(c);
+    }
+    expect: {
+        var a = 1, c = "FAIL";
+        (function f() {
+            (a-- && f()).p;
+            return {
+                get p() {
+                    c = "PASS";
+                }
+            };
+        })();
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}

test/compress/reduce_vars.js

@@ -1355,10 +1355,9 @@ defun_inline_1: {
         function f() {
             return function(b) {
                 return b;
-            }(2) + h();
-            function h() {
+            }(2) + function h() {
                 return h();
-            }
+            }();
         }
     }
 }
@@ -1382,12 +1381,11 @@ defun_inline_2: {
     }
     expect: {
         function f() {
-            function h() {
-                return h();
-            }
             return function(b) {
                 return b;
-            }(2) + h();
+            }(2) + function h() {
+                return h();
+            }();
         }
     }
 }
@@ -1396,7 +1394,7 @@ defun_inline_3: {
     options = {
         evaluate: true,
         inline: true,
-        passes: 2,
+        passes: 3,
         reduce_funcs: true,
         reduce_vars: true,
         side_effects: true,
@@ -1557,10 +1555,10 @@ defun_label: {
         !function() {
             console.log(function(a) {
                 L: {
-                    if (2) break L;
+                    if (a) break L;
                     return 1;
                 }
-            }());
+            }(2));
         }();
     }
     expect_stdout: true
@@ -2250,23 +2248,22 @@ redefine_farg_2: {
         console.log(f([]), g([]), h([]));
     }
     expect: {
-        console.log(function(a) {
-            return typeof a;
-        }([]), "number",function(a, b) {
+        console.log((a = [], typeof a), "number",function(a, b) {
             a = b;
             return typeof a;
         }([]));
+        var a;
     }
     expect_stdout: "object number undefined"
 }
 
 redefine_farg_3: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         evaluate: true,
         inline: true,
         keep_fargs: false,
-        passes: 2,
+        passes: 3,
         reduce_funcs: true,
         reduce_vars: true,
         sequences: true,
@@ -2634,11 +2631,10 @@ issue_1814_1: {
         evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
-        toplevel: true,
         unused: true,
     }
     input: {
-        var a = 42;
+        const a = 42;
         !function() {
             var b = a;
             !function(a) {
@@ -2647,6 +2643,7 @@ issue_1814_1: {
         }();
     }
     expect: {
+        const a = 42;
         !function() {
             !function(a) {
                 console.log(a++, 42);
@@ -2661,11 +2658,10 @@ issue_1814_2: {
         evaluate: true,
         reduce_funcs: true,
         reduce_vars: true,
-        toplevel: true,
         unused: true,
     }
     input: {
-        var a = "32";
+        const a = "32";
         !function() {
             var b = a + 1;
             !function(a) {
@@ -2674,6 +2670,7 @@ issue_1814_2: {
         }();
     }
     expect: {
+        const a = "32";
         !function() {
             !function(a) {
                 console.log(a++, "321");
@@ -3023,6 +3020,116 @@ accessor_2: {
     expect_stdout: "1"
 }
 
+method_1: {
+    options = {
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        console.log(new class {
+            a() {
+                a = 2;
+                return a;
+            }
+        }().a(), a);
+    }
+    expect: {
+        var a = 1;
+        console.log(new class {
+            a() {
+                a = 2;
+                return a;
+            }
+        }().a(), a);
+    }
+    expect_stdout: "2 2"
+    node_version: ">=6"
+}
+
+method_2: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var A = 1;
+        var B = class {
+            c() {
+                console.log(A);
+            }
+        };
+        new B().c();
+    }
+    expect: {
+        new class {
+            c() {
+                console.log(1);
+            }
+        }().c();
+    }
+    expect_stdout: "1"
+    node_version: ">=6"
+}
+
+issue_2090_1: {
+    options = {
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var x = 1;
+            [].forEach(() => x = 2);
+            return x;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var x = 1;
+            [].forEach(() => x = 2);
+            return x;
+        }());
+    }
+    expect_stdout: "1"
+    node_version: ">=4"
+}
+
+issue_2090_2: {
+    options = {
+        evaluate: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+    }
+    input: {
+        console.log(function() {
+            var x = 1;
+            [].forEach(() => {
+                x = 2;
+            });
+            return x;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var x = 1;
+            [].forEach(() => {
+                x = 2;
+            });
+            return x;
+        }());
+    }
+    expect_stdout: "1"
+    node_version: ">=4"
+}
+
 for_in_prop: {
     options = {
         reduce_funcs: true,
@@ -3107,6 +3214,7 @@ obj_var_2: {
 
 obj_arg_1: {
     options = {
+        collapse_vars: true,
         evaluate: true,
         inline: true,
         passes: 2,
@@ -3138,9 +3246,10 @@ obj_arg_1: {
 
 obj_arg_2: {
     options = {
+        collapse_vars: true,
         evaluate: true,
         inline: true,
-        passes: 2,
+        passes: 3,
         properties: true,
         reduce_funcs: true,
         reduce_vars: true,
@@ -3257,7 +3366,9 @@ obj_for_1: {
             console.log(i);
     }
     expect: {
-        for (var i = { a: 1 }.a--; i; i--)
+        // TODO make this work on harmony
+        var o = { a: 1 };
+        for (var i = o.a--; i; i--)
             console.log(i);
     }
     expect_stdout: "1"
@@ -3296,7 +3407,9 @@ array_forin_1: {
             console.log(b);
     }
     expect: {
-        for (var b in [ 1, 2, 3 ])
+        // TODO make this work on harmony
+        var a = [ 1, 2, 3 ];
+        for (var b in a)
             console.log(b);
     }
     expect_stdout: [
@@ -3328,6 +3441,55 @@ array_forin_2: {
     expect_stdout: "3"
 }
 
+array_forof_1: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = [ 1, 2, 3 ];
+        for (var b of a)
+            console.log(b);
+    }
+    expect: {
+        // TODO make this work on harmony
+        var a = [ 1, 2, 3 ];
+        for (var b of a)
+            console.log(b);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "3",
+    ]
+    node_version: ">=0.12"
+}
+
+array_forof_2: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = [];
+        for (var b of [ 1, 2, 3 ])
+            a.push(b);
+        console.log(a.length);
+    }
+    expect: {
+        var a = [];
+        for (var b of [ 1, 2, 3 ])
+            a.push(b);
+        console.log(a.length);
+    }
+    expect_stdout: "3"
+    node_version: ">=0.12"
+}
+
 const_expr_1: {
     options = {
         evaluate: true,
@@ -3390,6 +3552,93 @@ const_expr_2: {
     expect_stdout: "2 2"
 }
 
+issue_2406_1: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: false,
+        unused: true,
+    }
+    input: {
+        const c = {
+            fn: function() {
+                return this;
+            }
+        };
+        let l = {
+            fn: function() {
+                return this;
+            }
+        };
+        var v = {
+            fn: function() {
+                return this;
+            }
+        };
+        console.log(c.fn(), l.fn(), v.fn());
+    }
+    expect: {
+        const c = {
+            fn: function() {
+                return this;
+            }
+        };
+        let l = {
+            fn: function() {
+                return this;
+            }
+        };
+        var v = {
+            fn: function() {
+                return this;
+            }
+        };
+        console.log(c.fn(), l.fn(), v.fn());
+    }
+}
+
+issue_2406_2: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        const c = {
+            fn: function() {
+                return this;
+            }
+        };
+        let l = {
+            fn: function() {
+                return this;
+            }
+        };
+        var v = {
+            fn: function() {
+                return this;
+            }
+        };
+        console.log(c.fn(), l.fn(), v.fn());
+    }
+    expect: {
+        console.log({
+            fn: function() {
+                return this;
+            }
+        }.fn(), {
+            fn: function() {
+                return this;
+            }
+        }.fn(), {
+            fn: function() {
+                return this;
+            }
+        }.fn());
+    }
+}
+
 escaped_prop_1: {
     options = {
         collapse_vars: true,
@@ -3421,6 +3670,37 @@ escaped_prop_1: {
 }
 
 escaped_prop_2: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        pure_getters: "strict",
+        reduce_funcs: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var obj = { o: { a: 1 } };
+        (function(o) {
+            o.a++;
+        })(obj.o);
+        (function(o) {
+            console.log(o.a);
+        })(obj.o);
+    }
+    expect: {
+        var obj = { o: { a: 1 } };
+        obj.o.a++;
+        console.log(obj.o.a);
+    }
+    expect_stdout: "2"
+}
+
+escaped_prop_3: {
     options = {
         reduce_funcs: true,
         reduce_vars: true,
@@ -3541,6 +3821,50 @@ issue_2420_2: {
     ]
 }
 
+issue_2420_3: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var that = this;
+            if (that.bar)
+                that.foo();
+            else
+                ((that, self) => {
+                    console.log(this === that, self === this, that === self);
+                })(that, this);
+        }
+        f.call({
+            bar: 1,
+            foo: function() { console.log("foo", this.bar); },
+        });
+        f.call({});
+    }
+    expect: {
+        function f() {
+            if (this.bar)
+                this.foo();
+            else
+                ((that, self) => {
+                    console.log(this === that, self === this, that === self);
+                })(this, this);
+        }
+        f.call({
+            bar: 1,
+            foo: function() { console.log("foo", this.bar); },
+        });
+        f.call({});
+    }
+    expect_stdout: [
+        "foo 1",
+        "true true true",
+    ]
+    node_version: ">=4"
+}
+
 issue_2423_1: {
     options = {
         reduce_funcs: true,
@@ -4527,6 +4851,74 @@ issue_2485: {
     expect_stdout: "6"
 }
 
+issue_2496: {
+    options = {
+        passes: 2,
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function execute(callback) {
+            callback();
+        }
+        class Foo {
+            constructor(message) {
+                this.message = message;
+            }
+            go() {
+                this.message = "PASS";
+                console.log(this.message);
+            }
+            run() {
+                execute(() => {
+                    this.go();
+                });
+            }
+        }
+        new Foo("FAIL").run();
+    }
+    expect: {
+        new class {
+            constructor(message) {
+                this.message = message;
+            }
+            go() {
+                this.message = "PASS";
+                console.log(this.message);
+            }
+            run() {
+                (function(callback) {
+                    callback();
+                })(() => {
+                    this.go();
+                });
+            }
+        }("FAIL").run();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_2416: {
+    options = {
+        keep_classnames: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        class Foo {}
+        console.log(Foo.name);
+    }
+    expect: {
+        console.log((class Foo {}).name);
+    }
+    expect_stdout: "Foo"
+    node_version: ">=6"
+}
+
 issue_2455: {
     options = {
         reduce_vars: true,
@@ -4545,7 +4937,7 @@ issue_2455: {
     }
 }
 
-issue_2560_1: {
+escape_conditional: {
     options = {
         reduce_funcs: true,
         reduce_vars: true,
@@ -4584,7 +4976,7 @@ issue_2560_1: {
     expect_stdout: "PASS"
 }
 
-issue_2560_2: {
+escape_sequence: {
     options = {
         reduce_funcs: true,
         reduce_vars: true,
@@ -4622,7 +5014,7 @@ issue_2560_2: {
     expect_stdout: "PASS"
 }
 
-issue_2560_3: {
+escape_throw: {
     options = {
         reduce_funcs: true,
         reduce_vars: true,
@@ -4667,7 +5059,7 @@ issue_2560_3: {
     expect_stdout: "PASS"
 }
 
-issue_2560_4: {
+escape_local_conditional: {
     options = {
         reduce_funcs: true,
         reduce_vars: true,
@@ -4704,7 +5096,7 @@ issue_2560_4: {
     expect_stdout: "PASS"
 }
 
-issue_2560_5: {
+escape_local_sequence: {
     options = {
         reduce_funcs: true,
         reduce_vars: true,
@@ -4741,7 +5133,7 @@ issue_2560_5: {
     expect_stdout: "PASS"
 }
 
-issue_2560_6: {
+escape_local_throw: {
     options = {
         reduce_funcs: true,
         reduce_vars: true,
@@ -4768,8 +5160,10 @@ issue_2560_6: {
     }
     expect: {
         function baz() {
+            // TODO: improve to match `master`
+            function foo() {}
             try {
-                throw function() {};
+                throw foo;
             } catch (bar) {
                 return bar;
             }
@@ -4784,3 +5178,310 @@ issue_2560_6: {
     }
     expect_stdout: "PASS"
 }
+
+escape_yield: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function main() {
+            var thing = gen.next().value;
+            if (thing !== (thing = gen.next().value))
+                console.log("FAIL");
+            else
+                console.log("PASS");
+        }
+        function foo() {}
+        function* baz(s) {
+            for (;;) yield foo;
+        }
+        var gen = baz();
+        main();
+    }
+    expect: {
+        function foo() {}
+        var gen = function*(s) {
+            for (;;) yield foo;
+        }();
+        (function() {
+            var thing = gen.next().value;
+            if (thing !== (thing = gen.next().value))
+                console.log("FAIL");
+            else
+                console.log("PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+escape_await: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function main() {
+            var thing;
+            baz().then(x => {
+                thing = x;
+            });
+            baz().then(x => {
+                if (thing !== (thing = x))
+                    console.log("FAIL");
+                else
+                    console.log("PASS");
+            });
+        }
+        function foo() {}
+        async function baz() {
+            return await foo;
+        }
+        main();
+    }
+    expect: {
+        function foo() {}
+        async function baz() {
+            return await foo;
+        }
+        (function() {
+            var thing;
+            baz().then(x => {
+                thing = x;
+            });
+            baz().then(x => {
+                if (thing !== (thing = x))
+                    console.log("FAIL");
+                else
+                    console.log("PASS");
+            });
+        })();
+    }
+}
+
+escape_expansion: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function main() {
+            var thing = baz();
+            if (thing !== (thing = baz()))
+                console.log("FAIL");
+            else
+                console.log("PASS");
+        }
+        function foo() {}
+        function bar(...x) {
+            return x[0];
+        }
+        function baz() {
+            return bar(...[ foo ]);
+        }
+        main();
+    }
+    expect: {
+        function foo() {}
+        function baz() {
+            return function(...x) {
+                return x[0];
+            }(...[ foo ]);
+        }
+        (function() {
+            var thing = baz();
+            if (thing !== (thing = baz()))
+                console.log("FAIL");
+            else
+                console.log("PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+inverted_var: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 3,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = 1;
+            return a;
+        }(), function() {
+            var b;
+            b = 2;
+            return b;
+        }(), function() {
+            c = 3;
+            return c;
+            var c;
+        }(), function(c) {
+            c = 4;
+            return c;
+        }(), function (c) {
+            c = 5;
+            return c;
+            var c;
+        }(), function c() {
+            c = 6;
+            return c;
+        }(), function c() {
+            c = 7;
+            return c;
+            var c;
+        }(), function() {
+            c = 8;
+            return c;
+            var c = "foo";
+        }());
+    }
+    expect: {
+        console.log(1, 2, 3, 4, 5, function c() {
+            c = 6;
+            return c;
+        }(), 7, function() {
+            c = 8;
+            return c;
+            var c = "foo";
+        }());
+    }
+    expect_stdout: true
+}
+
+defun_single_use_loop: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        for (var x, i = 2; --i >= 0; ) {
+            var y = x;
+            x = f;
+            console.log(x === y);
+        }
+        function f() {};
+    }
+    expect: {
+        for (var x, i = 2; --i >= 0; ) {
+            var y = x;
+            x = f;
+            console.log(x === y);
+        }
+        function f() {};
+    }
+    expect_stdout: [
+        "false",
+        "true",
+    ]
+}
+
+do_while: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f(a) {
+            do {
+                (function() {
+                    a && (c = "PASS");
+                })();
+            } while (a = 0);
+        }
+        var c = "FAIL";
+        f(1);
+        console.log(c);
+    }
+    expect: {
+        function f(a) {
+            do {
+                (function() {
+                    a && (c = "PASS");
+                })();
+            } while (a = 0);
+        }
+        var c = "FAIL";
+        f(1);
+        console.log(c);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2598: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {}
+        function g(a) {
+            return a || f;
+        }
+        console.log(g(false) === g(null));
+    }
+    expect: {
+        function f() {}
+        function g(a) {
+            return a || f;
+        }
+        console.log(g(false) === g(null));
+    }
+    expect_stdout: "true"
+}
+
+issue_2669: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        let foo;
+        console.log(([ foo ] = [ "PASS" ]) && foo);
+    }
+    expect: {
+        let foo;
+        console.log(([ foo ] = [ "PASS" ]) && foo);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+issue_2670: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        const obj = {};
+        obj.prop = "PASS";
+        const {prop: value} = obj;
+        console.log(value);
+    }
+    expect: {
+        const obj = {};
+        obj.prop = "PASS";
+        const {prop: value} = obj;
+        console.log(value);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}

test/compress/return_undefined.js

@@ -17,7 +17,6 @@ return_undefined: {
         keep_fnames   : false,
         hoist_vars    : true,
         join_vars     : true,
-        cascade       : true,
         negate_iife   : true
     };
     input: {

test/compress/sequences.js

@@ -317,7 +317,7 @@ unsafe_undefined: {
 
 issue_1685: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -341,7 +341,7 @@ issue_1685: {
 
 func_def_1: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -361,7 +361,7 @@ func_def_1: {
 
 func_def_2: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -379,7 +379,7 @@ func_def_2: {
 
 func_def_3: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -401,7 +401,7 @@ func_def_3: {
 
 func_def_4: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -427,7 +427,7 @@ func_def_4: {
 
 func_def_5: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -634,7 +634,7 @@ side_effects: {
 
 side_effects_cascade_1: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         sequences: true,
         side_effects: true,
@@ -655,7 +655,7 @@ side_effects_cascade_1: {
 
 side_effects_cascade_2: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         side_effects: true,
     }
     input: {
@@ -677,7 +677,7 @@ side_effects_cascade_2: {
 
 side_effects_cascade_3: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         side_effects: true,
     }
@@ -692,14 +692,14 @@ side_effects_cascade_3: {
     expect: {
         function f(a, b) {
             !(b += a) && ((b = a) || (b -= a, b ^= a)),
-            --a;
+            a--;
         }
     }
 }
 
 issue_27: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         passes: 2,
         sequences: true,
         side_effects: true,
@@ -719,10 +719,34 @@ issue_27: {
     }
 }
 
+reassign_const: {
+    options = {
+        collapse_vars: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function f() {
+            const a = 1;
+            a++;
+            return a;
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            const a = 1;
+            return a++, a;
+        }
+        console.log(f());
+    }
+    expect_stdout: true
+}
+
 issue_2062: {
     options = {
         booleans: true,
-        cascade: true,
+        collapse_vars: true,
         conditionals: true,
         side_effects: true,
     }
@@ -741,7 +765,7 @@ issue_2062: {
 
 issue_2313: {
     options = {
-        cascade: true,
+        collapse_vars: true,
         sequences: true,
         side_effects: true,
     }
@@ -779,3 +803,20 @@ issue_2313: {
     }
     expect_stdout: "2 1"
 }
+
+cascade_assignment_in_return: {
+    options = {
+        collapse_vars: true,
+        unused: true,
+    }
+    input: {
+        function f(a, b) {
+            return a = x(), b(a);
+        }
+    }
+    expect: {
+        function f(a, b) {
+            return b(x());
+        }
+    }
+}

test/compress/super.js

@@ -0,0 +1,9 @@
+
+super_can_be_parsed: {
+    input: {
+        super(1,2);
+        super.meth();
+    }
+    expect_exact: "super(1,2);super.meth();"
+}
+

test/compress/template-string.js

@@ -0,0 +1,508 @@
+template_strings: {
+    beautify = {
+        quote_style: 3
+    }
+    input: {
+        ``;
+        `xx\`x`;
+        `${ foo + 2 }`;
+        ` foo ${ bar + `baz ${ qux }` }`;
+    }
+    expect_exact: "``;`xx\\`x`;`${foo+2}`;` foo ${bar+`baz ${qux}`}`;";
+}
+
+template_string_prefixes: {
+    beautify = {
+        quote_style: 3
+    }
+    input: {
+        String.raw`foo`;
+        foo `bar`;
+    }
+    expect_exact: "String.raw`foo`;foo`bar`;";
+}
+
+template_strings_ascii_only: {
+    beautify = {
+        ascii_only: true,
+        quote_style: 3
+    }
+    input: {
+        var foo = `foo
+        bar
+        ↂωↂ`;
+        var bar = `\``;
+    }
+    expect_exact: "var foo=`foo\\n        bar\\n        \\u2182\\u03c9\\u2182`;var bar=`\\``;"
+}
+
+template_strings_without_ascii_only: {
+    beautify = {
+        quote_style: 3
+    }
+    input: {
+        var foo = `foo
+        bar
+        ↂωↂ`
+    }
+    expect_exact: "var foo=`foo\\n        bar\\n        ↂωↂ`;"
+}
+
+template_string_with_constant_expression: {
+    options = {
+        evaluate: true
+    }
+    beautify = {
+        quote_style: 3
+    }
+    input: {
+        var foo = `${4 + 4} equals 4 + 4`;
+    }
+    expect: {
+        var foo = "8 equals 4 + 4";
+    }
+}
+
+template_string_with_predefined_constants: {
+    options = {
+        evaluate: true
+    }
+    beautify = {
+        quote_style: 3
+    }
+    input: {
+        var foo = `This is ${undefined}`;
+        var bar = `This is ${NaN}`;
+        var baz = `This is ${null}`;
+        var foofoo = `This is ${Infinity}`;
+        var foobar = "This is ${1/0}";
+        var foobaz = 'This is ${1/0}';
+        var barfoo = "This is ${NaN}";
+        var bazfoo = "This is ${null}";
+        var bazbaz = `This is ${1/0}`;
+        var barbar = `This is ${0/0}`;
+        var barbar = "This is ${0/0}";
+        var barber = 'This is ${0/0}';
+
+        var a = `${4**11}`; // 8 in template vs 7 chars - 4194304
+        var b = `${4**12}`; // 8 in template vs 8 chars - 16777216
+        var c = `${4**14}`; // 8 in template vs 9 chars - 268435456
+    }
+    expect: {
+        var foo = "This is undefined";
+        var bar = "This is NaN";
+        var baz = "This is null";
+        var foofoo = `This is ${1/0}`;
+        var foobar = "This is ${1/0}";
+        var foobaz = 'This is ${1/0}';
+        var barfoo = "This is ${NaN}";
+        var bazfoo = "This is ${null}";
+        var bazbaz = `This is ${1/0}`;
+        var barbar = "This is NaN";
+        var barbar = "This is ${0/0}";
+        var barber = 'This is ${0/0}';
+
+        var a = "4194304";
+        var b = "16777216"; // Potential for further concatentation
+        var c = `${4**14}`; // Not worth converting
+    }
+}
+
+template_string_evaluate_with_many_segments: {
+    options = {
+        evaluate: true
+    }
+    beautify = {
+        quote_style: 3
+    }
+    input: {
+        var foo = `Hello ${guest()}, welcome to ${location()}${"."}`;
+        var bar = `${1}${2}${3}${4}${5}${6}${7}${8}${9}${0}`;
+        var baz = `${foobar()}${foobar()}${foobar()}${foobar()}`;
+        var buzz = `${1}${foobar()}${2}${foobar()}${3}${foobar()}`;
+    }
+    expect: {
+        var foo = `Hello ${guest()}, welcome to ${location()}.`;
+        var bar = "1234567890";
+        var baz = `${foobar()}${foobar()}${foobar()}${foobar()}`;
+        var buzz = `1${foobar()}2${foobar()}3${foobar()}`;
+    }
+}
+
+template_string_with_many_segments: {
+    beautify = {
+        quote_style: 3
+    }
+    input: {
+        var foo = `Hello ${guest()}, welcome to ${location()}${"."}`;
+        var bar = `${1}${2}${3}${4}${5}${6}${7}${8}${9}${0}`;
+        var baz = `${foobar()}${foobar()}${foobar()}${foobar()}`;
+        var buzz = `${1}${foobar()}${2}${foobar()}${3}${foobar()}`;
+    }
+    expect: {
+        var foo = `Hello ${guest()}, welcome to ${location()}${"."}`;
+        var bar = `${1}${2}${3}${4}${5}${6}${7}${8}${9}${0}`;
+        var baz = `${foobar()}${foobar()}${foobar()}${foobar()}`;
+        var buzz = `${1}${foobar()}${2}${foobar()}${3}${foobar()}`;
+    }
+}
+
+template_string_to_normal_string: {
+    options = {
+        evaluate: true
+    }
+    beautify = {
+        quote_style: 0
+    }
+    input: {
+        var foo = `This is ${undefined}`;
+        var bar = "Decimals " + `${1}${2}${3}${4}${5}${6}${7}${8}${9}${0}`;
+    }
+    expect: {
+        var foo = "This is undefined";
+        var bar = "Decimals 1234567890";
+    }
+}
+
+template_concattenating_string: {
+    options = {
+        evaluate: true
+    }
+    beautify = {
+        quote_style: 3 // Yes, keep quotes
+    }
+    input: {
+        var foo = "Have a nice " + `day. ${`day. ` + `day.`}`;
+        var bar = "Have a nice " + `${day()}`;
+    }
+    expect: {
+        var foo = "Have a nice day. day. day.";
+        var bar = "Have a nice " + `${day()}`;
+    }
+}
+
+evaluate_nested_templates: {
+    options = {
+        evaluate: true
+    }
+    beautify = {
+        quote_style: 0
+    }
+    input: {
+        var baz = `${`${`${`foo`}`}`}`;
+    }
+    expect: {
+        var baz = "foo";
+    }
+}
+
+enforce_double_quotes: {
+    beautify = {
+        quote_style: 1
+    }
+    input: {
+        var foo = `Hello world`;
+        var bar = `Hello ${'world'}`;
+        var baz = `Hello ${world()}`;
+    }
+    expect: {
+        var foo = `Hello world`;
+        var bar = `Hello ${"world"}`;
+        var baz = `Hello ${world()}`;
+    }
+}
+
+enforce_single_quotes: {
+    beautify = {
+        quote_style: 2
+    }
+    input: {
+        var foo = `Hello world`;
+        var bar = `Hello ${"world"}`;
+        var baz = `Hello ${world()}`;
+    }
+    expect: {
+        var foo = `Hello world`;
+        var bar = `Hello ${'world'}`;
+        var baz = `Hello ${world()}`;
+    }
+}
+
+enforce_double_quotes_and_evaluate: {
+    beautify = {
+        quote_style: 1
+    }
+    options = {
+        evaluate: true
+    }
+    input: {
+        var foo = `Hello world`;
+        var bar = `Hello ${'world'}`;
+        var baz = `Hello ${world()}`;
+    }
+    expect: {
+        var foo = "Hello world";
+        var bar = "Hello world";
+        var baz = `Hello ${world()}`;
+    }
+}
+
+enforce_single_quotes_and_evaluate: {
+    beautify = {
+        quote_style: 2
+    }
+    options = {
+        evaluate: true
+    }
+    input: {
+        var foo = `Hello world`;
+        var bar = `Hello ${"world"}`;
+        var baz = `Hello ${world()}`;
+    }
+    expect: {
+        var foo = "Hello world";
+        var bar = "Hello world";
+        var baz = `Hello ${world()}`;
+    }
+}
+
+respect_inline_script: {
+    beautify = {
+        inline_script: true,
+        quote_style: 3
+    }
+    input: {
+        var foo = `</script>${content}`;
+        var bar = `<!--`;
+        var baz = `-->`;
+    }
+    expect_exact: "var foo=`<\\/script>${content}`;var bar=`\\x3c!--`;var baz=`--\\x3e`;";
+}
+
+do_not_optimize_tagged_template_1: {
+    beautify = {
+        quote_style: 0
+    }
+    options = {
+        evaluate: true
+    }
+    input: {
+        var foo = tag`Shall not be optimized. ${"But " + "this " + "is " + "fine."}`;
+        var bar = tag`Don't even mind changing my quotes!`;
+    }
+    expect_exact:
+        'var foo=tag`Shall not be optimized. ${"But this is fine."}`;var bar=tag`Don\'t even mind changing my quotes!`;';
+}
+
+do_not_optimize_tagged_template_2: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var foo = tag`test` + " something out";
+    }
+    expect_exact: 'var foo=tag`test`+" something out";';
+}
+
+keep_raw_content_in_tagged_template: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var foo = tag`\u0020\u{20}\u{00020}\x20\40\040 `;
+    }
+    expect_exact: "var foo=tag`\\u0020\\u{20}\\u{00020}\\x20\\40\\040 `;";
+}
+
+allow_chained_templates: {
+    input: {
+        var foo = tag`a``b``c``d`;
+    }
+    expect: {
+        var foo = tag`a``b``c``d`;
+    }
+}
+
+check_escaped_chars: {
+    input: {
+        var foo = `\u0020\u{20}\u{00020}\x20\40\040 `;
+    }
+    expect_exact: "var foo=`       `;";
+}
+
+escape_dollar_curly: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        console.log(`\$\{ beep \}`)
+        console.log(`${1-0}\${2-0}$\{3-0}${4-0}`)
+        console.log(`$${""}{not an expression}`)
+    }
+    expect_exact: 'console.log("${ beep }");console.log("1${2-0}${3-0}4");console.log("${not an expression}");'
+}
+
+template_starting_with_newline: {
+    options = {
+        dead_code: true
+    }
+    input: {
+        function foo(e) {
+            return `
+this is a template string!`;
+        };
+    }
+    expect_exact: "function foo(e){return`\\nthis is a template string!`}"
+}
+
+template_with_newline: {
+    options = {
+        dead_code: true
+    }
+    input: {
+        function foo(e) {
+            return `yep,
+this is a template string!`;
+        };
+    }
+    expect_exact: "function foo(e){return`yep,\\nthis is a template string!`}"
+}
+
+template_ending_with_newline: {
+    options = {
+        dead_code: true
+    }
+    input: {
+        function foo(e) {
+            return `this is a template string!
+`;
+        };
+    }
+    expect_exact: "function foo(e){return`this is a template string!\\n`}"
+}
+
+issue_1856: {
+    beautify = {
+        ascii_only: false,
+    }
+    input: {
+        console.log(`\\n\\r\\u2028\\u2029\n\r\u2028\u2029`);
+    }
+    expect_exact: "console.log(`\\\\n\\\\r\\\\u2028\\\\u2029\\n\\r\\u2028\\u2029`);"
+}
+
+issue_1856_ascii_only: {
+    beautify = {
+        ascii_only: true,
+    }
+    input: {
+        console.log(`\\n\\r\\u2028\\u2029\n\r\u2028\u2029`);
+    }
+    expect_exact: "console.log(`\\\\n\\\\r\\\\u2028\\\\u2029\\n\\r\\u2028\\u2029`);"
+}
+
+side_effects: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        `t1`;
+        tag`t2`;
+        `t${3}`;
+        tag`t${4}`;
+        console.log(`
+t${5}`);
+        function f(a) {
+            `t6${a}`;
+            a = `t7${a}` & a;
+            a = `t8${b}` | a;
+            a = f`t9${a}` ^ a;
+        }
+    }
+    expect: {
+        tag`t2`;
+        tag`t${4}`;
+        console.log("\nt5");
+        function f(a) {
+            a &= `t7${a}`;
+            a = `t8${b}` | a;
+            a = f`t9${a}` ^ a;
+        }
+    }
+}
+
+simple_string: {
+    options = {
+        computed_props: true,
+        evaluate: true,
+        properties: true,
+    }
+    input: {
+        console.log({[`foo`]: 1}[`foo`], `hi` == "hi", `world`);
+    }
+    expect: {
+        console.log([ 1 ][0], true, "world");
+    }
+    expect_stdout: "1 true 'world'"
+    node_version: ">=4"
+}
+
+semicolons: {
+    beautify = {
+        semicolons: false,
+    }
+    input: {
+        foo;
+        `bar`;
+    }
+    expect_exact: "foo;`bar`\n"
+}
+
+regex_1: {
+    input: {
+        console.log(`${/a/} ${6/2} ${/b/.test("b")} ${1?/c/:/d/}`);
+    }
+    expect_exact: 'console.log(`${/a/} ${6/2} ${/b/.test("b")} ${1?/c/:/d/}`);'
+    expect_stdout: "/a/ 3 true /c/"
+    node_version: ">=4"
+}
+
+regex_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(`${/a/} ${6/2} ${/b/.test("b")} ${1?/c/:/d/}`);
+    }
+    expect: {
+        console.log("/a/ 3 true /c/");
+    }
+    expect_stdout: "/a/ 3 true /c/"
+    node_version: ">=4"
+}
+
+sequence_1: {
+    input: {
+        console.log(`${1,2} ${/a/,/b/}`);
+    }
+    expect_exact: 'console.log(`${1,2} ${/a/,/b/}`);'
+    expect_stdout: "2 /b/"
+    node_version: ">=4"
+}
+
+sequence_2: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(`${1,2} ${/a/,/b/}`);
+    }
+    expect: {
+        console.log("2 /b/");
+    }
+    expect_stdout: "2 /b/"
+    node_version: ">=4"
+}

test/compress/try-catch.js

@@ -0,0 +1,12 @@
+catch_destructuring_with_sequence: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        try {
+            throw {};
+        } catch ({xCover = (0, function() {})} ) {
+        }
+    }
+    expect_exact: "try{throw{}}catch({xCover=(0,function(){})}){}"
+}

test/compress/unicode.js

@@ -16,6 +16,70 @@ unicode_parse_variables: {
     }
 }
 
+unicode_escaped_identifier: {
+    beautify = {ecma: 6}
+    input: {
+        var \u{61} = "foo";
+        var \u{10000} = "bar";
+    }
+    expect_exact: 'var a="foo";var \u{10000}="bar";';
+}
+
+unicode_identifier_ascii_only: {
+    beautify = {ascii_only: true, ecma: 6}
+    input: {
+        var \u{0061} = "hi";
+        var bar = "h\u{0065}llo";
+        var \u{10000} = "testing \u{101111}";
+    }
+    expect_exact: 'var a="hi";var bar="hello";var \\u{10000}="testing \\u{101111}";'
+}
+
+unicode_string_literals: {
+    beautify = {ascii_only: true, ecma: 6}
+    input: {
+        var a = "6 length unicode character: \u{101111}";
+    }
+    expect_exact: 'var a="6 length unicode character: \\u{101111}";'
+}
+
+check_escape_style: {
+    beautify = {ascii_only: true, ecma: 6}
+    input: {
+        var a = "\x01";
+        var \ua0081 = "\x10"; // \u0081 only in ID_Continue
+        var \u0100 = "\u0100";
+        var \u1000 = "\u1000";
+        var \u{10000} = "\u{10000}";
+        var \u{2f800} = "\u{100000}";
+    }
+    expect_exact: 'var a="\\x01";var \\ua0081="\\x10";var \\u0100="\\u0100";var \\u1000="\\u1000";var \\u{10000}="\\u{10000}";var \\u{2f800}="\\u{100000}";'
+}
+
+ID_continue_with_surrogate_pair: {
+    beautify = {ascii_only: true, ecma: 6}
+    input: {
+        var \u{2f800}\u{2f800}\u{2f800}\u{2f800} = "\u{100000}\u{100000}\u{100000}\u{100000}\u{100000}";
+    }
+    expect_exact: 'var \\u{2f800}\\u{2f800}\\u{2f800}\\u{2f800}="\\u{100000}\\u{100000}\\u{100000}\\u{100000}\\u{100000}";'
+}
+
+escape_non_escaped_identifier: {
+    beautify = {ascii_only: true, ecma: 6}
+    input: {
+        var µþ = "µþ";
+    }
+    expect_exact: 'var \\u00b5\\u00fe="\\xb5\\xfe";'
+}
+
+non_escape_2_non_escape: {
+    beautify = {ascii_only: false, ecma: 6}
+    input: {
+        var µþ = "µþ";
+    }
+    expect_exact: 'var µþ="µþ";'
+}
+
 issue_2242_1: {
     beautify = {
         ascii_only: false,
@@ -55,3 +119,10 @@ issue_2242_4: {
     }
     expect_exact: 'console.log("\ud83d\ude00","\\ud83d@\\ude00");'
 }
+
+issue_2569: {
+    input: {
+        new RegExp("[\udc42-\udcaa\udd74-\udd96\ude45-\ude4f\udea3-\udecc]");
+    }
+    expect_exact: 'new RegExp("[\\udc42-\\udcaa\\udd74-\\udd96\\ude45-\\ude4f\\udea3-\\udecc]");'
+}

test/compress/yield.js

@@ -0,0 +1,201 @@
+generators: {
+    input: {
+        function* fn() {};
+    }
+    expect_exact: "function*fn(){}"
+}
+
+generators_yield: {
+    input: {
+      function* fn() {
+        yield remote();
+      }
+    }
+    expect_exact: "function*fn(){yield remote()}"
+}
+
+generators_yield_assign: {
+    input: {
+      function* fn() {
+          var x = {};
+          x.prop = yield 5;
+      }
+    }
+    expect_exact: "function*fn(){var x={};x.prop=yield 5}"
+}
+
+generator_yield_undefined: {
+    input: {
+        function* fn() {
+            yield;
+        }
+    }
+    expect_exact: "function*fn(){yield}"
+}
+
+yield_optimize_expression: {
+    options = {
+    }
+    input: {
+        function* f1() { yield; }
+        function* f2() { yield undefined; }
+        function* f3() { yield null; }
+        function* f4() { yield* undefined; }
+    }
+    expect: {
+        function* f1() { yield }
+        function* f2() { yield; }
+        function* f3() { yield null; }
+        function* f4() { yield* void 0; }
+    }
+}
+
+yield_statements: {
+    input: {
+        function* fn() {
+            var a = (yield 1) + (yield 2);
+            var b = (yield 3) === (yield 4);
+            var c = (yield 5) << (yield 6);
+            var d = yield 7;
+            var e = (yield 8) ? yield 9 : yield 10;
+            var f = -(yield 11);
+        }
+    }
+    expect_exact: "function*fn(){var a=(yield 1)+(yield 2);var b=(yield 3)===(yield 4);var c=(yield 5)<<(yield 6);var d=yield 7;var e=(yield 8)?yield 9:yield 10;var f=-(yield 11)}"
+}
+
+yield_as_identifier_in_function_in_generator: {
+    input: {
+        var g = function*() {
+            function h() {
+                yield = 1;
+            }
+        };
+    }
+    expect: {
+        var g = function*() {
+            function h() {
+                yield = 1;
+            }
+        };
+    }
+}
+
+yield_before_punctuators: {
+    input: {
+        iter = (function*() {
+            assignmentResult = [ x = yield ] = value;
+        })();
+        function* g1() { (yield) }
+        function* g2() { [yield] }
+        function* g3() { return {yield} } // Added return to avoid {} drop
+        function* g4() { yield, yield; }
+        function* g5() { (yield) ? yield : yield; }
+    }
+    expect: {
+        iter = (function*() {
+            assignmentResult = [ x = yield ] = value;
+        })();
+        function* g1() { (yield) }
+        function* g2() { [yield] }
+        function* g3() { return {yield} }
+        function* g4() { yield, yield; }
+        function* g5() { (yield) ? yield : yield; }
+    }
+}
+
+yield_as_identifier_outside_strict_mode: {
+    input: {
+        import yield from "bar";
+        yield = 123;
+        while (true) {
+            yield:
+            for(;;) break yield;
+
+            foo();
+        }
+        while (true)
+            yield: for(;;) continue yield;
+        function yield(){}
+        function foo(...yield){}
+        try { new Error("") } catch (yield) {}
+        var yield = "foo";
+    }
+    expect: {
+        import yield from "bar";
+        yield = 123;
+        while (true) {
+            yield:
+            for(;;) break yield;
+
+            foo();
+        }
+        while (true)
+            yield: for(;;) continue yield;
+        function yield(){}
+        function foo(...yield){}
+        try { new Error("") } catch (yield) {}
+        var yield = "foo";
+    }
+}
+
+empty_generator_as_parameter_with_side_effects: {
+    options = {
+        side_effects: true
+    }
+    input: {
+        var GeneratorPrototype = Object.getPrototypeOf(
+          Object.getPrototypeOf(function*() {}())
+        );
+        evaluate(GeneratorPrototype);
+    }
+    expect_exact: "var GeneratorPrototype=Object.getPrototypeOf(Object.getPrototypeOf(function*(){}()));evaluate(GeneratorPrototype);"
+}
+
+empty_generator_as_parameter_without_side_effects: {
+    options = {
+        side_effects: false
+    }
+    input: {
+        var GeneratorPrototype = Object.getPrototypeOf(
+          Object.getPrototypeOf(function*() {}())
+        );
+        evaluate(GeneratorPrototype);
+    }
+    expect_exact: "var GeneratorPrototype=Object.getPrototypeOf(Object.getPrototypeOf(function*(){}()));evaluate(GeneratorPrototype);"
+}
+
+yield_dot: {
+    options = {
+    }
+    input: {
+        function* foo(){
+            yield x.foo;
+            (yield x).foo;
+            yield (yield obj.foo()).bar();
+        }
+    }
+    expect_exact: "function*foo(){yield x.foo;(yield x).foo;yield(yield obj.foo()).bar()}"
+}
+
+yield_sub: {
+    options = {
+    }
+    input: {
+        function* foo(){
+            yield x['foo'];
+            (yield x)['foo'];
+            yield (yield obj.foo())['bar']();
+        }
+    }
+    expect_exact: 'function*foo(){yield x["foo"];(yield x)["foo"];yield(yield obj.foo())["bar"]()}'
+}
+
+yield_as_ES5_property: {
+    input: {
+        "use strict";
+        console.log({yield: 42}.yield);
+    }
+    expect_exact: '"use strict";console.log({yield:42}.yield);'
+    expect_stdout: "42"
+}

test/input/invalid/const.js

@@ -0,0 +1,8 @@
+function f() {
+    const a;
+}
+
+function g() {
+    "use strict";
+    const a;
+}

test/input/invalid/export_1.js

@@ -0,0 +1,3 @@
+{
+    export var V = 1;
+}

test/input/invalid/export_2.js

@@ -0,0 +1 @@
+export class{};

test/input/invalid/export_3.js

@@ -0,0 +1 @@
+export function(){};

test/input/invalid/import.js

@@ -0,0 +1,3 @@
+{
+    import A from "B";
+}

test/input/invalid/sequence.js

@@ -0,0 +1 @@
+(a, ...b);

test/mocha/accessorTokens-1492.js

@@ -16,8 +16,8 @@ describe("Accessor tokens", function() {
                 assert.equal(node.start.pos, 12);
                 assert.equal(node.end.endpos, 46);
 
-                assert(node.key instanceof UglifyJS.AST_SymbolAccessor);
-                assert.equal(node.key.start.pos, 16);
+                assert(node.key instanceof UglifyJS.AST_SymbolMethod);
+                assert.equal(node.key.start.pos, 12);
                 assert.equal(node.key.end.endpos, 22);
 
                 assert(node.value instanceof UglifyJS.AST_Accessor);

test/mocha/arguments.js

@@ -27,4 +27,253 @@ describe("arguments", function() {
         assert.strictEqual(ast.body[0].body[0].uses_arguments, true);
         assert.strictEqual(ast.body[0].body[0].body[0].uses_arguments, false);
     });
-});
+
+    it("Should parse a function containing default assignment correctly", function() {
+        var ast = UglifyJS.parse("function foo(a = 123) {}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // First argument
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_DefaultAssign);
+        assert(ast.body[0].argnames[0].left instanceof UglifyJS.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].argnames[0].operator, "=");
+        assert(ast.body[0].argnames[0].right instanceof UglifyJS.AST_Number);
+
+        ast = UglifyJS.parse("function foo(a = a) {}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // First argument
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_DefaultAssign);
+        assert(ast.body[0].argnames[0].left instanceof UglifyJS.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].argnames[0].operator, "=");
+        assert(ast.body[0].argnames[0].right instanceof UglifyJS.AST_SymbolRef);
+    });
+
+    it("Should parse a function containing default assignments in destructuring correctly", function() {
+        var ast = UglifyJS.parse("function foo([a = 123]) {}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // First argument
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].is_array, true);
+        assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
+        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_DefaultAssign);
+        assert(ast.body[0].argnames[0].names[0].left instanceof UglifyJS.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].argnames[0].names[0].operator, "=");
+        assert(ast.body[0].argnames[0].names[0].right instanceof UglifyJS.AST_Number);
+
+
+        ast = UglifyJS.parse("function foo({a = 123}) {}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // First argument
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].is_array, false);
+        assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
+        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
+
+        // Property a of first argument
+        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_DefaultAssign);
+        assert(ast.body[0].argnames[0].names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].argnames[0].names[0].value.operator, "=");
+        assert(ast.body[0].argnames[0].names[0].value.right instanceof UglifyJS.AST_Number);
+
+
+        ast = UglifyJS.parse("function foo({a: a = 123}) {}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // First argument
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].is_array, false);
+        assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
+
+        // Content destructuring of first argument
+        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
+        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_DefaultAssign);
+
+        // Property a of first argument
+        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_DefaultAssign);
+        assert(ast.body[0].argnames[0].names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].argnames[0].names[0].value.operator, "=");
+        assert(ast.body[0].argnames[0].names[0].value.right instanceof UglifyJS.AST_Number);
+    });
+
+    it("Should parse a function containing default assignments in complex destructuring correctly", function() {
+        var ast = UglifyJS.parse("function foo([a, [b = 123]]){}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // Check first argument
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].is_array, true);
+        assert.strictEqual(ast.body[0].argnames[0].names.length, 2);
+
+        // Check whole destructuring structure of first argument
+        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
+        assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].names[1].is_array, true);
+
+        // Check content of second destructuring element (which is the nested destructuring pattern)
+        assert(ast.body[0].argnames[0].names[1].names[0] instanceof UglifyJS.AST_DefaultAssign);
+        assert(ast.body[0].argnames[0].names[1].names[0].left instanceof UglifyJS.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].argnames[0].names[1].names[0].operator, "=");
+        assert(ast.body[0].argnames[0].names[1].names[0].right instanceof UglifyJS.AST_Number);
+
+
+        ast = UglifyJS.parse("function foo([a, {b: c = 123}]){}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // Check first argument
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].is_array, true);
+        assert.strictEqual(ast.body[0].argnames[0].names.length, 2);
+
+        // Check whole destructuring structure of first argument
+        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
+        assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].names[1].is_array, false);
+
+        // Check content of second destructuring element (which is the nested destructuring pattern)
+        assert(ast.body[0].argnames[0].names[1].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].argnames[0].names[1].names[0].key, "b");
+        assert(ast.body[0].argnames[0].names[1].names[0].value instanceof UglifyJS.AST_DefaultAssign);
+
+        // Property b of second argument
+        assert(ast.body[0].argnames[0].names[1].names[0].value instanceof UglifyJS.AST_DefaultAssign);
+        assert(ast.body[0].argnames[0].names[1].names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].argnames[0].names[1].names[0].value.operator, "=");
+        assert(ast.body[0].argnames[0].names[1].names[0].value.right instanceof UglifyJS.AST_Number);
+
+
+        ast = UglifyJS.parse("function foo({a, b: {b = 123}}){}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // Check first argument
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].is_array, false);
+        assert.strictEqual(ast.body[0].argnames[0].names.length, 2);
+
+        // Check whole destructuring structure of first argument
+        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
+        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_SymbolFunarg);
+        assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].argnames[0].names[1].key, "b");
+        assert(ast.body[0].argnames[0].names[1].value instanceof UglifyJS.AST_Destructuring);
+
+        // Check content of nested destructuring in first parameter
+        var content = ast.body[0].argnames[0].names[1].value
+        assert.strictEqual(content.is_array, false);
+        assert.strictEqual(content.names.length, 1);
+        assert(content.names[0] instanceof UglifyJS.AST_ObjectKeyVal);
+        assert.strictEqual(content.names[0].key, "b");
+        assert(content.names[0].value instanceof UglifyJS.AST_DefaultAssign);
+        assert(content.names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
+        assert.strictEqual(content.names[0].value.operator, "=");
+        assert(content.names[0].value.right instanceof UglifyJS.AST_Number);
+
+
+        ast = UglifyJS.parse("function foo({a: {b = 123}}){}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // Check first argument
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].is_array, false);
+        assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
+
+        // Check whole destructuring structure of first argument
+        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
+        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_Destructuring);
+
+        // Check content of nested destructuring
+        content = ast.body[0].argnames[0].names[0].value
+        assert.strictEqual(content.is_array, false);
+        assert.strictEqual(content.names.length, 1);
+        assert(content.names[0] instanceof UglifyJS.AST_ObjectKeyVal);
+        assert.strictEqual(content.names[0].key, "b");
+        assert(content.names[0].value instanceof UglifyJS.AST_DefaultAssign);
+        assert(content.names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
+        assert.strictEqual(content.names[0].value.operator, "=");
+        assert(content.names[0].value.right instanceof UglifyJS.AST_Number);
+    });
+
+    it("Should parse spread correctly", function() {
+        var ast = UglifyJS.parse("function foo(a, b, ...c){}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 3);
+
+        // Check parameters
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_SymbolFunarg);
+        assert(ast.body[0].argnames[1] instanceof UglifyJS.AST_SymbolFunarg);
+        assert(ast.body[0].argnames[2] instanceof UglifyJS.AST_Expansion);
+        assert(ast.body[0].argnames[2].expression instanceof UglifyJS.AST_SymbolFunarg);
+
+
+        ast = UglifyJS.parse("function foo([a, b, ...c]){}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // Check first parameter
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].is_array, true);
+
+        // Check content first parameter
+        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
+        assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_SymbolFunarg);
+        assert(ast.body[0].argnames[0].names[2] instanceof UglifyJS.AST_Expansion);
+        assert(ast.body[0].argnames[0].names[2].expression instanceof UglifyJS.AST_SymbolFunarg);
+
+
+        ast = UglifyJS.parse("function foo([a, b, [c, ...d]]){}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // Check first parameter
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].is_array, true);
+
+        // Check content outer destructuring array
+        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
+        assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_SymbolFunarg);
+        assert(ast.body[0].argnames[0].names[2] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].names[2].is_array, true);
+
+        // Check content nested destructuring array
+        assert.strictEqual(ast.body[0].argnames[0].names[2].names.length, 2);
+        assert(ast.body[0].argnames[0].names[2].names[0] instanceof UglifyJS.AST_SymbolFunarg);
+        assert(ast.body[0].argnames[0].names[2].names[1] instanceof UglifyJS.AST_Expansion);
+        assert(ast.body[0].argnames[0].names[2].names[1].expression instanceof UglifyJS.AST_SymbolFunarg);
+
+
+        ast = UglifyJS.parse("function foo({a: [b, ...c]}){}");
+        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
+        assert.strictEqual(ast.body[0].argnames.length, 1);
+
+        // Check first parameter
+        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].is_array, false);
+
+        // Check outer destructuring object
+        assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
+        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
+        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_Destructuring);
+        assert.strictEqual(ast.body[0].argnames[0].names[0].value.is_array, true);
+
+        // Check content nested destructuring array
+        assert.strictEqual(ast.body[0].argnames[0].names[0].value.names.length, 2);
+        assert(ast.body[0].argnames[0].names[0].value.names[0] instanceof UglifyJS.AST_SymbolFunarg);
+        assert(ast.body[0].argnames[0].names[0].value.names[1] instanceof UglifyJS.AST_Expansion);
+        assert(ast.body[0].argnames[0].names[0].value.names[1].expression instanceof UglifyJS.AST_SymbolFunarg);
+    });
+});

test/mocha/arrow.js

@@ -0,0 +1,399 @@
+var assert = require("assert");
+var uglify = require("../node");
+
+describe("Arrow functions", function() {
+    it("Should not accept spread tokens on non-last parameters or without arguments parentheses", function() {
+        var tests = [
+            "var a = ...a => {return a.join()}",
+            "var b = (a, ...b, c) => { return a + b.join() + c}",
+            "var c = (...a, b) => a.join()"
+        ];
+        var test = function(code) {
+            return function() {
+                uglify.parse(code);
+            }
+        }
+        var error = function(e) {
+            return e instanceof uglify.JS_Parse_Error &&
+                e.message === "Unexpected token: expand (...)";
+        }
+
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error);
+        }
+    });
+    it("Should not accept holes in object binding patterns, while still allowing a trailing elision", function() {
+        var tests = [
+            "f = ({, , ...x} = [1, 2]) => {};"
+        ];
+        var test = function(code) {
+            return function() {
+                uglify.parse(code);
+            }
+        }
+        var error = function(e) {
+            return e instanceof uglify.JS_Parse_Error &&
+                e.message === "Unexpected token: punc (,)";
+        }
+
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error);
+        }
+    });
+    it("Should not accept newlines before arrow token", function() {
+        var tests = [
+            "f = foo\n=> 'foo';",
+            "f = (foo, bar)\n=> 'foo';",
+            "f = ()\n=> 'foo';",
+            "foo((bar)\n=>'baz';);"
+        ];
+        var test = function(code) {
+            return function() {
+                uglify.parse(code);
+            }
+        }
+        var error = function(e) {
+            return e instanceof uglify.JS_Parse_Error &&
+                e.message === "Unexpected newline before arrow (=>)";
+        }
+
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error);
+        }
+    });
+    it("Should not accept arrow functions in the middle or end of an expression", function() {
+        [
+            "0 + x => 0",
+            "0 + async x => 0",
+            "typeof x => 0",
+            "typeof async x => 0",
+            "typeof (x) => null",
+            "typeof async (x) => null",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                uglify.parse(code);
+            }, function(e) {
+                return e instanceof uglify.JS_Parse_Error && /^Unexpected /.test(e.message);
+            }, code);
+        });
+    });
+
+    it("Should parse a function containing default assignment correctly", function() {
+        var ast = uglify.parse("var a = (a = 123) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // First argument
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_DefaultAssign);
+        assert(ast.body[0].definitions[0].value.argnames[0].left instanceof uglify.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].operator, "=");
+        assert(ast.body[0].definitions[0].value.argnames[0].right instanceof uglify.AST_Number);
+
+        ast = uglify.parse("var a = (a = a) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // First argument
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_DefaultAssign);
+        assert(ast.body[0].definitions[0].value.argnames[0].left instanceof uglify.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].operator, "=");
+        assert(ast.body[0].definitions[0].value.argnames[0].right instanceof uglify.AST_SymbolRef);
+    });
+
+    it("Should parse a function containing default assignments in destructuring correctly", function() {
+        var ast = uglify.parse("var a = ([a = 123]) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // First argument
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_DefaultAssign);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].left instanceof uglify.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].operator, "=");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].right instanceof uglify.AST_Number);
+
+
+        ast = uglify.parse("var a = ({a = 123}) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // First argument
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
+
+        // First object element in first argument
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_DefaultAssign);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.left instanceof uglify.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.operator, "=");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.right instanceof uglify.AST_Number);
+
+
+        ast = uglify.parse("var a = ({a: a = 123}) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // First argument
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
+
+        // Content destructuring of first argument
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectProperty);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_DefaultAssign);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.left instanceof uglify.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.operator, "=");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.right instanceof uglify.AST_Number);
+    });
+
+    it("Should parse a function containing default assignments in complex destructuring correctly", function() {
+        var ast = uglify.parse("var a = ([a, [b = 123]]) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // Check first argument
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 2);
+
+        // Check whole destructuring structure of first argument
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].is_array, true);
+
+        // Check content of second destructuring element (which is the nested destructuring pattern)
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0] instanceof uglify.AST_DefaultAssign);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].left instanceof uglify.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].operator, "=");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].right instanceof uglify.AST_Number);
+
+
+        ast = uglify.parse("var a = ([a, {b: c = 123}]) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // Check first argument
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 2);
+
+        // Check whole destructuring structure of first argument
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].is_array, false);
+
+        // Check content of second destructuring element (which is the nested destructuring pattern)
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0] instanceof uglify.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].key, "b");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value instanceof uglify.AST_DefaultAssign);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value.left instanceof uglify.AST_SymbolFunarg);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value.operator, "=");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value.right instanceof uglify.AST_Number);
+
+
+        ast = uglify.parse("var a = ({a, b: {b = 123}}) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // Check first argument
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 2);
+
+        // First argument, property 1
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_SymbolFunarg);
+
+        // First argument, property 2
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].key, "b");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1].value instanceof uglify.AST_Destructuring);
+
+        // Check content of nested destructuring
+        var content = ast.body[0].definitions[0].value.argnames[0].names[1].value
+        assert.strictEqual(content.is_array, false);
+        assert.strictEqual(content.names.length, 1);
+        assert(content.names[0] instanceof uglify.AST_ObjectKeyVal);
+
+        // Content of first property in nested destructuring
+        assert.strictEqual(content.names[0].key, "b");
+        assert(content.names[0].value instanceof uglify.AST_DefaultAssign);
+        assert(content.names[0].value.left instanceof uglify.AST_SymbolFunarg);
+        assert.strictEqual(content.names[0].value.operator, "=");
+        assert(content.names[0].value.right instanceof uglify.AST_Number);
+
+
+        ast = uglify.parse("var a = ({a: {b = 123}}) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // Check first argument
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
+
+        // Check whole destructuring structure of first argument
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_Destructuring);
+
+        // Check content of nested destructuring
+        content = ast.body[0].definitions[0].value.argnames[0].names[0].value
+        assert.strictEqual(content.is_array, false);
+        assert.strictEqual(content.names.length, 1);
+        assert(content.names[0] instanceof uglify.AST_ObjectKeyVal);
+
+        // Check first property of nested destructuring
+        assert.strictEqual(content.names[0].key, "b");
+        assert(content.names[0].value instanceof uglify.AST_DefaultAssign);
+        assert(content.names[0].value.left instanceof uglify.AST_SymbolFunarg);
+        assert.strictEqual(content.names[0].value.operator, "=");
+        assert(content.names[0].value.right instanceof uglify.AST_Number);
+    });
+
+    it("Should parse spread correctly", function() {
+        var ast = uglify.parse("var a = (a, b, ...c) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 3);
+
+        // Check parameters
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_SymbolFunarg);
+        assert(ast.body[0].definitions[0].value.argnames[1] instanceof uglify.AST_SymbolFunarg);
+        assert(ast.body[0].definitions[0].value.argnames[2] instanceof uglify.AST_Expansion);
+        assert(ast.body[0].definitions[0].value.argnames[2].expression instanceof uglify.AST_SymbolFunarg);
+
+
+        ast = uglify.parse("var a = ([a, b, ...c]) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // Check first parameter
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
+
+        // Check content first parameter
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_SymbolFunarg);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[2] instanceof uglify.AST_Expansion);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[2].expression instanceof uglify.AST_SymbolFunarg);
+
+
+        ast = uglify.parse("var a = ([a, b, [c, ...d]]) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // Check first parameter
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
+
+        // Check content outer destructuring array
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_SymbolFunarg);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[2] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[2].is_array, true);
+
+        // Check content nested destructuring array
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[2].names.length, 2);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[2].names[0] instanceof uglify.AST_SymbolFunarg);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[2].names[1] instanceof uglify.AST_Expansion);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[2].names[1].expression instanceof uglify.AST_SymbolFunarg);
+
+
+        ast = uglify.parse("var a = ({a: [b, ...c]}) => {}");
+        assert(ast.body[0] instanceof uglify.AST_Var);
+        assert.strictEqual(ast.body[0].definitions.length, 1);
+        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
+        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
+        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
+
+        // Check first parameter
+        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
+
+        // Check outer destructuring object
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_Destructuring);
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.is_array, true);
+
+        // Check content nested destructuring array
+        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.names.length, 2);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.names[0] instanceof uglify.AST_SymbolFunarg);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.names[1] instanceof uglify.AST_Expansion);
+        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.names[1].expression instanceof uglify.AST_SymbolFunarg);
+    });
+
+    it("Should handle arrow function with bind", function() {
+        function minify(code) {
+            return uglify.minify(code, {
+                mangle: false
+            }).code;
+        }
+
+        assert.strictEqual(
+            minify(minify("test(((index) => { console.log(this, index); }).bind(this, 1));")),
+            "test((index=>{console.log(this,index)}).bind(this,1));"
+        );
+        assert.strictEqual(
+            minify(minify('test(((index) => { console.log(this, index); })["bind"](this, 1));')),
+            "test((index=>{console.log(this,index)}).bind(this,1));"
+        );
+    });
+
+});

test/mocha/builtins.js

@@ -0,0 +1,34 @@
+var UglifyJS = require("../../");
+var assert = require("assert");
+
+describe("builtins", function() {
+    it ("Should not mangle builtins", function() {
+        var test = "function foo(something){\n" +
+            "    return [Object,Array,Function,Number,String,Boolean,Error,Math,Date,RegExp,Symbol,Map,Promise,Proxy,Reflect,Set,WeakMap,WeakSet,Float32Array,something];\n" +
+            "};";
+
+        var result = UglifyJS.minify(test, {parse: {bare_returns: true}}).code;
+
+        assert.strictEqual(result.indexOf("something"), -1);
+
+        assert.notEqual(result.indexOf("Object"), -1);
+        assert.notEqual(result.indexOf("Array"), -1);
+        assert.notEqual(result.indexOf("Function"), -1);
+        assert.notEqual(result.indexOf("Number"), -1);
+        assert.notEqual(result.indexOf("String"), -1);
+        assert.notEqual(result.indexOf("Boolean"), -1);
+        assert.notEqual(result.indexOf("Error"), -1);
+        assert.notEqual(result.indexOf("Math"), -1);
+        assert.notEqual(result.indexOf("Date"), -1);
+        assert.notEqual(result.indexOf("RegExp"), -1);
+        assert.notEqual(result.indexOf("Symbol"), -1);
+        assert.notEqual(result.indexOf("Promise"), -1);
+        assert.notEqual(result.indexOf("Proxy"), -1);
+        assert.notEqual(result.indexOf("Reflect"), -1);
+        assert.notEqual(result.indexOf("Set"), -1);
+        assert.notEqual(result.indexOf("WeakMap"), -1);
+        assert.notEqual(result.indexOf("WeakSet"), -1);
+        assert.notEqual(result.indexOf("Map"), -1);
+        assert.notEqual(result.indexOf("Float32Array"), -1);
+    });
+});

test/mocha/class.js

@@ -0,0 +1,57 @@
+var assert = require("assert");
+var uglify = require("../node");
+
+describe("Class", function() {
+    it("Should not accept spread on non-last parameters in methods", function() {
+        var tests = [
+            "class foo { bar(...a, b) { return a.join(b) } }",
+            "class foo { bar(a, b, ...c, d) { return c.join(a + b) + d } }",
+            "class foo { *bar(...a, b) { return a.join(b) } }",
+            "class foo { *bar(a, b, ...c, d) { return c.join(a + b) + d } }"
+        ];
+        var test = function(code) {
+            return function() {
+                uglify.parse(code);
+            }
+        }
+        var error = function(e) {
+            return e instanceof uglify.JS_Parse_Error &&
+                /^Unexpected token: /.test(e.message);
+        }
+
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error);
+        }
+    });
+
+    it("Should return the correct token for class methods", function() {
+        var tests = [
+            {
+                code: "class foo{static test(){}}",
+                token_value_start: "static",
+                token_value_end: "}"
+            },
+            {
+                code: "class bar{*procedural(){}}",
+                token_value_start: "*",
+                token_value_end: "}"
+            },
+            {
+                code: "class foobar{aMethod(){}}",
+                token_value_start: "aMethod",
+                token_value_end: "}"
+            },
+            {
+                code: "class foobaz{get something(){}}",
+                token_value_start: "get",
+                token_value_end: "}"
+            }
+        ];
+
+        for (var i = 0; i < tests.length; i++) {
+            var ast = uglify.parse(tests[i].code);
+            assert.strictEqual(ast.body[0].properties[0].start.value, tests[i].token_value_start);
+            assert.strictEqual(ast.body[0].properties[0].end.value, tests[i].token_value_end);
+        }
+    });
+});

test/mocha/cli.js

@@ -1,6 +1,7 @@
 var assert = require("assert");
 var exec = require("child_process").exec;
 var readFileSync = require("fs").readFileSync;
+var semver = require("semver");
 
 function read(path) {
     return readFileSync(path, "utf8");
@@ -9,11 +10,13 @@ function read(path) {
 describe("bin/uglifyjs", function () {
     var uglifyjscmd = '"' + process.argv[0] + '" bin/uglifyjs';
     it("should produce a functional build when using --self", function (done) {
-        this.timeout(30000);
+        this.timeout(120000);
 
-        var command = uglifyjscmd + ' --self -cm --wrap WrappedUglifyJS';
+        var command = uglifyjscmd + ' --self -mc ecma=';
+        command += semver.satisfies(process.version, ">=4") ? "6" : "5";
+        command += ',passes=3,keep_fargs=false,unsafe --wrap WrappedUglifyJS';
 
-        exec(command, function (err, stdout) {
+        exec(command, { maxBuffer: 1048576 }, function (err, stdout) {
             if (err) throw err;
 
             eval(stdout);
@@ -398,6 +401,21 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("Should throw syntax error (const a)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/const.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/const.js:7,11",
+                "    const a;",
+                "           ^",
+                "ERROR: Missing initializer in const declaration"
+            ].join("\n"));
+            done();
+        });
+    });
     it("Should throw syntax error (delete x)", function(done) {
         var command = uglifyjscmd + ' test/input/invalid/delete.js';
 
@@ -468,7 +486,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 identifier as parameter inside strict mode"
             ].join("\n"));
             done();
         });
@@ -518,6 +536,81 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("Should throw syntax error (block-level export)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/export_1.js -m';
+
+        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/export_1.js:2,4",
+                "    export var V = 1;",
+                "    ^",
+                "ERROR: Export statement may only appear at top level"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (block-level import)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/import.js -m';
+
+        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/import.js:2,4",
+                '    import A from "B";',
+                "    ^",
+                "ERROR: Import statement may only appear at top level"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (anonymous class)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/export_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/export_2.js:1,12",
+                "export class{};",
+                "            ^",
+                "ERROR: Unexpected token: punc ({)"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (anonymous function)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/export_3.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/export_3.js:1,15",
+                "export function(){};",
+                "               ^",
+                "ERROR: Unexpected token: punc (()"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (spread in sequence)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/sequence.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/sequence.js:1,4",
+                "(a, ...b);",
+                "    ^",
+                "ERROR: Unexpected token: expand (...)"
+            ].join("\n"));
+            done();
+        });
+    });
     it("Should throw syntax error (for-in init)", function(done) {
         var command = uglifyjscmd + ' test/input/invalid/for-in_1.js';
 

test/mocha/comment-filter.js

@@ -14,7 +14,7 @@ describe("comment filters", function() {
 
     it("Should be able to filter commments with the 'some' option", function() {
         var ast = UglifyJS.parse("// foo\n/*@preserve*/\n// bar\n/*@license*/\n//@license with the wrong comment type\n/*@cc_on something*/");
-        assert.strictEqual(ast.print_to_string({comments: "some"}), "/*@preserve*/\n/*@license*/\n/*@cc_on something*/\n");
+        assert.strictEqual(ast.print_to_string({comments: "some"}), "/*@preserve*/\n/*@license*/\n/*@cc_on something*/");
     });
 
     it("Should be able to filter comments by passing a function", function() {
@@ -55,12 +55,12 @@ describe("comment filters", function() {
             return true;
         };
 
-        assert.strictEqual(ast.print_to_string({comments: f}), "#!Random comment\n//test1\n/*test2*/\n");
+        assert.strictEqual(ast.print_to_string({comments: f}), "#!Random comment\n//test1\n/*test2*/");
     });
 
     it("Should never be able to filter comment5 when using 'some' as filter", function() {
         var ast = UglifyJS.parse("#!foo\n//foo\n/*@preserve*/\n/* please hide me */");
-        assert.strictEqual(ast.print_to_string({comments: "some"}), "#!foo\n/*@preserve*/\n");
+        assert.strictEqual(ast.print_to_string({comments: "some"}), "#!foo\n/*@preserve*/");
     });
 
     it("Should have no problem on multiple calls", function() {

test/mocha/comment.js

@@ -31,7 +31,8 @@ describe("Comment", function() {
             "/*Some comment 2\r\n\r\n\r\n*/\r\n>\n\n\n\n\n\n",
             "/*Some comment 3\r\r\r*/\r>\n\n\n\n\n\n",
             "/*Some comment 4\u2028\u2028\u2028*/\u2028>\n\n\n\n\n\n",
-            "/*Some comment 5\u2029\u2029\u2029*/\u2029>\n\n\n\n\n\n"
+            "/*Some comment 5\u2029\u2029\u2029*/\u2029>\n\n\n\n\n\n",
+            "/*Some comment 6\udbff\udfff\udbff\udfff\n\n\n*/\n>\n\n\n\n\n"
         ];
 
         var fail = function(e) {
@@ -47,4 +48,176 @@ describe("Comment", function() {
             }, fail, tests[i]);
         }
     });
+
+    it("Should handle comment within return correctly", function() {
+        var result = uglify.minify([
+            "function unequal(x, y) {",
+            "    return (",
+            "        // Either one",
+            "        x < y",
+            "        ||",
+            "        y < x",
+            "    );",
+            "}",
+        ].join("\n"), {
+            compress: false,
+            mangle: false,
+            output: {
+                beautify: true,
+                comments: "all",
+            },
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "function unequal(x, y) {",
+            "    // Either one",
+            "    return x < y || y < x;",
+            "}",
+        ].join("\n"));
+    });
+
+    it("Should handle comment folded into return correctly", function() {
+        var result = uglify.minify([
+            "function f() {",
+            "    /* boo */ x();",
+            "    return y();",
+            "}",
+        ].join("\n"), {
+            mangle: false,
+            output: {
+                beautify: true,
+                comments: "all",
+            },
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, [
+            "function f() {",
+            "    /* boo */",
+            "    return x(), y();",
+            "}",
+        ].join("\n"));
+    });
+
+    it("Should not drop comments after first OutputStream", function() {
+        var code = "/* boo */\nx();";
+        var ast = uglify.parse(code);
+        var out1 = uglify.OutputStream({
+            beautify: true,
+            comments: "all",
+        });
+        ast.print(out1);
+        var out2 = uglify.OutputStream({
+            beautify: true,
+            comments: "all",
+        });
+        ast.print(out2);
+        assert.strictEqual(out1.get(), code);
+        assert.strictEqual(out2.get(), out1.get());
+    });
+
+    it("Should retain trailing comments", function() {
+        var code = [
+            "if (foo /* lost comment */ && bar /* lost comment */) {",
+            "    // this one is kept",
+            "    {/* lost comment */}",
+            "    !function() {",
+            "        // lost comment",
+            "    }();",
+            "    function baz() {/* lost comment */}",
+            "    // lost comment",
+            "}",
+            "// comments right before EOF are lost as well",
+        ].join("\n");
+        var result = uglify.minify(code, {
+            compress: false,
+            mangle: false,
+            output: {
+                beautify: true,
+                comments: "all",
+            },
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, code);
+    });
+
+    it("Should correctly preserve new lines around comments", function() {
+        var tests = [
+            [
+                "// foo",
+                "// bar",
+                "x();",
+            ].join("\n"),
+            [
+                "// foo",
+                "/* bar */",
+                "x();",
+            ].join("\n"),
+            [
+                "// foo",
+                "/* bar */ x();",
+            ].join("\n"),
+            [
+                "/* foo */",
+                "// bar",
+                "x();",
+            ].join("\n"),
+            [
+                "/* foo */ // bar",
+                "x();",
+            ].join("\n"),
+            [
+                "/* foo */",
+                "/* bar */",
+                "x();",
+            ].join("\n"),
+            [
+                "/* foo */",
+                "/* bar */ x();",
+            ].join("\n"),
+            [
+                "/* foo */ /* bar */",
+                "x();",
+            ].join("\n"),
+            "/* foo */ /* bar */ x();",
+        ].forEach(function(code) {
+            var result = uglify.minify(code, {
+                compress: false,
+                mangle: false,
+                output: {
+                    beautify: true,
+                    comments: "all",
+                },
+            });
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, code);
+        });
+    });
+
+    it("Should preserve new line before comment without beautify", function() {
+        var code = [
+            "function f(){",
+            "/* foo */bar()}",
+        ].join("\n");
+        var result = uglify.minify(code, {
+            compress: false,
+            mangle: false,
+            output: {
+                comments: "all",
+            },
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, code);
+    });
+
+    it("Should preserve comments around IIFE", function() {
+        var result = uglify.minify("/*a*/(/*b*/function(){/*c*/}/*d*/)/*e*/();", {
+            compress: false,
+            mangle: false,
+            output: {
+                comments: "all",
+            },
+        });
+        if (result.error) throw result.error;
+        assert.strictEqual(result.code, "/*a*/ /*b*/(function(){/*c*/}/*d*/ /*e*/)();");
+    });
 });

test/mocha/destructuring.js

@@ -0,0 +1,138 @@
+var assert = require("assert");
+var uglify = require("../node");
+
+describe("Destructuring", function() {
+    it("Should generate similar trees for destructuring in left hand side expressions, definitions, functions and arrow functions", function() {
+        var patterns = [
+            "[]",
+            "{}",
+
+            "[a, b, c]",
+            "{a: b, c: d}",
+            "{a}",
+            "{a, b}",
+
+            "{a: {}}",
+            "{a: []}",
+            "[{}]",
+            "[[]]",
+            "{a: {b}}",
+
+            // Can't do `a = 123` with lhs expression, so only test in destructuring
+            "[foo = bar]",
+            "{a = 123}",
+            "[{foo: abc = 123}]",
+            "{foo: [abc = 123]}",
+
+            "[...foo]",
+            "[...{}]",
+            "[...[]]"
+
+            // Can't do `...` because that is an invalid lhs expression, spread in array destructuring should be fine though
+        ];
+
+        var types = [
+            {
+                name: "lhs",
+                symbolType: uglify.AST_SymbolRef,
+                tree: function (ast) {
+                    return ast.body[0].body.left;
+                },
+                generate: function (code) {
+                    return "(" + code + " = a)";
+                }
+            },
+            {
+                name: "var",
+                symbolType: uglify.AST_SymbolVar,
+                tree: function (ast) {
+                    return ast.body[0].definitions[0].name;
+                },
+                generate: function (code) {
+                    return "var " + code + " = a";
+                }
+            },
+            {
+                name: "function",
+                symbolType: uglify.AST_SymbolFunarg,
+                tree: function (ast) {
+                    return ast.body[0].argnames[0];
+                },
+                generate: function (code) {
+                    return "function a(" + code + ") {}";
+                }
+            },
+            {
+                name: "arrow",
+                symbolType: uglify.AST_SymbolFunarg,
+                tree: function (ast) {
+                    return ast.body[0].definitions[0].value.argnames[0];
+                },
+                generate: function (code) {
+                    return "var a = (" + code + ") => {}";
+                }
+            }
+        ];
+
+        var walker = function(type, ref, code, result) {
+            var w = new uglify.TreeWalker(function(node) {
+                if (w.parent() instanceof uglify.AST_DefaultAssign &&
+                    w.parent().right === node
+                ) {
+                    return true; // Don't check the content of the default assignment
+
+                } else if (node instanceof uglify.AST_Symbol) {
+                    assert(node instanceof type.symbolType,
+                        node.TYPE + " while " + type.symbolType.TYPE + " expected at pos " +
+                        node.start.pos + " in `" + code + "`  (" + ref + ")"
+                    );
+
+                    result.push([
+                        new uglify.AST_Symbol({
+                            start: node.start,
+                            name: node.name,
+                            end: node.end
+                        }),
+                        w.parent()
+                    ]);
+
+                    return;
+                }
+
+                result.push([node, w.parent()]);
+            });
+
+            return w;
+        };
+
+        var getNodeType = function(node) {
+            return node[0].TYPE + (node[1] ? " " + node[1].TYPE : "");
+        }
+
+        for (var i = 0; i < patterns.length; i++) {
+            var results = [];
+
+            for (var j = 0; j < types.length; j++) {
+                var code = types[j].generate(patterns[i])
+                var ast = types[j].tree(
+                    uglify.parse(code)
+                );
+                results.push([]);
+                ast.walk(walker(
+                    types[j],
+                    "`" + patterns[i] + "` on " + types[j].name,
+                    code,
+                    results[j]
+                ));
+
+                if (j > 0) {
+                    assert.deepEqual(
+                        results[0].map(getNodeType),
+                        results[j].map(getNodeType),
+                        "AST disagree on " + patterns[i] + " with " + types[j].name
+                    );
+                }
+            }
+        }
+    });
+});

test/mocha/directives.js

@@ -62,10 +62,10 @@ describe("Directives", function() {
     it("Should know which strings are directive and which ones are not", function() {
         var test_directive = function(tokenizer, test) {
             test.directives.map(function(directive) {
-                assert.strictEqual(tokenizer.has_directive(directive), true, directive + " in " + test.input);
+                assert.strictEqual(tokenizer.has_directive(directive), true, "Didn't found directive `" + directive + "` at the end of `" + test.input + '`');
             });
             test.non_directives.map(function(fake_directive) {
-                assert.strictEqual(tokenizer.has_directive(fake_directive), false, fake_directive + " in " + test.input);
+                assert.strictEqual(tokenizer.has_directive(fake_directive), false, "Unexpectedly found directive `" + fake_directive + "` at the end of `" + test.input + '`');
             });
         }
 
@@ -156,6 +156,16 @@ describe("Directives", function() {
                 input: '"use strict";try{"use asm";',
                 directives: ["use strict"],
                 non_directives: ["use\nstrict", "use \nstrict", "use asm"]
+            },
+            {
+                input: 'class foo {',
+                directives: ["use strict"],
+                non_directives: ["use\nstrict", "use asm"]
+            },
+            {
+                input: 'class foo {}',
+                directives: [],
+                non_directives: ["use strict", "use asm", "use\nstrict"]
             }
         ];
 
@@ -378,4 +388,44 @@ describe("Directives", function() {
             );
         }
     });
+    it("Should be detect implicit usages of strict mode from tree walker", function() {
+        var tests = [
+            {
+                input: 'class foo {bar(){_check_}}',
+                directives: ["use strict"],
+                non_directives: ["use bar"]
+            },
+            {
+                input: 'class foo {bar(){}}_check_',
+                directives: [],
+                non_directives: ["use strict", "use bar"]
+            }
+        ];
+
+        var i = 0;
+        var checked;
+        var checkWalker = new uglify.TreeWalker(function(node, descend) {
+            if (node instanceof uglify.AST_Symbol && node.name === "_check_") {
+                checked = true;
+                for (var j = 0; j < tests[i].directives.length; j++) {
+                    assert.ok(checkWalker.has_directive(tests[i].directives[j]),
+                        "Did not found directive '" + tests[i].directives[j] +  "' in test " + tests[i].input)
+                }
+                for (var k = 0; k < tests[i].non_directives.length; k++) {
+                    assert.equal(checkWalker.has_directive(tests[i].non_directives[k]), undefined,
+                        "Found directive '" + tests[i].non_directives[k] +  "' in test " + tests[i].input)
+                }
+            }
+        });
+
+        for (; i < tests.length; i++) {
+            // Do tests - iterate the ast in each test - check only when _check_ occurs - fail when no _check_ has been found
+            checked = false;
+            var ast = uglify.parse(tests[i].input);
+            ast.walk(checkWalker);
+            if (!checked) {
+                throw "No _check_ symbol found in " + tests[i].input;
+            }
+        }
+    });
 });

test/mocha/eof.js

@@ -0,0 +1,35 @@
+var assert = require("assert");
+var uglify = require("../node");
+
+describe("EOF", function() {
+    it("Should test code for at least throwing syntax error when incomplete", function() {
+        var error = function(e) {
+            return e instanceof uglify.JS_Parse_Error;
+        }
+        var parse = function(test) {
+            return function() {
+                uglify.parse(test);
+            }
+        }
+        // Chops off 1 char at a time until limit or start of string is reached
+        // The passed code must still be valid when unchopped
+        var test_eol = function(input, chopLimit) {
+            if (chopLimit === undefined) {
+                chopLimit = input.length - 1;
+            }
+
+            assert.doesNotThrow(parse(input), "Expected valid code for \n" + input);
+
+            for (var i = input.length - 1; chopLimit > 0; chopLimit--, i--) {
+                var code = input.substr(0, i);
+                assert.throws(parse(code), error, code);
+            }
+        }
+
+        test_eol("var \\u1234", 7); // Incomplete identifier
+        test_eol("'Incomplete string'");
+        test_eol("/Unterminated regex/");
+        test_eol("` Unterminated template string`");
+        test_eol("/* Unfinishing multiline comment */");
+    });
+});

test/mocha/export.js

@@ -0,0 +1,57 @@
+var assert = require("assert");
+var uglify = require("../node");
+
+describe("Export/Import", function() {
+    it("Should parse export directives", function() {
+        var inputs = [
+            ['export * from "a.js"', ['*'], "a.js"],
+            ['export {A} from "a.js"', ['A'], "a.js"],
+            ['export {A as X} from "a.js"', ['X'], "a.js"],
+            ['export {A as Foo, B} from "a.js"', ['Foo', 'B'], "a.js"],
+            ['export {A, B} from "a.js"', ['A', 'B'], "a.js"],
+        ];
+
+        function test(code) {
+            return uglify.parse(code);
+        }
+
+        function extractNames(symbols) {
+            var ret = [];
+            for (var i = 0; i < symbols.length; i++) {
+                ret.push(symbols[i].foreign_name.name);
+            }
+            return ret;
+        }
+
+        for (var i = 0; i < inputs.length; i++) {
+            var ast = test(inputs[i][0]);
+            var names = inputs[i][1];
+            var filename = inputs[i][2];
+            assert(ast instanceof uglify.AST_Toplevel);
+            assert.equal(ast.body.length, 1);
+            var st = ast.body[0];
+            assert(st instanceof uglify.AST_Export);
+            var actualNames = extractNames(st.exported_names);
+            assert.deepEqual(actualNames, names);
+            assert.equal(st.module_name.value, filename);
+        }
+    });
+
+    it("Should not parse invalid uses of export", function() {
+        assert.equal(uglify.minify("export").error.message, "Unexpected token: eof (undefined)");
+        assert.equal(uglify.minify("export;").error.message, "Unexpected token: punc (;)");
+        assert.equal(uglify.minify("export();").error.message, "Unexpected token: keyword (export)");
+        assert.equal(uglify.minify("export(1);").error.message, "Unexpected token: keyword (export)");
+        assert.equal(uglify.minify("var export;").error.message, "Name expected");
+        assert.equal(uglify.minify("var export = 1;").error.message, "Name expected");
+        assert.equal(uglify.minify("function f(export){}").error.message, "Invalid function parameter");
+    });
+
+    it("Should not parse invalid uses of import", function() {
+        assert.equal(uglify.minify("import").error.message, "Unexpected token: eof (undefined)");
+        assert.equal(uglify.minify("import;").error.message, "Unexpected token: punc (;)");
+        assert.equal(uglify.minify("var import;").error.message, "Unexpected token: import");
+        assert.equal(uglify.minify("var import = 1;").error.message, "Unexpected token: import");
+        assert.equal(uglify.minify("function f(import){}").error.message, "Unexpected token: name (import)");
+    });
+});

test/mocha/expression.js

@@ -0,0 +1,32 @@
+var assert = require("assert");
+var uglify = require("../node");
+
+describe("Expression", function() {
+    it("Should not allow the first exponentiation operator to be prefixed with an unary operator", function() {
+        var tests = [
+            "+5 ** 3",
+            "-5 ** 3",
+            "~5 ** 3",
+            "!5 ** 3",
+            "void 5 ** 3",
+            "typeof 5 ** 3",
+            "delete 5 ** 3",
+            "var a = -(5) ** 3;"
+        ];
+
+        var fail = function(e) {
+            return e instanceof uglify.JS_Parse_Error &&
+                /^Unexpected token: operator \((?:[!+~-]|void|typeof|delete)\)/.test(e.message);
+        }
+
+        var exec = function(test) {
+            return function() {
+                uglify.parse(test);
+            }
+        }
+
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(exec(tests[i]), fail, tests[i]);
+        }
+    });
+});

test/mocha/function.js

@@ -0,0 +1,288 @@
+var assert = require("assert");
+var uglify = require("../node");
+
+describe("Function", function() {
+    it ("Should parse binding patterns correctly", function() {
+        // Function argument nodes are correct
+        function get_args(args) {
+            return args.map(function (arg) {
+                return [arg.TYPE, arg.name];
+            });
+        }
+
+        // Destructurings as arguments
+        var destr_fun1 = uglify.parse('(function ({a, b}) {})').body[0].body;
+        var destr_fun2 = uglify.parse('(function ([a, [b]]) {})').body[0].body;
+        var destr_fun3 = uglify.parse('({a, b}) => null').body[0].body;
+        var destr_fun4 = uglify.parse('([a, [b]]) => null').body[0].body;
+
+        assert.equal(destr_fun1.argnames.length, 1);
+        assert.equal(destr_fun2.argnames.length, 1);
+        assert.equal(destr_fun3.argnames.length, 1);
+        assert.equal(destr_fun4.argnames.length, 1);
+
+        var destruct1 = destr_fun1.argnames[0];
+        var destruct2 = destr_fun2.argnames[0];
+        var destruct3 = destr_fun3.argnames[0];
+        var destruct4 = destr_fun4.argnames[0];
+
+        assert(destruct1 instanceof uglify.AST_Destructuring);
+        assert(destruct2 instanceof uglify.AST_Destructuring);
+        assert(destruct3 instanceof uglify.AST_Destructuring);
+        assert(destruct4 instanceof uglify.AST_Destructuring);
+        assert(destruct2.names[1] instanceof uglify.AST_Destructuring);
+        assert(destruct4.names[1] instanceof uglify.AST_Destructuring);
+
+        assert.equal(destruct1.start.value, '{');
+        assert.equal(destruct1.end.value, '}');
+        assert.equal(destruct2.start.value, '[');
+        assert.equal(destruct2.end.value, ']');
+        assert.equal(destruct3.start.value, '{');
+        assert.equal(destruct3.end.value, '}');
+        assert.equal(destruct4.start.value, '[');
+        assert.equal(destruct4.end.value, ']');
+
+        assert.equal(destruct1.is_array, false);
+        assert.equal(destruct2.is_array, true);
+        assert.equal(destruct3.is_array, false);
+        assert.equal(destruct4.is_array, true);
+
+        // destruct 1
+        assert.deepEqual(
+            [
+                destruct1.names[0].TYPE,
+                destruct1.names[0].key,
+                destruct1.names[0].value.name
+            ],
+            ['ObjectKeyVal', 'a', 'a']
+        );
+        assert.deepEqual(
+            [
+                destruct1.names[1].TYPE,
+                destruct1.names[1].key,
+                destruct1.names[1].value.name
+            ],
+            ['ObjectKeyVal', 'b', 'b']
+        );
+
+        // destruct 2
+        assert.deepEqual(
+            [
+                destruct2.names[0].TYPE,
+                destruct2.names[0].name
+            ],
+            ['SymbolFunarg', 'a']
+        );
+        assert.deepEqual(
+            [
+                destruct2.names[1].names[0].TYPE,
+                destruct2.names[1].names[0].name
+            ],
+            ['SymbolFunarg', 'b']
+        );
+
+        // destruct 3
+        assert.strictEqual(typeof destruct3.names[0].key, "string");
+        assert.strictEqual(destruct3.names[0].key, "a");
+        assert.strictEqual(destruct3.names[0].value.TYPE, "SymbolFunarg");
+        assert.strictEqual(destruct3.names[0].value.name, "a");
+        assert.strictEqual(typeof destruct3.names[1].key, "string");
+        assert.strictEqual(destruct3.names[1].key, "b");
+        assert.strictEqual(destruct3.names[1].value.TYPE, "SymbolFunarg");
+        assert.strictEqual(destruct3.names[1].value.name, "b");
+
+        // destruct 4
+        assert.deepEqual(
+            [
+                destruct4.names[0].TYPE,
+                destruct4.names[0].name
+            ],
+            ['SymbolFunarg', 'a']
+        );
+        assert.strictEqual(destruct4.names[1].TYPE, "Destructuring");
+        assert.deepEqual(
+            [
+                destruct4.names[1].names[0].TYPE,
+                destruct4.names[1].names[0].name
+            ],
+            ['SymbolFunarg', 'b']
+        );
+
+        assert.deepEqual(
+            get_args(destr_fun1.args_as_names()),
+            [['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
+        );
+        assert.deepEqual(
+            get_args(destr_fun2.args_as_names()),
+            [['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
+        );
+        assert.deepEqual(
+            get_args(destr_fun3.args_as_names()),
+            [['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
+        );
+        assert.deepEqual(
+            get_args(destr_fun4.args_as_names()),
+            [['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
+        );
+
+        // Making sure we don't accidentally accept things which
+        // Aren't argument destructurings
+
+        assert.throws(function () {
+            uglify.parse('(function ( { a, [ b ] } ) { })')
+        });
+
+        assert.throws(function () {
+            uglify.parse('(function (1) { })');
+        }, /Invalid function parameter/);
+
+        assert.throws(function () {
+            uglify.parse('(function (this) { })');
+        });
+
+        assert.throws(function () {
+            uglify.parse('(function ([1]) { })');
+        }, /Invalid function parameter/);
+
+        assert.throws(function () {
+            uglify.parse('(function [a] { })');
+        });
+
+        // generators
+        var generators_def = uglify.parse('function* fn() {}').body[0];
+        assert.equal(generators_def.is_generator, true);
+
+        assert.throws(function () {
+            uglify.parse('function* (){ }');
+        });
+
+        var generators_yield_def = uglify.parse('function* fn() {\nyield remote();\}').body[0].body[0];
+        assert.strictEqual(generators_yield_def.body.is_star, false);
+    });
+    it("Should not accept spread on non-last parameters", function() {
+        var tests = [
+            "var a = function(...a, b) { return a.join(b) }",
+            "var b = function(a, b, ...c, d) { return c.join(a + b) + d }",
+            "function foo(...a, b) { return a.join(b) }",
+            "function bar(a, b, ...c, d) { return c.join(a + b) + d }",
+            "var a = function*(...a, b) { return a.join(b) }",
+            "var b = function*(a, b, ...c, d) { return c.join(a + b) + d }",
+            "function* foo(...a, b) { return a.join(b) }",
+            "function* bar(a, b, ...c, d) { return c.join(a + b) + d }"
+        ];
+        var test = function(code) {
+            return function() {
+                uglify.parse(code);
+            }
+        }
+        var error = function(e) {
+            return e instanceof uglify.JS_Parse_Error &&
+                /^Unexpected token: /.test(e.message);
+        }
+
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error);
+        }
+    });
+    it("Should not accept empty parameters after elision", function() {
+        var tests = [
+            "(function(,){})()",
+            "(function(a,){})()",
+        ];
+        var test = function(code) {
+            return function() {
+                uglify.parse(code, { ecma: 5 });
+            }
+        }
+        var error = function(e) {
+            return e instanceof uglify.JS_Parse_Error;
+        }
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error, tests[i]);
+        }
+    });
+    it("Should accept trailing commas only for ES8", function() {
+        [
+            "new Foo(a, );",
+            "async(...[1, 2], );",
+            "console.log(...[1, 2], );",
+            "!function(a, b, ){ console.log(a + b); }(3, 4, );",
+        ].forEach(function(code) {
+            uglify.parse(code, { ecma: 8 });
+            assert.throws(function() {
+                uglify.parse(code, { ecma: 6 });
+            }, function(e) {
+                return e instanceof uglify.JS_Parse_Error;
+            }, code);
+        });
+    });
+    it("Should not accept invalid trailing commas", function() {
+        var tests = [
+            "f(, );",
+            "(, ) => {};",
+            "(...p, ) => {};",
+            "function f(, ) {}",
+            "function f(...p, ) {}",
+            "function foo(a, b, , ) {}",
+            'console.log("hello", , );',
+        ];
+        var test = function(code) {
+            return function() {
+                uglify.parse(code, { ecma: 8 });
+            }
+        }
+        var error = function(e) {
+            return e instanceof uglify.JS_Parse_Error;
+        }
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error, tests[i]);
+        }
+    });
+    it("Should not accept an initializer when parameter is a rest parameter", function() {
+        var tests = [
+            "(function(...a = b){})()",
+            "(function(a, ...b = [c, d]))"
+        ];
+        var test = function(code) {
+            return function () {
+                uglify.parse(code);
+            }
+        }
+        var error = function (e) {
+            return e instanceof uglify.JS_Parse_Error;
+        }
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error, tests[i]);
+        }
+    });
+    it("Shoult not accept duplicated identifiers inside parameters in strict mode or when using default assigment or spread", function() {
+        // From: ES2016 9.2.12 FunctionDeclarationInstantiation (func, argumentsList)
+        // NOTE Early errors ensure that duplicate parameter names can only occur
+        // in non-strict functions that do not have parameter default values or
+        // rest parameters.
+        var tests = [
+            "(function(a = 1, a){})()",
+            "(function(a, [a = 3]){})()",
+            "(function(a, b, c, d, [{e: [...a]}]){})()",
+            "'use strict'; (function(a, a){})",
+            "(function({a, a = b}))",
+            "(function(a, [...a]){})",
+            "(function(a, ...a){})",
+            "(function(a, [a, ...b]){})",
+            "(function(a, {b: a, c: [...d]}){})",
+            "(function(a, a, {b: [...c]}){})"
+        ];
+        var test = function(code) {
+            return function () {
+                uglify.parse(code);
+            }
+        }
+        var error = function (e) {
+            return e instanceof uglify.JS_Parse_Error &&
+                /^Parameter [a-zA-Z]+ was used already$/.test(e.message);
+        }
+        for (var i = 0; i < tests.length; i++) {
+            assert.throws(test(tests[i]), error, tests[i]);
+        }
+    });
+});