harmony-v3.1.5

Sub-optimal result due to block scope.

.github/ISSUE_TEMPLATE.md

@@ -8,7 +8,14 @@
 
 **Uglify version (`uglifyjs -V`)**
 
-**JavaScript input**  <!-- ideally as small as possible -->
+**JavaScript input**
+
+<!--
+    A complete parsable JS program exhibiting the issue with
+    UglifyJS alone - without third party tools or libraries.
+    Ideally the input should be as small as possible.
+    Post a link to a gist if necessary.
+-->
 
 **The `uglifyjs` CLI command executed or `minify()` options used.**
 

.travis.yml

@@ -4,8 +4,11 @@ node_js:
     - "0.12"
     - "4"
     - "6"
+    - "8"
 env:
     - UGLIFYJS_TEST_ALL=1
 matrix:
   fast_finish: true
 sudo: false
+cache:
+  directories: tmp

README.md

@@ -1,11 +1,11 @@
 uglify-es
 =========
 
-**uglify-es** is an ECMAScript 2015 parser, minifier, compressor and beautifier toolkit.
+A JavaScript parser, mangler/compressor and beautifier toolkit for ES6+.
 
 #### Note:
-- **The `uglify-es` API and CLI is compatible with `uglify-js@3.x`.**
-- **`uglify-es` is not backwards compatible with the `uglify-js@2.x` API and CLI.**
+- **`uglify-es` is API/CLI compatible with `uglify-js@3`.**
+- **`uglify-es` is not backwards compatible with `uglify-js@2`.**
 
 Install
 -------
@@ -102,13 +102,14 @@ 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>            Specifiy 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-fnames               Do not mangle/drop function names.  Useful for
                                 code relying on Function.prototype.name.
-    --name-cache                File to hold mangled name mappings.
+    --name-cache <file>         File to hold mangled name mappings.
     --self                      Build UglifyJS as a library (implies --wrap UglifyJS)
     --source-map [options]      Enable source map/specify source map options:
                                 `base`  Path to compute relative paths from input files.
@@ -147,19 +148,19 @@ debugging your compressed JavaScript.  To get a source map, pass
 
 Additional options:
 
-- `--source-map filename=<NAME>` to specify the name of the source map.
+- `--source-map "filename='<NAME>'"` to specify the name of the source map.
 
-- `--source-map root=<URL>` to pass the URL where the original files can be found.
+- `--source-map "root='<URL>'"` to pass the URL where the original files can be found.
+
+- `--source-map "url='<URL>'"` to specify the URL where the source map can be found.
   Otherwise UglifyJS assumes HTTP `X-SourceMap` is being used and will omit the
   `//# sourceMappingURL=` directive.
 
-- `--source-map url=<URL>` to specify the URL where the source map can be found.
-
 For example:
 
     uglifyjs js/file1.js js/file2.js \
              -o foo.min.js -c -m \
-             --source-map root="http://foo.com/src",url=foo.min.js.map
+             --source-map "root='http://foo.com/src',url='foo.min.js.map'"
 
 The above will compress and mangle `file1.js` and `file2.js`, will drop the
 output in `foo.min.js` and the source map in `foo.min.js.map`.  The source
@@ -178,8 +179,8 @@ CoffeeScript → compiled JS, UglifyJS can generate a map from CoffeeScript →
 compressed JS by mapping every token in the compiled JS to its original
 location.
 
-To use this feature pass `--source-map content="/path/to/input/source.map"`
-or `--source-map content=inline` if the source map is included inline with
+To use this feature pass `--source-map "content='/path/to/input/source.map'"`
+or `--source-map "content=inline"` if the source map is included inline with
 the sources.
 
 ## CLI compress options
@@ -200,17 +201,15 @@ Example:
 To enable the mangler you need to pass `--mangle` (`-m`).  The following
 (comma-separated) options are supported:
 
-- `toplevel` — mangle names declared in the top level scope (disabled by
-  default).
+- `toplevel` (default `false`) -- mangle names declared in the top level scope.
 
-- `eval` — mangle names visible in scopes where `eval` or `with` are used
-  (disabled by default).
+- `eval` (default `false`) -- mangle names visible in scopes where `eval` or `with` are used.
 
 When mangling is enabled but you want to prevent certain names from being
 mangled, you can declare those names with `--mangle reserved` — pass a
 comma-separated list of names.  For example:
 
-    uglifyjs ... -m reserved=[$,require,exports]
+    uglifyjs ... -m reserved=['$','require','exports']
 
 to prevent the `require`, `exports` and `$` names from being changed.
 
@@ -380,7 +379,47 @@ var code = {
 var options = { toplevel: true };
 var result = UglifyJS.minify(code, options);
 console.log(result.code);
-// console.log(function(n,o){return n+o}(3,7));
+// console.log(3+7);
+```
+
+The `nameCache` option:
+```javascript
+var options = {
+    mangle: {
+        toplevel: true,
+    },
+    nameCache: {}
+};
+var result1 = UglifyJS.minify({
+    "file1.js": "function add(first, second) { return first + second; }"
+}, options);
+var result2 = UglifyJS.minify({
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
+}, options);
+console.log(result1.code);
+// function n(n,r){return n+r}
+console.log(result2.code);
+// console.log(n(3,7));
+```
+
+You may persist the name cache to the file system in the following way:
+```javascript
+var cacheFileName = "/tmp/cache.json";
+var options = {
+    mangle: {
+        properties: true,
+    },
+    nameCache: JSON.parse(fs.readFileSync(cacheFileName, "utf8"))
+};
+fs.writeFileSync("part1.js", UglifyJS.minify({
+    "file1.js": fs.readFileSync("file1.js", "utf8"),
+    "file2.js": fs.readFileSync("file2.js", "utf8")
+}, options).code, "utf8");
+fs.writeFileSync("part2.js", UglifyJS.minify({
+    "file3.js": fs.readFileSync("file3.js", "utf8"),
+    "file4.js": fs.readFileSync("file4.js", "utf8")
+}, options).code, "utf8");
+fs.writeFileSync(cacheFileName, JSON.stringify(options.nameCache), "utf8");
 ```
 
 An example of a combination of `minify()` options:
@@ -433,6 +472,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.
 
@@ -458,13 +500,22 @@ if (result.error) throw result.error;
 - `toplevel` (default `false`) - set to `true` if you wish to enable top level
   variable and function name mangling and to drop unused variables and functions.
 
+- `nameCache` (default `null`) - pass an empty object `{}` or a previously
+  used `nameCache` object if you wish to cache mangled variable and
+  property names across multiple invocations of `minify()`. Note: this is
+  a read/write property. `minify()` will read the name cache state of this
+  object and update it during minification so that it may be
+  reused or externally persisted by the user.
+
 - `ie8` (default `false`) - set to `true` to support IE8.
 
+- `keep_fnames` (default: `false`) - pass `true` to prevent discarding or mangling
+  of function names.  Useful for code relying on `Function.prototype.name`.
+
 ## Minify options structure
 
 ```javascript
 {
-    warnings: false,
     parse: {
         // parse options
     },
@@ -484,8 +535,11 @@ if (result.error) throw result.error;
     sourceMap: {
         // source map options
     },
+    ecma: 5, // specify one of: 5, 6, 7 or 8
+    nameCache: null, // or specify a name cache object
     toplevel: false,
     ie8: false,
+    warnings: false,
 }
 ```
 
@@ -539,102 +593,97 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 ## Parse options
 
 - `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
 
-- `sequences` (default: true) -- join consecutive simple statements using the
-  comma operator.  May be set to a positive integer to specify the maximum number
-  of consecutive comma sequences that will be generated. If this option is set to
-  `true` then the default `sequences` limit is `200`. Set option to `false` or `0`
-  to disable. The smallest `sequences` length is `2`. A `sequences` value of `1`
-  is grandfathered to be equivalent to `true` and as such means `200`. On rare
-  occasions the default sequences limit leads to very slow compress times in which
-  case a value of `20` or less is recommended.
+- `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.
 
-- `properties` -- rewrite property access using the dot notation, for
-  example `foo["bar"] → foo.bar`
+- `booleans` (default: `true`) -- various optimizations for boolean context, for example `!!a
+  ? b : c → a ? b : c`
 
-- `dead_code` -- remove unreachable code
+- `cascade` (default: `true`) -- small optimization for sequences, transform `x, x` into `x`
+  and `x = something(), x` into `x = something()`
 
-- `drop_debugger` -- remove `debugger;` statements
+- `collapse_vars` (default: `true`) -- Collapse single-use non-constant variables - side
+  effects permitting.
 
-- `unsafe` (default: false) -- apply "unsafe" transformations (discussion below)
-
-- `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`,
-  or `valueOf`. This could cause change in execution order after operands in the
-  comparison are switching. Compression only works if both `comparisons` and
-  `unsafe_comps` are both set to true.
-
-- `unsafe_math` (default: false) -- optimize numerical expressions like
-  `2 * x * 3` into `6 * x`, which may give imprecise floating point results.
-
-- `unsafe_proto` (default: false) -- optimize expressions like
-  `Array.prototype.slice.call(a)` into `[].slice.call(a)`
-
-- `unsafe_regexp` (default: false) -- enable substitutions of variables with
-  `RegExp` values the same way as if they are constants.
-
-- `conditionals` -- apply optimizations for `if`-s and conditional
-  expressions
-
-- `comparisons` -- apply certain optimizations to binary nodes, for example:
+- `comparisons` (default: `true`) -- apply certain optimizations to binary nodes, for example:
   `!(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.
 
-- `evaluate` -- attempt to evaluate constant expressions
+- `computed_props` (default: `true`) -- Transforms constant computed properties
+  into regular ones: `{["computed"]: 1}` is converted to `{computed: 1}`.
 
-- `booleans` -- various optimizations for boolean context, for example `!!a
-  ? b : c → a ? b : c`
+- `conditionals` (default: `true`) -- apply optimizations for `if`-s and conditional
+  expressions
 
-- `loops` -- optimizations for `do`, `while` and `for` loops when we can
-  statically determine the condition
+- `dead_code` (default: `true`) -- remove unreachable code
 
-- `unused` -- drop unreferenced functions and variables (simple direct variable
-  assignments do not count as references unless set to `"keep_assign"`)
+- `drop_console` (default: `false`) -- default `false`.  Pass `true` to discard calls to
+  `console.*` functions. If you wish to drop a specific function call
+  such as `console.info` and/or retain side effects from function arguments
+  after dropping the function call then use `pure_funcs` instead.
 
-- `toplevel` -- drop unreferenced functions (`"funcs"`) and/or variables (`"vars"`)
-  in the top level scope (`false` by default, `true` to drop both unreferenced
-  functions and variables)
+- `drop_debugger` (default: `true`) -- remove `debugger;` statements
 
-- `top_retain` -- prevent specific toplevel functions and variables from `unused`
-  removal (can be array, comma-separated, RegExp or function. Implies `toplevel`)
+- `ecma` (default: `5`) -- Pass `6` or greater to enable `compress` options that
+  will transform ES5 code into smaller ES6+ equivalent forms.
 
-- `hoist_funs` -- hoist function declarations
+- `evaluate` (default: `true`) -- attempt to evaluate constant expressions
 
-- `hoist_vars` (default: false) -- hoist `var` declarations (this is `false`
+- `expression` (default: `false`) -- default `false`.  Pass `true` to preserve completion values
+  from terminal statements without `return`, e.g. in bookmarklets.
+
+- `global_defs` (default: `{}`) -- see [conditional compilation](#conditional-compilation)
+
+- `hoist_funs` (default: `true`) -- hoist function declarations
+
+- `hoist_vars` (default: `false`) -- hoist `var` declarations (this is `false`
   by default because it seems to increase the size of the output in general)
 
-- `if_return` -- optimizations for if/return and if/continue
+- `if_return` (default: `true`) -- optimizations for if/return and if/continue
 
-- `join_vars` -- join consecutive `var` statements
+- `inline` (default: `true`) -- embed simple functions
 
-- `cascade` -- small optimization for sequences, transform `x, x` into `x`
-  and `x = something(), x` into `x = something()`
+- `join_vars` (default: `true`) -- join consecutive `var` statements
 
-- `collapse_vars` -- Collapse single-use non-constant variables - side
-  effects permitting.
+- `keep_fargs` (default: `true`) -- default `true`.  Prevents the
+  compressor from discarding unused function arguments.  You need this
+  for code which relies on `Function.length`.
 
-- `reduce_vars` -- Improve optimization on variables assigned with and
-  used as constant values.
+- `keep_fnames` (default: `false`) -- Pass `true` to prevent the
+  compressor from discarding function names.  Useful for code relying on
+  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
 
-- `warnings` -- display warnings when dropping unreachable code or unused
-  declarations etc.
+- `keep_infinity` (default: `false`) -- default `false`. Pass `true` to prevent `Infinity` from
+  being compressed into `1/0`, which may cause performance issues on Chrome.
 
-- `negate_iife` -- negate "Immediately-Called Function Expressions"
+- `loops` (default: `true`) -- optimizations for `do`, `while` and `for` loops when we can
+  statically determine the condition
+
+- `negate_iife` (default: `true`) -- negate "Immediately-Called Function Expressions"
   where the return value is discarded, to avoid the parens that the
   code generator would insert.
 
-- `pure_getters` -- the default is `false`.  If you pass `true` for
-  this, UglifyJS will assume that object property access
-  (e.g. `foo.bar` or `foo["bar"]`) doesn't have any side effects.
-  Specify `"strict"` to treat `foo.bar` as side-effect-free only when
-  `foo` is certain to not throw, i.e. not `null` or `undefined`.
+- `passes` (default: `1`) -- The maximum number of times to run compress.
+  In some cases more than one pass leads to further compressed code.  Keep in
+  mind more passes will take more time.
 
-- `pure_funcs` -- default `null`.  You can pass an array of names and
+- `properties` (default: `true`) -- rewrite property access using the dot notation, for
+  example `foo["bar"] → foo.bar`
+
+- `pure_funcs` (default: `null`) -- You can pass an array of names and
   UglifyJS will assume that those functions do not produce side
   effects.  DANGER: will not check if the name is redefined in scope.
   An example case here, for instance `var q = Math.floor(a/b)`.  If
@@ -645,47 +694,102 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
   statement would get discarded.  The current implementation adds some
   overhead (compression will be slower).
 
-- `drop_console` -- default `false`.  Pass `true` to discard calls to
-  `console.*` functions. If you wish to drop a specific function call
-  such as `console.info` and/or retain side effects from function arguments
-  after dropping the function call then use `pure_funcs` instead.
+- `pure_getters` (default: `"strict"`) -- If you pass `true` for
+  this, UglifyJS will assume that object property access
+  (e.g. `foo.bar` or `foo["bar"]`) doesn't have any side effects.
+  Specify `"strict"` to treat `foo.bar` as side-effect-free only when
+  `foo` is certain to not throw, i.e. not `null` or `undefined`.
 
-- `expression` -- default `false`.  Pass `true` to preserve completion values
-  from terminal statements without `return`, e.g. in bookmarklets.
+- `reduce_vars` (default: `true`) -- Improve optimization on variables assigned with and
+  used as constant values.
 
-- `keep_fargs` -- default `true`.  Prevents the
-  compressor from discarding unused function arguments.  You need this
-  for code which relies on `Function.length`.
+- `sequences` (default: `true`) -- join consecutive simple statements using the
+  comma operator.  May be set to a positive integer to specify the maximum number
+  of consecutive comma sequences that will be generated. If this option is set to
+  `true` then the default `sequences` limit is `200`. Set option to `false` or `0`
+  to disable. The smallest `sequences` length is `2`. A `sequences` value of `1`
+  is grandfathered to be equivalent to `true` and as such means `200`. On rare
+  occasions the default sequences limit leads to very slow compress times in which
+  case a value of `20` or less is recommended.
 
-- `keep_fnames` -- default `false`.  Pass `true` to prevent the
-  compressor from discarding function names.  Useful for code relying on
-  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
-
-- `passes` -- default `1`. Number of times to run compress with a maximum of 3.
-  In some cases more than one pass leads to further compressed code.  Keep in
-  mind more passes will take more time.
-
-- `keep_infinity` -- default `false`. Pass `true` to prevent `Infinity` from
-  being compressed into `1/0`, which may cause performance issues on Chrome.
-
-- `side_effects` -- default `true`. Pass `false` to disable potentially dropping
+- `side_effects` (default: `true`) -- default `true`. Pass `false` to disable potentially dropping
   functions marked as "pure".  A function call is marked as "pure" if a comment
   annotation `/*@__PURE__*/` or `/*#__PURE__*/` immediately precedes the call. For
   example: `/*@__PURE__*/foo();`
 
+- `switches` (default: `true`) -- de-duplicate and remove unreachable `switch` branches
+
+- `toplevel` (default: `false`) -- drop unreferenced functions (`"funcs"`) and/or variables (`"vars"`)
+  in the top level scope (`false` by default, `true` to drop both unreferenced
+  functions and variables)
+
+- `top_retain` (default: `null`) -- prevent specific toplevel functions and variables from `unused`
+  removal (can be array, comma-separated, RegExp or function. Implies `toplevel`)
+
+- `typeofs` (default: `true`) -- default `true`.  Transforms `typeof foo == "undefined"` into
+  `foo === void 0`.  Note: recommend to set this value to `false` for IE10 and
+  earlier versions due to known issues.
+
+- `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`,
+  or `valueOf`. This could cause change in execution order after operands in the
+  comparison are switching. Compression only works if both `comparisons` and
+  `unsafe_comps` are both set to true.
+
+- `unsafe_Func` (default: `false`) -- compress and mangle `Function(args, code)`
+  when both `args` and `code` are string literals.
+
+- `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)`
+
+- `unsafe_regexp` (default: `false`) -- enable substitutions of variables with
+  `RegExp` values the same way as if they are constants.
+
+- `unused` (default: `true`) -- drop unreferenced functions and variables (simple direct variable
+  assignments do not count as references unless set to `"keep_assign"`)
+
+- `warnings` (default: `false`) -- display warnings when dropping unreachable code or unused
+  declarations etc.
+
 ## Mangle options
 
-- `reserved` - pass an array of identifiers that should be excluded from mangling
+- `eval` (default `false`). Pass `true` to mangle names visible in scopes
+  where `eval` or `with` are used.
 
-- `toplevel` — mangle names declared in the top level scope (disabled by
-default).
+- `keep_classnames` (default `false`).  Pass `true` to not mangle class names.
 
-- `eval` — mangle names visible in scopes where eval or with are used
-(disabled by default).
+- `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).
 
-- `keep_fnames` -- default `false`.  Pass `true` to not mangle
-function names.  Useful for code relying on `Function.prototype.name`.
-See also: the `keep_fnames` [compress option](#compress-options).
+- `reserved` (default `[]`). Pass an array of identifiers that should be
+  excluded from mangling. Example: `["foo", "bar"]`.
+
+- `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".
 
 Examples:
 
@@ -711,16 +815,20 @@ UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
 
 ### Mangle properties options
 
-- `reserved` (default: `[]`) -- Do not mangle property names listed in the
-  `reserved` array.
-- `regex` (default: `null`) -— Pass a RegExp literal to only mangle property
-  names matching the regular expression.
-- `keep_quoted` (default: `false`) -— Only mangle unquoted property names.
-- `debug` (default: `false`) -— Mangle names with the original name still present.
-  Pass an empty string `""` to enable, or a non-empty string to set the debug suffix.
 - `builtins` (default: `false`) -- Use `true` to allow the mangling of builtin
   DOM properties. Not recommended to override this setting.
 
+- `debug` (default: `false`) -— Mangle names with the original name still present.
+  Pass an empty string `""` to enable, or a non-empty string to set the debug suffix.
+
+- `keep_quoted` (default: `false`) -— Only mangle unquoted property names.
+
+- `regex` (default: `null`) -— Pass a RegExp literal to only mangle property
+  names matching the regular expression.
+
+- `reserved` (default: `[]`) -- Do not mangle property names listed in the
+  `reserved` array.
+
 ## Output options
 
 The code generator tries to output shortest code possible by default.  In
@@ -729,51 +837,71 @@ can pass additional arguments that control the code output:
 
 - `ascii_only` (default `false`) -- escape Unicode characters in strings and
   regexps (affects directives with non-ascii characters becoming invalid)
+
 - `beautify` (default `true`) -- whether to actually beautify the output.
   Passing `-b` will set this to true, but you might need to pass `-b` even
   when you want to generate minified code, in order to specify additional
   arguments, so you can use `-b beautify=false` to override it.
+
 - `bracketize` (default `false`) -- always insert brackets in `if`, `for`,
   `do`, `while` or `with` statements, even if their body is a single
   statement.
+
 - `comments` (default `false`) -- pass `true` or `"all"` to preserve all
   comments, `"some"` to preserve some comments, a regular expression string
   (e.g. `/^!/`) or a function.
-- `ecma` (default `5`) -- set output printing mode.  This will only change the
-  output in direct control of the beautifier.  Non-compatible features in the
-  abstract syntax tree will still be outputted as is.
-- `indent_level` (default 4)
-- `indent_start` (default 0) -- prefix all lines by that many spaces
+
+- `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
+
 - `inline_script` (default `false`) -- escape the slash in occurrences of
   `</script` in strings
+
 - `keep_quoted_props` (default `false`) -- when turned on, prevents stripping
   quotes from property names in object literals.
+
 - `max_line_len` (default `false`) -- maximum line length (for uglified code)
+
 - `preamble` (default `null`) -- when passed it must be a string and
   it will be prepended to the output literally.  The source map will
   adjust for this text.  Can be used to insert a comment containing
   licensing information, for example.
+
 - `preserve_line` (default `false`) -- pass `true` to preserve lines, but it
   only works if `beautify` is set to `false`.
+
 - `quote_keys` (default `false`) -- pass `true` to quote all keys in literal
   objects
+
 - `quote_style` (default `0`) -- preferred quote style for strings (affects
   quoted property names and directives as well):
   - `0` -- prefers double quotes, switches to single quotes when there are
-    more double quotes in the string itself.
+    more double quotes in the string itself. `0` is best for gzip size.
   - `1` -- always use single quotes
   - `2` -- always use double quotes
   - `3` -- always use the original quotes
+
 - `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
   gzip could be smaller; size after gzip insignificantly larger).
+
 - `shebang` (default `true`) -- preserve shebang `#!` in preamble (bash scripts)
-- `width` (default 80) -- only takes effect when beautification is on, this
+
+- `width` (default `80`) -- only takes effect when beautification is on, this
   specifies an (orientative) line width that the beautifier will try to
   obey.  It refers to the width of the line text (excluding indentation).
   It doesn't work very well currently, but it does make the code generated
   by UglifyJS more readable.
+
 - `wrap_iife` (default `false`) -- pass `true` to wrap immediately invoked
   function expressions. See
   [#640](https://github.com/mishoo/UglifyJS2/issues/640) for more details.
@@ -819,7 +947,6 @@ when this flag is on:
 - `new Object()` → `{}`
 - `String(exp)` or `exp.toString()` → `"" + exp`
 - `new Object/RegExp/Function/Error/Array (...)` → we discard the `new`
-- `typeof foo == "undefined"` → `foo === void 0`
 - `void 0` → `undefined` (if there is a variable named "undefined" in
   scope; we do it because the variable name will be mangled, typically
   reduced to a single character)
@@ -972,3 +1099,30 @@ in total it's a bit more than just using UglifyJS's own parser.
 
 [acorn]: https://github.com/ternjs/acorn
 [sm-spec]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k
+
+### Uglify Fast Minify Mode
+
+It's not well known, but whitespace removal and symbol mangling accounts
+for 95% of the size reduction in minified code for most javascript - not
+elaborate code transforms. One can simply disable `compress` to speed up
+Uglify builds by 3 to 4 times. In this fast `mangle`-only mode Uglify has
+comparable minify speeds and gzip sizes to
+[`butternut`](https://www.npmjs.com/package/butternut):
+
+| d3.js | minify size | gzip size | minify time (seconds) |
+| --- | ---: | ---: | ---: |
+| original | 451,131 | 108,733 | - |
+| uglify-js@3.0.24 mangle=false, compress=false | 316,600 | 85,245 | 0.70 |
+| uglify-js@3.0.24 mangle=true, compress=false | 220,216 | 72,730 | 1.13 |
+| butternut@0.4.6 | 217,568 | 72,738 | 1.41 |
+| uglify-js@3.0.24 mangle=true, compress=true | 212,511 | 71,560 | 3.36 |
+| babili@0.1.4 | 210,713 | 72,140 | 12.64 |
+
+To enable fast minify mode from the CLI use:
+```
+uglifyjs file.js -m
+```
+To enable fast minify mode with the API use:
+```js
+UglifyJS.minify(code, { compress: false, mangle: true });
+```

bin/uglifyjs

@@ -30,27 +30,21 @@ else if (process.argv.indexOf("options") >= 0) program.helpInformation = functio
     var options = UglifyJS.default_options();
     for (var option in options) {
         text.push("--" + (option == "output" ? "beautify" : option == "sourceMap" ? "source-map" : option) + " options:");
-        var defs = options[option];
-        var padding = "";
-        Object.keys(defs).map(function(name) {
-            if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
-            return [ name, JSON.stringify(defs[name]) ];
-        }).forEach(function(tokens) {
-            text.push("  " + tokens[0] + padding.slice(tokens[0].length - 2) + tokens[1]);
-        });
+        text.push(format_object(options[option]));
         text.push("");
     }
     return text.join("\n");
 };
-program.option("-p, --parse <options>", "Specify parser options.", parse_js("parse", true));
-program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js("compress", true));
-program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js("mangle", true));
-program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js("mangle-props", true));
-program.option("-b, --beautify [options]", "Beautify output/specify output options.", parse_js("beautify", true));
+program.option("-p, --parse <options>", "Specify parser options.", parse_js());
+program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js());
+program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js());
+program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js());
+program.option("-b, --beautify [options]", "Beautify output/specify output options.", parse_js());
 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>", "Specifiy ECMAScript release: 5, 6, 7 or 8.");
 program.option("--ie8", "Support non-standard Internet Explorer 8.");
 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.");
@@ -80,6 +74,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)) {
@@ -113,17 +111,8 @@ if (program.mangleProps) {
     if (typeof options.mangle != "object") options.mangle = {};
     options.mangle.properties = program.mangleProps;
 }
-var cache;
 if (program.nameCache) {
-    cache = JSON.parse(read_file(program.nameCache, "{}"));
-    if (options.mangle) {
-        if (typeof options.mangle != "object") options.mangle = {};
-        options.mangle.cache = to_cache("vars");
-        if (options.mangle.properties) {
-            if (typeof options.mangle.properties != "object") options.mangle.properties = {};
-            options.mangle.properties.cache = to_cache("props");
-        }
-    }
+    options.nameCache = JSON.parse(read_file(program.nameCache, "{}"));
 }
 if (program.output == "ast") {
     options.output = {
@@ -157,7 +146,7 @@ if (program.verbose) {
 }
 if (program.self) {
     if (program.args.length) {
-        console.error("WARN: Ignoring input files since --self was passed");
+        print_error("WARN: Ignoring input files since --self was passed");
     }
     if (!options.wrap) options.wrap = "UglifyJS";
     simple_glob(UglifyJS.FILES).forEach(function(name) {
@@ -187,7 +176,7 @@ function convert_ast(fn) {
 
 function run() {
     UglifyJS.AST_Node.warn_function = function(msg) {
-        console.error("WARN:", msg);
+        print_error("WARN: " + msg);
     };
     if (program.timings) options.timings = true;
     try {
@@ -216,7 +205,7 @@ function run() {
     if (result.error) {
         var ex = result.error;
         if (ex.name == "SyntaxError") {
-            console.error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
+            print_error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
             var col = ex.col;
             var lines = files[ex.filename].split(/\r?\n/);
             var line = lines[ex.line - 1];
@@ -225,21 +214,22 @@ function run() {
                 col = line.length;
             }
             if (line) {
-                if (col > 40) {
-                    line = line.slice(col - 40);
-                    col = 40;
+                var limit = 70;
+                if (col > limit) {
+                    line = line.slice(col - limit);
+                    col = limit;
                 }
-                console.error(line.slice(0, 80));
-                console.error(line.slice(0, col).replace(/\S/g, " ") + "^");
+                print_error(line.slice(0, 80));
+                print_error(line.slice(0, col).replace(/\S/g, " ") + "^");
             }
         }
         if (ex.defs) {
-            console.error("Supported options:");
-            console.error(ex.defs);
+            print_error("Supported options:");
+            print_error(format_object(ex.defs));
         }
         fatal(ex);
     } else if (program.output == "ast") {
-        console.log(JSON.stringify(result.ast, function(key, value) {
+        print(JSON.stringify(result.ast, function(key, value) {
             if (skip_key(key)) return;
             if (value instanceof UglifyJS.AST_Token) return;
             if (value instanceof UglifyJS.Dictionary) return;
@@ -255,7 +245,7 @@ function run() {
             return value;
         }, 2));
     } else if (program.output == "spidermonkey") {
-        console.log(JSON.stringify(UglifyJS.minify(result.code, {
+        print(JSON.stringify(UglifyJS.minify(result.code, {
             compress: false,
             mangle: false,
             output: {
@@ -269,21 +259,19 @@ function run() {
             fs.writeFileSync(program.output + ".map", result.map);
         }
     } else {
-        console.log(result.code);
+        print(result.code);
     }
     if (program.nameCache) {
-        fs.writeFileSync(program.nameCache, JSON.stringify(cache, function(key, value) {
-            return value instanceof UglifyJS.Dictionary ? value.toObject() : value;
-        }));
+        fs.writeFileSync(program.nameCache, JSON.stringify(options.nameCache));
     }
     if (result.timings) for (var phase in result.timings) {
-        console.error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
+        print_error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
     }
 }
 
 function fatal(message) {
     if (message instanceof Error) message = message.stack.replace(/^\S*?Error:/, "ERROR:")
-    console.error(message);
+    print_error(message);
     process.exit(1);
 }
 
@@ -327,7 +315,7 @@ function read_file(path, default_value) {
     }
 }
 
-function parse_js(flag, constants) {
+function parse_js(flag) {
     return function(value, options) {
         options = options || {};
         try {
@@ -345,7 +333,7 @@ function parse_js(flag, constants) {
                 if (node instanceof UglifyJS.AST_Assign) {
                     var name = node.left.print_to_string();
                     var value = node.right;
-                    if (!constants) {
+                    if (flag) {
                         options[name] = value;
                     } else if (value instanceof UglifyJS.AST_Array) {
                         options[name] = value.elements.map(to_string);
@@ -368,37 +356,51 @@ function parse_js(flag, constants) {
                 }
             }));
         } catch(ex) {
-            options[value] = null;
+            if (flag) {
+                fatal("Error parsing arguments for '" + flag + "': " + value);
+            } else {
+                options[value] = null;
+            }
         }
         return options;
     }
 }
 
 function parse_source_map() {
-    var parse = parse_js("sourceMap", true);
+    var parse = parse_js();
     return function(value, options) {
-        var hasContent = options && options.sourceMap && "content" in options.sourceMap;
+        var hasContent = options && "content" in options;
         var settings = parse(value, options);
         if (!hasContent && settings.content && settings.content != "inline") {
-            console.error("INFO: Using input source map:", settings.content);
+            print_error("INFO: Using input source map: " + settings.content);
             settings.content = read_file(settings.content, settings.content);
         }
         return settings;
     }
 }
 
-function to_cache(key) {
-    if (cache[key]) {
-        cache[key].props = UglifyJS.Dictionary.fromObject(cache[key].props);
-    } else {
-        cache[key] = {
-            cname: -1,
-            props: new UglifyJS.Dictionary()
-        };
-    }
-    return cache[key];
-}
-
 function skip_key(key) {
     return skip_keys.indexOf(key) >= 0;
 }
+
+function format_object(obj) {
+    var lines = [];
+    var padding = "";
+    Object.keys(obj).map(function(name) {
+        if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
+        return [ name, JSON.stringify(obj[name]) ];
+    }).forEach(function(tokens) {
+        lines.push("  " + tokens[0] + padding.slice(tokens[0].length - 2) + tokens[1]);
+    });
+    return lines.join("\n");
+}
+
+function print_error(msg) {
+    process.stderr.write(msg);
+    process.stderr.write("\n");
+}
+
+function print(txt) {
+    process.stdout.write(txt);
+    process.stdout.write("\n");
+}

lib/ast.js

@@ -134,11 +134,10 @@ var AST_Debugger = DEFNODE("Debugger", null, {
     $documentation: "Represents a debugger statement",
 }, AST_Statement);
 
-var AST_Directive = DEFNODE("Directive", "value scope quote", {
+var AST_Directive = DEFNODE("Directive", "value quote", {
     $documentation: "Represents a directive, like \"use strict\";",
     $propdoc: {
         value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
-        scope: "[AST_Scope/S] The scope that this directive affects",
         quote: "[string] the original quote character"
     },
 }, AST_Statement);
@@ -303,10 +302,9 @@ var AST_With = DEFNODE("With", "expression", {
 
 /* -----[ scope and functions ]----- */
 
-var AST_Scope = DEFNODE("Scope", "directives variables functions uses_with uses_eval parent_scope enclosed cname", {
+var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent_scope enclosed cname", {
     $documentation: "Base class for all statements introducing a lexical scope",
     $propdoc: {
-        directives: "[string*/S] an array of directives declared in this scope",
         variables: "[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
         functions: "[Object/S] like `variables`, but only lists function declarations",
         uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
@@ -345,7 +343,7 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
 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_Symbol the thing to be expanded"
+        expression: "[AST_Node] the thing to be expanded"
     },
     _walk: function(visitor) {
         var self = this;
@@ -355,13 +353,14 @@ var AST_Expansion = DEFNODE("Expansion", "expression", {
     }
 });
 
-var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator", {
+var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator async", {
     $documentation: "Base class for functions",
     $propdoc: {
-        is_generator: "[boolean] is generatorFn or not",
         name: "[AST_SymbolDeclaration?] the name of this function",
         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"
+        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 = [];
@@ -445,7 +444,7 @@ var AST_PrefixedTemplateString = DEFNODE("PrefixedTemplateString", "template_str
 var AST_TemplateString = DEFNODE("TemplateString", "segments", {
     $documentation: "A template string literal",
     $propdoc: {
-        segments: "[AST_TemplateSegment|AST_Expression]* One or more segments, starting with AST_TemplateSegment. AST_Expression may follow AST_TemplateSegment, but each AST_Expression must be followed by AST_TemplateSegment."
+        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(){
@@ -628,11 +627,11 @@ var AST_Const = DEFNODE("Const", null, {
     $documentation: "A `const` statement"
 }, AST_Definitions);
 
-var AST_NameImport = DEFNODE("NameImport", "foreign_name name", {
-    $documentation: "The part of the import statement that imports names from a module.",
+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_SymbolImportForeign] The name being imported (as specified in the module)",
-        name: "[AST_SymbolImport] The name as it becomes available to this module."
+        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() {
@@ -646,7 +645,7 @@ 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_NameImport*] The names of non-default imported variables",
+        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) {
@@ -655,7 +654,7 @@ var AST_Import = DEFNODE("Import", "imported_name imported_names module_name", {
                 this.imported_name._walk(visitor);
             }
             if (this.imported_names) {
-                this.imported_names.forEach(function (name_import) {
+                this.imported_names.forEach(function(name_import) {
                     name_import._walk(visitor);
                 });
             }
@@ -669,7 +668,7 @@ var AST_Export = DEFNODE("Export", "exported_definition exported_value is_defaul
     $propdoc: {
         exported_definition: "[AST_Defun|AST_Definitions|AST_DefClass?] An exported definition",
         exported_value: "[AST_Node?] An exported value",
-        exported_names: "[AST_NameImport*?] List of exported names",
+        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"
     },
@@ -681,6 +680,14 @@ var AST_Export = DEFNODE("Export", "exported_definition exported_value is_defaul
             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);
@@ -688,7 +695,7 @@ var AST_Export = DEFNODE("Export", "exported_definition exported_value is_defaul
 var AST_VarDef = DEFNODE("VarDef", "name value", {
     $documentation: "A variable declaration; only appears in a AST_Definitions node",
     $propdoc: {
-        name: "[AST_SymbolVar|AST_SymbolConst|AST_Destructuring] 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) {
@@ -893,11 +900,12 @@ var AST_ObjectGetter = DEFNODE("ObjectGetter", "quote static", {
     $documentation: "An object getter property",
 }, AST_ObjectProperty);
 
-var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator", {
+var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator async", {
     $propdoc: {
         quote: "[string|undefined] the original quote character, if any",
-        static: "[boolean] whether this method is static (classes only)",
-        is_generator: "[boolean] is generatorFn or not",
+        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);
@@ -994,7 +1002,7 @@ var AST_SymbolCatch = DEFNODE("SymbolCatch", null, {
 }, AST_SymbolBlockDeclaration);
 
 var AST_SymbolImport = DEFNODE("SymbolImport", null, {
-    $documentation: "Symbol refering to an imported name",
+    $documentation: "Symbol referring to an imported name",
 }, AST_SymbolBlockDeclaration);
 
 var AST_SymbolImportForeign = DEFNODE("SymbolImportForeign", null, {
@@ -1016,6 +1024,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);
@@ -1026,7 +1042,7 @@ var AST_This = DEFNODE("This", null, {
 
 var AST_Super = DEFNODE("Super", null, {
     $documentation: "The `super` symbol",
-}, AST_Symbol);
+}, AST_This);
 
 var AST_Constant = DEFNODE("Constant", null, {
     $documentation: "Base class for all constants",
@@ -1101,7 +1117,17 @@ var AST_True = DEFNODE("True", null, {
     value: true
 }, AST_Boolean);
 
-/* -----[ Yield ]----- */
+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",
@@ -1132,7 +1158,7 @@ TreeWalker.prototype = {
         if (!ret && descend) {
             descend.call(node);
         }
-        this.pop(node);
+        this.pop();
         return ret;
     },
     parent: function(n) {
@@ -1151,8 +1177,8 @@ TreeWalker.prototype = {
         }
         this.stack.push(node);
     },
-    pop: function(node) {
-        this.stack.pop();
+    pop: function() {
+        var node = this.stack.pop();
         if (node instanceof AST_Lambda || node instanceof AST_Class) {
             this.directives = Object.getPrototypeOf(this.directives);
         }

lib/minify.js

@@ -27,14 +27,33 @@ function set_shorthand(name, options, keys) {
     }
 }
 
+function init_cache(cache) {
+    if (!cache) return;
+    if (!("cname" in cache)) cache.cname = -1;
+    if (!("props" in cache)) {
+        cache.props = new Dictionary();
+    } else if (!(cache.props instanceof Dictionary)) {
+        cache.props = Dictionary.fromObject(cache.props);
+    }
+}
+
+function to_json(cache) {
+    return {
+        cname: cache.cname,
+        props: cache.props.toObject()
+    };
+}
+
 function minify(files, options) {
     var warn_function = AST_Node.warn_function;
     try {
         options = defaults(options, {
             compress: {},
+            ecma: undefined,
             ie8: false,
             keep_fnames: false,
             mangle: {},
+            nameCache: null,
             output: {},
             parse: {},
             sourceMap: false,
@@ -46,13 +65,15 @@ function minify(files, options) {
         var timings = options.timings && {
             start: Date.now()
         };
+        set_shorthand("ecma", options, [ "parse", "compress", "output" ]);
         set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
         set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
         set_shorthand("toplevel", options, [ "compress", "mangle" ]);
         set_shorthand("warnings", options, [ "compress" ]);
+        var quoted_props;
         if (options.mangle) {
             options.mangle = defaults(options.mangle, {
-                cache: null,
+                cache: options.nameCache && (options.nameCache.vars || {}),
                 eval: false,
                 ie8: false,
                 keep_classnames: false,
@@ -62,6 +83,21 @@ function minify(files, options) {
                 safari10: false,
                 toplevel: false,
             }, true);
+            if (options.mangle.properties) {
+                if (typeof options.mangle.properties != "object") {
+                    options.mangle.properties = {};
+                }
+                if (options.mangle.properties.keep_quoted) {
+                    quoted_props = options.mangle.properties.reserved;
+                    if (!Array.isArray(quoted_props)) quoted_props = [];
+                    options.mangle.properties.reserved = quoted_props;
+                }
+                if (options.nameCache && !("cache" in options.mangle.properties)) {
+                    options.mangle.properties.cache = options.nameCache.props || {};
+                }
+            }
+            init_cache(options.mangle.cache);
+            init_cache(options.mangle.properties.cache);
         }
         if (options.sourceMap) {
             options.sourceMap = defaults(options.sourceMap, {
@@ -88,7 +124,7 @@ function minify(files, options) {
             }
             options.parse = options.parse || {};
             options.parse.toplevel = null;
-            for (var name in files) {
+            for (var name in files) if (HOP(files, name)) {
                 options.parse.filename = name;
                 options.parse.toplevel = parse(files[name], options.parse);
                 if (options.sourceMap && options.sourceMap.content == "inline") {
@@ -99,6 +135,9 @@ function minify(files, options) {
             }
             toplevel = options.parse.toplevel;
         }
+        if (quoted_props) {
+            reserve_quoted_keys(toplevel, quoted_props);
+        }
         if (options.wrap) {
             toplevel = toplevel.wrap_commonjs(options.wrap);
         }
@@ -136,7 +175,7 @@ function minify(files, options) {
                 if (options.sourceMap.includeSources) {
                     if (files instanceof AST_Toplevel) {
                         throw new Error("original source content unavailable");
-                    } else for (var name in files) {
+                    } else for (var name in files) if (HOP(files, name)) {
                         options.output.source_map.get().setSourceContent(name, files[name]);
                     }
                 }
@@ -155,6 +194,12 @@ function minify(files, options) {
                 }
             }
         }
+        if (options.nameCache && options.mangle) {
+            if (options.mangle.cache) options.nameCache.vars = to_json(options.mangle.cache);
+            if (options.mangle.properties && options.mangle.properties.cache) {
+                options.nameCache.props = to_json(options.mangle.properties.cache);
+            }
+        }
         if (timings) {
             timings.end = Date.now();
             result.timings = {

lib/output.js

@@ -54,7 +54,6 @@ function OutputStream(options) {
 
     options = defaults(options, {
         ascii_only       : false,
-        ascii_identifiers: undefined,
         beautify         : false,
         bracketize       : false,
         comments         : false,
@@ -73,13 +72,11 @@ function OutputStream(options) {
         shebang          : true,
         shorthand        : undefined,
         source_map       : null,
+        webkit           : false,
         width            : 80,
         wrap_iife        : false,
     }, true);
 
-    if (typeof options.ascii_identifiers === 'undefined')
-        options.ascii_identifiers = options.ascii_only;
-
     if (options.shorthand === undefined)
         options.shorthand = options.ecma > 5;
 
@@ -117,20 +114,16 @@ function OutputStream(options) {
     var current_pos = 0;
     var OUTPUT = "";
 
-    function to_ascii(str, identifier) {
-        return str.replace(/[\ud800-\udbff][\udc00-\udfff]|[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
-            var code = get_full_char_code(ch, 0).toString(16);
-
-            if ((identifier && code.length === 1 && options.ecma >= 6) || code.length > 4) {
-                if (options.ecma < 6) {
-                    if (identifier) {
-                        return ch; // no \u{} support
-                    }
-                    return "\\u" + ch.charCodeAt(0).toString(16) + "\\u"
-                        + ch.charCodeAt(1).toString(16);
-                }
+    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 + "}";
-            } else if (code.length <= 2 && !identifier) {
+            });
+        }
+        return str.replace(/[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
+            var code = ch.charCodeAt(0).toString(16);
+            if (code.length <= 2 && !identifier) {
                 while (code.length < 2) code = "0" + code;
                 return "\\x" + code;
             } else {
@@ -138,6 +131,12 @@ function OutputStream(options) {
                 return "\\u" + code;
             }
         });
+    } : 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);
+        });
     };
 
     function make_string(str, quote) {
@@ -158,7 +157,7 @@ function OutputStream(options) {
               case "\u2029": return "\\u2029";
               case "\ufeff": return "\\ufeff";
               case "\0":
-                  return /[0-7]/.test(get_full_char(str, i+1)) ? "\\x00" : "\\0";
+                  return /[0-9]/.test(get_full_char(str, i+1)) ? "\\x00" : "\\0";
             }
             return s;
         });
@@ -171,7 +170,7 @@ function OutputStream(options) {
         function quote_template() {
             return '`' + str.replace(/`/g, '\\`') + '`';
         }
-        if (options.ascii_only) str = to_ascii(str);
+        str = to_utf8(str);
         if (quote === "`") return quote_template();
         switch (options.quote_style) {
           case 1:
@@ -197,8 +196,7 @@ function OutputStream(options) {
 
     function make_name(name) {
         name = name.toString();
-        if (options.ascii_identifiers)
-            name = to_ascii(name, true);
+        name = to_utf8(name, true);
         return name;
     };
 
@@ -460,7 +458,7 @@ function OutputStream(options) {
         last            : function() { return last },
         semicolon       : semicolon,
         force_semicolon : force_semicolon,
-        to_ascii        : to_ascii,
+        to_utf8         : to_utf8,
         print_name      : function(name) { print(make_name(name)) },
         print_string    : function(str, quote, escape_directive) {
             var encoded = encode_string(str, quote);
@@ -508,13 +506,17 @@ function OutputStream(options) {
         nodetype.DEFMETHOD("_codegen", generator);
     };
 
-    var use_asm = false;
     var in_directive = false;
+    var active_scope = null;
+    var use_asm = null;
 
     AST_Node.DEFMETHOD("print", function(stream, force_parens){
-        var self = this, generator = self._codegen, prev_use_asm = use_asm;
-        if (self instanceof AST_Directive && self.value == "use asm" && stream.parent() instanceof AST_Scope) {
-            use_asm = true;
+        var self = this, generator = self._codegen;
+        if (self instanceof AST_Scope) {
+            active_scope = self;
+        }
+        else if (!use_asm && self instanceof AST_Directive && self.value == "use asm") {
+            use_asm = active_scope;
         }
         function doit() {
             self.add_comments(stream);
@@ -528,10 +530,11 @@ function OutputStream(options) {
             doit();
         }
         stream.pop_node();
-        if (self instanceof AST_Scope) {
-            use_asm = prev_use_asm;
+        if (self === use_asm) {
+            use_asm = null;
         }
     });
+    AST_Node.DEFMETHOD("_print", AST_Node.prototype.print);
 
     AST_Node.DEFMETHOD("print_to_string", function(options){
         var s = OutputStream(options);
@@ -629,6 +632,13 @@ function OutputStream(options) {
             return true;
         }
 
+        if (output.option('webkit')) {
+            var p = output.parent();
+            if (p instanceof AST_PropAccess && p.expression === this) {
+                return true;
+            }
+        }
+
         if (output.option('wrap_iife')) {
             var p = output.parent();
             return p instanceof AST_Call && p.expression === this;
@@ -642,6 +652,10 @@ function OutputStream(options) {
         return p instanceof AST_PropAccess && p.expression === this;
     });
 
+    PARENS(AST_ClassExpression, function(output){
+        return output.parent() instanceof AST_SimpleStatement;
+    });
+
     // same goes for an object literal, because otherwise it would be
     // interpreted as a block of code.
     PARENS(AST_Object, function(output){
@@ -660,6 +674,12 @@ function OutputStream(options) {
                 && 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;
+    });
+
     PARENS(AST_Sequence, function(output){
         var p = output.parent();
         return p instanceof AST_Call                          // (foo, bar)() or foo(1, (2, 3), 4)
@@ -673,6 +693,7 @@ function OutputStream(options) {
                                                                * ==> 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)]
         ;
     });
 
@@ -726,14 +747,15 @@ function OutputStream(options) {
             // parens around it too, otherwise the call will be
             // interpreted as passing the arguments to the upper New
             // expression.
-            try {
-                this.walk(new TreeWalker(function(node){
-                    if (node instanceof AST_Call) throw p;
-                }));
-            } catch(ex) {
-                if (ex !== p) throw ex;
-                return true;
-            }
+            var parens = false;
+            this.walk(new TreeWalker(function(node) {
+                if (parens || node instanceof AST_Scope) return true;
+                if (node instanceof AST_Call) {
+                    parens = true;
+                    return true;
+                }
+            }));
+            return parens;
         }
     });
 
@@ -805,17 +827,15 @@ function OutputStream(options) {
 
     DEFPRINT(AST_Destructuring, function (self, output) {
         output.print(self.is_array ? "[" : "{");
-        var first = true;
         var len = self.names.length;
         self.names.forEach(function (name, i) {
-            if (first) first = false; else { output.comma(); output.space(); }
+            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();
-        })
+            if (i == len - 1 && name instanceof AST_Hole) output.comma();
+        });
         output.print(self.is_array ? "]" : "}");
     });
 
@@ -968,8 +988,12 @@ 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 (this.is_generator) {
+            if (self.is_generator) {
                 output.star();
             }
             if (self.name) {
@@ -1025,6 +1049,10 @@ function OutputStream(options) {
             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 {
@@ -1039,9 +1067,9 @@ function OutputStream(options) {
         output.print('=>');
         output.space();
         if (self.body instanceof AST_Node) {
-            this.body.print(output);
+            self.body.print(output);
         } else {
-            print_bracketed(this.body, output);
+            print_bracketed(self.body, output);
         }
         if (needs_parens) { output.print(")") }
     });
@@ -1073,6 +1101,22 @@ function OutputStream(options) {
         }
     });
 
+    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);
@@ -1250,7 +1294,6 @@ function OutputStream(options) {
                     name_import.print(output);
                     if (i < self.imported_names.length - 1) {
                         output.print(",");
-                        output.space();
                     }
                 });
                 output.space();
@@ -1266,17 +1309,26 @@ function OutputStream(options) {
         output.semicolon();
     });
 
-    DEFPRINT(AST_NameImport, function(self, output) {
+    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) {
-            output.print(self.foreign_name.name);
+            if (is_import) {
+                output.print(self.foreign_name.name);
+            } else {
+                self.name.print(output);
+            }
             output.space();
             output.print("as");
             output.space();
-            self.name.print(output);
+            if (is_import) {
+                self.name.print(output);
+            } else {
+                output.print(self.foreign_name.name);
+            }
         } else {
             self.name.print(output);
         }
@@ -1290,24 +1342,20 @@ function OutputStream(options) {
             output.space();
         }
         if (self.exported_names) {
-            output.space();
-
             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_import, i) {
+                self.exported_names.forEach(function(name_export, i) {
                     output.space();
-                    name_import.print(output);
+                    name_export.print(output);
                     if (i < self.exported_names.length - 1) {
                         output.print(",");
-                        output.space();
                     }
                 });
                 output.space();
                 output.print("}");
             }
-            output.space();
         }
         else if (self.exported_value) {
             self.exported_value.print(output);
@@ -1324,19 +1372,17 @@ function OutputStream(options) {
     });
 
     function parenthesize_for_noin(node, output, noin) {
-        if (!noin) node.print(output);
-        else try {
-            // need to take some precautions here:
-            //    https://github.com/mishoo/UglifyJS2/issues/60
-            node.walk(new TreeWalker(function(node){
-                if (node instanceof AST_Binary && node.operator == "in")
-                    throw output;
-            }));
-            node.print(output);
-        } catch(ex) {
-            if (ex !== output) throw ex;
-            node.print(output, true);
-        }
+        var parens = false;
+        // need to take some precautions here:
+        //    https://github.com/mishoo/UglifyJS2/issues/60
+        if (noin) node.walk(new TreeWalker(function(node) {
+            if (parens || node instanceof AST_Scope) return true;
+            if (node instanceof AST_Binary && node.operator == "in") {
+                parens = true;
+                return true;
+            }
+        }));
+        node.print(output, parens);
     };
 
     DEFPRINT(AST_VarDef, function(self, output){
@@ -1356,6 +1402,9 @@ function OutputStream(options) {
         self.expression.print(output);
         if (self instanceof AST_New && !need_constructor_parens(self, output))
             return;
+        if (self.expression instanceof AST_Call || self.expression instanceof AST_Lambda) {
+            output.add_mapping(self.start);
+        }
         output.with_parens(function(){
             self.args.forEach(function(expr, i){
                 if (i) output.comma();
@@ -1395,15 +1444,23 @@ function OutputStream(options) {
     DEFPRINT(AST_Dot, function(self, output){
         var expr = self.expression;
         expr.print(output);
-        if (expr instanceof AST_Number && expr.getValue() >= 0) {
-            if (!/[xa-f.)]/i.test(output.last())) {
-                output.print(".");
+        var prop = self.property;
+        if (output.option("ie8") && RESERVED_WORDS(prop)) {
+            output.print("[");
+            output.add_mapping(self.end);
+            output.print_string(prop);
+            output.print("]");
+        } else {
+            if (expr instanceof AST_Number && expr.getValue() >= 0) {
+                if (!/[xa-f.)]/i.test(output.last())) {
+                    output.print(".");
+                }
             }
+            output.print(".");
+            // the name after dot would be mapped about here.
+            output.add_mapping(self.end);
+            output.print_name(prop);
         }
-        output.print(".");
-        // the name after dot would be mapped about here.
-        output.add_mapping(self.end);
-        output.print_name(self.property);
     });
     DEFPRINT(AST_Sub, function(self, output){
         self.expression.print(output);
@@ -1536,7 +1593,8 @@ function OutputStream(options) {
     DEFPRINT(AST_NewTarget, function(self, output) {
         output.print("new.target");
     });
-    AST_ObjectProperty.DEFMETHOD("print_property_name", function(key, quote, output) {
+
+    function print_property_name(key, quote, output) {
         if (output.option("quote_keys")) {
             output.print_string(key + "");
         } else if ((typeof key == "number"
@@ -1553,7 +1611,8 @@ function OutputStream(options) {
         } else {
             output.print_string(key, quote);
         }
-    });
+    }
+
     DEFPRINT(AST_ObjectKeyVal, function(self, output){
         function get_name(self) {
             var def = self.definition();
@@ -1566,7 +1625,7 @@ function OutputStream(options) {
             is_identifier_string(self.key) &&
             get_name(self.value) === self.key
         ) {
-            self.print_property_name(self.key, self.quote, output);
+            print_property_name(self.key, self.quote, output);
 
         } else if (allowShortHand &&
             self.value instanceof AST_DefaultAssign &&
@@ -1574,12 +1633,14 @@ function OutputStream(options) {
             is_identifier_string(self.key) &&
             get_name(self.value.left) === self.key
         ) {
-            self.print_property_name(self.key, self.quote, output);
+            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)) {
-                self.print_property_name(self.key, self.quote, output);
+                print_property_name(self.key, self.quote, output);
             } else {
                 output.with_square(function() {
                     self.key.print(output);
@@ -1589,15 +1650,18 @@ function OutputStream(options) {
             self.value.print(output);
         }
     });
-    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, self, output) {
+    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, output) {
+        var self = this;
         if (self.static) {
             output.print("static");
             output.space();
         }
-        output.print(type);
-        output.space();
+        if (type) {
+            output.print(type);
+            output.space();
+        }
         if (self.key instanceof AST_SymbolMethod) {
-            self.print_property_name(self.key.name, self.quote, output);
+            print_property_name(self.key.name, self.quote, output);
         } else {
             output.with_square(function() {
                 self.key.print(output);
@@ -1606,27 +1670,13 @@ function OutputStream(options) {
         self.value._do_print(output, true);
     });
     DEFPRINT(AST_ObjectSetter, function(self, output){
-        self._print_getter_setter("set", self, output);
+        self._print_getter_setter("set", output);
     });
     DEFPRINT(AST_ObjectGetter, function(self, output){
-        self._print_getter_setter("get", self, output);
+        self._print_getter_setter("get", output);
     });
     DEFPRINT(AST_ConciseMethod, function(self, output){
-        if (self.static) {
-            output.print("static");
-            output.space();
-        }
-        if (self.is_generator) {
-            output.print("*");
-        }
-        if (self.key instanceof AST_SymbolMethod) {
-            self.print_property_name(self.key.name, self.quote, output);
-        } else {
-            output.with_square(function() {
-                self.key.print(output);
-            });
-        }
-        self.value._do_print(output, true);
+        self._print_getter_setter(self.is_generator && "*" || self.async && "async", output);
     });
     AST_Symbol.DEFMETHOD("_do_print", function(output){
         var def = this.definition();
@@ -1635,9 +1685,6 @@ function OutputStream(options) {
     DEFPRINT(AST_Symbol, function (self, output) {
         self._do_print(output);
     });
-    DEFPRINT(AST_SymbolDeclaration, function(self, output){
-        self._do_print(output);
-    });
     DEFPRINT(AST_Hole, noop);
     DEFPRINT(AST_This, function(self, output){
         output.print("this");
@@ -1665,9 +1712,7 @@ function OutputStream(options) {
         if (regexp.raw_source) {
             str = "/" + regexp.raw_source + str.slice(str.lastIndexOf("/"));
         }
-        if (output.option("ascii_only")) {
-            str = output.to_ascii(str);
-        }
+        str = output.to_utf8(str);
         output.print(str);
         var p = output.parent();
         if (p instanceof AST_Binary && /^in/.test(p.operator) && p.left === self)

lib/parse.js

@@ -44,10 +44,10 @@
 
 "use strict";
 
-var KEYWORDS = 'break case catch class const continue debugger default delete do else export extends finally for function if in instanceof new return switch throw try typeof var let void while with import';
+var KEYWORDS = 'break case catch class const continue debugger default delete do else export extends finally for function if in instanceof let new return switch throw try typeof var void while with';
 var KEYWORDS_ATOM = 'false null true';
-var RESERVED_WORDS = 'enum implements interface package private protected public static super this ' + KEYWORDS_ATOM + " " + KEYWORDS;
-var KEYWORDS_BEFORE_EXPRESSION = 'return new delete throw else case yield';
+var RESERVED_WORDS = 'enum implements import interface package private protected public static super this ' + KEYWORDS_ATOM + " " + KEYWORDS;
+var KEYWORDS_BEFORE_EXPRESSION = 'return new delete throw else case yield await';
 
 KEYWORDS = makePredicate(KEYWORDS);
 RESERVED_WORDS = makePredicate(RESERVED_WORDS);
@@ -122,8 +122,6 @@ var PUNC_BEFORE_EXPRESSION = makePredicate(characters("[{(,;:"));
 
 var PUNC_CHARS = makePredicate(characters("[]{}(),;:"));
 
-var REGEXP_MODIFIERS = makePredicate(characters("gmsiy"));
-
 /* -----[ Tokenizer ]----- */
 
 // surrogate safe regexps adapted from https://github.com/mathiasbynens/unicode-8.0.0/tree/89b412d8a71ecca9ed593d9e9fa073ab64acfebe/Binary_Property
@@ -511,8 +509,11 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         }
         var content = "", raw = "", ch, tok;
         next(true, true);
-        while ((ch = next(true, true)) !== "`") {
-            if (ch === "$" && peek() === "{") {
+        while ((ch = next(true, true)) != "`") {
+            if (ch == "\r") {
+                if (peek() == "\n") ++S.pos;
+                ch = "\n";
+            } else if (ch == "$" && peek() == "{") {
                 next(true, true);
                 S.brace_counter++;
                 tok = token(begin ? "template_head" : "template_substitution", content);
@@ -523,7 +524,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             }
 
             raw += ch;
-            if (ch === "\\") {
+            if (ch == "\\") {
                 var tmp = S.pos;
                 ch = read_escaped_char();
                 raw += S.text.substr(tmp, S.pos - tmp);
@@ -850,9 +851,7 @@ var PRECEDENCE = (function(a, ret){
     {}
 );
 
-var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]);
-
-var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]);
+var ATOMIC_START_TOKEN = makePredicate([ "atom", "num", "string", "regexp", "name" ]);
 
 /* -----[ Parser ]----- */
 
@@ -860,6 +859,7 @@ function parse($TEXT, options) {
 
     options = defaults(options, {
         bare_returns   : false,
+        ecma           : 8,
         expression     : false,
         filename       : null,
         html5_comments : true,
@@ -877,6 +877,7 @@ function parse($TEXT, options) {
         prev          : null,
         peeked        : null,
         in_function   : 0,
+        in_async      : -1,
         in_generator  : -1,
         in_directives : true,
         in_loop       : 0,
@@ -947,6 +948,10 @@ function parse($TEXT, options) {
         return S.in_generator === S.in_function;
     }
 
+    function is_in_async() {
+        return S.in_async === S.in_function;
+    }
+
     function semicolon(optional) {
         if (is("punc", ";")) next();
         else if (!optional && !can_insert_semicolon()) unexpected();
@@ -1003,6 +1008,17 @@ function parse($TEXT, options) {
             return simple_statement();
 
           case "name":
+            if (S.token.value == "async" && is_token(peek(), "keyword", "function")) {
+                next();
+                next();
+                return function_(AST_Defun, false, true);
+            }
+            if (S.token.value == "import" && !is_token(peek(), "punc", "(")) {
+                next();
+                var node = import_();
+                semicolon();
+                return node;
+            }
             return is_token(peek(), "punc", ":")
                 ? labeled_statement()
                 : simple_statement();
@@ -1139,15 +1155,11 @@ function parse($TEXT, options) {
                     body       : statement()
                 });
 
-              case "import":
-                next();
-                var node = import_();
-                semicolon();
-                return node;
-
               case "export":
-                next();
-                return export_();
+                if (!is_token(peek(), "punc", "(")) {
+                    next();
+                    return export_();
+                }
             }
         }
         unexpected();
@@ -1159,6 +1171,9 @@ function parse($TEXT, options) {
             // Ecma-262, 12.1.1 Static Semantics: Early Errors
             token_error(S.prev, "Yield cannot be used as label inside generators");
         }
+        if (label.name === "await" && is_in_async()) {
+            token_error(S.prev, "await cannot be used as label inside async function");
+        }
         if (find_if(function(l){ return l.name == label.name }, S.labels)) {
             // ECMA-262, 12.12: An ECMAScript program is considered
             // syntactically incorrect if it contains a
@@ -1220,9 +1235,12 @@ function parse($TEXT, options) {
             var is_in = is("operator", "in");
             var is_of = is("name", "of");
             if (is_in || is_of) {
-                if ((init instanceof AST_Definitions) &&
-                        init.definitions.length > 1)
-                    croak("Only one variable declaration allowed in for..in loop");
+                if (init instanceof AST_Definitions) {
+                    if (init.definitions.length > 1)
+                        croak("Only one variable declaration allowed in for..in loop", init.start.line, init.start.col, init.start.pos);
+                } else if (!(is_assignable(init) || (init = to_destructuring(init)) instanceof AST_Destructuring)) {
+                    croak("Invalid left-hand side in for..in loop", init.start.line, init.start.col, init.start.pos);
+                }
                 next();
                 if (is_in) {
                     return for_in(init);
@@ -1272,42 +1290,48 @@ function parse($TEXT, options) {
         });
     };
 
-    var arrow_function = function(start, argnames) {
+    var arrow_function = function(start, argnames, is_async) {
         if (S.token.nlb) {
             croak("Unexpected newline before arrow (=>)");
         }
 
         expect_token("arrow", "=>");
 
-        var body = _function_body(is("punc", "{"));
+        var body = _function_body(is("punc", "{"), false, is_async);
 
         return new AST_Arrow({
             start    : start,
             end      : body.end,
+            async    : is_async,
             argnames : argnames,
             body     : body
         });
     };
 
-    var function_ = function(ctor, is_generator_property) {
+    var function_ = function(ctor, is_generator_property, is_async) {
+        if (is_generator_property && is_async) croak("generators cannot be async");
         var start = S.token
 
         var in_statement = ctor === AST_Defun;
         var is_generator = is("operator", "*");
         if (is_generator) {
-          next();
+            next();
         }
 
         var name = is("name") ? as_symbol(in_statement ? AST_SymbolDefun : AST_SymbolLambda) : null;
         if (in_statement && !name)
             unexpected();
 
+        if (name && ctor !== AST_Accessor && !(name instanceof AST_SymbolDeclaration))
+            unexpected(prev());
+
         var args = parameters();
-        var body = _function_body(true, is_generator || is_generator_property, name, args);
+        var body = _function_body(true, is_generator || is_generator_property, is_async, name, args);
         return new ctor({
             start : args.start,
             end   : body.end,
             is_generator: is_generator,
+            async : is_async,
             name  : name,
             argnames: args,
             body  : body
@@ -1374,22 +1398,20 @@ function parse($TEXT, options) {
 
     function parameters() {
         var start = S.token;
-        var first = true;
         var params = [];
         var used_parameters = track_used_binding_identifiers(true, S.input.has_directive("use strict"));
 
         expect("(");
 
         while (!is("punc", ")")) {
-            if (first) {
-                first = false;
-            } else {
-                expect(",");
-            }
-
             var param = parameter(used_parameters);
             params.push(param);
 
+            if (!is("punc", ")")) {
+                expect(",");
+                if (is("punc", ")") && options.ecma < 8) unexpected();
+            }
+
             if (param instanceof AST_Expansion) {
                 break;
             }
@@ -1505,7 +1527,7 @@ function parse($TEXT, options) {
                 }
                 if (is_expand) {
                     if (!is("punc", "]")) {
-                        unexpected(); // Must be last element
+                        croak("Rest element must be last element");
                     }
                     elements[elements.length - 1] = new AST_Expansion({
                         start: expand_token,
@@ -1530,18 +1552,33 @@ function parse($TEXT, options) {
                 } else {
                     expect(",");
                 }
+                if (is("expand", "...")) {
+                    is_expand = true;
+                    expand_token = S.token;
+                    used_parameters.mark_spread(S.token);
+                    next();
+                }
                 if (is("name") && (is_token(peek(), "punc") || is_token(peek(), "operator")) && [",", "}", "="].indexOf(peek().value) !== -1) {
                     used_parameters.add_parameter(S.token);
-                    elements.push(new AST_ObjectKeyVal({
-                        start: prev(),
-                        key: S.token.value,
-                        value: new symbol_type({
-                            start: S.token,
-                            name: S.token.value,
-                            end: S.token
-                        }),
-                        end: prev()
-                    }));
+                    var value = new symbol_type({
+                        start: S.token,
+                        name: S.token.value,
+                        end: S.token,
+                    });
+                    if (is_expand) {
+                        elements.push(new AST_Expansion({
+                            start: expand_token,
+                            expression: value,
+                            end: value.end,
+                        }));
+                    } else {
+                        elements.push(new AST_ObjectKeyVal({
+                            start: prev(),
+                            key: S.token.value,
+                            value: value,
+                            end: value.end,
+                        }));
+                    }
                     next();
                 } else if (is("punc", "}")) {
                     continue; // Allow trailing hole
@@ -1572,7 +1609,12 @@ function parse($TEXT, options) {
                         }));
                     }
                 }
-                if (is("operator", "=")) {
+                if (is_expand) {
+                    if (!is("punc", "}")) {
+                        croak("Rest element must be last element");
+                    }
+                }
+                else if (is("operator", "=")) {
                     used_parameters.mark_default_assignment(S.token);
                     next();
                     elements[elements.length - 1].value = new AST_DefaultAssign({
@@ -1605,36 +1647,54 @@ function parse($TEXT, options) {
         }
     }
 
-    function params_or_seq_() {
-        var first = true;
+    function params_or_seq_(allow_arrows, maybe_sequence) {
+        var spread_token;
+        var invalid_sequence;
+        var trailing_comma;
         var a = [];
+        expect("(");
         while (!is("punc", ")")) {
-            if (first) first = false; else expect(",");
+            if (spread_token) unexpected(spread_token);
             if (is("expand", "...")) {
-                var spread_token = S.token;
+                spread_token = S.token;
+                if (maybe_sequence) invalid_sequence = S.token;
                 next();
                 a.push(new AST_Expansion({
                     start: prev(),
                     expression: expression(),
                     end: S.token,
                 }));
-                if (!is("punc", ")")) {
-                    unexpected(spread_token);
-                }
             } else {
                 a.push(expression());
             }
+            if (!is("punc", ")")) {
+                expect(",");
+                if (is("punc", ")")) {
+                    if (options.ecma < 8) unexpected();
+                    trailing_comma = prev();
+                    if (maybe_sequence) invalid_sequence = trailing_comma;
+                }
+            }
+        }
+        expect(")");
+        if (allow_arrows && is("arrow", "=>")) {
+            if (spread_token && trailing_comma) unexpected(trailing_comma);
+        } else if (invalid_sequence) {
+            unexpected(invalid_sequence);
         }
         return a;
     }
 
-    function _function_body(block, generator, name, args) {
+    function _function_body(block, generator, is_async, name, args) {
         var loop = S.in_loop;
         var labels = S.labels;
         var current_generator = S.in_generator;
+        var current_async = S.in_async;
         ++S.in_function;
         if (generator)
             S.in_generator = S.in_function;
+        if (is_async)
+            S.in_async = S.in_function;
         if (block)
             S.in_directives = true;
         S.in_loop = 0;
@@ -1654,9 +1714,22 @@ function parse($TEXT, options) {
         S.in_loop = loop;
         S.labels = labels;
         S.in_generator = current_generator;
+        S.in_async = current_async;
         return a;
     }
 
+    function _await_expression() {
+        // Previous token must be "await" and not be interpreted as an identifier
+        if (!is_in_async()) {
+            croak("Unexpected await expression outside async function",
+                S.prev.line, S.prev.col, S.prev.pos);
+        }
+        // the await expression is parsed as a unary expression in Babel
+        return new AST_Await({
+            expression : maybe_unary(true),
+        });
+    }
+
     function _yield_expression() {
         // Previous token must be keyword yield and not be interpret as an identifier
         if (!is_in_generator()) {
@@ -1665,7 +1738,6 @@ function parse($TEXT, options) {
         }
         var star = false;
         var has_expression = true;
-        var tmp;
 
         // Attempt to get expression or star (and then the mandatory expression)
         // behind yield on the same line.
@@ -1808,7 +1880,8 @@ function parse($TEXT, options) {
                         : !no_in && kind === "const" && S.input.has_directive("use strict")
                             ? croak("Missing initializer in const declaration") : null,
                     end   : prev()
-                })
+                });
+                if (def.name.name == "import") croak("Unexpected token: import");
             }
             a.push(def);
             if (!is("punc", ","))
@@ -1856,7 +1929,7 @@ function parse($TEXT, options) {
         var newexp = expr_atom(false), args;
         if (is("punc", "(")) {
             next();
-            args = expr_list(")");
+            args = expr_list(")", options.ecma >= 8);
         } else {
             args = [];
         }
@@ -1872,7 +1945,6 @@ function parse($TEXT, options) {
         var tok = S.token, ret;
         switch (tok.type) {
           case "name":
-          case "keyword":
             ret = _make_symbol(AST_SymbolRef);
             break;
           case "num":
@@ -1902,13 +1974,6 @@ function parse($TEXT, options) {
                 break;
             }
             break;
-          case "operator":
-            if (!is_identifier_string(tok.value)) {
-                croak("Invalid getter/setter name: " + tok.value,
-                    tok.line, tok.col, tok.pos);
-            }
-            ret = _make_symbol(AST_SymbolRef);
-            break;
         }
         next();
         return ret;
@@ -1935,9 +2000,6 @@ function parse($TEXT, options) {
                 names: ex.properties.map(to_fun_args)
             }), default_seen_above);
         } else if (ex instanceof AST_ObjectKeyVal) {
-            if (ex.key instanceof AST_SymbolRef) {
-                ex.key = to_fun_args(ex.key, 0, [ex.key]);
-            }
             ex.value = to_fun_args(ex.value, 0, [ex.key]);
             return insert_default(ex, default_seen_above);
         } else if (ex instanceof AST_Hole) {
@@ -1971,21 +2033,24 @@ function parse($TEXT, options) {
         }
     }
 
-    var expr_atom = function(allow_calls) {
+    var expr_atom = function(allow_calls, allow_arrows) {
         if (is("operator", "new")) {
             return new_(allow_calls);
         }
         var start = S.token;
+        var async = is("name", "async") && as_atom_node();
         if (is("punc")) {
-            switch (start.value) {
+            switch (S.token.value) {
               case "(":
-                next();
-                var exprs = params_or_seq_();
-                expect(")");
-                if (is("arrow", "=>")) {
-                    return arrow_function(start, exprs.map(to_fun_args));
+                if (async && !allow_calls) break;
+                var exprs = params_or_seq_(allow_arrows, !async);
+                if (allow_arrows && is("arrow", "=>")) {
+                    return arrow_function(start, exprs.map(to_fun_args), !!async);
                 }
-                var ex = exprs.length == 1 ? exprs[0] : new AST_Sequence({
+                var ex = async ? new AST_Call({
+                    expression: async,
+                    args: exprs
+                }) : exprs.length == 1 ? exprs[0] : new AST_Sequence({
                     expressions: exprs
                 });
                 ex.start = start;
@@ -1994,17 +2059,27 @@ function parse($TEXT, options) {
               case "[":
                 return subscripts(array_(), allow_calls);
               case "{":
-                return subscripts(object_or_object_destructuring_(), allow_calls);
+                return subscripts(object_or_destructuring_(), allow_calls);
             }
-            unexpected();
+            if (!async) unexpected();
+        }
+        if (allow_arrows && is("name") && is_token(peek(), "arrow")) {
+            var param = new AST_SymbolFunarg({
+                name: S.token.value,
+                start: start,
+                end: start,
+            });
+            next();
+            return arrow_function(start, [param], !!async);
         }
         if (is("keyword", "function")) {
             next();
-            var func = function_(AST_Function);
+            var func = function_(AST_Function, false, !!async);
             func.start = start;
             func.end = prev();
             return subscripts(func, allow_calls);
         }
+        if (async) return subscripts(async, allow_calls);
         if (is("keyword", "class")) {
             next();
             var cls = class_(AST_ClassExpression);
@@ -2015,7 +2090,7 @@ function parse($TEXT, options) {
         if (is("template_head")) {
             return subscripts(template_string(), allow_calls);
         }
-        if (ATOMIC_START_TOKEN[S.token.type]) {
+        if (ATOMIC_START_TOKEN(S.token.type)) {
             return subscripts(as_atom_node(), allow_calls);
         }
         unexpected();
@@ -2079,11 +2154,11 @@ function parse($TEXT, options) {
         });
     });
 
-    var create_accessor = embed_tokens(function(is_generator) {
-        return function_(AST_Accessor, is_generator);
+    var create_accessor = embed_tokens(function(is_generator, is_async) {
+        return function_(AST_Accessor, is_generator, is_async);
     });
 
-    var object_or_object_destructuring_ = embed_tokens(function() {
+    var object_or_destructuring_ = embed_tokens(function object_or_destructuring_() {
         var start = S.token, first = true, a = [];
         expect("{");
         while (!is("punc", "}")) {
@@ -2091,7 +2166,18 @@ function parse($TEXT, options) {
             if (!options.strict && is("punc", "}"))
                 // allow trailing comma
                 break;
+
             start = S.token;
+            if (start.type == "expand") {
+                next();
+                a.push(new AST_Expansion({
+                    start: start,
+                    expression: expression(false),
+                    end: prev(),
+                }));
+                continue;
+            }
+
             var name = as_property_name();
             var value;
 
@@ -2196,6 +2282,7 @@ function parse($TEXT, options) {
             }
             return name;
         }
+        var is_async = false;
         var is_static = false;
         var is_generator = false;
         var property_token = start;
@@ -2204,6 +2291,11 @@ function parse($TEXT, options) {
             property_token = S.token;
             name = as_property_name();
         }
+        if (name === "async" && !is("punc", "(") && !is("punc", ",") && !is("punc", "}")) {
+            is_async = true;
+            property_token = S.token;
+            name = as_property_name();
+        }
         if (name === null) {
             is_generator = true;
             property_token = S.token;
@@ -2218,10 +2310,11 @@ function parse($TEXT, options) {
                 start       : start,
                 static      : is_static,
                 is_generator: is_generator,
+                async       : is_async,
                 key         : name,
                 quote       : name instanceof AST_SymbolMethod ?
                               property_token.quote : undefined,
-                value       : create_accessor(is_generator),
+                value       : create_accessor(is_generator, is_async),
                 end         : prev()
             });
             return node;
@@ -2269,7 +2362,7 @@ function parse($TEXT, options) {
             next();
         }
 
-        imported_names = import_names(true);
+        imported_names = map_names(true);
 
         if (imported_names || imported_name) {
             expect_token("name", "from");
@@ -2293,26 +2386,40 @@ function parse($TEXT, options) {
         });
     }
 
-    function import_name() {
+    function map_name(is_import) {
+        function make_symbol(type) {
+            return new type({
+                name: as_property_name(),
+                start: prev(),
+                end: prev()
+            });
+        }
+
+        var foreign_type = is_import ? AST_SymbolImportForeign : AST_SymbolExportForeign;
+        var type = is_import ? AST_SymbolImport : AST_SymbolExport;
         var start = S.token;
         var foreign_name;
         var name;
 
-        if (peek().value === "as" && peek().type === "name") {
-            foreign_name = as_symbol(AST_SymbolImportForeign);
+        if (is_import) {
+            foreign_name = make_symbol(foreign_type);
+        } else {
+            name = make_symbol(type);
+        }
+        if (is("name", "as")) {
             next();  // The "as" word
-        }
-        name = as_symbol(AST_SymbolImport);
-
-        if (foreign_name === undefined) {
-            foreign_name = new AST_SymbolImportForeign({
-                name: name.name,
-                start: name.start,
-                end: name.end,
-            });
+            if (is_import) {
+                name = make_symbol(type);
+            } else {
+                foreign_name = make_symbol(foreign_type);
+            }
+        } else if (is_import) {
+            name = new type(foreign_name);
+        } else {
+            foreign_name = new foreign_type(name);
         }
 
-        return new AST_NameImport({
+        return new AST_NameMapping({
             start: start,
             foreign_name: foreign_name,
             name: name,
@@ -2320,26 +2427,26 @@ function parse($TEXT, options) {
         })
     }
 
-    function import_nameAsterisk(name) {
+    function map_nameAsterisk(is_import, name) {
+        var foreign_type = is_import ? AST_SymbolImportForeign : AST_SymbolExportForeign;
+        var type = is_import ? AST_SymbolImport : AST_SymbolExport;
         var start = S.token;
         var foreign_name;
-
-
         var end = prev();
 
-        name = name || new AST_SymbolImport({
+        name = name || new type({
             name: '*',
             start: start,
             end: end,
         });
 
-        foreign_name = new AST_SymbolImportForeign({
+        foreign_name = new foreign_type({
             name: '*',
             start: start,
             end: end,
         });
 
-        return new AST_NameImport({
+        return new AST_NameMapping({
             start: start,
             foreign_name: foreign_name,
             name: name,
@@ -2347,13 +2454,13 @@ function parse($TEXT, options) {
         })
     }
 
-    function import_names(allow_as) {
+    function map_names(is_import) {
         var names;
         if (is("punc", "{")) {
             next();
             names = [];
             while (!is("punc", "}")) {
-                names.push(import_name());
+                names.push(map_name(is_import));
                 if (is("punc", ",")) {
                     next();
                 }
@@ -2362,11 +2469,11 @@ function parse($TEXT, options) {
         } else if (is("operator", "*")) {
             var name;
             next();
-            if (allow_as && is("name", "as")) {
+            if (is_import && is("name", "as")) {
                 next();  // The "as" word
                 name = as_symbol(AST_SymbolImportForeign);
             }
-            names = [import_nameAsterisk(name)];
+            names = [map_nameAsterisk(is_import, name)];
         }
         return names;
     }
@@ -2374,72 +2481,60 @@ function parse($TEXT, options) {
     function export_() {
         var start = S.token;
         var is_default;
-        var exported_value;
-        var exported_definition;
         var exported_names;
 
         if (is("keyword", "default")) {
             is_default = true;
             next();
-        } else {
-            exported_names = import_names(false);
+        } else if (exported_names = map_names(false)) {
+            if (is("name", "from")) {
+                next();
 
-            if (exported_names) {
-                if (is("name", "from")) {
-                    next();
-
-                    var mod_str = S.token;
-                    if (mod_str.type !== 'string') {
-                        unexpected();
-                    }
-                    next();
-
-                    return new AST_Export({
-                        start: start,
-                        is_default: is_default,
-                        exported_names: exported_names,
-                        module_name: new AST_String({
-                            start: mod_str,
-                            value: mod_str.value,
-                            quote: mod_str.quote,
-                            end: mod_str,
-                        }),
-                        end: prev(),
-                    });
-                } else {
-                    return new AST_Export({
-                        start: start,
-                        is_default: is_default,
-                        exported_names: exported_names,
-                        end: prev(),
-                    });
+                var mod_str = S.token;
+                if (mod_str.type !== 'string') {
+                    unexpected();
                 }
+                next();
+
+                return new AST_Export({
+                    start: start,
+                    is_default: is_default,
+                    exported_names: exported_names,
+                    module_name: new AST_String({
+                        start: mod_str,
+                        value: mod_str.value,
+                        quote: mod_str.quote,
+                        end: mod_str,
+                    }),
+                    end: prev(),
+                });
+            } else {
+                return new AST_Export({
+                    start: start,
+                    is_default: is_default,
+                    exported_names: exported_names,
+                    end: prev(),
+                });
             }
         }
 
-        var is_definition = is("keyword", "var") || is("keyword", "let") || is("keyword", "const");
-        if (is_definition) {
-            if (is_default) unexpected();
-            exported_definition = statement();
-        } else if (is("keyword", "class")) {
-            var cls = expr_atom(false);
-            if (cls.name) {
-                cls.name = new AST_SymbolDefClass(cls.name);
-                exported_definition = new AST_DefClass(cls);
-            } else {
-                exported_value = cls;
-            }
-        } else if (is("keyword", "function")) {
-            var func = expr_atom(false);
-            if (func.name) {
-                func.name = new AST_SymbolDefun(func.name);
-                exported_definition = new AST_Defun(func);
-            } else {
-                exported_value = func;
-            }
-        } else {
+        var node;
+        var exported_value;
+        var exported_definition;
+        if (is("punc", "{")
+            || is_default
+                && (is("keyword", "class") || is("keyword", "function"))
+                && is_token(peek(), "punc")) {
             exported_value = expression(false);
             semicolon();
+        } else if ((node = statement()) instanceof AST_Definitions && is_default) {
+            unexpected(node.start);
+        } else if (node instanceof AST_Definitions || node instanceof AST_Defun || node instanceof AST_DefClass) {
+            exported_definition = node;
+        } else if (node instanceof AST_SimpleStatement) {
+            exported_value = node.body;
+        } else {
+            unexpected(node.start);
         }
 
         return new AST_Export({
@@ -2470,7 +2565,7 @@ function parse($TEXT, options) {
                 unexpected(tmp);
             }
           case "name":
-            if (tmp.value == "yield" && !is_token(peek(), "punc", ":")
+            if (tmp.value == "yield" && !is_token(peek(), "punc", ":") && !is_token(peek(), "punc", "(")
                 && S.input.has_directive("use strict") && !is_in_generator()) {
                 token_error(tmp, "Unexpected yield identifier inside strict mode");
             }
@@ -2565,11 +2660,9 @@ function parse($TEXT, options) {
         return expr;
     };
 
-    var call_args = embed_tokens(function call_args() {
-        var first = true;
+    var call_args = embed_tokens(function _call_args() {
         var args = [];
         while (!is("punc", ")")) {
-            if (first) first = false; else expect(",");
             if (is("expand", "...")) {
                 next();
                 args.push(new AST_Expansion({
@@ -2579,13 +2672,25 @@ function parse($TEXT, options) {
             } else {
                 args.push(expression(false));
             }
+            if (!is("punc", ")")) {
+                expect(",");
+                if (is("punc", ")") && options.ecma < 8) unexpected();
+            }
         }
         next();
         return args;
     });
 
-    var maybe_unary = function(allow_calls) {
+    var maybe_unary = function(allow_calls, allow_arrows) {
         var start = S.token;
+        if (start.type == "name" && start.value == "await") {
+            if (is_in_async()) {
+                next();
+                return _await_expression();
+            } else if (S.input.has_directive("use strict")) {
+                token_error(S.token, "Unexpected await identifier inside strict mode")
+            }
+        }
         if (is("operator") && UNARY_PREFIX(start.value)) {
             next();
             handle_regexp();
@@ -2594,8 +2699,9 @@ function parse($TEXT, options) {
             ex.end = prev();
             return ex;
         }
-        var val = expr_atom(allow_calls);
+        var val = expr_atom(allow_calls, allow_arrows);
         while (is("operator") && UNARY_POSTFIX(S.token.value) && !S.token.nlb) {
+            if (val instanceof AST_Arrow) unexpected();
             val = make_unary(AST_UnaryPostfix, S.token, val);
             val.start = start;
             val.end = S.token;
@@ -2643,7 +2749,7 @@ function parse($TEXT, options) {
     };
 
     function expr_ops(no_in) {
-        return expr_op(maybe_unary(true), 0, no_in);
+        return expr_op(maybe_unary(true, true), 0, no_in);
     };
 
     var maybe_conditional = function(no_in) {
@@ -2724,22 +2830,6 @@ function parse($TEXT, options) {
             }
         }
 
-        if (start.type == "punc" && start.value == "(" && peek().value == ")") {
-            next();
-            next();
-            return arrow_function(start, []);
-        }
-
-        if (is("name") && is_token(peek(), "arrow")) {
-            var param = new AST_SymbolFunarg({
-                name: start.value,
-                start: start,
-                end: start,
-            });
-            next();
-            return arrow_function(start, [param]);
-        }
-
         var left = maybe_conditional(no_in);
         var val = S.token.value;
 

lib/propmangle.js

@@ -85,6 +85,36 @@ function find_builtins(reserved) {
     }
 }
 
+function reserve_quoted_keys(ast, reserved) {
+    function add(name) {
+        push_uniq(reserved, name);
+    }
+
+    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);
+        }
+    }));
+}
+
+function addStrings(node, add) {
+    node.walk(new TreeWalker(function(node) {
+        if (node instanceof AST_Sequence) {
+            addStrings(node.expressions[node.expressions.length - 1], add);
+        } else if (node instanceof AST_String) {
+            add(node.value);
+        } else if (node instanceof AST_Conditional) {
+            addStrings(node.consequent, add);
+            addStrings(node.alternative, add);
+        }
+        return true;
+    }));
+}
+
 function mangle_properties(ast, options) {
     options = defaults(options, {
         builtins: false,
@@ -94,9 +124,10 @@ function mangle_properties(ast, options) {
         only_cache: false,
         regex: null,
         reserved: null,
-    });
+    }, true);
 
-    var reserved = options.reserved || [];
+    var reserved = options.reserved;
+    if (!Array.isArray(reserved)) reserved = [];
     if (!options.builtins) find_builtins(reserved);
 
     var cache = options.cache;
@@ -108,7 +139,6 @@ function mangle_properties(ast, options) {
     }
 
     var regex = options.regex;
-    var keep_quoted = options.keep_quoted;
 
     // note debug is either false (disabled), or a string of the debug suffix to use (enabled).
     // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
@@ -121,12 +151,11 @@ function mangle_properties(ast, options) {
 
     var names_to_mangle = [];
     var unmangleable = [];
-    var to_keep = {};
 
     // step 1: find candidates to mangle
     ast.walk(new TreeWalker(function(node){
         if (node instanceof AST_ObjectKeyVal) {
-            add(node.key, keep_quoted && node.quote);
+            add(node.key);
         }
         else if (node instanceof AST_ObjectProperty) {
             // setter or getter, since KeyVal is handled above
@@ -136,18 +165,14 @@ function mangle_properties(ast, options) {
             add(node.property);
         }
         else if (node instanceof AST_Sub) {
-            addStrings(node.property, keep_quoted);
-        }
-        else if (node instanceof AST_ConciseMethod) {
-            add(node.name.name);
+            addStrings(node.property, add);
         }
     }));
 
     // step 2: transform the tree, renaming properties
     return ast.transform(new TreeTransformer(function(node){
         if (node instanceof AST_ObjectKeyVal) {
-            if (!(keep_quoted && node.quote))
-                node.key = mangle(node.key);
+            node.key = mangle(node.key);
         }
         else if (node instanceof AST_ObjectProperty) {
             // setter or getter
@@ -156,27 +181,9 @@ function mangle_properties(ast, options) {
         else if (node instanceof AST_Dot) {
             node.property = mangle(node.property);
         }
-        else if (node instanceof AST_Sub) {
-            if (!keep_quoted)
-                node.property = mangleStrings(node.property);
+        else if (!options.keep_quoted && node instanceof AST_Sub) {
+            node.property = mangleStrings(node.property);
         }
-        else if (node instanceof AST_ConciseMethod) {
-            if (should_mangle(node.name.name)) {
-                node.name.name = mangle(node.name.name);
-            }
-        }
-        // else if (node instanceof AST_String) {
-        //     if (should_mangle(node.value)) {
-        //         AST_Node.warn(
-        //             "Found \"{prop}\" property candidate for mangling in an arbitrary string [{file}:{line},{col}]", {
-        //                 file : node.start.file,
-        //                 line : node.start.line,
-        //                 col  : node.start.col,
-        //                 prop : node.value
-        //             }
-        //         );
-        //     }
-        // }
     }));
 
     // only function declarations after this line
@@ -192,19 +199,13 @@ function mangle_properties(ast, options) {
     }
 
     function should_mangle(name) {
-        if (keep_quoted && name in to_keep) return false;
         if (regex && !regex.test(name)) return false;
         if (reserved.indexOf(name) >= 0) return false;
         return cache.props.has(name)
             || names_to_mangle.indexOf(name) >= 0;
     }
 
-    function add(name, keep) {
-        if (keep) {
-            to_keep[name] = true;
-            return;
-        }
-
+    function add(name) {
         if (can_mangle(name))
             push_uniq(names_to_mangle, name);
 
@@ -224,19 +225,16 @@ function mangle_properties(ast, options) {
                 // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_.
                 var debug_mangled = "_$" + name + "$" + debug_name_suffix + "_";
 
-                if (can_mangle(debug_mangled) && !(keep_quoted && debug_mangled in to_keep)) {
+                if (can_mangle(debug_mangled)) {
                     mangled = debug_mangled;
                 }
             }
 
             // either debug mode is off, or it is on and we could not use the mangled name
             if (!mangled) {
-                // Note: `can_mangle()` does not check if the name collides with the `to_keep` set
-                // (filled with quoted properties when `keep_quoted` is set). Make sure we add this
-                // check so we don't collide with a quoted name.
                 do {
                     mangled = base54(++cache.cname);
-                } while (!can_mangle(mangled) || keep_quoted && mangled in to_keep);
+                } while (!can_mangle(mangled));
             }
 
             cache.props.set(name, mangled);
@@ -244,32 +242,6 @@ function mangle_properties(ast, options) {
         return mangled;
     }
 
-    function addStrings(node, keep) {
-        var out = {};
-        try {
-            (function walk(node){
-                node.walk(new TreeWalker(function(node){
-                    if (node instanceof AST_Sequence) {
-                        walk(node.expressions[node.expressions.length - 1]);
-                        return true;
-                    }
-                    if (node instanceof AST_String) {
-                        add(node.value, keep);
-                        return true;
-                    }
-                    if (node instanceof AST_Conditional) {
-                        walk(node.consequent);
-                        walk(node.alternative);
-                        return true;
-                    }
-                    throw out;
-                }));
-            })(node);
-        } catch(ex) {
-            if (ex !== out) throw ex;
-        }
-    }
-
     function mangleStrings(node) {
         return node.transform(new TreeTransformer(function(node){
             if (node instanceof AST_Sequence) {

lib/scope.js

@@ -51,7 +51,6 @@ function SymbolDef(scope, index, orig) {
     this.global = false;
     this.export = false;
     this.mangled_name = null;
-    this.object_destructuring_arg = false;
     this.undeclared = false;
     this.index = index;
     this.id = SymbolDef.next_id++;
@@ -65,7 +64,6 @@ SymbolDef.prototype = {
 
         return (this.global && !options.toplevel)
             || this.export
-            || this.object_destructuring_arg
             || this.undeclared
             || (!options.eval && (this.scope.uses_eval || this.scope.uses_with))
             || (options.keep_fnames
@@ -87,7 +85,7 @@ SymbolDef.prototype = {
             if (options.ie8 && sym instanceof AST_SymbolLambda)
                 s = s.parent_scope;
             var def;
-            if (this.defun && (def = this.defun.variables.get(this.name))) {
+            if (def = this.redefined()) {
                 this.mangled_name = def.mangled_name || def.name;
             } else
                 this.mangled_name = s.next_mangled(options, this);
@@ -95,6 +93,9 @@ SymbolDef.prototype = {
                 cache.set(this.name, this.mangled_name);
             }
         }
+    },
+    redefined: function() {
+        return this.defun && this.defun.variables.get(this.name);
     }
 };
 
@@ -115,7 +116,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     var tw = new TreeWalker(function(node, descend){
         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;
@@ -131,7 +132,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             scope = save_scope;
             return true;
         }
-        if (node instanceof AST_Destructuring && node.is_array === false) {
+        if (node instanceof AST_Destructuring) {
             in_destructuring = node;  // These don't nest
             descend();
             in_destructuring = null;
@@ -168,9 +169,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
         if (node instanceof AST_Symbol) {
             node.scope = scope;
         }
-        if (node instanceof AST_SymbolFunarg) {
-            node.object_destructuring_arg = !!in_destructuring;
-        }
         if (node instanceof AST_Label) {
             node.thedef = node;
             node.references = [];
@@ -205,6 +203,21 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             || 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) {
@@ -228,10 +241,25 @@ 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 && !node.is_default;
+            def.export = node instanceof AST_Export;
         }
     });
     self.walk(tw);
@@ -250,17 +278,27 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
                     s.uses_eval = true;
                 }
             }
-            var sym = node.scope.find_variable(name);
-            if (node.scope instanceof AST_Lambda && name == "arguments") {
-                node.scope.uses_arguments = true;
-            }
-            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;
             }
             node.thedef = sym;
             node.reference(options);
             return true;
         }
+        // ensure mangling works if catch reuses a scope variable
+        var def;
+        if (node instanceof AST_SymbolCatch && (def = node.definition().redefined())) {
+            var s = node.scope;
+            while (s) {
+                push_uniq(s.enclosed, def);
+                if (s === def.scope) break;
+                s = s.parent_scope;
+            }
+        }
     });
     self.walk(tw);
 
@@ -277,6 +315,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
                     ref.reference(options);
                 });
                 node.thedef = def;
+                node.reference(options);
                 return true;
             }
         }));
@@ -334,7 +373,7 @@ 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;
-    this.def_variable(new AST_SymbolConst({
+    this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
         start: this.start,
         end: this.end
@@ -378,7 +417,6 @@ AST_Scope.DEFMETHOD("def_variable", function(symbol){
     if (!this.variables.has(symbol.name)) {
         def = new SymbolDef(this, this.variables.size(), symbol);
         this.variables.set(symbol.name, def);
-        def.object_destructuring_arg = symbol.object_destructuring_arg;
         def.global = !this.parent_scope;
     } else {
         def = this.variables.get(symbol.name);
@@ -428,7 +466,7 @@ AST_Function.DEFMETHOD("next_mangled", function(options, def){
 
 AST_Symbol.DEFMETHOD("unmangleable", function(options){
     var def = this.definition();
-    return def && def.unmangleable(options);
+    return !def || def.unmangleable(options);
 });
 
 // labels are always mangleable
@@ -439,14 +477,6 @@ AST_Symbol.DEFMETHOD("unreferenced", function(){
         && !(this.scope.uses_eval || this.scope.uses_with);
 });
 
-AST_Symbol.DEFMETHOD("undeclared", function(){
-    return this.definition().undeclared;
-});
-
-AST_LabelRef.DEFMETHOD("undeclared", return_false);
-
-AST_Label.DEFMETHOD("undeclared", return_false);
-
 AST_Symbol.DEFMETHOD("definition", function(){
     return this.thedef;
 });
@@ -456,7 +486,7 @@ AST_Symbol.DEFMETHOD("global", function(){
 });
 
 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
-    return defaults(options, {
+    options = defaults(options, {
         eval        : false,
         ie8         : false,
         keep_classnames: false,
@@ -464,6 +494,8 @@ AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
         reserved    : [],
         toplevel    : false,
     });
+    if (!Array.isArray(options.reserved)) options.reserved = [];
+    return options;
 });
 
 AST_Toplevel.DEFMETHOD("mangle_names", function(options){
@@ -514,7 +546,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
         var mangle_with_block_scope =
             (!options.ie8 && node instanceof AST_SymbolCatch) ||
             node instanceof AST_SymbolBlockDeclaration;
-        if (mangle_with_block_scope) {
+        if (mangle_with_block_scope && options.reserved.indexOf(node.name) < 0) {
             to_mangle.push(node.definition());
             return;
         }
@@ -531,111 +563,69 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
 
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
     options = this._default_mangler_options(options);
-    var tw = new TreeWalker(function(node){
-        if (node instanceof AST_Constant)
-            base54.consider(node.print_to_string());
-        else if (node instanceof AST_Return)
-            base54.consider("return");
-        else if (node instanceof AST_Throw)
-            base54.consider("throw");
-        else if (node instanceof AST_Continue)
-            base54.consider("continue");
-        else if (node instanceof AST_Break)
-            base54.consider("break");
-        else if (node instanceof AST_Debugger)
-            base54.consider("debugger");
-        else if (node instanceof AST_Directive)
-            base54.consider(node.value);
-        else if (node instanceof AST_While)
-            base54.consider("while");
-        else if (node instanceof AST_Do)
-            base54.consider("do while");
-        else if (node instanceof AST_If) {
-            base54.consider("if");
-            if (node.alternative) base54.consider("else");
-        }
-        else if (node instanceof AST_Var)
-            base54.consider("var");
-        else if (node instanceof AST_Const)
-            base54.consider("const");
-        else if (node instanceof AST_Lambda)
-            base54.consider("function");
-        else if (node instanceof AST_For)
-            base54.consider("for");
-        else if (node instanceof AST_ForIn)
-            base54.consider("for in");
-        else if (node instanceof AST_Switch)
-            base54.consider("switch");
-        else if (node instanceof AST_Case)
-            base54.consider("case");
-        else if (node instanceof AST_Default)
-            base54.consider("default");
-        else if (node instanceof AST_With)
-            base54.consider("with");
-        else if (node instanceof AST_ObjectSetter)
-            base54.consider("set" + (typeof node.key === "string" ? node.key : ""));
-        else if (node instanceof AST_ObjectGetter)
-            base54.consider("get" + (typeof node.key === "string" ? node.key : ""));
-        else if (node instanceof AST_ObjectKeyVal && typeof node.key === "string")
-            base54.consider(node.key);
-        else if (node instanceof AST_ConciseMethod && typeof node.key === "string")
-            base54.consider(node.key);
-        else if (node instanceof AST_New)
-            base54.consider("new");
-        else if (node instanceof AST_This)
-            base54.consider("this");
-        else if (node instanceof AST_Super)
-            base54.consider("super");
-        else if (node instanceof AST_Try)
-            base54.consider("try");
-        else if (node instanceof AST_Catch)
-            base54.consider("catch");
-        else if (node instanceof AST_Finally)
-            base54.consider("finally");
-        else if (node instanceof AST_Yield)
-            base54.consider("yield");
-        else if (node instanceof AST_Symbol && node.unmangleable(options))
-            base54.consider(node.name);
-        else if (node instanceof AST_Unary || node instanceof AST_Binary)
-            base54.consider(node.operator);
-        else if (node instanceof AST_Dot)
-            base54.consider(node.property);
-    });
-    this.walk(tw);
+    try {
+        AST_Node.prototype.print = function(stream, force_parens) {
+            this._print(stream, force_parens);
+            if (this instanceof AST_Symbol && !this.unmangleable(options)) {
+                base54.consider(this.name, -1);
+            } else if (options.properties) {
+                if (this instanceof AST_Dot) {
+                    base54.consider(this.property, -1);
+                } else if (this instanceof AST_Sub) {
+                    skip_string(this.property);
+                }
+            }
+        };
+        base54.consider(this.print_to_string(), 1);
+    } finally {
+        AST_Node.prototype.print = AST_Node.prototype._print;
+    }
     base54.sort();
+
+    function skip_string(node) {
+        if (node instanceof AST_String) {
+            base54.consider(node.value, -1);
+        } else if (node instanceof AST_Conditional) {
+            skip_string(node.consequent);
+            skip_string(node.alternative);
+        } else if (node instanceof AST_Sequence) {
+            skip_string(node.expressions[node.expressions.length - 1]);
+        }
+    }
 });
 
 var base54 = (function() {
-    var string = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789";
+    var leading = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_".split("");
+    var digits = "0123456789".split("");
     var chars, frequency;
     function reset() {
         frequency = Object.create(null);
-        chars = string.split("").map(function(ch){ return ch.charCodeAt(0) });
-        chars.forEach(function(ch){ frequency[ch] = 0 });
+        leading.forEach(function(ch) {
+            frequency[ch] = 0;
+        });
+        digits.forEach(function(ch) {
+            frequency[ch] = 0;
+        });
     }
-    base54.consider = function(str){
+    base54.consider = function(str, delta) {
         for (var i = str.length; --i >= 0;) {
-            var code = str.charCodeAt(i);
-            if (code in frequency) ++frequency[code];
+            frequency[str[i]] += delta;
         }
     };
+    function compare(a, b) {
+        return frequency[b] - frequency[a];
+    }
     base54.sort = function() {
-        chars = mergeSort(chars, function(a, b){
-            if (is_digit(a) && !is_digit(b)) return 1;
-            if (is_digit(b) && !is_digit(a)) return -1;
-            return frequency[b] - frequency[a];
-        });
+        chars = mergeSort(leading, compare).concat(mergeSort(digits, compare));
     };
     base54.reset = reset;
     reset();
-    base54.get = function(){ return chars };
-    base54.freq = function(){ return frequency };
     function base54(num) {
         var ret = "", base = 54;
         num++;
         do {
             num--;
-            ret += String.fromCharCode(chars[num % base]);
+            ret += chars[num % base];
             num = Math.floor(num / base);
             base = 64;
         } while (num > 0);

lib/transform.js

@@ -70,7 +70,7 @@ TreeTransformer.prototype = new TreeWalker;
                     if (y !== undefined) x = y;
                 }
             }
-            tw.pop(this);
+            tw.pop();
             return x;
         });
     };
@@ -199,6 +199,10 @@ TreeTransformer.prototype = new TreeWalker;
         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);
     });
@@ -239,9 +243,22 @@ TreeTransformer.prototype = new TreeWalker;
         self.expression = self.expression.transform(tw);
     });
 
-    _(AST_Export, function(self, 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) {

lib/utils.js

@@ -43,13 +43,6 @@
 
 "use strict";
 
-function array_to_hash(a) {
-    var ret = Object.create(null);
-    for (var i = 0; i < a.length; ++i)
-        ret[a[i]] = true;
-    return ret;
-};
-
 function slice(a, start) {
     return Array.prototype.slice.call(a, start || 0);
 };

package.json

@@ -1,20 +1,17 @@
 {
   "name": "uglify-es",
-  "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
+  "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.0.13",
+  "version": "3.1.5",
   "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"
   },
@@ -29,16 +26,33 @@
     "LICENSE"
   ],
   "dependencies": {
-    "commander": "~2.9.0",
-    "source-map": "~0.5.1"
+    "commander": "~2.11.0",
+    "source-map": "~0.6.1"
   },
   "devDependencies": {
-    "acorn": "~5.0.3",
-    "mocha": "~2.3.4",
-    "semver": "~5.3.0"
+    "acorn": "~5.1.1",
+    "mocha": "~3.5.1",
+    "semver": "~5.4.1"
   },
   "scripts": {
     "test": "node test/run-tests.js"
   },
-  "keywords": ["uglify", "uglify-js", "uglify-es", "minify", "minifier", "es5", "es6", "es2015"]
+  "keywords": [
+    "uglify",
+    "uglify-es",
+    "uglify-js",
+    "minify",
+    "minifier",
+    "javascript",
+    "ecmascript",
+    "es5",
+    "es6",
+    "es7",
+    "es8",
+    "es2015",
+    "es2016",
+    "es2017",
+    "async",
+    "await"
+  ]
 }

test/benchmark.js

@@ -4,7 +4,9 @@
 "use strict";
 
 var createHash = require("crypto").createHash;
+var fetch = require("./fetch");
 var fork = require("child_process").fork;
+var zlib = require("zlib");
 var args = process.argv.slice(2);
 if (!args.length) {
     args.push("-mc");
@@ -32,6 +34,7 @@ function done() {
             console.log(info.log);
             console.log("Original:", info.input, "bytes");
             console.log("Uglified:", info.output, "bytes");
+            console.log("GZipped: ", info.gzip, "bytes");
             console.log("SHA1 sum:", info.sha1);
             if (info.code) {
                 failures.push(url);
@@ -50,15 +53,21 @@ urls.forEach(function(url) {
     results[url] = {
         input: 0,
         output: 0,
+        gzip: 0,
         log: ""
     };
-    require(url.slice(0, url.indexOf(":"))).get(url, function(res) {
+    fetch(url, function(err, res) {
+        if (err) throw err;
         var uglifyjs = fork("bin/uglifyjs", args, { silent: true });
         res.on("data", function(data) {
             results[url].input += data.length;
         }).pipe(uglifyjs.stdin);
         uglifyjs.stdout.on("data", function(data) {
             results[url].output += data.length;
+        }).pipe(zlib.createGzip({
+            level: zlib.Z_BEST_COMPRESSION
+        })).on("data", function(data) {
+            results[url].gzip += data.length;
         }).pipe(createHash("sha1")).on("data", function(data) {
             results[url].sha1 = data.toString("hex");
             done();

test/compress/arrow.js

@@ -135,3 +135,527 @@ arrow_with_regexp: {
         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_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: {
+        (() => {
+            var quux = () => {
+                console.log("PASS");
+            };
+            return {
+                prop() {
+                    console.log;
+                    quux();
+                }
+            };
+        })().prop();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_2105_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 2,
+        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: {
+        (() => {
+            var quux = () => {
+                console.log("PASS");
+            };
+            return {
+                prop: () => {
+                    console.log;
+                    quux();
+                }
+            };
+        })().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_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_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_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,
+    }
+    input: {
+        (function(a) {
+            if (true) return;
+            var b = 42;
+        })(this);
+    }
+    expect: {
+        this, void 0;
+    }
+}
+
+issue_2084: {
+    options = {
+        unsafe_arrows: true,
+        collapse_vars: true,
+        conditionals: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        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/ascii.js

@@ -13,7 +13,7 @@ ascii_only_true: {
                    "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
         }
     }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\08\\0"+"\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\b\\t\\n\\v\\f\\r\\x0e\\x0f"+"\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f"+\' !"# ... }~\\x7f\\x80\\x81 ... \\xfe\\xff\\u0fff\\uffff\'}'
+    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\0"+"\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\b\\t\\n\\v\\f\\r\\x0e\\x0f"+"\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f"+\' !"# ... }~\\x7f\\x80\\x81 ... \\xfe\\xff\\u0fff\\uffff\'}'
 }
 
 ascii_only_false: {
@@ -31,5 +31,5 @@ ascii_only_false: {
                    "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
         }
     }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\08\\0"+"\\0\x01\x02\x03\x04\x05\x06\x07\\b\\t\\n\\v\\f\\r\x0e\x0f"+"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"+\' !"# ... }~\x7f\x80\x81 ... \xfe\xff\u0fff\uffff\'}'
+    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\0"+"\\0\x01\x02\x03\x04\x05\x06\x07\\b\\t\\n\\v\\f\\r\x0e\x0f"+"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"+\' !"# ... }~\x7f\x80\x81 ... \xfe\xff\u0fff\uffff\'}'
 }

test/compress/asm.js

@@ -104,3 +104,65 @@ asm_mixed: {
     }
 }
 
+asm_toplevel: {
+    options = {}
+    input: {
+        "use asm";
+        0.0;
+        function f() {
+            0.0;
+            (function(){
+                0.0;
+            });
+        }
+        0.0;
+    }
+    expect_exact: '"use asm";0.0;function f(){0.0;(function(){0.0})}0.0;'
+}
+
+asm_function_expression: {
+    options = {}
+    input: {
+        0.0;
+        var a = function() {
+            "use asm";
+            0.0;
+        }
+        function f() {
+            0.0;
+            return function(){
+                "use asm";
+                0.0;
+            }
+            0.0;
+        }
+        0.0;
+    }
+    expect_exact: '0;var a=function(){"use asm";0.0};function f(){0;return function(){"use asm";0.0};0}0;'
+}
+
+asm_nested_functions: {
+    options = {}
+    input: {
+        0.0;
+        function a() {
+            "use asm";
+            0.0;
+        }
+        0.0;
+        function b() {
+            0.0;
+            function c(){
+                "use asm";
+                0.0;
+            }
+            0.0;
+            function d(){
+                0.0;
+            }
+            0.0;
+        }
+        0.0;
+    }
+    expect_exact: '0;function a(){"use asm";0.0}0;function b(){0;function c(){"use asm";0.0}0;function d(){0}0}0;'
+}

test/compress/async.js

@@ -0,0 +1,294 @@
+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_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()})();"
+}

test/compress/block-scope.js

@@ -104,34 +104,36 @@ regression_block_scope_resolves: {
     };
     input: {
         (function () {
-            if(1) {
+            if (1) {
                 let x;
-                const y;
+                const y = 1;
                 class Zee {};
             }
-            if(1) {
+            if (1) {
                 let ex;
-                const why;
+                const why = 2;
                 class Zi {};
             }
-            console.log(x, y, Zee, ex, why, Zi);
+            console.log(typeof x, typeof y, typeof Zee, typeof ex, typeof why, typeof Zi);
         }());
     }
     expect: {
         (function () {
             if (1) {
-                let o;
-                const n;
-                class c {};
+                let e;
+                const o = 1;
+                class t {};
             }
             if (1) {
-                let o;
-                const n;
-                class c {};
+                let e;
+                const o = 2;
+                class t {};
             }
-            console.log(x, y, Zee, ex, why, Zi);
+            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: {
@@ -153,25 +155,37 @@ switch_block_scope_mangler: {
                     console.log(cat);
             }
         };
+        fn(1);
+        fn(2);
+        fn(3);
     }
     expect: {
-        var fn = function(o) {
-            switch (o) {
+        var fn = function(e) {
+            switch (e) {
               case 1:
-                let e = o + 1
-                let c = o + 4;
-                console.log(e, c);
+                let l = e + 1
+                let o = e + 4;
+                console.log(l, o);
                 break;
 
               case 2:
-                let l = o + 2;
-                console.log(l);
+                let n = e + 2;
+                console.log(n);
                 break;
 
               default:
-                let a = o + 3;
-                console.log(a);
+                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/concat-strings.js

@@ -21,7 +21,7 @@ concat_1: {
         var c = 1 + x() + 2 + "boo";
         var d = 1 + x() + 2 + 3 + "boo";
         var e = 1 + x() + 2 + "X3boo";
-        var f = "\x00360\08\0";
+        var f = "\x00360\x008\0";
     }
 }
 

test/compress/dead-code.js

@@ -377,3 +377,186 @@ accessor: {
     }
     expect: {}
 }
+
+issue_2233_1: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        Array.isArray;
+        Boolean;
+        console.log;
+        Date;
+        decodeURI;
+        decodeURIComponent;
+        encodeURI;
+        encodeURIComponent;
+        Error.name;
+        escape;
+        eval;
+        EvalError;
+        Function.length;
+        isFinite;
+        isNaN;
+        JSON;
+        Math.random;
+        Number.isNaN;
+        parseFloat;
+        parseInt;
+        RegExp;
+        Object.defineProperty;
+        String.fromCharCode;
+        RangeError;
+        ReferenceError;
+        SyntaxError;
+        TypeError;
+        unescape;
+        URIError;
+    }
+    expect: {}
+    expect_stdout: true
+}
+
+global_timeout_and_interval_symbols: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        // These global symbols do not exist in the test sandbox
+        // and must be tested separately.
+        clearInterval;
+        clearTimeout;
+        setInterval;
+        setTimeout;
+    }
+    expect: {}
+}
+
+issue_2233_2: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var RegExp;
+        Array.isArray;
+        RegExp;
+        UndeclaredGlobal;
+        function foo() {
+            var Number;
+            AnotherUndeclaredGlobal;
+            Math.sin;
+            Number.isNaN;
+        }
+    }
+    expect: {
+        var RegExp;
+        UndeclaredGlobal;
+        function foo() {
+            var Number;
+            AnotherUndeclaredGlobal;
+            Number.isNaN;
+        }
+    }
+}
+
+issue_2233_3: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var RegExp;
+        Array.isArray;
+        RegExp;
+        UndeclaredGlobal;
+        function foo() {
+            var Number;
+            AnotherUndeclaredGlobal;
+            Math.sin;
+            Number.isNaN;
+        }
+    }
+    expect: {
+        UndeclaredGlobal;
+    }
+}
+
+global_fns: {
+    options = {
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        Boolean(1, 2);
+        decodeURI(1, 2);
+        decodeURIComponent(1, 2);
+        Date(1, 2);
+        encodeURI(1, 2);
+        encodeURIComponent(1, 2);
+        Error(1, 2);
+        escape(1, 2);
+        EvalError(1, 2);
+        isFinite(1, 2);
+        isNaN(1, 2);
+        Number(1, 2);
+        Object(1, 2);
+        parseFloat(1, 2);
+        parseInt(1, 2);
+        RangeError(1, 2);
+        ReferenceError(1, 2);
+        String(1, 2);
+        SyntaxError(1, 2);
+        TypeError(1, 2);
+        unescape(1, 2);
+        URIError(1, 2);
+        try {
+            Function(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            RegExp(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            Array(NaN);
+        } catch (e) {
+            console.log(e.name);
+        }
+    }
+    expect: {
+        try {
+            Function(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            RegExp(1, 2);
+        } catch (e) {
+            console.log(e.name);
+        }
+        try {
+            Array(NaN);
+        } catch (e) {
+            console.log(e.name);
+        }
+    }
+    expect_stdout: [
+        "SyntaxError",
+        "SyntaxError",
+        "RangeError",
+    ]
+}

test/compress/destructuring.js

@@ -65,10 +65,10 @@ nested_destructuring_objects: {
     }
     input: {
         const [{a},b] = c;
-        let [{a},b] = c;
-        var [{a},b] = c;
+        let [{d},e] = f;
+        var [{g},h] = i;
     }
-    expect_exact: 'const[{a},b]=c;let[{a},b]=c;var[{a},b]=c;';
+    expect_exact: 'const[{a},b]=c;let[{d},e]=f;var[{g},h]=i;';
 }
 
 destructuring_constdef_in_loops: {
@@ -274,8 +274,8 @@ reduce_vars: {
         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 [{a},b] = c;
-        var [{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);
@@ -292,8 +292,8 @@ reduce_vars: {
         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 [{a},b] = c;
-        var [{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);
@@ -425,8 +425,8 @@ mangle_destructuring_decl: {
     expect: {
         function test(t) {
             let e = t.a || { e: 7, n: 8 };
-            let {t: n,  e: o,  n: s,  s: a = 9,  o: c,  r: l} = e;
-            console.log(n, o, s, a, c, l);
+            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({});
@@ -462,15 +462,15 @@ mangle_destructuring_assign_toplevel_true: {
         test({});
     }
     expect: {
-        function n(n) {
-            let t, a, c;
-            let l = n.a || { e: 7, n: 8 };
-            ({t: o,  e,  n: s,  s: t = 9,  o: a,  r: c} = l);
-            console.log(o, e, s, t, a, c);
+        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 o, e, s;
-        n({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
-        n({});
+        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",
@@ -504,10 +504,10 @@ mangle_destructuring_assign_toplevel_false: {
     }
     expect: {
         function test(o) {
-            let s, a, c;
-            let l = o.a || { e: 7, n: 8 };
-            ({t,  e,  n,  s = 9,  o: a,  r: c} = l);
-            console.log(t, e, n, s, a, c);
+            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 } });
@@ -543,3 +543,119 @@ mangle_destructuring_decl_array: {
     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/drop-unused.js

@@ -863,11 +863,11 @@ issue_1583: {
     expect: {
         function m(t) {
             (function(e) {
-                t = (function() {
+                t = function() {
                     return (function(a) {
-                        return a;
-                    })(function(a) {});
-                })();
+                        return function(a) {};
+                    })();
+                }();
             })();
         }
     }
@@ -1210,6 +1210,7 @@ var_catch_toplevel: {
             a--;
             try {
                 a++;
+                x();
             } catch(a) {
                 if (a) var a;
                 var a = 10;
@@ -1219,9 +1220,8 @@ var_catch_toplevel: {
     }
     expect: {
         !function() {
-            a--;
             try {
-                a++;
+                x();
             } catch(a) {
                 var a;
             }
@@ -1280,3 +1280,258 @@ issue_1968: {
     expect_stdout: "5"
     node_version: ">=6"
 }
+
+issue_2063: {
+    options = {
+        unused: true,
+    }
+    input: {
+        var a;
+        var a;
+    }
+    expect: {
+        var a;
+        var a;
+    }
+}
+
+issue_2105: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        passes: 3,
+        reduce_vars: true,
+        side_effects: 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: {
+        (function() {
+            var quux = function() {
+                console.log("PASS");
+            };
+            return {
+                prop: function() {
+                    console.log;
+                    quux();
+                }
+            };
+        })().prop();
+    }
+    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_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,
+        unused: true,
+    }
+    input: {
+        function f1() {
+            var a = b;
+            a += c;
+        }
+        function f2(a) {
+            a <<= b;
+        }
+        function f3(a) {
+            --a;
+        }
+        function f4() {
+            var a = b;
+            return a *= c;
+        }
+        function f5(a) {
+            x(a /= b);
+        }
+    }
+    expect: {
+        function f1() {
+            b;
+            c;
+        }
+        function f2(a) {
+            b;
+        }
+        function f3(a) {
+            0;
+        }
+        function f4() {
+            var a = b;
+            return a *= c;
+        }
+        function f5(a) {
+            x(a /= b);
+        }
+    }
+}
+
+issue_2226_2: {
+    options = {
+        cascade: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a, b) {
+            a += b;
+            return a;
+        }(1, 2));
+    }
+    expect: {
+        console.log(function(a, b) {
+            return a += b;
+        }(1, 2));
+    }
+    expect_stdout: "3"
+}
+
+issue_2226_3: {
+    options = {
+        collapse_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a, b) {
+            a += b;
+            return a;
+        }(1, 2));
+    }
+    expect: {
+        console.log(function(a, b) {
+            return a += 2;
+        }(1));
+    }
+    expect_stdout: "3"
+}
+
+issue_2288: {
+    options = {
+        unused: true,
+    }
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        function foo(o) {
+            for (var j = o.a, i = 0; i < 0; i++);
+            for (var i = 0; i < 0; i++);
+        }
+    }
+    expect: {
+        function foo(o) {
+            o.a;
+            for (i = 0; i < 0; i++);
+            for (var i = 0; i < 0; i++);
+        }
+    }
+}

test/compress/evaluate.js

@@ -344,22 +344,26 @@ unsafe_constant: {
 
 unsafe_object: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
     }
     input: {
+        var o = { a: 1 };
         console.log(
-            ({a:1}) + 1,
-            ({a:1}).a + 1,
-            ({a:1}).b + 1,
-            ({a:1}).a.b + 1
+            o + 1,
+            o.a + 1,
+            o.b + 1,
+            o.a.b + 1
         );
     }
     expect: {
+        var o = { a: 1 };
         console.log(
-            ({a:1}) + 1,
+            o + 1,
             2,
-            ({a:1}).b + 1,
+            o.b + 1,
             1..b + 1
         );
     }
@@ -368,22 +372,26 @@ unsafe_object: {
 
 unsafe_object_nested: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
     }
     input: {
+        var o = { a: { b: 1 } };
         console.log(
-            ({a:{b:1}}) + 1,
-            ({a:{b:1}}).a + 1,
-            ({a:{b:1}}).b + 1,
-            ({a:{b:1}}).a.b + 1
+            o + 1,
+            o.a + 1,
+            o.b + 1,
+            o.a.b + 1
         );
     }
     expect: {
+        var o = { a: { b: 1 } };
         console.log(
-            ({a:{b:1}}) + 1,
-            ({a:{b:1}}).a + 1,
-            ({a:{b:1}}).b + 1,
+            o + 1,
+            o.a + 1,
+            o.b + 1,
             2
         );
     }
@@ -392,21 +400,25 @@ unsafe_object_nested: {
 
 unsafe_object_complex: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
     }
     input: {
+        var o = { a: { b: 1 }, b: 1 };
         console.log(
-            ({a:{b:1},b:1}) + 1,
-            ({a:{b:1},b:1}).a + 1,
-            ({a:{b:1},b:1}).b + 1,
-            ({a:{b:1},b:1}).a.b + 1
+            o + 1,
+            o.a + 1,
+            o.b + 1,
+            o.a.b + 1
         );
     }
     expect: {
+        var o = { a: { b: 1 }, b: 1 };
         console.log(
-            ({a:{b:1},b:1}) + 1,
-            ({a:{b:1},b:1}).a + 1,
+            o + 1,
+            o.a + 1,
             2,
             2
         );
@@ -416,22 +428,26 @@ unsafe_object_complex: {
 
 unsafe_object_repeated: {
     options = {
-        evaluate  : true,
-        unsafe    : true
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
     }
     input: {
+        var o = { a: { b: 1 }, a: 1 };
         console.log(
-            ({a:{b:1},a:1}) + 1,
-            ({a:{b:1},a:1}).a + 1,
-            ({a:{b:1},a:1}).b + 1,
-            ({a:{b:1},a:1}).a.b + 1
+            o + 1,
+            o.a + 1,
+            o.b + 1,
+            o.a.b + 1
         );
     }
     expect: {
+        var o = { a: { b: 1 }, a: 1 };
         console.log(
-            ({a:{b:1},a:1}) + 1,
+            o + 1,
             2,
-            ({a:{b:1},a:1}).b + 1,
+            o.b + 1,
             1..b + 1
         );
     }
@@ -480,9 +496,9 @@ unsafe_function: {
     expect: {
         console.log(
             ({a:{b:1},b:function(){}}) + 1,
-            ({a:{b:1},b:function(){}}).a + 1,
-            ({a:{b:1},b:function(){}}).b + 1,
-            ({a:{b:1},b:function(){}}).a.b + 1
+            ({b:function(){}}, {b:1}) + 1,
+            ({a:{b:1}}, function(){}) + 1,
+            ({b:function(){}}, {b:1}).b + 1
         );
     }
     expect_stdout: true
@@ -730,14 +746,15 @@ unsafe_prototype_function: {
         var d = ({toString: 0}) + "";
         var e = (({valueOf: 0}) + "")[2];
         var f = (({toString: 0}) + "")[2];
-        var g = ({valueOf: 0}).valueOf();
-        var h = "" + ({toString: 0});
+        var g = ({}, 0)();
+        var h = ({}, 0)();
     }
 }
 
 call_args: {
     options = {
         evaluate: true,
+        inline: true,
         reduce_vars: true,
     }
     input: {
@@ -758,6 +775,7 @@ call_args: {
 call_args_drop_param: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
         reduce_vars: true,
         unused: true,
@@ -873,13 +891,15 @@ unsafe_charAt_noop: {
     input: {
         console.log(
             s.charAt(0),
-            "string".charAt(x)
+            "string".charAt(x),
+            (typeof x).charAt()
         );
     }
     expect: {
         console.log(
             s.charAt(0),
-            "string".charAt(x)
+            "string".charAt(x),
+            (typeof x)[0]
         );
     }
 }
@@ -1094,6 +1114,7 @@ issue_1964_1: {
     input: {
         function f() {
             var long_variable_name = /\s/;
+            console.log(long_variable_name.source);
             return "a b c".split(long_variable_name)[1];
         }
         console.log(f());
@@ -1101,11 +1122,15 @@ issue_1964_1: {
     expect: {
         function f() {
             var long_variable_name = /\s/;
+            console.log(long_variable_name.source);
             return "a b c".split(long_variable_name)[1];
         }
         console.log(f());
     }
-    expect_stdout: "b"
+    expect_stdout: [
+        "\\s",
+        "b",
+    ]
 }
 
 issue_1964_2: {
@@ -1118,15 +1143,148 @@ issue_1964_2: {
     input: {
         function f() {
             var long_variable_name = /\s/;
+            console.log(long_variable_name.source);
             return "a b c".split(long_variable_name)[1];
         }
         console.log(f());
     }
     expect: {
         function f() {
+            console.log(/\s/.source);
             return "a b c".split(/\s/)[1];
         }
         console.log(f());
     }
-    expect_stdout: "b"
+    expect_stdout: [
+        "\\s",
+        "b",
+    ]
+}
+
+array_slice_index: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log([1,2,3].slice(1)[1]);
+    }
+    expect: {
+        console.log(3);
+    }
+    expect_stdout: "3"
+}
+
+string_charCodeAt: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log("foo".charCodeAt("bar".length));
+    }
+    expect: {
+        console.log(NaN);
+    }
+    expect_stdout: "NaN"
+}
+
+issue_2207_1: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(String.fromCharCode(65));
+        console.log(Math.max(3, 6, 2, 7, 3, 4));
+        console.log(Math.cos(1.2345));
+        console.log(Math.cos(1.2345) - Math.sin(4.321));
+        console.log(Math.pow(Math.PI, Math.E - Math.LN10));
+    }
+    expect: {
+        console.log("A");
+        console.log(7);
+        console.log(Math.cos(1.2345));
+        console.log(1.2543732512566947);
+        console.log(1.6093984514472044);
+    }
+    expect_stdout: true
+}
+
+issue_2207_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Math.E);
+        console.log(Math.LN10);
+        console.log(Math.LN2);
+        console.log(Math.LOG2E);
+        console.log(Math.LOG10E);
+        console.log(Math.PI);
+        console.log(Math.SQRT1_2);
+        console.log(Math.SQRT2);
+    }
+    expect: {
+        console.log(Math.E);
+        console.log(Math.LN10);
+        console.log(Math.LN2);
+        console.log(Math.LOG2E);
+        console.log(Math.LOG10E);
+        console.log(Math.PI);
+        console.log(Math.SQRT1_2);
+        console.log(Math.SQRT2);
+    }
+    expect_stdout: true
+}
+
+issue_2207_3: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Number.MAX_VALUE);
+        console.log(Number.MIN_VALUE);
+        console.log(Number.NaN);
+        console.log(Number.NEGATIVE_INFINITY);
+        console.log(Number.POSITIVE_INFINITY);
+    }
+    expect: {
+        console.log(Number.MAX_VALUE);
+        console.log(5e-324);
+        console.log(NaN);
+        console.log(-1/0);
+        console.log(1/0);
+    }
+    expect_stdout: true
+}
+
+issue_2231_1: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Object.keys(void 0));
+    }
+    expect: {
+        console.log(Object.keys(void 0));
+    }
+    expect_stdout: true
+}
+
+issue_2231_2: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        console.log(Object.getOwnPropertyNames(null));
+    }
+    expect: {
+        console.log(Object.getOwnPropertyNames(null));
+    }
+    expect_stdout: true
 }

test/compress/expansions.js

@@ -26,3 +26,46 @@ expand_parameters: {
     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];
+
+        if (Math)
+            print(a);
+        else
+            print(b);
+
+        if (Math)
+            print(...a);
+        else
+            print(b);
+
+        if (Math.no_such_property)
+            print(a);
+        else
+            print(...b);
+    }
+    expect: {
+        function print(...x) {
+            console.log(...x);
+        }
+        var a = [ 1, 2 ], b = [ 3, 4 ];
+        print(Math ? a : b);
+        Math ? print(...a) : print(b);
+        Math.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,252 @@
+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_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_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();
+    }
+}

test/compress/functions.js

@@ -21,6 +21,7 @@ iifes_returning_constants_keep_fargs_true: {
         join_vars     : true,
         reduce_vars   : true,
         cascade       : true,
+        inline        : true,
     }
     input: {
         (function(){ return -1.23; }());
@@ -56,6 +57,7 @@ iifes_returning_constants_keep_fargs_false: {
         join_vars     : true,
         reduce_vars   : true,
         cascade       : true,
+        inline        : true,
     }
     input: {
         (function(){ return -1.23; }());
@@ -82,6 +84,7 @@ issue_485_crashing_1530: {
         conditionals: true,
         dead_code: true,
         evaluate: true,
+        inline: true,
     }
     input: {
         (function(a) {
@@ -154,6 +157,7 @@ function_returning_constant_literal: {
         evaluate: true,
         cascade: true,
         unused: true,
+        inline: true,
     }
     input: {
         function greeter() {
@@ -245,3 +249,262 @@ hoist_funs_strict: {
     ]
     node_version: ">=4"
 }
+
+issue_203: {
+    options = {
+        keep_fargs: false,
+        side_effects: true,
+        unsafe_Func: true,
+        unused: true,
+    }
+    input: {
+        var m = {};
+        var fn = Function("require", "module", "exports", "module.exports = 42;");
+        fn(null, m, m.exports);
+        console.log(m.exports);
+    }
+    expect: {
+        var m = {};
+        var fn = Function("n,o", "o.exports=42");
+        fn(null, m, m.exports);
+        console.log(m.exports);
+    }
+    expect_stdout: "42"
+}
+
+no_webkit: {
+    beautify = {
+        webkit: false,
+    }
+    input: {
+        console.log(function() {
+            1 + 1;
+        }.a = 1);
+    }
+    expect_exact: "console.log(function(){1+1}.a=1);"
+    expect_stdout: "1"
+}
+
+webkit: {
+    beautify = {
+        webkit: true,
+    }
+    input: {
+        console.log(function() {
+            1 + 1;
+        }.a = 1);
+    }
+    expect_exact: "console.log((function(){1+1}).a=1);"
+    expect_stdout: "1"
+}
+
+issue_2084: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        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;
+        !function(c) {
+            c = 1 + c,
+            c = 1 + (c = 0),
+            0 !== 23..toString() && (c = 1 + c);
+        }(-1),
+        console.log(c);
+    }
+    expect_stdout: "0"
+}
+
+issue_2097: {
+    options = {
+        negate_iife: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            try {
+                throw 0;
+            } catch (e) {
+                console.log(arguments[0]);
+            }
+        }
+        f(1);
+    }
+    expect: {
+        !function() {
+            try {
+                throw 0;
+            } catch (e) {
+                console.log(arguments[0]);
+            }
+        }(1);
+    }
+    expect_stdout: "1"
+}
+
+issue_2101: {
+    options = {
+        inline: true,
+    }
+    input: {
+        a = {};
+        console.log(function() {
+            return function() {
+                return this.a;
+            }();
+        }() === function() {
+            return a;
+        }());
+    }
+    expect: {
+        a = {};
+        console.log(function() {
+            return this.a;
+        }() === a);
+    }
+    expect_stdout: "true"
+}
+
+inner_ref: {
+    options = {
+        inline: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            return function() {
+                return a;
+            }();
+        }(1), function(a) {
+            return function(a) {
+                return a;
+            }();
+        }(2));
+    }
+    expect: {
+        console.log(function(a) {
+            return a;
+        }(1), function(a) {
+            return a;
+        }());
+    }
+    expect_stdout: "1 undefined"
+}
+
+issue_2107: {
+    options = {
+        cascade: true,
+        collapse_vars: true,
+        inline: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        !function() {
+            c++;
+        }(c++ + new function() {
+            this.a = 0;
+            var a = (c = c + 1) + (c = 1 + c);
+            return c++ + a;
+        }());
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        c++, new function() {
+            this.a = 0, c = 1 + (c += 1), c++;
+        }(), c++, console.log(c);
+    }
+    expect_stdout: "5"
+}
+
+issue_2114_1: {
+    options = {
+        collapse_vars: true,
+        if_return: true,
+        inline: true,
+        keep_fargs: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        !function(a) {
+            a = 0;
+        }([ {
+            0: c = c + 1,
+            length: c = 1 + c
+        }, typeof void function a() {
+            var b = function f1(a) {
+            }(b && (b.b += (c = c + 1, 0)));
+        }() ]);
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        c = 1 + (c += 1), function() {
+            var b = void (b && (b.b += (c += 1, 0)));
+        }();
+        console.log(c);
+    }
+    expect_stdout: "2"
+}
+
+issue_2114_2: {
+    options = {
+        collapse_vars: true,
+        if_return: true,
+        inline: true,
+        keep_fargs: false,
+        passes: 2,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var c = 0;
+        !function(a) {
+            a = 0;
+        }([ {
+            0: c = c + 1,
+            length: c = 1 + c
+        }, typeof void function a() {
+            var b = function f1(a) {
+            }(b && (b.b += (c = c + 1, 0)));
+        }() ]);
+        console.log(c);
+    }
+    expect: {
+        var c = 0;
+        c = 1 + (c += 1), function() {
+            var b = void (b && (b.b += (c += 1, 0)));
+        }();
+        console.log(c);
+    }
+    expect_stdout: "2"
+}

test/compress/global_defs.js

@@ -37,6 +37,7 @@ object: {
                 VALUE: 42,
             },
         },
+        side_effects: true,
         unsafe: true,
     }
     input: {
@@ -140,9 +141,9 @@ mixed: {
         console.log(CONFIG);
     }
     expect_warnings: [
-        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:126,22]',
         'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:127,22]',
-        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:129,8]',
+        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:128,22]',
+        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:130,8]',
     ]
 }
 
@@ -174,3 +175,24 @@ issue_1986: {
         console.log(42);
     }
 }
+
+issue_2167: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+        global_defs: {
+            "@isDevMode": "function(){}",
+        },
+        side_effects: true,
+    }
+    input: {
+        if (isDevMode()) {
+            greetOverlord();
+        }
+        doWork();
+    }
+    expect: {
+        doWork();
+    }
+}

test/compress/harmony.js

@@ -16,9 +16,12 @@ typeof_arrow_functions: {
         evaluate: true
     }
     input: {
-        var foo = typeof (x) => null;
+        var foo = typeof (x => null);
+        console.log(foo);
     }
-    expect_exact: "var foo=\"function\";"
+    expect_exact: "var foo=\"function\";console.log(foo);"
+    expect_stdout: "function"
+    node_version: ">=4"
 }
 
 classes: {
@@ -60,15 +63,15 @@ class_name_can_be_mangled: {
         function x() {
             class Foo {
             }
-            var class1 = Foo
-            var class2 = class Bar {}
+            var class1 = Foo;
+            var class2 = class Bar {};
         }
     }
     expect: {
         function x() {
             class a { }
-            var n = a
-            var r = class a {}
+            var s = a;
+            var c = class a {};
         }
     }
 }
@@ -208,13 +211,13 @@ export_statement: {
     }
     input: {
         export default 1 + 2;
-        export var foo = 4;
-        export let foo = 6;
-        export const foo = 6;
-        export function foo() {};
-        export class foo { };
+        export var a = 4;
+        export let b = 6;
+        export const c = 6;
+        export function d() {};
+        export class e {};
     }
-    expect_exact: "export default 3;export var foo=4;export let foo=6;export const foo=6;export function foo(){};export class foo{};"
+    expect_exact: "export default 3;export var a=4;export let b=6;export const c=6;export function d(){};export class e{};"
 }
 
 export_default_object_expression: {
@@ -287,12 +290,12 @@ import_statement_mangling: {
         Whatever();
     }
     expect: {
-        import l from "foo";
-        import e, {Food as o} from "lel";
+        import o from "foo";
+        import m, {Food as r} from "lel";
         import {What as f} from "lel";
-        l();
-        e();
         o();
+        m();
+        r();
         f();
     }
 }
@@ -466,10 +469,10 @@ issue_1898: {
     expect: {
         class Foo {
             bar() {
-                for (const n of [ 6, 5 ])
+                for (const f of [ 6, 5 ])
                     for (let r of [ 4, 3 ])
                         for (var o of [ 2, 1 ])
-                            console.log(n, r, o);
+                            console.log(f, r, o);
             }
         }
         new Foo().bar();
@@ -494,9 +497,9 @@ issue_1753: {
     expect: {
         class SomeClass {
             constructor(r) {
-                let a = [];
-                for (let s = 0; s < 6; s++)
-                    a.push({
+                let s = [];
+                for (let a = 0; a < 6; a++)
+                    s.push({
                         mainDrawNumbers: [],
                         extraDrawNumbers: []
                     });
@@ -523,9 +526,9 @@ issue_1753_disable: {
     expect: {
         class SomeClass {
             constructor(r) {
-                let a = [];
+                let s = [];
                 for (let r = 0; r < 6; r++)
-                    a.push({
+                    s.push({
                         mainDrawNumbers: [],
                         extraDrawNumbers: []
                     });
@@ -583,3 +586,352 @@ class_extends_regex: {
     }
     expect_exact: "function f(){class rx1 extends(/rx/){}}"
 }
+
+issue_2028: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        var a = {};
+        (function(x) {
+            x.X = function() {
+                return X;
+            };
+            class X {
+                static hello() {
+                    console.log("hello");
+                }
+            }
+        }(a));
+        a.X().hello();
+    }
+    expect: {
+        var a = {};
+        (function(x) {
+            x.X = function() {
+                return X;
+            };
+            class X {
+                static hello() {
+                    console.log("hello");
+                }
+            }
+        }(a));
+        a.X().hello();
+    }
+    expect_stdout: "hello"
+    node_version: ">=6"
+}
+
+class_expression_statement: {
+    options = {
+        toplevel: false,
+        side_effects: false,
+        unused: false,
+    }
+    input: {
+        (class {});
+        (class NamedClassExpr {});
+        let expr = (class AnotherClassExpr {});
+        class C {}
+    }
+    expect_exact: "(class{});(class NamedClassExpr{});let expr=class AnotherClassExpr{};class C{}"
+}
+
+class_expression_statement_unused: {
+    options = {
+        toplevel: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (class {});
+        (class NamedClassExpr {});
+        let expr = (class AnotherClassExpr {});
+        class C {}
+    }
+    expect_exact: "let expr=class{};class C{}"
+}
+
+class_expression_statement_unused_toplevel: {
+    options = {
+        toplevel: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (class {});
+        (class NamedClassExpr {});
+        let expr = (class AnotherClassExpr {});
+        class C {}
+    }
+    expect_exact: ""
+}
+
+export_default_function_decl: {
+    options = {
+        toplevel: true,
+        passes: 3,
+        unused: true,
+    }
+    input: {
+        // do not drop "unused" exports
+        export default function Foo() {};
+        export function Far() {};
+    }
+    expect_exact: "export default function Foo(){};export function Far(){};"
+}
+
+export_default_class_decl: {
+    options = {
+        toplevel: true,
+        passes: 3,
+        unused: true,
+    }
+    input: {
+        // do not drop "unused" exports
+        export default class Car {};
+        export class Cab {};
+    }
+    expect_exact: "export default class Car{};export class Cab{};"
+}
+
+object_rest_spread: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var   { w: w1, ...V } = { w: 7, x: 1, y: 2 }; console.log(w1, V);
+        let   { w: w2, ...L } = { w: 8, x: 3, y: 4 }; console.log(w2, L);
+        const { w: w3, ...C } = { w: 9, x: 5, y: 6 }; console.log(w3, C);
+
+        let b;
+        ({ b, ...V } = { a: 1, b: 2, c: 3 }); console.log(V);
+        ({ b, ...L } = { a: 4, b: 5, c: 6 }); console.log(L);
+
+        (function({ y, ...p }){ console.log(p); })({ x: 1, y: 2, z: 3 });
+        (({ y, ...p }) =>     { console.log(p); })({ x: 4, y: 5, z: 6 });
+
+        const T = { a: 1, b: 2 }; console.log({ ...T, w: 0, ...{}, ...L, ...{K: 9} });
+    }
+    expect: {
+        var   { w: o, ...l } = { w: 7, x: 1, y: 2 }; console.log(o, l);
+        let   { w: c, ...n } = { w: 8, x: 3, y: 4 }; console.log(c, n);
+        const { w: e, ...s } = { w: 9, x: 5, y: 6 }; console.log(e, s);
+
+        let g;
+        ({ b: g, ...l } = { a: 1, b: 2, c: 3 }); console.log(l);
+        ({ b: g, ...n } = { a: 4, b: 5, c: 6 }); console.log(n);
+
+        (function({ y: o, ...l }) { console.log(l); })({ x: 1, y: 2, z: 3 });
+        (({ y: o, ...l }) =>      { console.log(l); })({ x: 4, y: 5, z: 6 });
+
+        const w = { a: 1, b: 2 }; console.log({ ...w, w: 0, ...{}, ...n, ...{ K: 9 } });
+    }
+}
+
+object_spread_unsafe: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        join_vars: true,
+        passes: 3,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var o1 = { x: 1, y: 2 };
+        var o2 = { x: 3, z: 4 };
+        var cloned = { ...o1 };
+        var merged = { ...o1, ...o2 };
+        console.log(cloned, merged);
+    }
+    expect: {
+        var o = { x: 1, y: 2 }, l = { ...o }, x = { ...o, ...{ x: 3, z: 4 } };
+        console.log(l, x);
+    }
+}
+
+array_spread_of_sequence: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var a = [1];
+        console.log([...(a, a)]);
+        console.log([...a, a]);
+        console.log([...(a || a)]);
+        console.log([...a || a]);
+    }
+    expect: {
+        var o = [1];
+        console.log([...(o, o)]);
+        console.log([...o, o]);
+        console.log([...o || o]);
+        console.log([...o || o]);
+    }
+    expect_stdout: [
+        "[ 1 ]",
+        "[ 1, [ 1 ] ]",
+        "[ 1 ]",
+        "[ 1 ]",
+    ]
+    node_version: ">=6"
+}
+
+object_spread_of_sequence: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var a = {x: 1};
+        console.log({ ...(a, a) });
+        console.log({ ...a, a });
+        console.log({ ...(a || a) });
+        console.log({ ...a || a });
+    }
+    expect: {
+        var o = { x: 1 };
+        console.log({ ...(o, o) });
+        console.log({ ...o, a: o });
+        console.log({ ...o || o });
+        console.log({ ...o || o });
+    }
+}
+
+// issue 2316
+class_name_can_be_preserved_with_reserved: {
+    mangle = {
+        reserved: [ "Foo" ],
+    }
+    input: {
+        function x() {
+            class Foo {}
+            Foo.bar;
+            class Bar {}
+            Bar.foo;
+        }
+        function y() {
+            var Foo = class Foo {};
+            Foo.bar;
+            var Bar = class Bar {};
+            Bar.bar;
+        }
+    }
+    expect: {
+        function x() {
+            class Foo {}
+            Foo.bar;
+            class a {}
+            a.foo;
+        }
+        function y() {
+            var Foo = class Foo {};
+            Foo.bar;
+            var a = class a {};
+            a.bar;
+        }
+    }
+}
+
+issue_2345: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        console.log([...[3, 2, 1]].join("-"));
+        var a = [3, 2, 1];
+        console.log([...a].join("-"));
+    }
+    expect: {
+        console.log([...[3, 2, 1]].join("-"));
+        var a = [3, 2, 1];
+        console.log([...a].join("-"));
+    }
+    expect_stdout: [
+        "3-2-1",
+        "3-2-1",
+    ]
+    node_version: ">=6"
+}
+
+issue_2349: {
+    mangle = {}
+    input: {
+        function foo(boo, key) {
+            const value = boo.get();
+            return value.map(({[key]: bar}) => bar);
+        }
+        console.log(foo({
+            get: () => [ {
+                blah: 42
+            } ]
+        }, "blah"));
+    }
+    expect: {
+        function foo(o, n) {
+            const t = o.get();
+            return t.map(({[n]: o}) => o);
+        }
+        console.log(foo({
+            get: () => [ {
+                blah: 42
+            } ]
+        }, "blah"));
+    }
+    expect_stdout: [
+        "[ 42 ]",
+    ]
+    node_version: ">=7"
+}
+
+issue_2349b: {
+    options = {
+        arrows: true,
+        collapse_vars: true,
+        ecma: 6,
+        evaluate: true,
+        inline: true,
+        passes: 3,
+        reduce_vars: true,
+        toplevel: true,
+        side_effects: true,
+        unsafe: true,
+        unsafe_arrows: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        function foo(boo, key) {
+            const value = boo.get();
+            return value.map(function({[key]: bar}){ return bar; });
+        }
+        console.log(foo({
+            get: function() {
+                return  [ {
+                    blah: 42
+                } ];
+            }
+        }, "blah"));
+    }
+    expect: {
+        console.log([ {
+            blah: 42
+        } ].map(({["blah"]: l}) => l));
+    }
+    expect_stdout: [
+        "[ 42 ]",
+    ]
+    node_version: ">=7"
+}

test/compress/hoist_vars.js

@@ -88,3 +88,24 @@ sequences_funs: {
         }
     }
 }
+
+issue_2295: {
+    options = {
+        collapse_vars: true,
+        hoist_vars: true,
+    }
+    input: {
+        function foo(o) {
+            var a = o.a;
+            if (a) return a;
+            var a = 1;
+        }
+    }
+    expect: {
+        function foo(o) {
+            var a = o.a;
+            if (a) return a;
+            a = 1;
+        }
+    }
+}

test/compress/issue-1034.js

@@ -71,11 +71,13 @@ non_hoisted_function_after_return_2a: {
         "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:51,16]",
         "WARN: Dropping unused variable a [test/compress/issue-1034.js:48,20]",
         "WARN: Dropping unused function nope [test/compress/issue-1034.js:55,21]",
+        "WARN: pass 0: last_count: Infinity, count: 37",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:53,12]",
         "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:53,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:56,12]",
         "WARN: Dropping unused variable b [test/compress/issue-1034.js:51,20]",
         "WARN: Dropping unused variable c [test/compress/issue-1034.js:53,16]",
+        "WARN: pass 1: last_count: 37, count: 18",
     ]
 }
 
@@ -109,11 +111,11 @@ non_hoisted_function_after_return_2b: {
     }
     expect_warnings: [
         // duplicate warnings no longer emitted
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:95,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:95,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:97,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:97,12]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:101,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:97,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:97,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:99,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:99,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:103,12]",
     ]
 }
 
@@ -151,10 +153,10 @@ non_hoisted_function_after_return_strict: {
     }
     expect_stdout: "8 7"
     expect_warnings: [
-        'WARN: Dropping unreachable code [test/compress/issue-1034.js:131,16]',
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:134,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:137,12]",
-        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:138,21]"
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:133,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:136,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:139,12]",
+        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:140,21]",
     ]
 }
 
@@ -194,17 +196,19 @@ non_hoisted_function_after_return_2a_strict: {
     }
     expect_stdout: "5 6"
     expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:173,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:173,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:176,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:176,16]",
-        "WARN: Dropping unused variable a [test/compress/issue-1034.js:173,20]",
-        "WARN: Dropping unused function nope [test/compress/issue-1034.js:180,21]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:178,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:178,12]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:181,12]",
-        "WARN: Dropping unused variable b [test/compress/issue-1034.js:176,20]",
-        "WARN: Dropping unused variable c [test/compress/issue-1034.js:178,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:175,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:175,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:178,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:178,16]",
+        "WARN: Dropping unused variable a [test/compress/issue-1034.js:175,20]",
+        "WARN: Dropping unused function nope [test/compress/issue-1034.js:182,21]",
+        "WARN: pass 0: last_count: Infinity, count: 48",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:180,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:180,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:183,12]",
+        "WARN: Dropping unused variable b [test/compress/issue-1034.js:178,20]",
+        "WARN: Dropping unused variable c [test/compress/issue-1034.js:180,16]",
+        "WARN: pass 1: last_count: 48, count: 29",
     ]
 }
 
@@ -243,10 +247,10 @@ non_hoisted_function_after_return_2b_strict: {
     expect_stdout: "5 6"
     expect_warnings: [
         // duplicate warnings no longer emitted
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:225,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:225,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:227,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:227,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:229,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:229,16]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:231,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:231,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:235,12]",
     ]
 }

test/compress/issue-1261.js

@@ -96,6 +96,13 @@ pure_function_calls_toplevel: {
             })();
         })();
 
+        // pure top-level calls will be dropped regardless of the leading comments position
+        var MyClass = /*#__PURE__*//*@class*/(function(){
+            function MyClass() {}
+            MyClass.prototype.method = function() {};
+            return MyClass;
+        })();
+
         // comment #__PURE__ comment
         bar(), baz(), quux();
         a.b(), /* @__PURE__ */ c.d.e(), f.g();
@@ -110,10 +117,12 @@ pure_function_calls_toplevel: {
         "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:100,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:101,31]",
+        "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]",
     ]
 }
 
@@ -148,29 +157,29 @@ should_warn: {
         baz();
     }
     expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:128,61]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:128,23]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:128,23]",
-        "WARN: Boolean || always true [test/compress/issue-1261.js:129,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:129,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:129,23]",
-        "WARN: Condition left of || always true [test/compress/issue-1261.js:130,8]",
-        "WARN: Condition always true [test/compress/issue-1261.js:130,8]",
-        "WARN: Boolean && always false [test/compress/issue-1261.js:131,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:131,23]",
-        "WARN: Condition always false [test/compress/issue-1261.js:131,23]",
-        "WARN: Condition left of && always false [test/compress/issue-1261.js:132,8]",
-        "WARN: Condition always false [test/compress/issue-1261.js:132,8]",
-        "WARN: + in boolean context always true [test/compress/issue-1261.js:133,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:133,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:133,23]",
-        "WARN: + in boolean context always true [test/compress/issue-1261.js:134,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:134,31]",
-        "WARN: Condition always true [test/compress/issue-1261.js:134,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:135,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:136,24]",
-        "WARN: Condition always true [test/compress/issue-1261.js:136,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:137,31]",
-        "WARN: Condition always false [test/compress/issue-1261.js:137,8]",
+        "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: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: 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: 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: 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]",
     ]
 }

test/compress/issue-1321.js

@@ -1,6 +1,8 @@
 issue_1321_no_debug: {
-    mangle_props = {
-        keep_quoted: true
+    mangle = {
+        properties: {
+            keep_quoted: true,
+        },
     }
     input: {
         var x = {};
@@ -10,17 +12,19 @@ issue_1321_no_debug: {
     }
     expect: {
         var x = {};
-        x.b = 1;
-        x["a"] = 2 * x.b;
-        console.log(x.b, x["a"]);
+        x.x = 1;
+        x["a"] = 2 * x.x;
+        console.log(x.x, x["a"]);
     }
     expect_stdout: true
 }
 
 issue_1321_debug: {
-    mangle_props = {
-        keep_quoted: true,
-        debug: ""
+    mangle = {
+        properties: {
+            debug: "",
+            keep_quoted: true,
+        },
     }
     input: {
         var x = {};
@@ -30,16 +34,18 @@ issue_1321_debug: {
     }
     expect: {
         var x = {};
-        x.a = 1;
-        x["_$foo$_"] = 2 * x.a;
-        console.log(x.a, x["_$foo$_"]);
+        x.x = 1;
+        x["_$foo$_"] = 2 * x.x;
+        console.log(x.x, x["_$foo$_"]);
     }
     expect_stdout: true
 }
 
 issue_1321_with_quoted: {
-    mangle_props = {
-        keep_quoted: false
+    mangle = {
+        properties: {
+            keep_quoted: false,
+        },
     }
     input: {
         var x = {};
@@ -49,9 +55,9 @@ issue_1321_with_quoted: {
     }
     expect: {
         var x = {};
-        x.a = 1;
-        x["b"] = 2 * x.a;
-        console.log(x.a, x["b"]);
+        x.x = 1;
+        x["o"] = 2 * x.x;
+        console.log(x.x, x["o"]);
     }
     expect_stdout: true
 }

test/compress/issue-1446.js

@@ -1,6 +1,7 @@
 typeof_eq_undefined: {
     options = {
-        comparisons: true
+        comparisons: true,
+        typeofs: true,
     }
     input: {
         var a = typeof b != "undefined";
@@ -24,6 +25,7 @@ typeof_eq_undefined_ie8: {
     options = {
         comparisons: true,
         ie8: true,
+        typeofs: true,
     }
     input: {
         var a = typeof b != "undefined";
@@ -45,7 +47,8 @@ typeof_eq_undefined_ie8: {
 
 undefined_redefined: {
     options = {
-        comparisons: true
+        comparisons: true,
+        typeofs: true,
     }
     input: {
         function f(undefined) {
@@ -58,7 +61,8 @@ undefined_redefined: {
 
 undefined_redefined_mangle: {
     options = {
-        comparisons: true
+        comparisons: true,
+        typeofs: true,
     }
     mangle = {}
     input: {

test/compress/issue-1466.js

@@ -33,8 +33,8 @@ same_variable_in_multiple_for_loop: {
             console.log(o, l);
             for (let o = 0; o < 2; o++) {
                 console.log(o, l);
-                let c = 2;
-                console.log(c);
+                let e = 2;
+                console.log(e);
             }
         }
     }
@@ -114,12 +114,12 @@ same_variable_in_multiple_forIn: {
     }
     expect: {
         var test = [ "a", "b", "c" ];
-        for (let o in test) {
-            console.log(o);
-            let e;
-            e = [ "e", "f", "g" ];
-            for (let o in test)
-                console.log(o);
+        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
@@ -160,8 +160,8 @@ different_variable_in_multiple_for_loop: {
             console.log(o, l);
             for (let o = 0; o < 2; o++) {
                 console.log(o, l);
-                let c = 2;
-                console.log(c);
+                let e = 2;
+                console.log(e);
             }
         }
     }
@@ -241,12 +241,12 @@ different_variable_in_multiple_forIn: {
     }
     expect: {
         var test = [ "a", "b", "c" ];
-        for (let o in test) {
-            console.log(o);
-            let e;
-            e = [ "e", "f", "g" ];
-            for (let o in test)
-                console.log(o);
+        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
@@ -281,10 +281,10 @@ more_variable_in_multiple_for: {
     }
     expect: {
         for (let o = 9, l = 0; l < 20; l += o) {
-            let c = o++ + l;
-            console.log(o, c, l);
-            for (let l = c, e = c * c, f = 0; f < 10; f++)
-                console.log(o, c, e, l, f);
+            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-1770.js

@@ -1,5 +1,7 @@
 mangle_props: {
-    mangle_props = {}
+    mangle = {
+        properties: true,
+    }
     input: {
         var obj = {
             undefined: 1,
@@ -54,10 +56,12 @@ mangle_props: {
 }
 
 numeric_literal: {
+    mangle = {
+        properties: true,
+    }
     beautify = {
         beautify: true,
     }
-    mangle_props = {}
     input: {
         var obj = {
             0: 0,
@@ -82,7 +86,7 @@ numeric_literal: {
         '    42: 2,',
         '    "42": 3,',
         '    37: 4,',
-        '    a: 5,',
+        '    o: 5,',
         '    1e42: 6,',
         '    b: 7,',
         '    "1e+42": 8',
@@ -92,7 +96,7 @@ numeric_literal: {
         '',
         'console.log(obj[42], obj["42"]);',
         '',
-        'console.log(obj[37], obj["a"], obj[37], obj["37"]);',
+        'console.log(obj[37], obj["o"], obj[37], obj["37"]);',
         '',
         'console.log(obj[1e42], obj["b"], obj["1e+42"]);',
     ]

test/compress/issue-1787.js

@@ -1,6 +1,7 @@
 unary_prefix: {
     options = {
         evaluate: true,
+        inline: true,
         reduce_vars: true,
         unused: true,
     }

test/compress/issue-2001.js

@@ -45,7 +45,7 @@ export_default_func_1: {
     input: {
         export default function f(){};
     }
-    expect_exact: "export default function(){};"
+    expect_exact: "export default function f(){};"
 }
 
 export_default_func_2: {
@@ -58,7 +58,7 @@ export_default_func_2: {
     input: {
         export default function f(){}(1);
     }
-    expect_exact: "export default function(){};1;"
+    expect_exact: "export default function f(){};1;"
 }
 
 export_default_func_3: {
@@ -71,7 +71,7 @@ export_default_func_3: {
     input: {
         export default function f(){}(1);
     }
-    expect_exact: "export default function(){};"
+    expect_exact: "export default function f(){};"
 }
 
 export_class_1: {
@@ -121,7 +121,7 @@ export_default_class_1: {
     input: {
         export default class C {};
     }
-    expect_exact: "export default class{};"
+    expect_exact: "export default class C{};"
 }
 
 export_default_class_2: {
@@ -134,7 +134,7 @@ export_default_class_2: {
     input: {
         export default class C {}(1);
     }
-    expect_exact: "export default class{};1;"
+    expect_exact: "export default class C{};1;"
 }
 
 export_default_class_3: {
@@ -147,7 +147,7 @@ export_default_class_3: {
     input: {
         export default class C {}(1);
     }
-    expect_exact: "export default class{};"
+    expect_exact: "export default class C{};"
 }
 
 export_mangle_1: {
@@ -159,7 +159,7 @@ export_mangle_1: {
             return one - two;
         };
     }
-    expect_exact: "export function foo(n,o){return n-o};"
+    expect_exact: "export function foo(o,n){return o-n};"
 }
 
 export_mangle_2: {
@@ -171,7 +171,7 @@ export_mangle_2: {
             return one - two;
         };
     }
-    expect_exact: "export default function n(n,r){return n-r};"
+    expect_exact: "export default function foo(o,t){return o-t};"
 }
 
 export_mangle_3: {
@@ -189,7 +189,7 @@ export_mangle_3: {
             }
         };
     }
-    expect_exact: "export class C{go(n,r){return n-r+n}};"
+    expect_exact: "export class C{go(r,e){return r-e+r}};"
 }
 
 export_mangle_4: {
@@ -207,7 +207,7 @@ export_mangle_4: {
             }
         };
     }
-    expect_exact: "export default class n{go(n,r){return n-r+n}};"
+    expect_exact: "export default class C{go(e,r){return e-r+e}};"
 }
 
 export_mangle_5: {
@@ -221,7 +221,7 @@ export_mangle_5: {
             }
         };
     }
-    expect_exact: "export default{prop:function(n,r){return n-r}};"
+    expect_exact: "export default{prop:function(r,t){return r-t}};"
 }
 
 export_mangle_6: {
@@ -232,7 +232,7 @@ export_mangle_6: {
         var baz = 2;
         export let foo = 1, bar = baz;
     }
-    expect_exact: "var a=2;export let foo=1,bar=a;"
+    expect_exact: "var o=2;export let foo=1,bar=o;"
 }
 
 export_toplevel_1: {
@@ -247,7 +247,7 @@ export_toplevel_1: {
     }
     expect: {
         export function g(){};
-        export default function(){};
+        export default function h(){};
     }
 }
 
@@ -263,7 +263,7 @@ export_toplevel_2: {
     }
     expect: {
         export class B {};
-        export default class {};
+        export default class C {};
     }
 }
 

test/compress/issue-203.js

@@ -1,19 +1,21 @@
 
 compress_new_function: {
     options = {
-        unsafe: true
+        unsafe: true,
+        unsafe_Func: true,
     }
     input: {
         new Function("aa, bb", 'return aa;');
     }
     expect: {
-        Function("a", "b", "return a");
+        Function("n,r", "return n");
     }
 }
 
 compress_new_function_with_destruct: {
     options = {
         unsafe: true,
+        unsafe_Func: true,
         ecma: 6
     }
     beautify = {
@@ -25,10 +27,31 @@ compress_new_function_with_destruct: {
         new Function("[[aa]], [{bb}]", 'return aa;');
     }
     expect: {
-        Function("a", "[b]", "return a");
-        Function("a", "{bb}", "return a");
-        Function("[[a]]", "[{bb}]", 'return a');
+        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-281.js

@@ -0,0 +1,493 @@
+collapse_vars_constants: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f1(x) {
+            var a = 4, b = x.prop, c = 5, d = sideeffect1(), e = sideeffect2();
+            return b + (function() { return d - a * e - c; })();
+        }
+        function f2(x) {
+            var a = 4, b = x.prop, c = 5, not_used = sideeffect1(), e = sideeffect2();
+            return b + (function() { return -a * e - c; })();
+        }
+    }
+    expect: {
+        function f1(x) {
+            var b = x.prop, d = sideeffect1(), e = sideeffect2();
+            return b + (d - 4 * e - 5);
+        }
+        function f2(x) {
+            var b = x.prop;
+            sideeffect1();
+            return b + (-4 * sideeffect2() - 5);
+        }
+    }
+}
+
+modified: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        unused: true,
+    }
+    input: {
+        function f5(b) {
+            var a = function() {
+                return b;
+            }();
+            return b++ + a;
+        }
+        console.log(f5(1));
+    }
+    expect: {
+        function f5(b) {
+            var a = b;
+            return b++ + a;
+        }
+        console.log(f5(1));
+    }
+    expect_stdout: "2"
+}
+
+ref_scope: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a = 1, b = 2, c = 3;
+            var a = c++, b = b /= a;
+            return function() {
+                return a;
+            }() + b;
+        }());
+    }
+    expect: {
+        console.log(function() {
+            var a = 1, b = 2, c = 3;
+            b = b /= a = c++;
+            return a + b;
+        }());
+    }
+    expect_stdout: true
+}
+
+safe_undefined: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        inline: true,
+        unsafe: false,
+        unused: true,
+    }
+    mangle = {}
+    input: {
+        var a, c;
+        console.log(function(undefined) {
+            return function() {
+                if (a)
+                    return b;
+                if (c)
+                    return d;
+            };
+        }(1)());
+    }
+    expect: {
+        var a, c;
+        console.log(a ? b : c ? d : void 0);
+    }
+    expect_stdout: true
+}
+
+negate_iife_3: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        t ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_3_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: false,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        t ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_4: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        t ? console.log(true) : console.log(false), void console.log("something");
+    }
+}
+
+negate_iife_5: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        t ? foo(true) : bar(false), void console.log("something");
+    }
+}
+
+negate_iife_5_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        inline: true,
+        negate_iife: false,
+        sequences: true,
+    };
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        t ? foo(true) : bar(false), void console.log("something");
+    }
+}
+
+issue_1254_negate_iife_true: {
+    options = {
+        expression: true,
+        inline: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: 'void console.log("test");'
+    expect_stdout: true
+}
+
+issue_1254_negate_iife_nested: {
+    options = {
+        expression: true,
+        inline: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()()()()();
+    }
+    expect_exact: '(void console.log("test"))()()();'
+}
+
+negate_iife_issue_1073: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        negate_iife: true,
+        reduce_vars: true,
+        sequences: true,
+        unused: true,
+    };
+    input: {
+        new (function(a) {
+            return function Foo() {
+                this.x = a;
+                console.log(this);
+            };
+        }(7))();
+    }
+    expect: {
+        new function() {
+            this.x = 7,
+            console.log(this);
+        }();
+    }
+    expect_stdout: true
+}
+
+issue_1288_side_effects: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        inline: true,
+        negate_iife: true,
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    };
+    input: {
+        if (w) ;
+        else {
+            (function f() {})();
+        }
+        if (!x) {
+            (function() {
+                x = {};
+            })();
+        }
+        if (y)
+            (function() {})();
+        else
+            (function(z) {
+                return z;
+            })(0);
+    }
+    expect: {
+        w;
+        x || (x = {});
+        y;
+    }
+}
+
+inner_var_for_in_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        reduce_vars: true,
+    }
+    input: {
+        function f() {
+            var a = 1, b = 2;
+            for (b in (function() {
+                return x(a, b, c);
+            })()) {
+                var c = 3, d = 4;
+                x(a, b, c, d);
+            }
+            x(a, b, c, d);
+        }
+    }
+    expect: {
+        function f() {
+            var a = 1, b = 2;
+            for (b in x(1, b, c)) {
+                var c = 3, d = 4;
+                x(1, b, c, d);
+            }
+            x(1, b, c, d);
+        }
+    }
+}
+
+issue_1595_3: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function f(a) {
+            return g(a + 1);
+        })(2);
+    }
+    expect: {
+        g(3);
+    }
+}
+
+issue_1758: {
+    options = {
+        inline: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(c) {
+            var undefined = 42;
+            return function() {
+                c--;
+                c--, c.toString();
+                return;
+            }();
+        }());
+    }
+    expect: {
+        console.log(function(c) {
+            var undefined = 42;
+            return c--, c--, void c.toString();
+        }());
+    }
+    expect_stdout: "undefined"
+}
+wrap_iife: {
+    options = {
+        inline: true,
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: 'void console.log("test");'
+}
+
+wrap_iife_in_expression: {
+    options = {
+        inline: true,
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        foo = (function () {
+            return bar();
+        })();
+    }
+    expect_exact: 'foo=bar();'
+}
+
+wrap_iife_in_return_call: {
+    options = {
+        inline: true,
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        (function() {
+            return (function() {
+                console.log('test')
+            })();
+        })()();
+    }
+    expect_exact: '(void console.log("test"))();'
+}
+
+pure_annotation_1: {
+    options = {
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        /*@__PURE__*/(function() {
+            console.log("hello");
+        }());
+    }
+    expect_exact: ""
+}
+
+pure_annotation_2: {
+    options = {
+        collapse_vars: true,
+        inline: true,
+        side_effects: true,
+    }
+    input: {
+        /*@__PURE__*/(function(n) {
+            console.log("hello", n);
+        }(42));
+    }
+    expect_exact: ""
+}
+
+drop_fargs: {
+    options = {
+        cascade: true,
+        inline: true,
+        keep_fargs: false,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        !function(a_1) {
+            a++;
+        }(a++ + (a && a.var));
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        ++a && a.var, a++;
+        console.log(a);
+    }
+    expect_stdout: "3"
+}
+
+keep_fargs: {
+    options = {
+        cascade: true,
+        inline: true,
+        keep_fargs: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        !function(a_1) {
+            a++;
+        }(a++ + (a && a.var));
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        ++a && a.var, a++;
+        console.log(a);
+    }
+    expect_stdout: "3"
+}

test/compress/issue-747.js

@@ -1,37 +1,45 @@
 dont_reuse_prop: {
-    mangle_props = {
-        regex: /asd/
-    };
-
+    mangle = {
+        properties: {
+            regex: /asd/,
+        },
+    }
     input: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.a = 123;
         obj.asd = 256;
         console.log(obj.a);
     }
     expect: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.a = 123;
         obj.b = 256;
         console.log(obj.a);
     }
+    expect_stdout: "123"
 }
 
 unmangleable_props_should_always_be_reserved: {
-    mangle_props = {
-        regex: /asd/
-    };
-
+    mangle = {
+        properties: {
+            regex: /asd/,
+        },
+    }
     input: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.asd = 256;
         obj.a = 123;
         console.log(obj.a);
     }
     expect: {
+        "aaaaaaaaaabbbbb";
         var obj = {};
         obj.b = 256;
         obj.a = 123;
         console.log(obj.a);
     }
-}
+    expect_stdout: "123"
+}

test/compress/loops.js

@@ -480,3 +480,17 @@ do_switch: {
         } while (false);
     }
 }
+
+in_parenthesis_1: {
+    input: {
+        for (("foo" in {});0;);
+    }
+    expect_exact: 'for(("foo"in{});0;);'
+}
+
+in_parenthesis_2: {
+    input: {
+        for ((function(){ "foo" in {}; });0;);
+    }
+    expect_exact: 'for(function(){"foo"in{}};0;);'
+}

test/compress/negate-iife.js

@@ -22,7 +22,8 @@ negate_iife_1_off: {
 
 negate_iife_2: {
     options = {
-        negate_iife: true
+        inline: true,
+        negate_iife: true,
     };
     input: {
         (function(){ return {} })().x = 10;
@@ -32,6 +33,7 @@ negate_iife_2: {
 
 negate_iife_2_side_effects: {
     options = {
+        inline: true,
         negate_iife: true,
         side_effects: true,
     }
@@ -58,6 +60,7 @@ negate_iife_3_evaluate: {
     options = {
         conditionals: true,
         evaluate: true,
+        inline: true,
         negate_iife: true,
     }
     input: {
@@ -100,6 +103,7 @@ negate_iife_3_off_evaluate: {
     options = {
         conditionals: true,
         evaluate: true,
+        inline: true,
         negate_iife: false,
     }
     input: {

test/compress/new.js

@@ -98,3 +98,19 @@ new_with_assignement_expression: {
         new y([a, b] = [3, 4]);
     }
 }
+
+dot_parenthesis_1: {
+    input: {
+        console.log(new (Math.random().constructor) instanceof Number);
+    }
+    expect_exact: "console.log(new(Math.random().constructor)instanceof Number);"
+    expect_stdout: "true"
+}
+
+dot_parenthesis_2: {
+    input: {
+        console.log(typeof new function(){Math.random()}.constructor);
+    }
+    expect_exact: "console.log(typeof new function(){Math.random()}.constructor);"
+    expect_stdout: "function"
+}

test/compress/node_version.js

@@ -1,4 +1,4 @@
-eval_let: {
+eval_let_6: {
     input: {
         eval("let a;");
         console.log();
@@ -10,3 +10,29 @@ eval_let: {
     expect_stdout: ""
     node_version: ">=6"
 }
+
+eval_let_4: {
+    input: {
+        eval("let a;");
+        console.log();
+    }
+    expect: {
+        eval("let a;");
+        console.log();
+    }
+    expect_stdout: SyntaxError("Block-scoped declarations (let, const, function, class) not yet supported outside strict mode")
+    node_version: "4"
+}
+
+eval_let_0: {
+    input: {
+        eval("let a;");
+        console.log();
+    }
+    expect: {
+        eval("let a;");
+        console.log();
+    }
+    expect_stdout: SyntaxError("Unexpected identifier")
+    node_version: "<=0.12"
+}

test/compress/object.js

@@ -105,7 +105,7 @@ getter_setter_mangler: {
             };
         }
     }
-    expect_exact: "function f(n,t){return{get:n,set:t,get g(){},set s(n){},c,a:1,m(){}}}"
+    expect_exact: "function f(t,e){return{get:t,set:e,get g(){},set s(t){},c,a:1,m(){}}}"
 }
 
 use_shorthand_opportunity: {
@@ -126,6 +126,67 @@ computed_property_names: {
     expect_exact: 'obj({["x"+"x"]:6});'
 }
 
+convert_computed_props_to_regular_ones: {
+    options = {
+        booleans: true,
+        computed_props: true,
+        evaluate: true,
+    }
+    input: {
+        var o = {
+            ["hi"]: 0,
+            ["A" + 1]: 1,
+            [/B/]: 2,
+            [100 + 23]: 3,
+            [1 + .5]: 4,
+            [Math.PI]: 5,
+            [undefined]: 6,
+            [true]: 7,
+            [false]: 8,
+            [null]: 9,
+            [Infinity]: 10,
+            [NaN]: 11,
+        };
+        for (var k in o) {
+            console.log(k, o[k]);
+        }
+    }
+    expect: {
+        var o = {
+            hi: 0,
+            A1: 1,
+            [/B/]: 2,
+            123: 3,
+            1.5: 4,
+            [Math.PI]: 5,
+
+            // leave these problematic cases as is
+            [void 0]: 6,
+            [!0]: 7,
+            [!1]: 8,
+            [null]: 9,
+            [1 / 0]: 10,
+            [NaN]: 11
+        };
+        for (var k in o) console.log(k, o[k]);
+    }
+    expect_stdout: [
+        "123 3",
+        "hi 0",
+        "A1 1",
+        "/B/ 2",
+        "1.5 4",
+        "3.141592653589793 5",
+        "undefined 6",
+        "true 7",
+        "false 8",
+        "null 9",
+        "Infinity 10",
+        "NaN 11",
+    ]
+    node_version: ">=6"
+}
+
 computed_property_names_evaluated_1: {
     options = {
         evaluate: true
@@ -284,9 +345,11 @@ concise_methods_with_various_property_names: {
 }
 
 concise_methods_and_mangle_props: {
-    mangle_props = {
-        regex: /_/
-    };
+    mangle = {
+        properties: {
+            regex: /_/,
+        },
+    }
     input: {
         function x() {
             obj = {
@@ -297,7 +360,7 @@ concise_methods_and_mangle_props: {
     expect: {
         function x() {
             obj = {
-                a() { return 1; }
+                o() { return 1; }
             }
         }
     }
@@ -510,3 +573,242 @@ variable_as_computed_property: {
     }
     expect_exact: "function getLine(header){return{[header]:{}}}"
 }
+
+prop_func_to_concise_method: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        ({
+            emit: function NamedFunctionExpression() {
+                console.log("PASS");
+            },
+            run: function() {
+                this.emit();
+            }
+        }).run();
+    }
+    expect: {
+        ({
+            emit: function NamedFunctionExpression() {
+                console.log("PASS");
+            },
+            run() {
+                this.emit();
+            }
+        }).run();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+prop_arrow_to_concise_method: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        ({
+            run: () => {
+                console.log("PASS");
+            }
+        }).run();
+    }
+    expect: {
+        ({
+            run() {
+                console.log("PASS");
+            }
+        }).run();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=6"
+}
+
+concise_method_to_prop_arrow: {
+    options = {
+        arrows: true,
+        ecma: 6,
+    }
+    input: {
+        console.log(({ a: () => 1 }).a());
+        console.log(({ a: () => { return 2; } }).a());
+        console.log(({ a() { return 3; } }).a());
+        console.log(({ a() { return this.b; }, b: 4 }).a());
+    }
+    expect: {
+        console.log({ a: () => 1 }.a());
+        console.log({ a: () => 2 }.a());
+        console.log({ a: () => 3 }.a());
+        console.log({ a() { return this.b; }, b: 4 }.a());
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "3",
+        "4",
+    ]
+    node_version: ">=4"
+}
+
+prop_func_to_async_concise_method: {
+    options = {
+        ecma: 8,
+        unsafe_methods: true,
+    }
+    input: {
+        ({
+            run: async function() {
+                console.log("PASS");
+            }
+        }).run();
+    }
+    expect: {
+        ({
+            async run() {
+                console.log("PASS");
+            }
+        }).run();
+    }
+    expect_stdout: "PASS"
+    node_version: ">=8"
+}
+
+prop_func_to_concise_method_various: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        ({
+            null: function(x, y){ x(y); },
+            123: function(x, y){ x(y); },
+            "A B": function(x, y){ x(y); },
+            p1: function(x, y){ x(y); },
+            p2: function*(x, y){ yield x(y); },
+            p3: async function(x, y){ await x(y); },
+            [c1]: function(x, y){ x(y); },
+            [c2]: function*(x, y){ yield x(y); },
+            [c3]: async function(x, y){ await x(y); },
+        });
+    }
+    expect: {
+        ({
+            null(x, y) { x(y); },
+            123(x, y) { x(y); },
+            "A B"(x, y) { x(y); },
+            p1(x, y) { x(y); },
+            *p2(x, y) { yield x(y); },
+            async p3(x, y) { await x(y); },
+            [c1](x, y) { x(y); },
+            *[c2](x, y) { yield x(y); },
+            async [c3](x, y) { await x(y); },
+        });
+    }
+}
+
+prop_arrows_to_concise_method_various: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        ({
+            null: (x, y) => { x(y); },
+            123: (x, y) => { x(y); },
+            "A B": (x, y) => { x(y); },
+            p1: (x, y) => { x(y); },
+            p3: async (x, y) => { await x(y); },
+            [c1]: (x, y) => { x(y); },
+            [c3]: async (x, y) => { await x(y); },
+        });
+    }
+    expect: {
+        ({
+            null(x, y) { x(y); },
+            123(x, y) { x(y); },
+            "A B"(x, y) { x(y); },
+            p1(x, y) { x(y); },
+            async p3(x, y) { await x(y); },
+            [c1](x, y) { x(y); },
+            async [c3](x, y) { await x(y); },
+        });
+    }
+}
+
+prop_arrow_with_this: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        function run(arg) {
+            console.log(arg === this ? "global" : arg === foo ? "foo" : arg);
+        }
+        var foo = {
+            func_no_this: function() { run(); },
+            func_with_this: function() { run(this); },
+            arrow_no_this: () => { run(); },
+            arrow_with_this: () => { run(this); },
+        };
+        for (var key in foo) foo[key]();
+    }
+    expect: {
+        function run(arg) {
+            console.log(arg === this ? "global" : arg === foo ? "foo" : arg);
+        }
+        var foo = {
+            func_no_this() { run(); },
+            func_with_this() { run(this); },
+            arrow_no_this() { run(); },
+            arrow_with_this: () => { run(this); },
+        };
+        for (var key in foo) foo[key]();
+    }
+    expect_stdout: [
+        "undefined",
+        "foo",
+        "undefined",
+        "global",
+    ]
+    node_version: ">=4"
+}
+
+prop_arrow_with_nested_this: {
+    options = {
+        ecma: 6,
+        unsafe_methods: true,
+    }
+    input: {
+        function run(arg) {
+            console.log(arg === this ? "global" : arg === foo ? "foo" : arg);
+        }
+        var foo = {
+            func_func_this: function() { (function() { run(this); })(); },
+            func_arrow_this: function() { (() => { run(this); })(); },
+            arrow_func_this: () => { (function() { run(this); })(); },
+            arrow_arrow_this: () => { (() => { run(this); })(); },
+        };
+        for (var key in foo) foo[key]();
+    }
+    expect: {
+        function run(arg) {
+            console.log(arg === this ? "global" : arg === foo ? "foo" : arg);
+        }
+        var foo = {
+            func_func_this() { (function() { run(this); })(); },
+            func_arrow_this() { (() => { run(this); })(); },
+            arrow_func_this() { (function() { run(this); })(); },
+            arrow_arrow_this: () => { (() => { run(this); })(); },
+        };
+        for (var key in foo) foo[key]();
+    }
+    expect_stdout: [
+        "global",
+        "foo",
+        "global",
+        "global",
+    ]
+    node_version: ">=4"
+}

test/compress/parameters.js

@@ -1,4 +1,7 @@
 arrow_functions: {
+    options = {
+        arrows: true,
+    }
     input: {
         (a) => b;  // 1 args
         (a, b) => c;  // n args
@@ -13,6 +16,9 @@ arrow_functions: {
 }
 
 arrow_return: {
+    options = {
+        arrows: true,
+    }
     input: {
         () => {};
         () => { return; };
@@ -136,11 +142,11 @@ destructuring_arguments_3: {
     }
     input: {
         function fn3({x: {y: {z: {} = 42}}}) {}
-        const { cover = (function () {}), xCover = (0, function() {})  } = {};
-        let { cover = (function () {}), xCover = (0, function() {})  } = {};
-        var { cover = (function () {}), xCover = (0, function() {})  } = {};
+        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{cover=function(){},xCover=(0,function(){})}={};let{cover=function(){},xCover=(0,function(){})}={};var{cover=function(){},xCover=(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: {

test/compress/properties.js

@@ -13,8 +13,10 @@ keep_properties: {
 dot_properties: {
     options = {
         properties: true,
+    }
+    beautify = {
         ie8: true,
-    };
+    }
     input: {
         a["foo"] = "bar";
         a["if"] = "if";
@@ -36,8 +38,10 @@ dot_properties: {
 dot_properties_es5: {
     options = {
         properties: true,
+    }
+    beautify = {
         ie8: false,
-    };
+    }
     input: {
         a["foo"] = "bar";
         a["if"] = "if";
@@ -124,9 +128,11 @@ evaluate_string_length: {
 }
 
 mangle_properties: {
-    mangle_props = {
-        keep_quoted: false
-    };
+    mangle = {
+        properties: {
+            keep_quoted: false,
+        },
+    }
     input: {
         a["foo"] = "bar";
         a.color = "red";
@@ -137,9 +143,9 @@ mangle_properties: {
     expect: {
         a["a"] = "bar";
         a.b = "red";
-        x = {c: 10};
-        a.d(x.c, a.a);
-        a['d']({b: "blue", a: "baz"});
+        x = {o: 10};
+        a.r(x.o, a.a);
+        a['r']({b: "blue", a: "baz"});
     }
 }
 
@@ -147,9 +153,11 @@ mangle_unquoted_properties: {
     options = {
         properties: false
     }
-    mangle_props = {
-        builtins: true,
-        keep_quoted: true
+    mangle = {
+        properties: {
+            builtins: true,
+            keep_quoted: true,
+        },
     }
     beautify = {
         beautify: false,
@@ -178,24 +186,26 @@ mangle_unquoted_properties: {
         function f1() {
             a["foo"] = "bar";
             a.color = "red";
-            a.b = 2;
-            x = {"bar": 10, c: 7};
-            a.c = 9;
+            a.r = 2;
+            x = {"bar": 10, b: 7};
+            a.b = 9;
         }
         function f2() {
             a.foo = "bar";
             a['color'] = "red";
-            x = {bar: 10, c: 7};
-            a.c = 9;
-            a.b = 3;
+            x = {bar: 10, b: 7};
+            a.b = 9;
+            a.r = 3;
         }
     }
 }
 
 mangle_debug: {
-    mangle_props = {
-        debug: ""
-    };
+    mangle = {
+        properties: {
+            debug: "",
+        },
+    }
     input: {
         a.foo = "bar";
         x = { baz: "ban" };
@@ -207,9 +217,11 @@ mangle_debug: {
 }
 
 mangle_debug_true: {
-    mangle_props = {
-        debug: true
-    };
+    mangle = {
+        properties: {
+            debug: true,
+        },
+    }
     input: {
         a.foo = "bar";
         x = { baz: "ban" };
@@ -221,9 +233,11 @@ mangle_debug_true: {
 }
 
 mangle_debug_suffix: {
-    mangle_props = {
-        debug: "XYZ"
-    };
+    mangle = {
+        properties: {
+            debug: "XYZ",
+        },
+    }
     input: {
         a.foo = "bar";
         x = { baz: "ban" };
@@ -238,11 +252,13 @@ mangle_debug_suffix_keep_quoted: {
     options = {
         properties: false
     }
-    mangle_props = {
-        builtins: true,
-        keep_quoted: true,
-        debug: "XYZ",
-        reserved: []
+    mangle = {
+        properties: {
+            builtins: true,
+            debug: "XYZ",
+            keep_quoted: true,
+            reserved: [],
+        },
     }
     beautify = {
         beautify: false,
@@ -557,3 +573,482 @@ native_prototype: {
         "".indexOf.call(e, "bar");
     }
 }
+
+accessor_boolean: {
+    input: {
+        var a = 1;
+        var b = {
+            get true() {
+                return a;
+            },
+            set false(c) {
+                a = c;
+            }
+        };
+        console.log(b.true, b.false = 2, b.true);
+    }
+    expect_exact: 'var a=1;var b={get true(){return a},set false(c){a=c}};console.log(b.true,b.false=2,b.true);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_get_set: {
+    input: {
+        var a = 1;
+        var b = {
+            get set() {
+                return a;
+            },
+            set get(c) {
+                a = c;
+            }
+        };
+        console.log(b.set, b.get = 2, b.set);
+    }
+    expect_exact: 'var a=1;var b={get set(){return a},set get(c){a=c}};console.log(b.set,b.get=2,b.set);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_null_undefined: {
+    input: {
+        var a = 1;
+        var b = {
+            get null() {
+                return a;
+            },
+            set undefined(c) {
+                a = c;
+            }
+        };
+        console.log(b.null, b.undefined = 2, b.null);
+    }
+    expect_exact: 'var a=1;var b={get null(){return a},set undefined(c){a=c}};console.log(b.null,b.undefined=2,b.null);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_number: {
+    input: {
+        var a = 1;
+        var b = {
+            get 42() {
+                return a;
+            },
+            set 42(c) {
+                a = c;
+            }
+        };
+        console.log(b[42], b[42] = 2, b[42]);
+    }
+    expect_exact: 'var a=1;var b={get 42(){return a},set 42(c){a=c}};console.log(b[42],b[42]=2,b[42]);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_string: {
+    input: {
+        var a = 1;
+        var b = {
+            get "a-b"() {
+                return a;
+            },
+            set "a-b"(c) {
+                a = c;
+            }
+        };
+        console.log(b["a-b"], b["a-b"] = 2, b["a-b"]);
+    }
+    expect_exact: 'var a=1;var b={get"a-b"(){return a},set"a-b"(c){a=c}};console.log(b["a-b"],b["a-b"]=2,b["a-b"]);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_this: {
+    input: {
+        var a = 1;
+        var b = {
+            get this() {
+                return a;
+            },
+            set this(c) {
+                a = c;
+            }
+        };
+        console.log(b.this, b.this = 2, b.this);
+    }
+    expect_exact: 'var a=1;var b={get this(){return a},set this(c){a=c}};console.log(b.this,b.this=2,b.this);'
+    expect_stdout: "1 2 2"
+}
+
+issue_2208_1: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        console.log({
+            p: function() {
+                return 42;
+            }
+        }.p());
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+}
+
+issue_2208_2: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        console.log({
+            a: 42,
+            p: function() {
+                return this.a;
+            }
+        }.p());
+    }
+    expect: {
+        console.log({
+            a: 42,
+            p: function() {
+                return this.a;
+            }
+        }.p());
+    }
+    expect_stdout: "42"
+}
+
+issue_2208_3: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        a = 42;
+        console.log({
+            p: function() {
+                return function() {
+                    return this.a;
+                }();
+            }
+        }.p());
+    }
+    expect: {
+        a = 42;
+        console.log(function() {
+            return this.a;
+        }());
+    }
+    expect_stdout: "42"
+}
+
+issue_2208_4: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        function foo() {}
+        console.log({
+            a: foo(),
+            p: function() {
+                return 42;
+            }
+        }.p());
+    }
+    expect: {
+        function foo() {}
+        console.log((foo(), function() {
+            return 42;
+        })());
+    }
+    expect_stdout: "42"
+}
+
+issue_2208_5: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        console.log({
+            p: "FAIL",
+            p: function() {
+                return 42;
+            }
+        }.p());
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+}
+
+issue_2208_6: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        console.log({
+            p: () => 42
+        }.p());
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+issue_2208_7: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        console.log({
+            p() {
+                return 42;
+            }
+        }.p());
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+issue_2208_8: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unsafe: 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 function() {
+            return await x();
+        }());
+    }
+}
+
+issue_2208_9: {
+    options = {
+        inline: true,
+        side_effects: true,
+        unsafe: 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_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,
+    }
+    mangle = {
+        properties: {
+            keep_quoted: true,
+        },
+    }
+    input: {
+        ({ "keep": 1 });
+        g.keep = g.change;
+    }
+    expect: {
+        g.keep = g.g;
+    }
+}
+
+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"
+}

test/compress/pure_getters.js

@@ -178,3 +178,545 @@ impure_getter_2: {
     }
     expect: {}
 }
+
+issue_2110_1: {
+    options = {
+        cascade: true,
+        pure_getters: "strict",
+        sequences: true,
+        side_effects: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function f() {}
+            function g() {
+                return this;
+            }
+            f.g = g;
+            return f.g();
+        }
+        console.log(typeof f());
+    }
+    expect: {
+        function f() {
+            function f() {}
+            return f.g = function() {
+                return this;
+            }, f.g();
+        }
+        console.log(typeof f());
+    }
+    expect_stdout: "function"
+}
+
+issue_2110_2: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function f() {}
+            function g() {
+                return this;
+            }
+            f.g = g;
+            return f.g();
+        }
+        console.log(typeof f());
+    }
+    expect: {
+        function f() {
+            function f() {}
+            f.g = function() {
+                return this;
+            };
+            return f.g();
+        }
+        console.log(typeof f());
+    }
+    expect_stdout: "function"
+}
+
+set_immutable_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        1..foo += "";
+        if (1..foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+set_immutable_2: {
+    options = {
+        cascade: true,
+        conditionals: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        var a = 1;
+        a.foo += "", a.foo ? console.log("FAIL") : console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+set_immutable_3: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        1..foo += "";
+        if (1..foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect_stdout: true
+}
+
+set_immutable_4: {
+    options = {
+        cascade: true,
+        conditionals: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        var a = 1;
+        a.foo += "";
+        if (a.foo) console.log("FAIL");
+        else console.log("PASS");
+    }
+    expect: {
+        "use strict";
+        var a = 1;
+        a.foo += "", a.foo ? console.log("FAIL") : console.log("PASS");
+    }
+    expect_stdout: true
+}
+
+set_mutable_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        !function a() {
+            a.foo += "";
+            if (a.foo) console.log("PASS");
+            else console.log("FAIL");
+        }();
+    }
+    expect: {
+        !function a() {
+            if (a.foo += "") console.log("PASS");
+            else console.log("FAIL");
+        }();
+    }
+    expect_stdout: "PASS"
+}
+
+set_mutable_2: {
+    options = {
+        cascade: true,
+        conditionals: true,
+        pure_getters: "strict",
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        !function a() {
+            a.foo += "";
+            if (a.foo) console.log("PASS");
+            else console.log("FAIL");
+        }();
+    }
+    expect: {
+        !function a() {
+            (a.foo += "") ? console.log("PASS") : console.log("FAIL");
+        }();
+    }
+    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_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_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_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = { b: 1 };
+        ({...a}).b;
+    }
+    expect: {}
+}
+
+issue_2313_1: {
+    options = {
+        cascade: true,
+        conditionals: true,
+        pure_getters: "strict",
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        if (x().y().z) {
+            console.log(3);
+        }
+    }
+    expect: {
+        function x() {
+            return console.log(1), {
+                y: function() {
+                    return console.log(2), {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++,
+        x().y().z && console.log(3);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "1",
+        "2",
+    ]
+}
+
+issue_2313_2: {
+    options = {
+        cascade: true,
+        conditionals: true,
+        pure_getters: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        if (x().y().z) {
+            console.log(3);
+        }
+    }
+    expect: {
+        function x() {
+            return console.log(1), {
+                y: function() {
+                    return console.log(2), {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++,
+        x().y().z && console.log(3);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "1",
+        "2",
+    ]
+}
+
+issue_2313_3: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: "strict",
+    }
+    input: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        if (x().y().z) {
+            console.log(3);
+        }
+    }
+    expect: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        x().y().z && console.log(3);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "1",
+        "2",
+    ]
+}
+
+issue_2313_4: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        pure_getters: true,
+    }
+    input: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        if (x().y().z) {
+            console.log(3);
+        }
+    }
+    expect: {
+        function x() {
+            console.log(1);
+            return {
+                y: function() {
+                    console.log(2);
+                    return {
+                        z: 0
+                    };
+                }
+            };
+        }
+        x().y().z++;
+        x().y().z && console.log(3);
+    }
+    expect_stdout: [
+        "1",
+        "2",
+        "1",
+        "2",
+    ]
+}
+
+issue_2313_5: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        x().y++;
+        x().y;
+    }
+    expect: {
+        x().y++;
+        x().y;
+    }
+}
+
+issue_2313_6: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        x().y++;
+        x().y;
+    }
+    expect: {
+        x().y++;
+        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"
+}

test/compress/reduce_vars.js

@@ -2,6 +2,7 @@ reduce_vars: {
     options = {
         conditionals  : true,
         evaluate      : true,
+        inline        : true,
         global_defs   : {
             C : 0
         },
@@ -171,6 +172,7 @@ unsafe_evaluate: {
     options = {
         evaluate     : true,
         reduce_vars  : true,
+        side_effects : true,
         unsafe       : true,
         unused       : true
     }
@@ -1032,6 +1034,7 @@ defun_inline_2: {
 defun_inline_3: {
     options = {
         evaluate: true,
+        inline: true,
         passes: 2,
         reduce_vars: true,
         side_effects: true,
@@ -1054,6 +1057,7 @@ defun_inline_3: {
 
 defun_call: {
     options = {
+        inline: true,
         reduce_vars: true,
         unused: true,
     }
@@ -1080,6 +1084,7 @@ defun_call: {
 
 defun_redefine: {
     options = {
+        inline: true,
         reduce_vars: true,
         unused: true,
     }
@@ -1112,6 +1117,7 @@ defun_redefine: {
 
 func_inline: {
     options = {
+        inline: true,
         reduce_vars: true,
         unused: true,
     }
@@ -1138,6 +1144,7 @@ func_inline: {
 
 func_modified: {
     options = {
+        inline: true,
         reduce_vars: true,
         unused: true,
     }
@@ -1311,19 +1318,47 @@ iife_func_side_effects: {
         unused: true,
     }
     input: {
+        function x() {
+            console.log("x");
+        }
+        function y() {
+            console.log("y");
+        }
+        function z() {
+            console.log("z");
+        }
         (function(a, b, c) {
-            return b();
+            function y() {
+                console.log("FAIL");
+            }
+            return y + b();
         })(x(), function() {
             return y();
         }, z());
     }
     expect: {
+        function x() {
+            console.log("x");
+        }
+        function y() {
+            console.log("y");
+        }
+        function z() {
+            console.log("z");
+        }
         (function(a, b, c) {
             return function() {
-                return y();
-            }();
-        })(x(), 0, z());
+                console.log("FAIL");
+            } + b();
+        })(x(), function() {
+            return y();
+        }, z());
     }
+    expect_stdout: [
+        "x",
+        "z",
+        "y",
+    ]
 }
 
 issue_1595_1: {
@@ -1435,6 +1470,7 @@ issue_1670_1: {
         reduce_vars: true,
         side_effects: true,
         switches: true,
+        typeofs: true,
         unused: true,
     }
     input: {
@@ -1498,6 +1534,7 @@ issue_1670_3: {
         reduce_vars: true,
         side_effects: true,
         switches: true,
+        typeofs: true,
         unused: true,
     }
     input: {
@@ -1687,6 +1724,7 @@ redefine_arguments_1: {
 redefine_arguments_2: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
         reduce_vars: true,
         side_effects: true,
@@ -1723,6 +1761,7 @@ redefine_arguments_2: {
 redefine_arguments_3: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
         passes: 3,
         reduce_vars: true,
@@ -1799,6 +1838,7 @@ redefine_farg_1: {
 redefine_farg_2: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
         reduce_vars: true,
         side_effects: true,
@@ -1835,6 +1875,7 @@ redefine_farg_2: {
 redefine_farg_3: {
     options = {
         evaluate: true,
+        inline: true,
         keep_fargs: false,
         passes: 3,
         reduce_vars: true,
@@ -1858,10 +1899,7 @@ redefine_farg_3: {
         console.log(f([]), g([]), h([]));
     }
     expect: {
-        console.log(function(a) {
-            var a;
-            return typeof a;
-        }([]), "number", "undefined");
+        console.log(typeof [], "number", "undefined");
     }
     expect_stdout: "object number undefined"
 }
@@ -2509,7 +2547,7 @@ issue_1922_2: {
     expect_stdout: "1"
 }
 
-accessor: {
+accessor_1: {
     options = {
         evaluate: true,
         reduce_vars: true,
@@ -2537,3 +2575,539 @@ accessor: {
     }
     expect_stdout: "1 1"
 }
+
+accessor_2: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var A = 1;
+        var B = {
+            get c() {
+                console.log(A);
+            }
+        };
+        B.c;
+    }
+    expect: {
+        ({
+            get c() {
+                console.log(1);
+            }
+        }).c;
+    }
+    expect_stdout: "1"
+}
+
+method_1: {
+    options = {
+        evaluate: 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_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_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_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_vars: true,
+    }
+    input: {
+        var a = {
+            foo: function() {
+                for (this.b in [1, 2]);
+            }
+        };
+        a.foo();
+        console.log(a.b);
+    }
+    expect: {
+        var a = {
+            foo: function() {
+                for (this.b in [1, 2]);
+            }
+        };
+        a.foo();
+        console.log(a.b);
+    }
+    expect_stdout: "1"
+}
+
+obj_var_1: {
+    options = {
+        evaluate: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var C = 1;
+        var obj = {
+            bar: function() {
+                return C + C;
+            }
+        };
+        console.log(obj.bar());
+    }
+    expect: {
+        console.log({
+            bar: function() {
+                return 2;
+            }
+        }.bar());
+    }
+    expect_stdout: "2"
+}
+
+obj_var_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var C = 1;
+        var obj = {
+            bar: function() {
+                return C + C;
+            }
+        };
+        console.log(obj.bar());
+    }
+    expect: {
+        console.log(2);
+    }
+    expect_stdout: "2"
+}
+
+obj_arg_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var C = 1;
+        function f(obj) {
+            return obj.bar();
+        }
+        console.log(f({
+            bar: function() {
+                return C + C;
+            }
+        }));
+    }
+    expect: {
+        console.log({
+            bar: function() {
+                return 2;
+            }
+        }.bar());
+    }
+    expect_stdout: "2"
+}
+
+obj_arg_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var C = 1;
+        function f(obj) {
+            return obj.bar();
+        }
+        console.log(f({
+            bar: function() {
+                return C + C;
+            }
+        }));
+    }
+    expect: {
+        console.log(2);
+    }
+    expect_stdout: "2"
+}
+
+func_arg_1: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 42;
+        !function(a) {
+            console.log(a());
+        }(function() {
+            return a;
+        });
+    }
+    expect: {
+        console.log(42);
+    }
+    expect_stdout: "42"
+}
+
+func_arg_2: {
+    options = {
+        evaluate: true,
+        inline: true,
+        passes: 2,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 42;
+        !function(a) {
+            console.log(a());
+        }(function(a) {
+            return a;
+        });
+    }
+    expect: {
+        console.log(void 0);
+    }
+    expect_stdout: "undefined"
+}
+
+regex_loop: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(x) {
+            for (var r, s = "acdabcdeabbb"; r = x().exec(s);)
+                console.log(r[0]);
+        }
+        var a = /ab*/g;
+        f(function() {
+            return a;
+        });
+    }
+    expect: {
+        var a = /ab*/g;
+        (function(x) {
+            for (var r, s = "acdabcdeabbb"; r = x().exec(s);)
+                console.log(r[0]);
+        })(function() {
+            return a;
+        });
+    }
+    expect_stdout: true
+}
+
+obj_for_1: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = { a: 1 };
+        for (var i = o.a--; i; i--)
+            console.log(i);
+    }
+    expect: {
+        // TODO make this work on harmony
+        var o = { a: 1 };
+        for (var i = o.a--; i; i--)
+            console.log(i);
+    }
+    expect_stdout: "1"
+}
+
+obj_for_2: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var o = { a: 1 };
+        for (var i; i = o.a--;)
+            console.log(i);
+    }
+    expect: {
+        var o = { a: 1 };
+        for (var i; i = o.a--;)
+            console.log(i);
+    }
+    expect_stdout: "1"
+}
+
+array_forin_1: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = [ 1, 2, 3 ];
+        for (var b in a)
+            console.log(b);
+    }
+    expect: {
+        // TODO make this work on harmony
+        var a = [ 1, 2, 3 ];
+        for (var b in a)
+            console.log(b);
+    }
+    expect_stdout: [
+        "0",
+        "1",
+        "2",
+    ]
+}
+
+array_forin_2: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = [];
+        for (var b in [ 1, 2, 3 ])
+            a.push(b);
+        console.log(a.length);
+    }
+    expect: {
+        var a = [];
+        for (var b in [ 1, 2, 3 ])
+            a.push(b);
+        console.log(a.length);
+    }
+    expect_stdout: "3"
+}
+
+array_forof_1: {
+    options = {
+        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_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,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        var o = {
+            a: 1,
+            b: 2
+        };
+        o.a++;
+        console.log(o.a, o.b);
+    }
+    expect: {
+        var o = {
+            a: 1,
+            b: 2
+        };
+        o.a++;
+        console.log(o.a, o.b);
+    }
+    expect_stdout: "2 2"
+}
+
+const_expr_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unsafe: true,
+        unused: true,
+    }
+    input: {
+        Object.prototype.c = function() {
+            this.a++;
+        };
+        var o = {
+            a: 1,
+            b: 2
+        };
+        o.c();
+        console.log(o.a, o.b);
+    }
+    expect: {
+        Object.prototype.c = function() {
+            this.a++;
+        };
+        var o = {
+            a: 1,
+            b: 2
+        };
+        o.c();
+        console.log(o.a, o.b);
+    }
+    expect_stdout: "2 2"
+}

test/compress/sandbox.js

@@ -0,0 +1,14 @@
+console_log: {
+    input: {
+        console.log("%% %s");
+        console.log("%% %s", "%s");
+    }
+    expect: {
+        console.log("%% %s");
+        console.log("%% %s", "%s");
+    }
+    expect_stdout: [
+        "%% %s",
+        "% %s",
+    ]
+}

test/compress/screw-ie8.js

@@ -255,3 +255,139 @@ issue_1586_2: {
     }
     expect_exact: "function f(){try{x()}catch(c){console.log(c.message)}}"
 }
+
+issue_2120_1: {
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (t) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (t) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2120_2: {
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect: {
+        "aaaaaaaa";
+        var a = 1, b = "FAIL";
+        try {
+            throw 1;
+        } catch (c) {
+            try {
+                throw 0;
+            } catch (a) {
+                if (c) b = "PASS";
+            }
+        }
+        console.log(b);
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2254_1: {
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(s) {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return s;
+            }
+        }
+    }
+    expect: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(e) {
+            try {
+                throw "FAIL";
+            } catch (t) {
+                return e;
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_2254_2: {
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(s) {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return s;
+            }
+        }
+    }
+    expect: {
+        "eeeeee";
+        try {
+            console.log(f("PASS"));
+        } catch (e) {}
+        function f(t) {
+            try {
+                throw "FAIL";
+            } catch (e) {
+                return t;
+            }
+        }
+    }
+    expect_stdout: "PASS"
+}

test/compress/sequences.js

@@ -176,6 +176,11 @@ for_sequences: {
         // 4
         x = (foo in bar);
         for (y = 5; false;);
+        // 5
+        x = function() {
+            foo in bar;
+        };
+        for (y = 5; false;);
     }
     expect: {
         // 1
@@ -188,6 +193,10 @@ for_sequences: {
         // 4
         x = (foo in bar);
         for (y = 5; false;);
+        // 5
+        for (x = function() {
+            foo in bar;
+        }, y = 5; false;);
     }
 }
 
@@ -734,3 +743,64 @@ reassign_const: {
     }
     expect_stdout: true
 }
+
+issue_2062: {
+    options = {
+        booleans: true,
+        cascade: true,
+        conditionals: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 1;
+        if ([ a || a++ + a--, a++ + a--, a && a.var ]);
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        a || (a++, a--), a++, --a && a.var;
+        console.log(a);
+    }
+    expect_stdout: "1"
+}
+
+issue_2313: {
+    options = {
+        cascade: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 0, b = 0;
+        var foo = {
+            get c() {
+                a++;
+                return 42;
+            },
+            set c(c) {
+                b++;
+            },
+            d: function() {
+                this.c++;
+                if (this.c) console.log(a, b);
+            }
+        }
+        foo.d();
+    }
+    expect: {
+        var a = 0, b = 0;
+        var foo = {
+            get c() {
+                return a++, 42;
+            },
+            set c(c) {
+                b++;
+            },
+            d: function() {
+                if (this.c++, this.c) console.log(a, b);
+            }
+        }
+        foo.d();
+    }
+    expect_stdout: "2 1"
+}

test/compress/unicode.js

@@ -43,15 +43,6 @@ unicode_string_literals: {
     expect_exact: 'var a="6 length unicode character: \\u{101111}";'
 }
 
-// Don't escape identifiers below es6 (or in this case double escaped in expect_exact)
-unicode_output_es5_surrogates: {
-    beautify = {ascii_only: true, ecma: 5}
-    input: {
-        var \u{10000} = "6 length unicode character: \u{10FFFF}";
-    }
-    expect_exact: 'var \u{10000}="6 length unicode character: \\udbff\\udfff";'
-}
-
 check_escape_style: {
     beautify = {ascii_only: true, ecma: 6}
     input: {
@@ -65,20 +56,6 @@ check_escape_style: {
     expect_exact: 'var a="\\x01";var \\ua0081="\\x10";var \\u0100="\\u0100";var \\u1000="\\u1000";var \\u{10000}="\\u{10000}";var \\u{2f800}="\\u{100000}";'
 }
 
-// Don't escape identifiers below es6, no escaped identifiers support and no \u{} syntax
-check_escape_style_es5: {
-    beautify = {ascii_only: true, ecma: 5}
-    input: {
-        var a = "\x01";
-        var \ua0081 = "\x10"; // \u0081 only in ID_Continue
-        var \u0100 = "\u0100";
-        var \u1000 = "\u1000";
-        var \u{10000} = "\u{10000}"; // Identifier won't be escaped in es 5.1
-        var \u{2f800} = "\u{100000}"; // Same
-    }
-    expect_exact: 'var a="\\x01";var \\ua0081="\\x10";var \\u0100="\\u0100";var \\u1000="\\u1000";var \ud800\udc00="\\ud800\\udc00";var \ud87e\udc00="\\udbc0\\udc00";'
-}
-
 ID_continue_with_surrogate_pair: {
     beautify = {ascii_only: true, ecma: 6}
     input: {
@@ -103,18 +80,42 @@ non_escape_2_non_escape: {
     expect_exact: 'var µþ="µþ";'
 }
 
-non_escape_2_half_escape1: {
-    beautify = {ascii_only: false, ascii_identifiers: true, ecma: 6}
-    input: {
-        var µþ = "µþ";
+issue_2242_1: {
+    beautify = {
+        ascii_only: false,
     }
-    expect_exact: 'var \\u00b5\\u00fe="µþ";'
+    input: {
+        console.log("\ud83d", "\ude00", "\ud83d\ude00", "\ud83d@\ude00");
+    }
+    expect_exact: 'console.log("\\ud83d","\\ude00","\ud83d\ude00","\\ud83d@\\ude00");'
 }
 
-non_escape_2_half_escape2: {
-    beautify = {ascii_only: true, ascii_identifiers: false, ecma: 6}
-    input: {
-        var µþ = "µþ";
+issue_2242_2: {
+    beautify = {
+        ascii_only: true,
     }
-    expect_exact: 'var µþ="\\xb5\\xfe";'
-}
+    input: {
+        console.log("\ud83d", "\ude00", "\ud83d\ude00", "\ud83d@\ude00");
+    }
+    expect_exact: 'console.log("\\ud83d","\\ude00","\\ud83d\\ude00","\\ud83d@\\ude00");'
+}
+
+issue_2242_3: {
+    options = {
+        evaluate: false,
+    }
+    input: {
+        console.log("\ud83d" + "\ude00", "\ud83d" + "@" + "\ude00");
+    }
+    expect_exact: 'console.log("\\ud83d"+"\\ude00","\\ud83d"+"@"+"\\ude00");'
+}
+
+issue_2242_4: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log("\ud83d" + "\ude00", "\ud83d" + "@" + "\ude00");
+    }
+    expect_exact: 'console.log("\ud83d\ude00","\\ud83d@\\ude00");'
+}

test/exports.js

@@ -8,6 +8,7 @@ exports["defaults"] = defaults;
 exports["mangle_properties"] = mangle_properties;
 exports["minify"] = minify;
 exports["parse"] = parse;
+exports["reserve_quoted_keys"] = reserve_quoted_keys;
 exports["string_template"] = string_template;
 exports["tokenizer"] = tokenizer;
 exports["is_identifier"] = is_identifier;

test/fetch.js

@@ -0,0 +1,31 @@
+var fs = require("fs");
+var path = require("path");
+
+try {
+    fs.mkdirSync("./tmp");
+} catch (e) {
+    if (e.code != "EEXIST") throw e;
+}
+
+function local(url) {
+    return path.join("./tmp", encodeURIComponent(url));
+}
+
+function read(url) {
+    return fs.createReadStream(local(url));
+}
+
+module.exports = function(url, callback) {
+    var result = read(url);
+    result.on("error", function(e) {
+        if (e.code != "ENOENT") return callback(e);
+        require(url.slice(0, url.indexOf(":"))).get(url, function(res) {
+            if (res.statusCode !== 200) return callback(res);
+            res.pipe(fs.createWriteStream(local(url)).on("close", function() {
+                callback(null, read(url));
+            }));
+        });
+    }).on("open", function() {
+        callback(null, result);
+    });
+};

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/for-in_1.js

@@ -0,0 +1,4 @@
+var a, b = [1, 2];
+for (1, 2, a in b) {
+    console.log(a, b[a]);
+}

test/input/invalid/for-in_2.js

@@ -0,0 +1,4 @@
+var c = [1, 2];
+for (var a, b in c) {
+    console.log(a, c[a]);
+}

test/input/invalid/import.js

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

test/input/invalid/sequence.js

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

test/input/issue-2082/sample.js

@@ -0,0 +1 @@
+console.log(x);

test/input/issue-2082/sample.js.map

@@ -0,0 +1 @@
+{"version": 3,"sources": ["index.js"],"mappings": ";"}

test/input/issue-2310/input.js

@@ -0,0 +1,10 @@
+function foo() {
+    return function() {
+        console.log("PASS");
+    };
+}
+
+(function() {
+    var f = foo();
+    f();
+})();

test/jetstream.js

@@ -3,7 +3,7 @@
 
 "use strict";
 
-var site = "http://browserbench.org/JetStream/";
+var site = "http://browserbench.org/JetStream";
 if (typeof phantom == "undefined") {
     // workaround for tty output truncation upon process.exit()
     [process.stdout, process.stderr].forEach(function(stream){
@@ -11,45 +11,69 @@ if (typeof phantom == "undefined") {
             stream._handle.setBlocking(true);
     });
     var args = process.argv.slice(2);
+    var debug = args.indexOf("--debug");
+    if (debug >= 0) {
+        args.splice(debug, 1);
+        debug = true;
+    } else {
+        debug = false;
+    }
     if (!args.length) {
-        args.push("-mc");
+        args.push("-mcb", "beautify=false,webkit");
     }
     args.push("--timings");
     var child_process = require("child_process");
-    try {
-        require("phantomjs-prebuilt");
-    } catch(e) {
-        child_process.execSync("npm install phantomjs-prebuilt@2.1.14");
-    }
+    var fetch = require("./fetch");
     var http = require("http");
     var server = http.createServer(function(request, response) {
         request.resume();
-        var url = decodeURIComponent(request.url.slice(1));
-        var stderr = "";
-        var uglifyjs = child_process.fork("bin/uglifyjs", args, {
-            silent: true
-        }).on("exit", function(code) {
-            console.log("uglifyjs", url.indexOf(site) == 0 ? url.slice(site.length) : url, args.join(" "));
-            console.log(stderr);
-            if (code) throw new Error("uglifyjs failed with code " + code);
-        });
-        uglifyjs.stderr.on("data", function(data) {
-            stderr += data;
-        }).setEncoding("utf8");
-        uglifyjs.stdout.pipe(response);
-        http.get(url, function(res) {
-            res.pipe(uglifyjs.stdin);
-        });
-    }).listen().on("listening", function() {
-        var phantomjs = require("phantomjs-prebuilt");
-        var program = phantomjs.exec(process.argv[1], server.address().port);
-        program.stdout.pipe(process.stdout);
-        program.stderr.pipe(process.stderr);
-        program.on("exit", function(code) {
-            server.close();
-            if (code) throw new Error("JetStream failed!");
-            console.log("JetStream completed successfully.");
+        var url = site + request.url;
+        fetch(url, function(err, res) {
+            if (err) throw err;
+            response.writeHead(200, {
+                "Content-Type": {
+                    css: "text/css",
+                    js: "application/javascript",
+                    png: "image/png"
+                }[url.slice(url.lastIndexOf(".") + 1)] || "text/html; charset=utf-8"
+            });
+            if (/\.js$/.test(url)) {
+                var stderr = "";
+                var uglifyjs = child_process.fork("bin/uglifyjs", args, {
+                    silent: true
+                }).on("exit", function(code) {
+                    console.log("uglifyjs", url.slice(site.length + 1), args.join(" "));
+                    console.log(stderr);
+                    if (code) throw new Error("uglifyjs failed with code " + code);
+                });
+                uglifyjs.stderr.on("data", function(data) {
+                    stderr += data;
+                }).setEncoding("utf8");
+                uglifyjs.stdout.pipe(response);
+                res.pipe(uglifyjs.stdin);
+            } else {
+                res.pipe(response);
+            }
         });
+    }).listen();
+    server.on("listening", function() {
+        var port = server.address().port;
+        if (debug) {
+            console.log("http://localhost:" + port + "/");
+        } else {
+            child_process.exec("npm install phantomjs-prebuilt@2.1.14 --no-save", function(error) {
+                if (error) throw error;
+                var program = require("phantomjs-prebuilt").exec(process.argv[1], port);
+                program.stdout.pipe(process.stdout);
+                program.stderr.pipe(process.stderr);
+                program.on("exit", function(code) {
+                    server.close();
+                    if (code) throw new Error("JetStream failed!");
+                    console.log("JetStream completed successfully.");
+                    process.exit(0);
+                });
+            });
+        }
     });
     server.timeout = 0;
 } else {
@@ -63,10 +87,6 @@ if (typeof phantom == "undefined") {
         phantom.exit(1);
     };
     var url = "http://localhost:" + require("system").args[1] + "/";
-    page.onResourceRequested = function(requestData, networkRequest) {
-        if (/\.js$/.test(requestData.url))
-            networkRequest.changeUrl(url + encodeURIComponent(requestData.url));
-    }
     page.onConsoleMessage = function(msg) {
         if (/Error:/i.test(msg)) {
             console.error(msg);
@@ -77,8 +97,8 @@ if (typeof phantom == "undefined") {
             phantom.exit();
         }
     };
-    page.open(site, function(status) {
-        if (status != "success") phantomjs.exit(1);
+    page.open(url, function(status) {
+        if (status != "success") phantom.exit(1);
         page.evaluate(function() {
             JetStream.switchToQuick();
             JetStream.start();

test/mocha/arrow.js

@@ -62,23 +62,20 @@ describe("Arrow functions", function() {
         }
     });
     it("Should not accept arrow functions in the middle or end of an expression", function() {
-        var tests = [
+        [
+            "0 + x => 0",
+            "0 + async x => 0",
             "typeof x => 0",
-            "0 + x => 0"
-        ];
-        var test = function(code) {
-            return function() {
+            "typeof async x => 0",
+            "typeof (x) => null",
+            "typeof async (x) => null",
+        ].forEach(function(code) {
+            assert.throws(function() {
                 uglify.parse(code);
-            }
-        }
-        var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                e.message === "Unexpected token: arrow (=>)";
-        }
-
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error);
-        }
+            }, function(e) {
+                return e instanceof uglify.JS_Parse_Error && /^Unexpected /.test(e.message);
+            }, code);
+        });
     });
 
     it("Should parse a function containing default assignment correctly", function() {

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,9 +10,11 @@ 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(15000);
+        this.timeout(60000);
 
-        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) {
             if (err) throw err;
@@ -63,7 +66,7 @@ describe("bin/uglifyjs", function () {
             if (err) throw err;
 
             assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n" +
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DIn0=\n");
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DLElBTEQifQ==\n");
             done();
         });
     });
@@ -77,6 +80,23 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
+    it("should not consider source map file content as source map file name (issue #2082)", function (done) {
+        var command = [
+            uglifyjscmd,
+            "test/input/issue-2082/sample.js",
+            "--source-map", "content=test/input/issue-2082/sample.js.map",
+            "--source-map", "url=inline",
+        ].join(" ");
+
+        exec(command, function (err, stdout, stderr) {
+            if (err) throw err;
+
+            var stderrLines = stderr.split('\n');
+            assert.strictEqual(stderrLines[0], 'INFO: Using input source map: test/input/issue-2082/sample.js.map');
+            assert.notStrictEqual(stderrLines[1], 'INFO: Using input source map: {"version": 3,"sources": ["index.js"],"mappings": ";"}');
+            done();
+        });
+    });
     it("Should work with --keep-fnames (mangle only)", function (done) {
         var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m';
 
@@ -175,7 +195,7 @@ describe("bin/uglifyjs", function () {
 
             assert.strictEqual(stdout, [
                 "var bar=function(){function foo(bar){return bar}return foo}();",
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DIn0=",
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DLElBTEQifQ==",
                 "",
             ].join("\n"));
             assert.strictEqual(stderr, "WARN: inline source map not found\n");
@@ -516,6 +536,111 @@ 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';
+
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/for-in_1.js:2,5",
+                "for (1, 2, a in b) {",
+                "     ^",
+                "ERROR: Invalid left-hand side in for..in loop"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (for-in var)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/for-in_2.js';
+
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/for-in_2.js:2,5",
+                "for (var a, b in c) {",
+                "     ^",
+                "ERROR: Only one variable declaration allowed in for..in loop"
+            ].join("\n"));
+            done();
+        });
+    });
     it("Should handle literal string as source map input", function(done) {
         var command = [
             uglifyjscmd,
@@ -541,6 +666,25 @@ describe("bin/uglifyjs", function () {
             return JSON.stringify(map).replace(/"/g, '\\"');
         }
     });
+    it("Should include function calls in source map", function(done) {
+        var command = [
+            uglifyjscmd,
+            "test/input/issue-2310/input.js",
+            "-c",
+            "--source-map", "url=inline",
+        ].join(" ");
+
+        exec(command, function(err, stdout, stderr) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, [
+                'function foo(){return function(){console.log("PASS")}}foo()();',
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMjMxMC9pbnB1dC5qcyJdLCJuYW1lcyI6WyJmb28iLCJjb25zb2xlIiwibG9nIiwiZiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsTUFDTCxPQUFPLFdBQ0hDLFFBQVFDLElBQUksU0FLUkYsS0FDUkcifQ==",
+                ""
+            ].join("\n"));
+            done();
+        });
+    });
     it("Should dump AST as JSON", function(done) {
         var command = uglifyjscmd + " test/input/global_defs/simple.js -mco ast";
         exec(command, function (err, stdout) {
@@ -557,7 +701,45 @@ describe("bin/uglifyjs", function () {
         exec(command, function (err, stdout, stderr) {
             assert.ok(err);
             assert.strictEqual(stdout, "");
-            assert.ok(/^Supported options:\n\{[^}]+}\nERROR: `ascii-only` is not a supported option/.test(stderr), stderr);
+            assert.ok(/^Supported options:\n[\s\S]*?\nERROR: `ascii-only` is not a supported option/.test(stderr), stderr);
+            done();
+        });
+    });
+    it("Should work with --mangle reserved=[]", function(done) {
+        var command = uglifyjscmd + " test/input/issue-505/input.js -m reserved=[callback]";
+
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, 'function test(callback){"aaaaaaaaaaaaaaaa";callback(err,data);callback(err,data)}\n');
+            done();
+        });
+    });
+    it("Should work with --mangle reserved=false", function(done) {
+        var command = uglifyjscmd + " test/input/issue-505/input.js -m reserved=false";
+
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            assert.strictEqual(stdout, 'function test(a){"aaaaaaaaaaaaaaaa";a(err,data);a(err,data)}\n');
+            done();
+        });
+    });
+    it("Should fail with --mangle-props reserved=[in]", function(done) {
+        var command = uglifyjscmd + " test/input/issue-505/input.js --mangle-props reserved=[in]";
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.ok(/^Supported options:\n[\s\S]*?\nERROR: `reserved=\[in]` is not a supported option/.test(stderr), stderr);
+            done();
+        });
+    });
+    it("Should fail with --define a-b", function(done) {
+        var command = uglifyjscmd + " test/input/issue-505/input.js --define a-b";
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr, "Error parsing arguments for 'define': a-b\n");
             done();
         });
     });

test/mocha/export.js

@@ -1,9 +1,8 @@
 var assert = require("assert");
 var uglify = require("../node");
 
-describe("Export", function() {
-    it ("Should parse export directives", function() {
-
+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"],
@@ -12,17 +11,17 @@ describe("Export", function() {
             ['export {A, B} from "a.js"', ['A', 'B'], "a.js"],
         ];
 
-        var test = function(code) {
+        function test(code) {
             return uglify.parse(code);
-        };
+        }
 
-        var extractNames = function(symbols) {
+        function extractNames(symbols) {
             var ret = [];
             for (var i = 0; i < symbols.length; i++) {
-                ret.push(symbols[i].name.name)
+                ret.push(symbols[i].foreign_name.name);
             }
             return ret;
-        };
+        }
 
         for (var i = 0; i < inputs.length; i++) {
             var ast = test(inputs[i][0]);
@@ -34,7 +33,25 @@ describe("Export", function() {
             assert(st instanceof uglify.AST_Export);
             var actualNames = extractNames(st.exported_names);
             assert.deepEqual(actualNames, names);
-            assert.equal(st.module_name.value, filename)
+            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/function.js

@@ -191,15 +191,51 @@ describe("Function", function() {
         ];
         var test = function(code) {
             return function() {
-                uglify.parse(code);
+                uglify.parse(code, { ecma: 5 });
             }
         }
         var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                e.message === "Invalid function parameter";
+            return e instanceof uglify.JS_Parse_Error;
         }
         for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error);
+            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() {

test/mocha/glob.js

@@ -26,12 +26,12 @@ describe("bin/uglifyjs with input file globs", function() {
         });
     });
     it("bin/uglifyjs with multiple input file globs.", function(done) {
-        var command = uglifyjscmd + ' "test/input/issue-1242/???.es5" "test/input/issue-1242/*.js" -mc toplevel';
+        var command = uglifyjscmd + ' "test/input/issue-1242/???.es5" "test/input/issue-1242/*.js" -mc toplevel,passes=2';
 
         exec(command, function(err, stdout) {
             if (err) throw err;
 
-            assert.strictEqual(stdout, 'var print=console.log.bind(console),a=function(n){return 3*n}(3),b=function(n){return n/2}(12);print("qux",a,b),function(n){print("Foo:",2*n)}(11);\n');
+            assert.strictEqual(stdout, 'var print=console.log.bind(console);print("qux",9,6),print("Foo:",22);\n');
             done();
         });
     });

test/mocha/let.js

@@ -2,29 +2,56 @@ var Uglify = require('../../');
 var assert = require("assert");
 
 describe("let", function() {
-    it("Should not produce `let` as a variable name in mangle", function(done) {
-        this.timeout(10000);
-
+    this.timeout(30000);
+    it("Should not produce reserved keywords as variable name in mangle", function() {
         // Produce a lot of variables in a function and run it through mangle.
-        var s = '"use strict"; function foo() {';
-        for (var i = 0; i < 21000; ++i) {
+        var s = '"dddddeeeeelllllooooottttt"; function foo() {';
+        for (var i = 0; i < 18000; i++) {
             s += "var v" + i + "=0;";
         }
         s += '}';
-        var result = Uglify.minify(s, {compress: false});
+        var result = Uglify.minify(s, {
+            compress: false
+        }).code;
 
         // Verify that select keywords and reserved keywords not produced
-        assert.strictEqual(result.code.indexOf("var let="), -1);
-        assert.strictEqual(result.code.indexOf("var do="), -1);
-        assert.strictEqual(result.code.indexOf("var var="), -1);
+        [
+            "do",
+            "let",
+            "var",
+        ].forEach(function(name) {
+            assert.strictEqual(result.indexOf("var " + name + "="), -1);
+        });
 
         // Verify that the variable names that appeared immediately before
-        // and after the erroneously generated `let` variable name still exist
+        // and after the erroneously generated variable name still exist
         // to show the test generated enough symbols.
-        assert(result.code.indexOf("var ket=") >= 0);
-        assert(result.code.indexOf("var met=") >= 0);
-
-        done();
+        [
+            "to", "eo",
+            "eet", "fet",
+            "rar", "oar",
+        ].forEach(function(name) {
+            assert.notStrictEqual(result.indexOf("var " + name + "="), -1);
+        });
+    });
+    it("Should quote mangled properties that are reserved keywords", function() {
+        var s = '"rrrrrnnnnniiiiiaaaaa";';
+        for (var i = 0; i < 18000; i++) {
+            s += "v.b" + i + ";";
+        }
+        var result = Uglify.minify(s, {
+            compress: false,
+            ie8: true,
+            mangle: {
+                properties: true,
+            }
+        }).code;
+        [
+            "in",
+            "var",
+        ].forEach(function(name) {
+            assert.notStrictEqual(result.indexOf(name), -1);
+            assert.notStrictEqual(result.indexOf('v["' + name + '"]'), -1);
+        });
     });
 });
-

test/mocha/lhs-expressions.js

@@ -253,13 +253,19 @@ describe("Left-hand side expressions", function () {
         // Multiple spreads are not allowed in destructuring array
         expect("[...a, ...b] = [1, 2, 3, 4]", "Spread must the be last element in destructuring array");
 
-        // Spread in obvious object pattern
-        expect("({...a} = foo)", "Unexpected token: expand (...)");
+        // Array spread must be last in destructuring declaration
+        expect("let [ ...x, a ] = o;", "Rest element must be last element");
+
+        // Only one spread per destructuring array declaration
+        expect("let [ a, ...x, ...y ] = o;", "Rest element must be last element");
 
         // Spread in block should not be allowed
         expect("{...a} = foo", "Unexpected token: expand (...)");
 
-        // Not in standard yet
-        expect("let foo = {bar: 42}, bar; bar = {...foo}", "Unexpected token: expand (...)");
+        // Object spread must be last in destructuring declaration
+        expect("let { ...x, a } = o;", "Rest element must be last element");
+
+        // Only one spread per destructuring declaration
+        expect("let { a, ...x, ...y } = o;", "Rest element must be last element");
     });
 });

test/mocha/minify.js

@@ -1,6 +1,7 @@
 var Uglify = require('../../');
 var assert = require("assert");
 var readFileSync = require("fs").readFileSync;
+var run_code = require("../sandbox").run_code;
 
 function read(path) {
     return readFileSync(path, "utf8");
@@ -13,6 +14,72 @@ describe("minify", function() {
         assert.strictEqual(result.code, 'function foo(n){return n?3:7}');
     });
 
+    it("Should skip inherited keys from `files`", function() {
+        var files = Object.create({ skip: this });
+        files[0] = "alert(1 + 1)";
+        var result = Uglify.minify(files);
+        assert.strictEqual(result.code, "alert(2);");
+    });
+
+    it("Should work with mangle.cache", function() {
+        var cache = {};
+        var original = "";
+        var compressed = "";
+        [
+            "bar.es5",
+            "baz.es5",
+            "foo.es5",
+            "qux.js",
+        ].forEach(function(file) {
+            var code = read("test/input/issue-1242/" + file);
+            var result = Uglify.minify(code, {
+                mangle: {
+                    cache: cache,
+                    toplevel: true
+                }
+            });
+            if (result.error) throw result.error;
+            original += code;
+            compressed += result.code;
+        });
+        assert.strictEqual(JSON.stringify(cache).slice(0, 20), '{"cname":5,"props":{');
+        assert.strictEqual(compressed, 'function n(n){return 3*n}function r(n){return n/2}function c(o){l("Foo:",2*o)}var l=console.log.bind(console);var f=n(3),i=r(12);l("qux",f,i),c(11);');
+        assert.strictEqual(run_code(compressed), run_code(original));
+    });
+
+    it("Should work with nameCache", function() {
+        var cache = {};
+        var original = "";
+        var compressed = "";
+        [
+            "bar.es5",
+            "baz.es5",
+            "foo.es5",
+            "qux.js",
+        ].forEach(function(file) {
+            var code = read("test/input/issue-1242/" + file);
+            var result = Uglify.minify(code, {
+                mangle: {
+                    toplevel: true
+                },
+                nameCache: cache
+            });
+            if (result.error) throw result.error;
+            original += code;
+            compressed += result.code;
+        });
+        assert.strictEqual(JSON.stringify(cache).slice(0, 28), '{"vars":{"cname":5,"props":{');
+        assert.strictEqual(compressed, 'function n(n){return 3*n}function r(n){return n/2}function c(o){l("Foo:",2*o)}var l=console.log.bind(console);var f=n(3),i=r(12);l("qux",f,i),c(11);');
+        assert.strictEqual(run_code(compressed), run_code(original));
+    });
+
+    it("should not parse invalid use of reserved words", function() {
+        assert.strictEqual(Uglify.minify("function enum(){}").error, undefined);
+        assert.strictEqual(Uglify.minify("function static(){}").error, undefined);
+        assert.strictEqual(Uglify.minify("function super(){}").error.message, "Unexpected token: name (super)");
+        assert.strictEqual(Uglify.minify("function this(){}").error.message, "Unexpected token: name (this)");
+    });
+
     describe("keep_quoted_props", function() {
         it("Should preserve quotes in object literals", function() {
             var js = 'var foo = {"x": 1, y: 2, \'z\': 3};';
@@ -64,6 +131,17 @@ describe("minify", function() {
             assert.strictEqual(result.code,
                     'a["foo"]="bar",a.a="red",x={"bar":10};');
         });
+        it("Should not mangle quoted property within dead code", function() {
+            var result = Uglify.minify('({ "keep": 1 }); g.keep = g.change;', {
+                mangle: {
+                    properties: {
+                        keep_quoted: true
+                    }
+                }
+            });
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, "g.keep=g.g;");
+        });
     });
 
     describe("inSourceMap", function() {
@@ -106,7 +184,7 @@ describe("minify", function() {
                         content: "inline"
                     }
                 });
-                assert.strictEqual(result.code, "var bar=function(){function foo(bar){return bar}return foo}();");
+                assert.strictEqual(result.code, "var bar=function(){return function(bar){return bar}}();");
                 assert.strictEqual(warnings.length, 1);
                 assert.strictEqual(warnings[0], "inline source map not found");
             } finally {
@@ -205,7 +283,49 @@ describe("minify", function() {
             });
             var err = result.error;
             assert.ok(err instanceof Error);
-            assert.strictEqual(err.stack.split(/\n/)[0], "Error: Can't handle expression: debugger");
+            assert.strictEqual(err.stack.split(/\n/)[0], "SyntaxError: Unexpected token: keyword (debugger)");
+        });
+        it("should skip inherited properties", function() {
+            var foo = Object.create({ skip: this });
+            foo.bar = 42;
+            var result = Uglify.minify("alert(FOO);", {
+                compress: {
+                    global_defs: {
+                        FOO: foo
+                    }
+                }
+            });
+            assert.strictEqual(result.code, "alert({bar:42});");
+        });
+    });
+
+    describe("duplicated block-scoped declarations", function() {
+        [
+            "let a=1;let a=2;",
+            "let a=1;var a=2;",
+            "var a=1;let a=2;",
+            "let[a]=[1];var a=2;",
+            "let a=1;var[a]=[2];",
+            "let[a]=[1];var[a]=[2];",
+            "const a=1;const a=2;",
+            "const a=1;var a=2;",
+            "var a=1;const a=2;",
+            "const[a]=[1];var a=2;",
+            "const a=1;var[a]=[2];",
+            "const[a]=[1];var[a]=[2];",
+        ].forEach(function(code) {
+            it(code, function() {
+                var result = Uglify.minify(code, {
+                    compress: false,
+                    mangle: false
+                });
+                assert.strictEqual(result.error, undefined);
+                assert.strictEqual(result.code, code);
+                result = Uglify.minify(code);
+                var err = result.error;
+                assert.ok(err instanceof Error);
+                assert.strictEqual(err.stack.split(/\n/)[0], "SyntaxError: a redeclared");
+            });
         });
     });
 });

test/mocha/object.js

@@ -4,7 +4,11 @@ var assert = require("assert");
 describe("Object", function() {
     it("Should allow objects to have a methodDefinition as property", function() {
         var code = "var a = {test() {return true;}}";
-        assert.equal(Uglify.minify(code).code, "var a={test(){return!0}};");
+        assert.equal(Uglify.minify(code, {
+            compress: {
+                arrows: false
+            }
+        }).code, "var a={test(){return!0}};");
     });
 
     it("Should not allow objects to use static keywords like in classes", function() {

test/mocha/release.js

@@ -1,23 +1,20 @@
 var assert = require("assert");
+var semver = require("semver");
 var spawn = require("child_process").spawn;
 
 if (!process.env.UGLIFYJS_TEST_ALL) return;
 
 function run(command, args, done) {
-    var id = setInterval(function() {
-        process.stdout.write("\0");
-    }, 5 * 60 * 1000);
     spawn(command, args, {
-        stdio: "ignore"
+        stdio: [ "ignore", 1, 2 ]
     }).on("exit", function(code) {
-        clearInterval(id);
         assert.strictEqual(code, 0);
         done();
     });
 }
 
 describe("test/benchmark.js", function() {
-    this.timeout(5 * 60 * 1000);
+    this.timeout(10 * 60 * 1000);
     [
         "-b",
         "-b bracketize",
@@ -36,11 +33,9 @@ describe("test/benchmark.js", function() {
     });
 });
 
+if (semver.satisfies(process.version, "0.12")) return;
 describe("test/jetstream.js", function() {
     this.timeout(20 * 60 * 1000);
-    it("Should install phantomjs-prebuilt", function(done) {
-        run("npm", ["install", "phantomjs-prebuilt@2.1.14"], done);
-    });
     [
         "-mc",
         "-mc keep_fargs=false,passes=3,pure_getters,unsafe,unsafe_comps,unsafe_math,unsafe_proto",
@@ -48,6 +43,7 @@ describe("test/jetstream.js", function() {
         it("Should pass with options " + options, function(done) {
             var args = options.split(/ /);
             args.unshift("test/jetstream.js");
+            args.push("-b", "beautify=false,webkit");
             run(process.argv[0], args, done);
         });
     });

test/mocha/spidermonkey.js

@@ -4,7 +4,7 @@ var uglify = require("../node");
 
 describe("spidermonkey export/import sanity test", function() {
     it("should produce a functional build when using --self with spidermonkey", function(done) {
-        this.timeout(30000);
+        this.timeout(60000);
 
         var uglifyjs = '"' + process.argv[0] + '" bin/uglifyjs';
         var command = uglifyjs + " --self -cm --wrap SpiderUglify -o spidermonkey | " +

test/mocha/string-literal.js

@@ -61,9 +61,9 @@ describe("String literals", function() {
         var tests = [
             ['"\\76";', ';">";'],
             ['"\\0"', '"\\0";'],
-            ['"\\08"', '"\\08";'],
-            ['"\\008"', '"\\08";'],
-            ['"\\0008"', '"\\08";'],
+            ['"\\08"', '"\\x008";'],
+            ['"\\008"', '"\\x008";'],
+            ['"\\0008"', '"\\x008";'],
             ['"use strict" === "use strict";\n"\\76";', '"use strict"==="use strict";">";'],
             ['"use\\\n strict";\n"\\07";', ';"use strict";"\07";']
         ];
@@ -75,7 +75,44 @@ describe("String literals", function() {
     });
 
     it("Should not throw error when digit is 8 or 9", function() {
-        assert.equal(UglifyJS.parse('"use strict";"\\08"').print_to_string(), '"use strict";"\\08";');
-        assert.equal(UglifyJS.parse('"use strict";"\\09"').print_to_string(), '"use strict";"\\09";');
+        assert.equal(UglifyJS.parse('"use strict";"\\08"').print_to_string(), '"use strict";"\\x008";');
+        assert.equal(UglifyJS.parse('"use strict";"\\09"').print_to_string(), '"use strict";"\\x009";');
+    });
+
+    it("Should not unescape unpaired surrogates", function() {
+        var code = [];
+        for (var i = 0; i <= 0xF; i++) {
+            code.push("\\u000" + i.toString(16));
+        }
+        for (;i <= 0xFF; i++) {
+            code.push("\\u00" + i.toString(16));
+        }
+        for (;i <= 0xFFF; i++) {
+            code.push("\\u0" + i.toString(16));
+        }
+        for (; i <= 0xFFFF; i++) {
+            code.push("\\u" + i.toString(16));
+        }
+        code = '"' + code.join() + '"';
+        var normal = UglifyJS.minify(code, {
+            compress: false,
+            mangle: false,
+            output: {
+                ascii_only: false
+            }
+        });
+        if (normal.error) throw normal.error;
+        assert.ok(code.length > normal.code.length);
+        assert.strictEqual(eval(code), eval(normal.code));
+        var ascii = UglifyJS.minify(code, {
+            compress: false,
+            mangle: false,
+            output: {
+                ascii_only: false
+            }
+        });
+        if (ascii.error) throw ascii.error;
+        assert.ok(code.length > ascii.code.length);
+        assert.strictEqual(eval(code), eval(ascii.code));
     });
 });

test/mocha/template-string.js

@@ -30,4 +30,13 @@ describe("Template string", function() {
             assert.throws(exec(tests[i]), fail, tests[i]);
         }
     });
+    it("Should process all line terminators as LF", function() {
+        [
+            "`a\rb`",
+            "`a\nb`",
+            "`a\r\nb`",
+        ].forEach(function(code) {
+            assert.strictEqual(uglify.parse(code).print_to_string(), "`a\\nb`;");
+        });
+    });
 });

test/mocha/unicode.js

@@ -1,4 +1,5 @@
 var assert = require("assert");
+var semver = require("semver");
 var uglify = require("../node");
 
 describe("Unicode", function() {
@@ -138,8 +139,34 @@ describe("Unicode", function() {
 
     it("Should parse raw characters correctly", function() {
         var ast = uglify.parse('console.log("\\udbff");');
-        assert.strictEqual(ast.print_to_string(), 'console.log("\udbff");');
+        assert.strictEqual(ast.print_to_string(), 'console.log("\\udbff");');
         ast = uglify.parse(ast.print_to_string());
-        assert.strictEqual(ast.print_to_string(), 'console.log("\udbff");');
+        assert.strictEqual(ast.print_to_string(), 'console.log("\\udbff");');
     });
+
+    if (semver.satisfies(process.version, ">=4")) {
+        it("Should not unescape unpaired surrogates", function() {
+            this.timeout(5000);
+            var code = [];
+            for (var i = 0; i <= 0x20001; i++) {
+                code.push("\\u{" + i.toString(16) + "}");
+            }
+            code = '"' + code.join() + '"';
+            [true, false].forEach(function(ascii_only) {
+                [5, 6].forEach(function(ecma) {
+                    var result = uglify.minify(code, {
+                        compress: false,
+                        mangle: false,
+                        output: {
+                            ascii_only: ascii_only
+                        },
+                        ecma: ecma
+                    });
+                    if (result.error) throw result.error;
+                    if (ecma > 5) assert.ok(code.length > result.code.length);
+                    assert.strictEqual(eval(code), eval(result.code));
+                });
+            });
+        });
+    }
 });

test/mocha/yield.js

@@ -102,4 +102,15 @@ describe("Yield", function() {
             assert.throws(test(tests[i]), fail, tests[i]);
         }
     });
+
+    it("Should allow yield to be used as class/object property name", function() {
+        var input = [
+            '"use strict";',
+            "({yield:42});",
+            "({yield(){}});",
+            "(class{yield(){}});",
+            "class C{yield(){}}",
+        ].join("");
+        assert.strictEqual(UglifyJS.minify(input, { compress: false }).code, input);
+    });
 });

test/run-tests.js

@@ -86,7 +86,6 @@ function run_compress_tests() {
         log_start_file(file);
         function test_case(test) {
             log_test(test.name);
-            U.base54.reset();
             var output_options = test.beautify || {};
             var expect;
             if (test.expect) {
@@ -101,9 +100,6 @@ function run_compress_tests() {
                 quote_style: 3,
                 keep_quoted_props: true
             });
-            if (test.mangle_props) {
-                input = U.mangle_properties(input, test.mangle_props);
-            }
             var options = U.defaults(test.options, {
                 warnings: false
             });
@@ -115,12 +111,22 @@ function run_compress_tests() {
                 };
                 if (!options.warnings) options.warnings = true;
             }
+            if (test.mangle && test.mangle.properties && test.mangle.properties.keep_quoted) {
+                var quoted_props = test.mangle.properties.reserved;
+                if (!Array.isArray(quoted_props)) quoted_props = [];
+                test.mangle.properties.reserved = quoted_props;
+                U.reserve_quoted_keys(input, quoted_props);
+            }
             var cmp = new U.Compressor(options, true);
             var output = cmp.compress(input);
             output.figure_out_scope(test.mangle);
             if (test.mangle) {
+                U.base54.reset();
                 output.compute_char_frequency(test.mangle);
                 output.mangle_names(test.mangle);
+                if (test.mangle.properties) {
+                    output = U.mangle_properties(output, test.mangle.properties);
+                }
             }
             output = make_code(output, output_options);
             if (expect != output) {
@@ -294,8 +300,22 @@ function parse_test(file) {
                 if (label.name == "expect_exact" || label.name == "node_version") {
                     test[label.name] = read_string(stat);
                 } else if (label.name == "expect_stdout") {
-                    if (stat.TYPE == "SimpleStatement" && stat.body instanceof U.AST_Boolean) {
-                        test[label.name] = stat.body.value;
+                    var body = stat.body;
+                    if (body instanceof U.AST_Boolean) {
+                        test[label.name] = body.value;
+                    } else if (body instanceof U.AST_Call) {
+                        var ctor = global[body.expression.name];
+                        assert.ok(ctor === Error || ctor.prototype instanceof Error, tmpl("Unsupported expect_stdout format [{line},{col}]", {
+                            line: label.start.line,
+                            col: label.start.col
+                        }));
+                        test[label.name] = ctor.apply(null, body.args.map(function(node) {
+                            assert.ok(node instanceof U.AST_Constant, tmpl("Unsupported expect_stdout format [{line},{col}]", {
+                                line: label.start.line,
+                                col: label.start.col
+                            }));
+                            return node.value;
+                        }));
                     } else {
                         test[label.name] = read_string(stat) + "\n";
                     }

test/sandbox.js

@@ -19,23 +19,25 @@ function safe_log(arg, level) {
 
 var FUNC_TOSTRING = [
     "Function.prototype.toString = Function.prototype.valueOf = function() {",
-    "    var id = 0;",
+    "    var id = 100000;",
     "    return function() {",
     '        if (this === Array) return "[Function: Array]";',
     '        if (this === Object) return "[Function: Object]";',
     "        var i = this.name;",
     '        if (typeof i != "number") {',
     "            i = ++id;",
+].concat(Object.getOwnPropertyDescriptor(Function.prototype, "name").configurable ? [
     '            Object.defineProperty(this, "name", {',
     "                get: function() {",
     "                    return i;",
     "                }",
     "            });",
+] : [], [
     "        }",
     '        return "[Function: " + i + "]";',
     "    }",
     "}();",
-].join("\n");
+]).join("\n");
 exports.run_code = function(code) {
     var stdout = "";
     var original_write = process.stdout.write;
@@ -50,7 +52,10 @@ exports.run_code = function(code) {
             "}();",
         ].join("\n"), {
             console: {
-                log: function() {
+                log: function(msg) {
+                    if (arguments.length == 1 && typeof msg == "string") {
+                        return console.log("%s", msg);
+                    }
                     return console.log.apply(console, [].map.call(arguments, function(arg) {
                         return safe_log(arg, 3);
                     }));

test/ufuzz.js

@@ -102,23 +102,23 @@ for (var i = 2; i < process.argv.length; ++i) {
       case '--help':
       case '-h':
       case '-?':
-        console.log('** UglifyJS fuzzer help **');
-        console.log('Valid options (optional):');
-        console.log('<number>: generate this many cases (if used must be first arg)');
-        console.log('-v: print every generated test case');
-        console.log('-V: print every 100th generated test case');
-        console.log('-t <int>: generate this many toplevels per run (more take longer)');
-        console.log('-r <int>: maximum recursion depth for generator (higher takes longer)');
-        console.log('-s1 <statement name>: force the first level statement to be this one (see list below)');
-        console.log('-s2 <statement name>: force the second level statement to be this one (see list below)');
-        console.log('--no-catch-redef: do not redefine catch variables');
-        console.log('--no-directive: do not generate directives');
-        console.log('--use-strict: generate "use strict"');
-        console.log('--stmt-depth-from-func: reset statement depth counter at each function, counts from global otherwise');
-        console.log('--only-stmt <statement names>: a comma delimited white list of statements that may be generated');
-        console.log('--without-stmt <statement names>: a comma delimited black list of statements never to generate');
-        console.log('List of accepted statement names: ' + Object.keys(STMT_ARG_TO_ID));
-        console.log('** UglifyJS fuzzer exiting **');
+        println('** UglifyJS fuzzer help **');
+        println('Valid options (optional):');
+        println('<number>: generate this many cases (if used must be first arg)');
+        println('-v: print every generated test case');
+        println('-V: print every 100th generated test case');
+        println('-t <int>: generate this many toplevels per run (more take longer)');
+        println('-r <int>: maximum recursion depth for generator (higher takes longer)');
+        println('-s1 <statement name>: force the first level statement to be this one (see list below)');
+        println('-s2 <statement name>: force the second level statement to be this one (see list below)');
+        println('--no-catch-redef: do not redefine catch variables');
+        println('--no-directive: do not generate directives');
+        println('--use-strict: generate "use strict"');
+        println('--stmt-depth-from-func: reset statement depth counter at each function, counts from global otherwise');
+        println('--only-stmt <statement names>: a comma delimited white list of statements that may be generated');
+        println('--without-stmt <statement names>: a comma delimited black list of statements never to generate');
+        println('List of accepted statement names: ' + Object.keys(STMT_ARG_TO_ID));
+        println('** UglifyJS fuzzer exiting **');
         return 0;
       default:
         // first arg may be a number.
@@ -941,7 +941,17 @@ if (require.main !== module) {
     return;
 }
 
-function try_beautify(code, result) {
+function println(msg) {
+    if (typeof msg != "undefined") process.stdout.write(msg);
+    process.stdout.write("\n");
+}
+
+function errorln(msg) {
+    if (typeof msg != "undefined") process.stderr.write(msg);
+    process.stderr.write("\n");
+}
+
+function try_beautify(code, result, printfn) {
     var beautified = UglifyJS.minify(code, {
         compress: false,
         mangle: false,
@@ -951,15 +961,15 @@ function try_beautify(code, result) {
         },
     });
     if (beautified.error) {
-        console.log("// !!! beautify failed !!!");
-        console.log(beautified.error.stack);
+        printfn("// !!! beautify failed !!!");
+        printfn(beautified.error.stack);
     } else if (sandbox.same_stdout(sandbox.run_code(beautified.code), result)) {
-        console.log("// (beautified)");
-        console.log(beautified.code);
+        printfn("// (beautified)");
+        printfn(beautified.code);
         return;
     }
-    console.log("//");
-    console.log(code);
+    printfn("//");
+    printfn(code);
 }
 
 var default_options = UglifyJS.default_options();
@@ -977,8 +987,8 @@ function log_suspects(minify_options, component) {
             m[component] = o;
             var result = UglifyJS.minify(original_code, m);
             if (result.error) {
-                console.log("Error testing options." + component + "." + name);
-                console.log(result.error);
+                errorln("Error testing options." + component + "." + name);
+                errorln(result.error.stack);
             } else {
                 var r = sandbox.run_code(result.code);
                 return sandbox.same_stdout(original_result, r);
@@ -986,49 +996,49 @@ function log_suspects(minify_options, component) {
         }
     });
     if (suspects.length > 0) {
-        console.log("Suspicious", component, "options:");
+        errorln("Suspicious " + component + " options:");
         suspects.forEach(function(name) {
-            console.log("  " + name);
+            errorln("  " + name);
         });
-        console.log();
+        errorln();
     }
 }
 
 function log(options) {
-    if (!ok) console.log('\n\n\n\n\n\n!!!!!!!!!!\n\n\n');
-    console.log("//=============================================================");
-    if (!ok) console.log("// !!!!!! Failed... round", round);
-    console.log("// original code");
-    try_beautify(original_code, original_result);
-    console.log();
-    console.log();
-    console.log("//-------------------------------------------------------------");
+    if (!ok) errorln('\n\n\n\n\n\n!!!!!!!!!!\n\n\n');
+    errorln("//=============================================================");
+    if (!ok) errorln("// !!!!!! Failed... round " + round);
+    errorln("// original code");
+    try_beautify(original_code, original_result, errorln);
+    errorln();
+    errorln();
+    errorln("//-------------------------------------------------------------");
     if (typeof uglify_code == "string") {
-        console.log("// uglified code");
-        try_beautify(uglify_code, uglify_result);
-        console.log();
-        console.log();
-        console.log("original result:");
-        console.log(original_result);
-        console.log("uglified result:");
-        console.log(uglify_result);
+        errorln("// uglified code");
+        try_beautify(uglify_code, uglify_result, errorln);
+        errorln();
+        errorln();
+        errorln("original result:");
+        errorln(typeof original_result == "string" ? original_result : original_result.stack);
+        errorln("uglified result:");
+        errorln(typeof uglify_result == "string" ? uglify_result : uglify_result.stack);
     } else {
-        console.log("// !!! uglify failed !!!");
-        console.log(uglify_code.stack);
+        errorln("// !!! uglify failed !!!");
+        errorln(uglify_code.stack);
         if (typeof original_result != "string") {
-            console.log();
-            console.log();
-            console.log("original stacktrace:");
-            console.log(original_result.stack);
+            errorln();
+            errorln();
+            errorln("original stacktrace:");
+            errorln(original_result.stack);
         }
     }
-    console.log("minify(options):");
+    errorln("minify(options):");
     options = JSON.parse(options);
-    console.log(options);
-    console.log();
+    errorln(JSON.stringify(options, null, 2));
+    errorln();
     if (!ok && typeof uglify_code == "string") {
         Object.keys(default_options).forEach(log_suspects.bind(null, options));
-        console.log("!!!!!! Failed... round", round);
+        errorln("!!!!!! Failed... round " + round);
     }
 }
 
@@ -1058,19 +1068,19 @@ for (var round = 1; round <= num_iterations; round++) {
         }
         if (verbose || (verbose_interval && !(round % INTERVAL_COUNT)) || !ok) log(options);
         else if (typeof original_result != "string") {
-            console.log("//=============================================================");
-            console.log("// original code");
-            try_beautify(original_code, original_result);
-            console.log();
-            console.log();
-            console.log("original result:");
-            console.log(original_result);
-            console.log();
+            println("//=============================================================");
+            println("// original code");
+            try_beautify(original_code, original_result, println);
+            println();
+            println();
+            println("original result:");
+            println(original_result.stack);
+            println();
         }
         if (!ok && isFinite(num_iterations)) {
-            console.log();
+            println();
             process.exit(1);
         }
     });
 }
-console.log();
+println();