fix if_return on block-scoped variables (#2021 )

fixes #1317
Merge pull request #2020 from alexlamsl/harmony-v3.0.13
2017-05-29 18:08:08 +08:00 · 2017-05-29 12:24:38 +08:00 · 2017-05-29 10:58:05 +08:00 · 2017-05-29 10:52:13 +08:00 · 2017-05-29 10:51:41 +08:00 · 2017-05-28 22:57:20 +08:00
38 changed files with 1889 additions and 532 deletions
--- a/README.md
+++ b/README.md
@@ -1,6 +1,5 @@
 uglify-es
 =========
-[![Build Status](https://travis-ci.org/mishoo/UglifyJS2.svg)](https://travis-ci.org/mishoo/UglifyJS2)

 **uglify-es** is an ECMAScript 2015 parser, minifier, compressor and beautifier toolkit.

@@ -43,6 +42,7 @@ a double dash to prevent input files being used as option arguments:

 ```
    -h, --help                  Print usage information.
+                                `--help options` for details on available options.
    -V, --version               Print version number.
    -p, --parse <options>       Specify parser options:
                                `acorn`  Use Acorn for parsing.
@@ -124,8 +124,8 @@ a double dash to prevent input files being used as option arguments:
                                        the source map.
                                `url`  If specified, path to the source map to append in
                                       `//# sourceMappingURL`.
-    --stats                     Display operations run time on STDERR.
-    --toplevel                  Compress and/or mangle variables in toplevel scope.
+    --timings                   Display operations run time on STDERR.
+    --toplevel                  Compress and/or mangle variables in top level scope.
    --verbose                   Print diagnostic messages.
    --warn                      Print warning messages.
    --wrap <name>               Embed everything in a big function, making the
@@ -200,7 +200,7 @@ Example:
 To enable the mangler you need to pass `--mangle` (`-m`).  The following
 (comma-separated) options are supported:

- `toplevel` — mangle names declared in the toplevel scope (disabled by
+- `toplevel` — mangle names declared in the top level scope (disabled by
  default).

 - `eval` — mangle names visible in scopes where `eval` or `with` are used
@@ -216,24 +216,54 @@ to prevent the `require`, `exports` and `$` names from being changed.

 ### CLI mangling property names (`--mangle-props`)

-**Note:** this will probably break your code.  Mangling property names is a
-separate step, different from variable name mangling.  Pass
-`--mangle-props`.  It will mangle all properties that are seen in some
-object literal, or that are assigned to.  For example:
+**Note:** THIS WILL PROBABLY BREAK YOUR CODE.  Mangling property names
+is a separate step, different from variable name mangling.  Pass
+`--mangle-props` to enable it.  It will mangle all properties in the
+input code with the exception of built in DOM properties and properties
+in core javascript classes.  For example:

 ```javascript
+// example.js
 var x = {
-    foo: 1
+    baz_: 0,
+    foo_: 1,
+    calc: function() {
+        return this.foo_ + this.baz_;
+    }
 };
-
-x.bar = 2;
-x["baz"] = 3;
-x[condition ? "moo" : "boo"] = 4;
-console.log(x.something());
+x.bar_ = 2;
+x["baz_"] = 3;
+console.log(x.calc());
+```
+Mangle all properties (except for javascript `builtins`):
+```bash
+$ uglifyjs example.js -c -m --mangle-props
+```
+```javascript
+var x={o:0,_:1,l:function(){return this._+this.o}};x.t=2,x.o=3,console.log(x.l());
+```
+Mangle all properties except for `reserved` properties:
+```bash
+$ uglifyjs example.js -c -m --mangle-props reserved=[foo_,bar_]
+```
+```javascript
+var x={o:0,foo_:1,_:function(){return this.foo_+this.o}};x.bar_=2,x.o=3,console.log(x._());
+```
+Mangle all properties matching a `regex`:
+```bash
+$ uglifyjs example.js -c -m --mangle-props regex=/_$/
+```
+```javascript
+var x={o:0,_:1,calc:function(){return this._+this.o}};x.l=2,x.o=3,console.log(x.calc());
 ```

-In the above code, `foo`, `bar`, `baz`, `moo` and `boo` will be replaced
-with single characters, while `something()` will be left as is.
+Combining mangle properties options:
+```bash
+$ uglifyjs example.js -c -m --mangle-props regex=/_$/,reserved=[bar_]
+```
+```javascript
+var x={o:0,_:1,calc:function(){return this._+this.o}};x.bar_=2,x.o=3,console.log(x.calc());
+```

 In order for this to be of any use, we avoid mangling standard JS names by
 default (`--mangle-props builtins` to override).
@@ -242,7 +272,7 @@ A default exclusion file is provided in `tools/domprops.json` which should
 cover most standard JS and DOM properties defined in various browsers.  Pass
 `--mangle-props domprops` to disable this feature.

-You can also use a regular expression to define which property names should be
+A regular expression can be used to define which property names should be
 mangled.  For example, `--mangle-props regex=/^_/` will only mangle property
 names that start with an underscore.

@@ -270,9 +300,20 @@ Using quoted property name (`o["foo"]`) reserves the property name (`foo`)
 so that it is not mangled throughout the entire script even when used in an
 unquoted style (`o.foo`). Example:

+```javascript
+// stuff.js
+var o = {
+    "foo": 1,
+    bar: 3
+};
+o.foo += o.bar;
+console.log(o.foo);
+```
 ```bash
-$ echo 'var o={"foo":1, bar:3}; o.foo += o.bar; console.log(o.foo);' | uglifyjs --mangle-props keep_quoted -mc
-var o={foo:1,a:3};o.foo+=o.a,console.log(o.foo);
+$ uglifyjs stuff.js --mangle-props keep_quoted -c -m
+```
+```javascript
+var o={foo:1,o:3};o.foo+=o.o,console.log(o.foo);
 ```

 ### Debugging property name mangling
@@ -283,6 +324,13 @@ would mangle to `o._$foo$_` with this option. This allows property mangling
 of a large codebase while still being able to debug the code and identify
 where mangling is breaking things.

+```bash
+$ uglifyjs stuff.js --mangle-props debug -c -m
+```
+```javascript
+var o={_$foo$_:1,_$bar$_:3};o._$foo$_+=o._$bar$_,console.log(o._$foo$_);
+```
+
 You can also pass a custom suffix using `--mangle-props debug=XYZ`. This would then
 mangle `o.foo` to `o._$foo$XYZ_`. You can change this each time you compile a
 script to identify how a property got mangled. One technique is to pass a
@@ -299,27 +347,94 @@ like this:
 var UglifyJS = require("uglify-es");
 ```

-There is a single high level minification function, `minify(files, options)`, which will
-performs all the steps in a configurable manner.
-Example:
+There is a single high level function, **`minify(code, options)`**,
+which will perform all minification [phases](#minify-options) in a configurable
+manner. By default `minify()` will enable the options [`compress`](#compress-options)
+and [`mangle`](#mangle-options). Example:
 ```javascript
-var result = UglifyJS.minify("var b = function() {};");
-console.log(result.code);  // minified output
-console.log(result.error); // runtime error
+var code = "function add(first, second) { return first + second; }";
+var result = UglifyJS.minify(code);
+console.log(result.error); // runtime error, or `undefined` if no error
+console.log(result.code);  // minified output: function add(n,d){return n+d}
 ```

-You can also compress multiple files:
+You can `minify` more than one JavaScript file at a time by using an object
+for the first argument where the keys are file names and the values are source
+code:
 ```javascript
-var result = UglifyJS.minify({
-    "file1.js": "var a = function() {};",
-    "file2.js": "var b = function() {};"
-});
+var code = {
+    "file1.js": "function add(first, second) { return first + second; }",
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
+};
+var result = UglifyJS.minify(code);
 console.log(result.code);
+// function add(d,n){return d+n}console.log(add(3,7));
+```
+
+The `toplevel` option:
+```javascript
+var code = {
+    "file1.js": "function add(first, second) { return first + second; }",
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
+};
+var options = { toplevel: true };
+var result = UglifyJS.minify(code, options);
+console.log(result.code);
+// console.log(function(n,o){return n+o}(3,7));
+```
+
+An example of a combination of `minify()` options:
+```javascript
+var code = {
+    "file1.js": "function add(first, second) { return first + second; }",
+    "file2.js": "console.log(add(1 + 2, 3 + 4));"
+};
+var options = {
+    toplevel: true,
+    compress: {
+        global_defs: {
+            "@console.log": "alert"
+        },
+        passes: 2
+    },
+    output: {
+        beautify: false,
+        preamble: "/* uglified */"
+    }
+};
+var result = UglifyJS.minify(code, options);
+console.log(result.code);
+// /* uglified */
+// alert(10);"
+```
+
+To produce warnings:
+```javascript
+var code = "function f(){ var u; return 2 + 3; }";
+var options = { warnings: true };
+var result = UglifyJS.minify(code, options);
+console.log(result.error);    // runtime error, `undefined` in this case
+console.log(result.warnings); // [ 'Dropping unused variable u [0:1,18]' ]
+console.log(result.code);     // function f(){return 5}
+```
+
+An error example:
+```javascript
+var result = UglifyJS.minify({"foo.js" : "if (0) else console.log(1);"});
+console.log(JSON.stringify(result.error));
+// {"message":"Unexpected token: keyword (else)","filename":"foo.js","line":1,"col":7,"pos":7}
+```
+Note: unlike `uglify-js@2.x`, the `3.x` API does not throw errors. To
+achieve a similar effect one could do the following:
+```javascript
+var result = UglifyJS.minify(code, options);
+if (result.error) throw result.error;
 ```

 ## Minify options

- `warnings` (default `false`) — pass `true` to display compressor warnings.
+- `warnings` (default `false`) — pass `true` to return compressor warnings
+  in `result.warnings`. Use the value `"verbose"` for more detailed warnings.

 - `parse` (default `{}`) — pass an object if you wish to specify some
  additional [parse options](#parse-options).
@@ -345,7 +460,7 @@ console.log(result.code);

 - `ie8` (default `false`) - set to `true` to support IE8.

-## Minify option structure
+## Minify options structure

 ```javascript
 {
@@ -460,6 +575,9 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 - `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

@@ -479,7 +597,7 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
  assignments do not count as references unless set to `"keep_assign"`)

 - `toplevel` -- drop unreferenced functions (`"funcs"`) and/or variables (`"vars"`)
-  in the toplevel scope (`false` by default, `true` to drop both unreferenced
+  in the top level scope (`false` by default, `true` to drop both unreferenced
  functions and variables)

 - `top_retain` -- prevent specific toplevel functions and variables from `unused`
@@ -497,8 +615,8 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 - `cascade` -- small optimization for sequences, transform `x, x` into `x`
  and `x = something(), x` into `x = something()`

- `collapse_vars` -- Collapse single-use `var` and `const` definitions
-  when possible.
+- `collapse_vars` -- Collapse single-use non-constant variables - side
+  effects permitting.

 - `reduce_vars` -- Improve optimization on variables assigned with and
  used as constant values.
@@ -550,16 +668,16 @@ If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.u
 - `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 `false`. Pass `true` to potentially drop 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()`;
+- `side_effects` -- 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();`

 ## Mangle options

 - `reserved` - pass an array of identifiers that should be excluded from mangling

- `toplevel` — mangle names declared in the toplevel scope (disabled by
+- `toplevel` — mangle names declared in the top level scope (disabled by
 default).

 - `eval` — mangle names visible in scopes where eval or with are used
@@ -593,10 +711,15 @@ UglifyJS.minify(code, { mangle: { toplevel: true } }).code;

 ### Mangle properties options

- `regex` — Pass a RegExp to only mangle certain names
- `keep_quoted` — Only mangle unquoted property names
- `debug` — Mangle names with the original name still present. Defaults to `false`.
-  Pass an empty string to enable, or a non-empty string to set the suffix.
+- `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.

 ## Output options

@@ -604,36 +727,36 @@ The code generator tries to output shortest code possible by default.  In
 case you want beautified output, pass `--beautify` (`-b`).  Optionally you
 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.
- `indent_level` (default 4)
- `indent_start` (default 0) -- prefix all lines by that many spaces
- `quote_keys` (default `false`) -- pass `true` to quote all keys in literal
-  objects
- `space_colon` (default `true`) -- insert a space after the colon signs
- `ascii_only` (default `false`) -- escape Unicode characters in strings and
-  regexps (affects directives with non-ascii characters becoming invalid)
- `inline_script` (default `false`) -- escape the slash in occurrences of
-  `</script` in strings
- `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.
- `max_line_len` (default 32000) -- maximum line length (for uglified code)
 - `bracketize` (default `false`) -- always insert brackets in `if`, `for`,
  `do`, `while` or `with` statements, even if their body is a single
  statement.
- `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).
+- `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
+- `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
@@ -641,12 +764,19 @@ can pass additional arguments that control the code output:
  - `1` -- always use single quotes
  - `2` -- always use double quotes
  - `3` -- always use the original quotes
- `keep_quoted_props` (default `false`) -- when turned on, prevents stripping
-  quotes from property names in object literals.
- `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.
-
+- `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
+  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.

 # Miscellaneous

@@ -716,8 +846,8 @@ Another way of doing that is to declare your globals as constants in a
 separate file and include it into the build.  For example you can have a
 `build/defines.js` file with the following:
 ```javascript
-const DEBUG = false;
-const PRODUCTION = true;
+var DEBUG = false;
+var PRODUCTION = true;
 // etc.
 ```

@@ -737,7 +867,7 @@ You can also use conditional compilation via the programmatic API. With the diff
 property name is `global_defs` and is a compressor property:

 ```javascript
-var result = uglifyJS.minify(fs.readFileSync("input.js", "utf8"), {
+var result = UglifyJS.minify(fs.readFileSync("input.js", "utf8"), {
    compress: {
        dead_code: true,
        global_defs: {
@@ -747,6 +877,32 @@ var result = uglifyJS.minify(fs.readFileSync("input.js", "utf8"), {
 });
 ```

+To replace an identifier with an arbitrary non-constant expression it is
+necessary to prefix the `global_defs` key with `"@"` to instruct UglifyJS
+to parse the value as an expression:
+```javascript
+UglifyJS.minify("alert('hello');", {
+    compress: {
+        global_defs: {
+            "@alert": "console.log"
+        }
+    }
+}).code;
+// returns: 'console.log("hello");'
+```
+
+Otherwise it would be replaced as string literal:
+```javascript
+UglifyJS.minify("alert('hello');", {
+    compress: {
+        global_defs: {
+            "alert": "console.log"
+        }
+    }
+}).code;
+// returns: '"console.log"("hello");'
+```
+
 ### Using native Uglify AST with `minify()`
 ```javascript
 // example: parse only, produce native Uglify AST
--- a/bin/uglifyjs
+++ b/bin/uglifyjs
@@ -21,9 +21,27 @@ var options = {
    compress: false,
    mangle: false
 };
-program.version(info.name + ' ' + info.version);
+program.version(info.name + " " + info.version);
 program.parseArgv = program.parse;
 program.parse = undefined;
+if (process.argv.indexOf("ast") >= 0) program.helpInformation = UglifyJS.describe_ast;
+else if (process.argv.indexOf("options") >= 0) program.helpInformation = function() {
+    var text = [];
+    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("");
+    }
+    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));
@@ -38,7 +56,7 @@ program.option("--keep-fnames", "Do not mangle/drop function names. Useful for c
 program.option("--name-cache <file>", "File to hold mangled name mappings.");
 program.option("--self", "Build UglifyJS as a library (implies --wrap UglifyJS)");
 program.option("--source-map [options]", "Enable source map/specify source map options.", parse_source_map());
-program.option("--stats", "Display operations run time on STDERR.")
+program.option("--timings", "Display operations run time on STDERR.")
 program.option("--toplevel", "Compress and/or mangle variables in toplevel scope.");
 program.option("--verbose", "Print diagnostic messages.");
 program.option("--warn", "Print warning messages.");
@@ -114,10 +132,10 @@ if (program.output == "ast") {
    };
 }
 if (program.parse) {
-    if (program.parse.acorn || program.parse.spidermonkey) {
-        if (program.sourceMap) fatal("ERROR: inline source map only works with built-in parser");
-    } else {
+    if (!program.parse.acorn && !program.parse.spidermonkey) {
        options.parse = program.parse;
+    } else if (program.sourceMap && program.sourceMap.content == "inline") {
+        fatal("ERROR: inline source map only works with built-in parser");
    }
 }
 var convert_path = function(name) {
@@ -171,7 +189,7 @@ function run() {
    UglifyJS.AST_Node.warn_function = function(msg) {
        console.error("WARN:", msg);
    };
-    if (program.stats) program.stats = Date.now();
+    if (program.timings) options.timings = true;
    try {
        if (program.parse) {
            if (program.parse.acorn) {
@@ -258,7 +276,9 @@ function run() {
            return value instanceof UglifyJS.Dictionary ? value.toObject() : value;
        }));
    }
-    if (program.stats) console.error("Elapsed:", Date.now() - program.stats);
+    if (result.timings) for (var phase in result.timings) {
+        console.error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
+    }
 }

 function fatal(message) {
@@ -348,7 +368,7 @@ function parse_js(flag, constants) {
                }
            }));
        } catch(ex) {
-            fatal("Error parsing arguments for '" + flag + "': " + value);
+            options[value] = null;
        }
        return options;
    }
--- a/lib/ast.js
+++ b/lib/ast.js
@@ -355,79 +355,6 @@ var AST_Expansion = DEFNODE("Expansion", "expression", {
    }
 });

-var AST_ArrowParametersOrSeq = DEFNODE("ArrowParametersOrSeq", "expressions", {
-    $documentation: "A set of arrow function parameters or a sequence expression. This is used because when the parser sees a \"(\" it could be the start of a seq, or the start of a parameter list of an arrow function.",
-    $propdoc: {
-        expressions: "[AST_Expression|AST_Destructuring|AST_Expansion*] array of expressions or argument names or destructurings."
-    },
-    as_params: function (croak) {
-        // We don't want anything which doesn't belong in a destructuring
-        var root = this;
-        return this.expressions.map(function to_fun_args(ex, _, __, default_seen_above) {
-            var insert_default = function(ex, default_value) {
-                if (default_value) {
-                    return new AST_DefaultAssign({
-                        start: ex.start,
-                        left: ex,
-                        operator: "=",
-                        right: default_value,
-                        end: default_value.end
-                    });
-                }
-                return ex;
-            }
-            if (ex instanceof AST_Object) {
-                return insert_default(new AST_Destructuring({
-                    start: ex.start,
-                    end: ex.end,
-                    is_array: false,
-                    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) {
-                return ex;
-            } else if (ex instanceof AST_Destructuring) {
-                ex.names = ex.names.map(to_fun_args);
-                return insert_default(ex, default_seen_above);
-            } else if (ex instanceof AST_SymbolRef) {
-                return insert_default(new AST_SymbolFunarg({
-                    name: ex.name,
-                    start: ex.start,
-                    end: ex.end
-                }), default_seen_above);
-            } else if (ex instanceof AST_Expansion) {
-                ex.expression = to_fun_args(ex.expression);
-                return insert_default(ex, default_seen_above);
-            } else if (ex instanceof AST_Array) {
-                return insert_default(new AST_Destructuring({
-                    start: ex.start,
-                    end: ex.end,
-                    is_array: true,
-                    names: ex.elements.map(to_fun_args)
-                }), default_seen_above);
-            } else if (ex instanceof AST_Assign) {
-                return insert_default(to_fun_args(ex.left, undefined, undefined, ex.right), default_seen_above);
-            } else if (ex instanceof AST_DefaultAssign) {
-                ex.left = to_fun_args(ex.left, 0, [ex.left]);
-                return ex;
-            } else {
-                croak("Invalid function parameter", ex.start.line, ex.start.col);
-            }
-        });
-    },
-    as_expr: function() {
-        var exprs = this.expressions;
-        return exprs.length == 1 ? exprs[0] : new AST_Sequence({
-            expressions: exprs
-        });
-    }
-});
-
 var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator", {
    $documentation: "Base class for functions",
    $propdoc: {
--- a/lib/compress.js
+++ b/lib/compress.js
@@ -84,9 +84,21 @@ function Compressor(options, false_by_default) {
        unsafe_comps  : false,
        unsafe_math   : false,
        unsafe_proto  : false,
+        unsafe_regexp : false,
        unused        : !false_by_default,
        warnings      : false,
    }, true);
+    var global_defs = this.options["global_defs"];
+    if (typeof global_defs == "object") for (var key in global_defs) {
+        if (/^@/.test(key) && HOP(global_defs, key)) {
+            var ast = parse(global_defs[key]);
+            if (ast.body.length == 1 && ast.body[0] instanceof AST_SimpleStatement) {
+                global_defs[key.slice(1)] = ast.body[0].body;
+            } else throw new Error(string_template("Can't handle expression: {value}", {
+                value: global_defs[key]
+            }));
+        }
+    }
    var pure_funcs = this.options["pure_funcs"];
    if (typeof pure_funcs == "function") {
        this.pure_funcs = pure_funcs;
@@ -545,11 +557,11 @@ merge(Compressor.prototype, {
        return lhs instanceof AST_SymbolRef && lhs.definition().orig[0] instanceof AST_SymbolLambda;
    }

-    function is_reference_const(ref) {
+    function is_ref_of(ref, type) {
        if (!(ref instanceof AST_SymbolRef)) return false;
        var orig = ref.definition().orig;
        for (var i = orig.length; --i >= 0;) {
-            if (orig[i] instanceof AST_SymbolConst) return true;
+            if (orig[i] instanceof type) return true;
        }
    }

@@ -828,7 +840,7 @@ merge(Compressor.prototype, {
                    }
                } else {
                    var lhs = expr[expr instanceof AST_Assign ? "left" : "expression"];
-                    return !is_reference_const(lhs) && lhs;
+                    return !is_ref_of(lhs, AST_SymbolConst) && lhs;
                }
            }

@@ -938,13 +950,52 @@ merge(Compressor.prototype, {
                    // step.  nevertheless, it's good to check.
                    continue loop;
                  case stat instanceof AST_If:
+                    var ab = aborts(stat.body);
+                    if (can_merge_flow(ab)) {
+                        if (ab.label) {
+                            remove(ab.label.thedef.references, ab);
+                        }
+                        CHANGED = true;
+                        var funs = extract_functions_from_statement_array(ret);
+                        var body = as_statement_array_with_return(stat.body, ab);
+                        stat = stat.clone();
+                        stat.condition = stat.condition.negate(compressor);
+                        stat.body = make_node(AST_BlockStatement, stat, {
+                            body: as_statement_array(stat.alternative).concat(ret)
+                        });
+                        stat.alternative = make_node(AST_BlockStatement, stat, {
+                            body: body
+                        });
+                        ret = [ stat.transform(compressor) ].concat(funs);
+                        continue loop;
+                    }
+
+                    var ab = aborts(stat.alternative);
+                    if (can_merge_flow(ab)) {
+                        if (ab.label) {
+                            remove(ab.label.thedef.references, ab);
+                        }
+                        CHANGED = true;
+                        var funs = extract_functions_from_statement_array(ret);
+                        stat = stat.clone();
+                        stat.body = make_node(AST_BlockStatement, stat.body, {
+                            body: as_statement_array(stat.body).concat(ret)
+                        });
+                        var body = as_statement_array_with_return(stat.alternative, ab);
+                        stat.alternative = make_node(AST_BlockStatement, stat.alternative, {
+                            body: body
+                        });
+                        ret = [ stat.transform(compressor) ].concat(funs);
+                        continue loop;
+                    }
+
                    if (stat.body instanceof AST_Return) {
+                        var value = stat.body.value;
                        //---
                        // pretty silly case, but:
                        // if (foo()) return; return; ==> foo(); return;
-                        if (((in_lambda && ret.length == 0)
-                             || (ret[0] instanceof AST_Return && !ret[0].value))
-                            && !stat.body.value && !stat.alternative) {
+                        if ((in_lambda && ret.length == 0 || ret[0] instanceof AST_Return && !ret[0].value)
+                            && !value && !stat.alternative) {
                            CHANGED = true;
                            var cond = make_node(AST_SimpleStatement, stat.condition, {
                                body: stat.condition
@@ -954,7 +1005,7 @@ merge(Compressor.prototype, {
                        }
                        //---
                        // if (foo()) return x; return y; ==> return foo() ? x : y;
-                        if (ret[0] instanceof AST_Return && stat.body.value && ret[0].value && !stat.alternative) {
+                        if (ret[0] instanceof AST_Return && value && ret[0].value && !stat.alternative) {
                            CHANGED = true;
                            stat = stat.clone();
                            stat.alternative = ret[0];
@@ -964,7 +1015,7 @@ merge(Compressor.prototype, {
                        //---
                        // if (foo()) return x; [ return ; ] ==> return foo() ? x : undefined;
                        if (multiple_if_returns && (ret.length == 0 || ret[0] instanceof AST_Return)
-                            && stat.body.value && !stat.alternative && in_lambda) {
+                            && value && !stat.alternative && in_lambda) {
                            CHANGED = true;
                            stat = stat.clone();
                            stat.alternative = ret[0] || make_node(AST_Return, stat, {
@@ -973,22 +1024,6 @@ merge(Compressor.prototype, {
                            ret[0] = stat.transform(compressor);
                            continue loop;
                        }
-                        //---
-                        // if (foo()) return; [ else x... ]; y... ==> if (!foo()) { x...; y... }
-                        if (!stat.body.value && in_lambda) {
-                            CHANGED = true;
-                            stat = stat.clone();
-                            stat.condition = stat.condition.negate(compressor);
-                            var body = as_statement_array(stat.alternative).concat(ret);
-                            var funs = extract_functions_from_statement_array(body);
-                            stat.body = make_node(AST_BlockStatement, stat, {
-                                body: body
-                            });
-                            stat.alternative = null;
-                            ret = funs.concat([ stat.transform(compressor) ]);
-                            continue loop;
-                        }
-
                        //---
                        // if (a) return b; if (c) return d; e; ==> return a ? b : c ? d : void e;
                        //
@@ -1008,48 +1043,6 @@ merge(Compressor.prototype, {
                        }
                    }

-                    var ab = aborts(stat.body);
-                    var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab) : null;
-                    if (ab && ((ab instanceof AST_Return && !ab.value && in_lambda)
-                               || (ab instanceof AST_Continue && self === loop_body(lct))
-                               || (ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct))) {
-                        if (ab.label) {
-                            remove(ab.label.thedef.references, ab);
-                        }
-                        CHANGED = true;
-                        var body = as_statement_array(stat.body).slice(0, -1);
-                        stat = stat.clone();
-                        stat.condition = stat.condition.negate(compressor);
-                        stat.body = make_node(AST_BlockStatement, stat, {
-                            body: as_statement_array(stat.alternative).concat(ret)
-                        });
-                        stat.alternative = make_node(AST_BlockStatement, stat, {
-                            body: body
-                        });
-                        ret = [ stat.transform(compressor) ];
-                        continue loop;
-                    }
-
-                    var ab = aborts(stat.alternative);
-                    var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab) : null;
-                    if (ab && ((ab instanceof AST_Return && !ab.value && in_lambda)
-                               || (ab instanceof AST_Continue && self === loop_body(lct))
-                               || (ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct))) {
-                        if (ab.label) {
-                            remove(ab.label.thedef.references, ab);
-                        }
-                        CHANGED = true;
-                        stat = stat.clone();
-                        stat.body = make_node(AST_BlockStatement, stat.body, {
-                            body: as_statement_array(stat.body).concat(ret)
-                        });
-                        stat.alternative = make_node(AST_BlockStatement, stat.alternative, {
-                            body: as_statement_array(stat.alternative).slice(0, -1)
-                        });
-                        ret = [ stat.transform(compressor) ];
-                        continue loop;
-                    }
-
                    ret.unshift(stat);
                    break;
                  default:
@@ -1069,6 +1062,30 @@ merge(Compressor.prototype, {
                }
                return false;
            }
+
+            function is_return_void(value) {
+                return !value || value instanceof AST_UnaryPrefix && value.operator == "void";
+            }
+
+            function can_merge_flow(ab) {
+                if (!ab || !all(ret, function(stat) {
+                    return !(stat instanceof AST_Const || stat instanceof AST_Let);
+                })) return false;
+                var lct = ab instanceof AST_LoopControl ? compressor.loopcontrol_target(ab) : null;
+                return ab instanceof AST_Return && in_lambda && is_return_void(ab.value)
+                    || ab instanceof AST_Continue && self === loop_body(lct)
+                    || ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct;
+            }
+
+            function as_statement_array_with_return(node, ab) {
+                var body = as_statement_array(node).slice(0, -1);
+                if (ab.value) {
+                    body.push(make_node(AST_SimpleStatement, ab.value, {
+                        body: ab.value.expression
+                    }));
+                }
+                return body;
+            }
        };

        function eliminate_dead_code(statements, compressor) {
@@ -1235,8 +1252,15 @@ merge(Compressor.prototype, {
                target.push(node);
                return true;
            }
-            if (node instanceof AST_Defun) {
-                target.push(node);
+            if (node instanceof AST_Defun && (node === stat || !compressor.has_directive("use strict"))) {
+                target.push(node === stat ? node : make_node(AST_Var, node, {
+                    definitions: [
+                        make_node(AST_VarDef, node, {
+                            name: make_node(AST_SymbolVar, node.name, node.name),
+                            value: null
+                        })
+                    ]
+                }));
                return true;
            }
            if (node instanceof AST_Scope) {
@@ -2056,7 +2080,7 @@ merge(Compressor.prototype, {
                    && node instanceof AST_Assign
                    && node.operator == "="
                    && node.left instanceof AST_SymbolRef
-                    && !is_reference_const(node.left)
+                    && !is_ref_of(node.left, AST_SymbolBlockDeclaration)
                    && scope === self) {
                    node.right.walk(tw);
                    return true;
@@ -2095,15 +2119,21 @@ merge(Compressor.prototype, {
                                }));
                            }
                        }
-                        else if (node.names[i] instanceof AST_Hole) {
-                            continue;
-                        }
-                        else if (node.names[i] instanceof AST_ObjectKeyVal && typeof node.names[i].key === "string") {
-                            initializations.add(node.names[i].key, destructuring_value);
+                        else if (node.names[i] instanceof AST_ObjectKeyVal) {
+                            if (typeof node.names[i].key === "string") {
+                                initializations.add(node.names[i].key, destructuring_value);
+                            }
                        }
                        else if (node.names[i] instanceof AST_Symbol) {
                            initializations.add(node.names[i].name, destructuring_value);
-                        } else {
+                        }
+                        else if (node.names[i] instanceof AST_DefaultAssign) {
+                            continue;
+                        }
+                        else if (node.names[i] instanceof AST_Hole) {
+                            continue;
+                        }
+                        else {
                            throw new Error(string_template("Unknown destructuring element of type: {type}", {
                                type: Object.getPrototypeOf(node.names[i]).TYPE
                            }));
@@ -2138,9 +2168,11 @@ merge(Compressor.prototype, {
        // pass 3: we should drop declarations not in_use
        var tt = new TreeTransformer(
            function before(node, descend, in_list) {
-                if (node instanceof AST_Function
-                    && node.name
-                    && !compressor.option("keep_fnames")) {
+                var parent = tt.parent();
+                if (!compressor.option("keep_fnames")
+                    && ((node instanceof AST_Function || node instanceof AST_ClassExpression) && node.name
+                        || (node instanceof AST_Defun || node instanceof AST_DefClass)
+                            && parent instanceof AST_Export && parent.is_default)) {
                    var def = node.name.definition();
                    // any declarations with same name will overshadow
                    // name of this anonymous function and can therefore
@@ -2175,7 +2207,7 @@ merge(Compressor.prototype, {
                        }
                    }
                }
-                if ((node instanceof AST_Defun || node instanceof AST_DefClass) && node !== self) {
+                if ((node instanceof AST_Defun || node instanceof AST_DefClass) && !(parent instanceof AST_Export) && node !== self) {
                    var keep = (node.name.definition().id in in_use_ids) || !drop_funcs && node.name.definition().global;
                    if (!keep) {
                        compressor[node.name.unreferenced() ? "warn" : "info"]("Dropping unused function {name} [{file}:{line},{col}]", template(node.name));
@@ -2183,7 +2215,7 @@ merge(Compressor.prototype, {
                    }
                    return node;
                }
-                if (node instanceof AST_Definitions && !(tt.parent() instanceof AST_ForIn && tt.parent().init === node)) {
+                if (node instanceof AST_Definitions && !(parent instanceof AST_ForIn && parent.init === node)) {
                    // place uninitialized names at the start
                    var body = [], head = [], tail = [];
                    // for unused names whose initialization has
@@ -2279,7 +2311,7 @@ merge(Compressor.prototype, {
                    if (!(def.id in in_use_ids)
                        && (drop_vars || !def.global)
                        && self.variables.get(def.name) === def) {
-                        return maintain_this_binding(tt.parent(), node, node.right.transform(tt));
+                        return maintain_this_binding(parent, node, node.right.transform(tt));
                    }
                }
                // certain combination of unused name + side effect leads to:
@@ -2365,11 +2397,13 @@ merge(Compressor.prototype, {
                            dirs.push(node);
                            return make_node(AST_EmptyStatement, node);
                        }
-                        if (node instanceof AST_Defun && hoist_funs) {
+                        if (hoist_funs && node instanceof AST_Defun
+                            && !(tt.parent() instanceof AST_Export)
+                            && tt.parent() === self) {
                            hoisted.push(node);
                            return make_node(AST_EmptyStatement, node);
                        }
-                        if (node instanceof AST_Var && hoist_vars) {
+                        if (hoist_vars && node instanceof AST_Var) {
                            node.definitions.forEach(function(def){
                                if (def.name instanceof AST_Destructuring) return;
                                vars.set(def.name.name, def);
@@ -3160,7 +3194,6 @@ merge(Compressor.prototype, {
                    // Symbol's argument is only used for debugging.
                    self.args = [];
                    return self;
-                    break;
                }
            }
            else if (exp instanceof AST_Dot && exp.property == "toString" && self.args.length == 0) {
@@ -3343,7 +3376,7 @@ merge(Compressor.prototype, {
                    && (left.operator == "++" || left.operator == "--")) {
                    left = left.expression;
                } else left = null;
-                if (!left || is_lhs_read_only(left) || is_reference_const(left)) {
+                if (!left || is_lhs_read_only(left) || is_ref_of(left, AST_SymbolConst)) {
                    expressions[++i] = cdr;
                    continue;
                }
@@ -3912,7 +3945,7 @@ merge(Compressor.prototype, {
            if (fixed) {
                if (d.should_replace === undefined) {
                    var init = fixed.evaluate(compressor);
-                    if (init !== fixed) {
+                    if (init !== fixed && (compressor.option("unsafe_regexp") || !(init instanceof RegExp))) {
                        init = make_node_from_constant(init, fixed);
                        var value_length = init.optimize(compressor).print_to_string().length;
                        var fn;
--- a/lib/minify.js
+++ b/lib/minify.js
@@ -30,9 +30,6 @@ function set_shorthand(name, options, keys) {
 function minify(files, options) {
    var warn_function = AST_Node.warn_function;
    try {
-        if (typeof files == "string") {
-            files = [ files ];
-        }
        options = defaults(options, {
            compress: {},
            ie8: false,
@@ -41,10 +38,14 @@ function minify(files, options) {
            output: {},
            parse: {},
            sourceMap: false,
+            timings: false,
            toplevel: false,
            warnings: false,
            wrap: false,
        }, true);
+        var timings = options.timings && {
+            start: Date.now()
+        };
        set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
        set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
        set_shorthand("toplevel", options, [ "compress", "mangle" ]);
@@ -77,10 +78,14 @@ function minify(files, options) {
                warnings.push(warning);
            };
        }
+        if (timings) timings.parse = Date.now();
        var toplevel;
        if (files instanceof AST_Toplevel) {
            toplevel = files;
        } else {
+            if (typeof files == "string") {
+                files = [ files ];
+            }
            options.parse = options.parse || {};
            options.parse.toplevel = null;
            for (var name in files) {
@@ -97,19 +102,23 @@ function minify(files, options) {
        if (options.wrap) {
            toplevel = toplevel.wrap_commonjs(options.wrap);
        }
-        if (options.compress) {
-            toplevel.figure_out_scope(options.mangle);
-            toplevel = new Compressor(options.compress).compress(toplevel);
-        }
+        if (timings) timings.scope1 = Date.now();
+        if (options.compress) toplevel.figure_out_scope(options.mangle);
+        if (timings) timings.compress = Date.now();
+        if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
+        if (timings) timings.scope2 = Date.now();
+        if (options.mangle) toplevel.figure_out_scope(options.mangle);
+        if (timings) timings.mangle = Date.now();
        if (options.mangle) {
-            toplevel.figure_out_scope(options.mangle);
            base54.reset();
            toplevel.compute_char_frequency(options.mangle);
            toplevel.mangle_names(options.mangle);
-            if (options.mangle.properties) {
-                toplevel = mangle_properties(toplevel, options.mangle.properties);
-            }
        }
+        if (timings) timings.properties = Date.now();
+        if (options.mangle && options.mangle.properties) {
+            toplevel = mangle_properties(toplevel, options.mangle.properties);
+        }
+        if (timings) timings.output = Date.now();
        var result = {};
        if (options.output.ast) {
            result.ast = toplevel;
@@ -125,7 +134,9 @@ function minify(files, options) {
                    root: options.sourceMap.root
                });
                if (options.sourceMap.includeSources) {
-                    for (var name in files) {
+                    if (files instanceof AST_Toplevel) {
+                        throw new Error("original source content unavailable");
+                    } else for (var name in files) {
                        options.output.source_map.get().setSourceContent(name, files[name]);
                    }
                }
@@ -144,6 +155,18 @@ function minify(files, options) {
                }
            }
        }
+        if (timings) {
+            timings.end = Date.now();
+            result.timings = {
+                parse: 1e-3 * (timings.scope1 - timings.parse),
+                scope: 1e-3 * (timings.compress - timings.scope1 + timings.mangle - timings.scope2),
+                compress: 1e-3 * (timings.scope2 - timings.compress),
+                mangle: 1e-3 * (timings.properties - timings.mangle),
+                properties: 1e-3 * (timings.output - timings.properties),
+                output: 1e-3 * (timings.end - timings.output),
+                total: 1e-3 * (timings.end - timings.start)
+            }
+        }
        if (warnings.length) {
            result.warnings = warnings;
        }
--- a/lib/output.js
+++ b/lib/output.js
@@ -73,8 +73,6 @@ function OutputStream(options) {
        shebang          : true,
        shorthand        : undefined,
        source_map       : null,
-        space_colon      : true,
-        unescape_regexps : false,
        width            : 80,
        wrap_iife        : false,
    }, true);
@@ -214,12 +212,43 @@ function OutputStream(options) {
    var might_need_semicolon = false;
    var might_add_newline = 0;
    var last = "";
+    var mapping_token, mapping_name, mappings = options.source_map && [];
+
+    var do_add_mapping = mappings ? function() {
+        mappings.forEach(function(mapping) {
+            try {
+                options.source_map.add(
+                    mapping.token.file,
+                    mapping.line, mapping.col,
+                    mapping.token.line, mapping.token.col,
+                    !mapping.name && mapping.token.type == "name" ? mapping.token.value : mapping.name
+                );
+            } catch(ex) {
+                AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]", {
+                    file: mapping.token.file,
+                    line: mapping.token.line,
+                    col: mapping.token.col,
+                    cline: mapping.line,
+                    ccol: mapping.col,
+                    name: mapping.name || ""
+                })
+            }
+        });
+        mappings = [];
+    } : noop;

    var ensure_line_len = options.max_line_len ? function() {
        if (current_col > options.max_line_len) {
            if (might_add_newline) {
                var left = OUTPUT.slice(0, might_add_newline);
                var right = OUTPUT.slice(might_add_newline);
+                if (mappings) {
+                    var delta = right.length - current_col;
+                    mappings.forEach(function(mapping) {
+                        mapping.line++;
+                        mapping.col += delta;
+                    });
+                }
                OUTPUT = left + "\n" + right;
                current_line++;
                current_pos++;
@@ -229,7 +258,10 @@ function OutputStream(options) {
                AST_Node.warn("Output exceeds {max_line_len} characters", options);
            }
        }
-        might_add_newline = 0;
+        if (might_add_newline) {
+            might_add_newline = 0;
+            do_add_mapping();
+        }
    } : noop;

    var requireSemicolonChars = makePredicate("( [ + * / - , .");
@@ -289,6 +321,18 @@ function OutputStream(options) {
            }
            might_need_space = false;
        }
+
+        if (mapping_token) {
+            mappings.push({
+                token: mapping_token,
+                name: mapping_name,
+                line: current_line,
+                col: current_col
+            });
+            mapping_token = false;
+            if (!might_add_newline) do_add_mapping();
+        }
+
        OUTPUT += str;
        current_pos += str.length;
        var a = str.split(/\r?\n/), n = a.length - 1;
@@ -384,27 +428,12 @@ function OutputStream(options) {

    function colon() {
        print(":");
-        if (options.space_colon) space();
+        space();
    };

-    var add_mapping = options.source_map ? function(token, name) {
-        try {
-            if (token) options.source_map.add(
-                token.file || "?",
-                current_line, current_col,
-                token.line, token.col,
-                (!name && token.type == "name") ? token.value : name
-            );
-        } catch(ex) {
-            AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]", {
-                file: token.file,
-                line: token.line,
-                col: token.col,
-                cline: current_line,
-                ccol: current_col,
-                name: name || ""
-            })
-        }
+    var add_mapping = mappings ? function(token, name) {
+        mapping_token = token;
+        mapping_name = name;
    } : noop;

    function get() {
@@ -644,7 +673,6 @@ 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_Class && p.extends === this) // class D extends (calls++, C) {}
        ;
    });

@@ -1474,10 +1502,24 @@ function OutputStream(options) {
            output.space();
        }
        if (self.extends) {
+            var parens = (
+                   !(self.extends instanceof AST_SymbolRef)
+                && !(self.extends instanceof AST_PropAccess)
+                && !(self.extends instanceof AST_ClassExpression)
+                && !(self.extends instanceof AST_Function)
+            );
            output.print("extends");
-            output.space();
+            if (parens) {
+                output.print("(");
+            } else {
+                output.space();
+            }
            self.extends.print(output);
-            output.space();
+            if (parens) {
+                output.print(")");
+            } else {
+                output.space();
+            }
        }
        if (self.properties.length > 0) output.with_block(function(){
            self.properties.forEach(function(prop, i){
@@ -1617,45 +1659,14 @@ function OutputStream(options) {
        }
    });

-    function regexp_safe_literal(code) {
-        return [
-            0x5c   , // \
-            0x2f   , // /
-            0x2e   , // .
-            0x2b   , // +
-            0x2a   , // *
-            0x3f   , // ?
-            0x28   , // (
-            0x29   , // )
-            0x5b   , // [
-            0x5d   , // ]
-            0x7b   , // {
-            0x7d   , // }
-            0x24   , // $
-            0x5e   , // ^
-            0x3a   , // :
-            0x7c   , // |
-            0x21   , // !
-            0x0a   , // \n
-            0x0d   , // \r
-            0x00   , // \0
-            0xfeff , // Unicode BOM
-            0x2028 , // unicode "line separator"
-            0x2029 , // unicode "paragraph separator"
-        ].indexOf(code) < 0;
-    };
-
    DEFPRINT(AST_RegExp, function(self, output){
-        var str = self.getValue().toString();
+        var regexp = self.getValue();
+        var str = regexp.toString();
+        if (regexp.raw_source) {
+            str = "/" + regexp.raw_source + str.slice(str.lastIndexOf("/"));
+        }
        if (output.option("ascii_only")) {
            str = output.to_ascii(str);
-        } else if (output.option("unescape_regexps")) {
-            str = str.split("\\\\").map(function(str){
-                return str.replace(/\\u[0-9a-fA-F]{4}|\\x[0-9a-fA-F]{2}/g, function(s){
-                    var code = parseInt(s.substr(2), 16);
-                    return regexp_safe_literal(code) ? String.fromCharCode(code) : s;
-                });
-            }).join("\\\\");
        }
        output.print(str);
        var p = output.parent();
--- a/lib/parse.js
+++ b/lib/parse.js
@@ -611,31 +611,33 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
        return name;
    });

-    var read_regexp = with_eof_error("Unterminated regular expression", function(regexp){
+    var read_regexp = with_eof_error("Unterminated regular expression", function(source) {
        var prev_backslash = false, ch, in_class = false;
        while ((ch = next(true))) if (NEWLINE_CHARS(ch)) {
            parse_error("Unexpected line terminator");
        } else if (prev_backslash) {
-            regexp += "\\" + ch;
+            source += "\\" + ch;
            prev_backslash = false;
        } else if (ch == "[") {
            in_class = true;
-            regexp += ch;
+            source += ch;
        } else if (ch == "]" && in_class) {
            in_class = false;
-            regexp += ch;
+            source += ch;
        } else if (ch == "/" && !in_class) {
            break;
        } else if (ch == "\\") {
            prev_backslash = true;
        } else {
-            regexp += ch;
+            source += ch;
        }
        var mods = read_name();
        try {
-          return token("regexp", new RegExp(regexp, mods));
+            var regexp = new RegExp(source, mods);
+            regexp.raw_source = source;
+            return token("regexp", regexp);
        } catch(e) {
-          parse_error(e.message);
+            parse_error(e.message);
        }
    });

@@ -864,7 +866,7 @@ function parse($TEXT, options) {
        shebang        : true,
        strict         : false,
        toplevel       : null,
-    });
+    }, true);

    var S = {
        input         : (typeof $TEXT == "string"
@@ -1270,26 +1272,17 @@ function parse($TEXT, options) {
        });
    };

-    var arrow_function = function(args) {
+    var arrow_function = function(start, argnames) {
        if (S.token.nlb) {
            croak("Unexpected newline before arrow (=>)");
        }

        expect_token("arrow", "=>");

-        var argnames;
-        if (typeof args.length === 'number') {
-            argnames = args;
-        } else {
-            argnames = args.as_params(croak);
-        }
-
-        var body = is("punc", "{") ?
-            _function_body(true) :
-            _function_body(false);
+        var body = _function_body(is("punc", "{"));

        return new AST_Arrow({
-            start    : args.start,
+            start    : start,
            end      : body.end,
            argnames : argnames,
            body     : body
@@ -1613,8 +1606,6 @@ function parse($TEXT, options) {
    }

    function params_or_seq_() {
-        var start = S.token
-        expect("(");
        var first = true;
        var a = [];
        while (!is("punc", ")")) {
@@ -1624,23 +1615,17 @@ function parse($TEXT, options) {
                next();
                a.push(new AST_Expansion({
                    start: prev(),
-                    expression: expression(false),
+                    expression: expression(),
                    end: S.token,
                }));
                if (!is("punc", ")")) {
                    unexpected(spread_token);
                }
            } else {
-                a.push(expression(false));
+                a.push(expression());
            }
        }
-        var end = S.token
-        next();
-        return new AST_ArrowParametersOrSeq({
-            start: start,
-            end: end,
-            expressions: a
-        });
+        return a;
    }

    function _function_body(block, generator, name, args) {
@@ -1929,6 +1914,63 @@ function parse($TEXT, options) {
        return ret;
    };

+    function to_fun_args(ex, _, __, default_seen_above) {
+        var insert_default = function(ex, default_value) {
+            if (default_value) {
+                return new AST_DefaultAssign({
+                    start: ex.start,
+                    left: ex,
+                    operator: "=",
+                    right: default_value,
+                    end: default_value.end
+                });
+            }
+            return ex;
+        }
+        if (ex instanceof AST_Object) {
+            return insert_default(new AST_Destructuring({
+                start: ex.start,
+                end: ex.end,
+                is_array: false,
+                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) {
+            return ex;
+        } else if (ex instanceof AST_Destructuring) {
+            ex.names = ex.names.map(to_fun_args);
+            return insert_default(ex, default_seen_above);
+        } else if (ex instanceof AST_SymbolRef) {
+            return insert_default(new AST_SymbolFunarg({
+                name: ex.name,
+                start: ex.start,
+                end: ex.end
+            }), default_seen_above);
+        } else if (ex instanceof AST_Expansion) {
+            ex.expression = to_fun_args(ex.expression);
+            return insert_default(ex, default_seen_above);
+        } else if (ex instanceof AST_Array) {
+            return insert_default(new AST_Destructuring({
+                start: ex.start,
+                end: ex.end,
+                is_array: true,
+                names: ex.elements.map(to_fun_args)
+            }), default_seen_above);
+        } else if (ex instanceof AST_Assign) {
+            return insert_default(to_fun_args(ex.left, undefined, undefined, ex.right), default_seen_above);
+        } else if (ex instanceof AST_DefaultAssign) {
+            ex.left = to_fun_args(ex.left, 0, [ex.left]);
+            return ex;
+        } else {
+            croak("Invalid function parameter", ex.start.line, ex.start.col);
+        }
+    }
+
    var expr_atom = function(allow_calls) {
        if (is("operator", "new")) {
            return new_(allow_calls);
@@ -1937,13 +1979,15 @@ function parse($TEXT, options) {
        if (is("punc")) {
            switch (start.value) {
              case "(":
-                var ex = params_or_seq_();
+                next();
+                var exprs = params_or_seq_();
+                expect(")");
                if (is("arrow", "=>")) {
-                    ex.start = start;
-                    ex.end = S.token;
-                    return arrow_function(ex);
+                    return arrow_function(start, exprs.map(to_fun_args));
                }
-                ex = ex.as_expr(croak);
+                var ex = exprs.length == 1 ? exprs[0] : new AST_Sequence({
+                    expressions: exprs
+                });
                ex.start = start;
                ex.end = S.token;
                return subscripts(ex, allow_calls);
@@ -2373,14 +2417,28 @@ function parse($TEXT, options) {
            }
        }

-        var is_definition =
-            is("keyword", "var") || is("keyword", "let") || is("keyword", "const") ||
-            is("keyword", "class") || is("keyword", "function");
-
+        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 {
-            exported_value = expression();
+            exported_value = expression(false);
            semicolon();
        }

@@ -2412,7 +2470,8 @@ function parse($TEXT, options) {
                unexpected(tmp);
            }
          case "name":
-            if (tmp.value === "yield" && S.input.has_directive("use strict") && !is_in_generator()) {
+            if (tmp.value == "yield" && !is_token(peek(), "punc", ":")
+                && S.input.has_directive("use strict") && !is_in_generator()) {
                token_error(tmp, "Unexpected yield identifier inside strict mode");
            }
          case "string":
@@ -2668,7 +2727,7 @@ function parse($TEXT, options) {
        if (start.type == "punc" && start.value == "(" && peek().value == ")") {
            next();
            next();
-            return arrow_function([]);
+            return arrow_function(start, []);
        }

        if (is("name") && is_token(peek(), "arrow")) {
@@ -2678,7 +2737,7 @@ function parse($TEXT, options) {
                end: start,
            });
            next();
-            return arrow_function([param])
+            return arrow_function(start, [param]);
        }

        var left = maybe_conditional(no_in);
@@ -2709,16 +2768,7 @@ function parse($TEXT, options) {
            next();
            commas = true;
        }
-        if (exprs.length == 1) {
-            var expr = exprs[0];
-            if (!(expr instanceof AST_SymbolRef) || !is("arrow", "=>")) return expr;
-            return arrow_function(new AST_ArrowParametersOrSeq({
-                start: expr.start,
-                end: expr.end,
-                expressions: [expr]
-            }));
-        }
-        return new AST_Sequence({
+        return exprs.length == 1 ? exprs[0] : new AST_Sequence({
            start       : start,
            expressions : exprs,
            end         : peek()
--- a/lib/scope.js
+++ b/lib/scope.js
@@ -111,8 +111,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
    var labels = new Dictionary();
    var defun = null;
    var in_destructuring = null;
-    var in_export = false;
-    var in_block = 0;
    var for_scopes = [];
    var tw = new TreeWalker(function(node, descend){
        if (node.is_block_scope()) {
@@ -152,22 +150,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
            labels = save_labels;
            return true;        // don't descend again in TreeWalker
        }
-        if (node instanceof AST_Export) {
-            in_export = true;
-            descend();
-            in_export = false;
-            return true;
-        }
-        if (node instanceof AST_BlockStatement
-            || node instanceof AST_Switch
-            || node instanceof AST_Try
-            || node instanceof AST_Catch
-            || node instanceof AST_Finally) {
-            in_block++;
-            descend();
-            in_block--;
-            return true;
-        }
        if (node instanceof AST_LabeledStatement) {
            var l = node.label;
            if (labels.has(l.name)) {
@@ -194,7 +176,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
            node.references = [];
        }
        if (node instanceof AST_SymbolLambda) {
-            defun.def_function(node, in_export, in_block);
+            defun.def_function(node);
        }
        else if (node instanceof AST_SymbolDefun) {
            // Careful here, the scope where this should be defined is
@@ -206,23 +188,24 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
            while (parent_lambda.is_block_scope()) {
                parent_lambda = parent_lambda.parent_scope;
            }
-            (node.scope = parent_lambda).def_function(node, in_export, in_block);
+            mark_export((node.scope = parent_lambda).def_function(node), 1);
        }
        else if (node instanceof AST_SymbolClass) {
-            defun.def_variable(node, in_export, in_block);
+            mark_export(defun.def_variable(node), 1);
        }
        else if (node instanceof AST_SymbolImport) {
-            scope.def_variable(node, in_export, in_block);
+            scope.def_variable(node);
        }
        else if (node instanceof AST_SymbolDefClass) {
            // This deals with the name of the class being available
            // inside the class.
-            (node.scope = defun.parent_scope).def_function(node, in_export, in_block);
+            mark_export((node.scope = defun.parent_scope).def_function(node), 1);
        }
        else if (node instanceof AST_SymbolVar
            || node instanceof AST_SymbolLet
            || node instanceof AST_SymbolConst) {
-            var def = ((node instanceof AST_SymbolBlockDeclaration) ? scope : defun).def_variable(node, in_export, in_block);
+            var def = ((node instanceof AST_SymbolBlockDeclaration) ? scope : defun).def_variable(node);
+            if (!(node instanceof AST_SymbolFunarg)) mark_export(def, 2);
            def.destructuring = in_destructuring;
            if (defun !== scope) {
                node.mark_enclosed(options);
@@ -234,7 +217,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
            }
        }
        else if (node instanceof AST_SymbolCatch) {
-            scope.def_variable(node, in_export, in_block).defun = defun;
+            scope.def_variable(node).defun = defun;
        }
        else if (node instanceof AST_LabelRef) {
            var sym = labels.get(node.name);
@@ -245,28 +228,17 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
            }));
            node.thedef = sym;
        }
+
+        function mark_export(def, level) {
+            var node = tw.parent(level);
+            def.export = node instanceof AST_Export && !node.is_default;
+        }
    });
    self.walk(tw);

    // pass 2: find back references and eval
-    var func = null;
-    var cls = null;
-    var globals = self.globals = new Dictionary();
+    self.globals = new Dictionary();
    var tw = new TreeWalker(function(node, descend){
-        if (node instanceof AST_Lambda) {
-            var prev_func = func;
-            func = node;
-            descend();
-            func = prev_func;
-            return true;
-        }
-        if (node instanceof AST_Class) {
-            var prev_cls = cls;
-            cls = node;
-            descend();
-            cls = prev_cls;
-            return true;
-        }
        if (node instanceof AST_LoopControl && node.label) {
            node.label.thedef.references.push(node);
            return true;
@@ -351,22 +323,13 @@ AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
    this.cname = -1;                    // the current index for mangling functions/variables
 });

-AST_Node.DEFMETHOD("is_block_scope", function(){
-    return false; // Behaviour will be overridden by AST_Block
-});
-
-AST_Block.DEFMETHOD("is_block_scope", function(){
-    return (
-        !(this instanceof AST_Lambda) &&
-        !(this instanceof AST_Toplevel) &&
-        !(this instanceof AST_Class) &&
-        !(this instanceof AST_SwitchBranch)
-    );
-});
-
-AST_IterationStatement.DEFMETHOD("is_block_scope", function(){
-     return true;
-});
+AST_Node.DEFMETHOD("is_block_scope", return_false);
+AST_Class.DEFMETHOD("is_block_scope", return_false);
+AST_Lambda.DEFMETHOD("is_block_scope", return_false);
+AST_Toplevel.DEFMETHOD("is_block_scope", return_false);
+AST_SwitchBranch.DEFMETHOD("is_block_scope", return_false);
+AST_Block.DEFMETHOD("is_block_scope", return_true);
+AST_IterationStatement.DEFMETHOD("is_block_scope", return_true);

 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
    AST_Scope.prototype.init_scope_vars.apply(this, arguments);
@@ -404,24 +367,19 @@ AST_Scope.DEFMETHOD("find_variable", function(name){
        || (this.parent_scope && this.parent_scope.find_variable(name));
 });

-AST_Scope.DEFMETHOD("def_function", function(symbol, in_export, in_block){
-    this.functions.set(symbol.name, this.def_variable(symbol, in_export, in_block));
+AST_Scope.DEFMETHOD("def_function", function(symbol){
+    var def = this.def_variable(symbol);
+    this.functions.set(symbol.name, def);
+    return def;
 });

-AST_Scope.DEFMETHOD("def_variable", function(symbol, in_export, in_block){
+AST_Scope.DEFMETHOD("def_variable", function(symbol){
    var def;
    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;
-        if (in_export) {
-            def.export = true;
-        }
-        if (in_block && symbol instanceof AST_SymbolBlockDeclaration) {
-            def.global = false;
-        } else {
-            def.global = !this.parent_scope;
-        }
+        def.global = !this.parent_scope;
    } else {
        def = this.variables.get(symbol.name);
        def.orig.push(symbol);
@@ -474,9 +432,7 @@ AST_Symbol.DEFMETHOD("unmangleable", function(options){
 });

 // labels are always mangleable
-AST_Label.DEFMETHOD("unmangleable", function(){
-    return false;
-});
+AST_Label.DEFMETHOD("unmangleable", return_false);

 AST_Symbol.DEFMETHOD("unreferenced", function(){
    return this.definition().references.length == 0
@@ -487,13 +443,9 @@ AST_Symbol.DEFMETHOD("undeclared", function(){
    return this.definition().undeclared;
 });

-AST_LabelRef.DEFMETHOD("undeclared", function(){
-    return false;
-});
+AST_LabelRef.DEFMETHOD("undeclared", return_false);

-AST_Label.DEFMETHOD("undeclared", function(){
-    return false;
-});
+AST_Label.DEFMETHOD("undeclared", return_false);

 AST_Symbol.DEFMETHOD("definition", function(){
    return this.thedef;
@@ -569,7 +521,6 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
    });
    this.walk(tw);
    to_mangle.forEach(function(def){
-        if (def.destructuring && !def.destructuring.is_array) return;
        def.mangle(options);
    });

--- a/lib/transform.js
+++ b/lib/transform.js
@@ -240,6 +240,7 @@ TreeTransformer.prototype = new TreeWalker;
    });

    _(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);
    });

--- a/package.json
+++ b/package.json
@@ -4,7 +4,7 @@
  "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.7",
+  "version": "3.0.13",
  "engines": {
    "node": ">=0.8.0"
  },
@@ -34,10 +34,11 @@
  },
  "devDependencies": {
    "acorn": "~5.0.3",
-    "mocha": "~2.3.4"
+    "mocha": "~2.3.4",
+    "semver": "~5.3.0"
  },
  "scripts": {
    "test": "node test/run-tests.js"
  },
-  "keywords": ["uglify", "uglify-js", "minify", "minifier"]
+  "keywords": ["uglify", "uglify-js", "uglify-es", "minify", "minifier", "es5", "es6", "es2015"]
 }
--- a/test/benchmark.js
+++ b/test/benchmark.js
@@ -9,7 +9,7 @@ var args = process.argv.slice(2);
 if (!args.length) {
    args.push("-mc");
 }
-args.push("--stats");
+args.push("--timings");
 var urls = [
    "https://code.jquery.com/jquery-3.2.1.js",
    "https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.4/angular.js",
@@ -29,12 +29,7 @@ function done() {
            var info = results[url];
            console.log();
            console.log(url);
-            var elapsed = 0;
-            console.log(info.log.replace(/Elapsed: ([0-9]+)\s*/g, function(match, time) {
-                elapsed += 1e-3 * parseInt(time);
-                return "";
-            }));
-            console.log("Run-time:", elapsed.toFixed(3), "s");
+            console.log(info.log);
            console.log("Original:", info.input, "bytes");
            console.log("Uglified:", info.output, "bytes");
            console.log("SHA1 sum:", info.sha1);
--- a/test/compress/dead-code.js
+++ b/test/compress/dead-code.js
@@ -31,7 +31,7 @@ dead_code_2_should_warn: {
        function f() {
            g();
            x = 10;
-            throw "foo";
+            throw new Error("foo");
            // completely discarding the `if` would introduce some
            // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
            // we copy any declarations to the upper scope.
@@ -46,16 +46,60 @@ dead_code_2_should_warn: {
                })();
            }
        }
+        f();
    }
    expect: {
        function f() {
            g();
            x = 10;
-            throw "foo";
+            throw new Error("foo");
            var x;
-            function g(){};
+            var g;
        }
+        f();
    }
+    expect_stdout: true
+    node_version: ">=6"
+}
+
+dead_code_2_should_warn_strict: {
+    options = {
+        dead_code: true
+    };
+    input: {
+        "use strict";
+        function f() {
+            g();
+            x = 10;
+            throw new Error("foo");
+            // completely discarding the `if` would introduce some
+            // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
+            // we copy any declarations to the upper scope.
+            if (x) {
+                y();
+                var x;
+                function g(){};
+                // but nested declarations should not be kept.
+                (function(){
+                    var q;
+                    function y(){};
+                })();
+            }
+        }
+        f();
+    }
+    expect: {
+        "use strict";
+        function f() {
+            g();
+            x = 10;
+            throw new Error("foo");
+            var x;
+        }
+        f();
+    }
+    expect_stdout: true
+    node_version: ">=4"
 }

 dead_code_constant_boolean_should_warn_more: {
@@ -78,16 +122,55 @@ dead_code_constant_boolean_should_warn_more: {
            foo();
            var moo;
        }
+        bar();
    }
    expect: {
        var foo;
-        function bar() {}
+        var bar;
        // nothing for the while
        // as for the for, it should keep:
        var x = 10, y;
        var moo;
+        bar();
    }
    expect_stdout: true
+    node_version: ">=6"
+}
+
+dead_code_constant_boolean_should_warn_more_strict: {
+    options = {
+        dead_code    : true,
+        loops        : true,
+        booleans     : true,
+        conditionals : true,
+        evaluate     : true,
+        side_effects : true,
+    };
+    input: {
+        "use strict";
+        while (!((foo && bar) || (x + "0"))) {
+            console.log("unreachable");
+            var foo;
+            function bar() {}
+        }
+        for (var x = 10, y; x && (y || x) && (!typeof x); ++x) {
+            asdf();
+            foo();
+            var moo;
+        }
+        bar();
+    }
+    expect: {
+        "use strict";
+        var foo;
+        // nothing for the while
+        // as for the for, it should keep:
+        var x = 10, y;
+        var moo;
+        bar();
+    }
+    expect_stdout: true
+    node_version: ">=4"
 }

 dead_code_block_decls_die: {
@@ -134,7 +217,7 @@ dead_code_const_declaration: {
        var unused;
        const CONST_FOO = !1;
        var moo;
-        function bar() {}
+        var bar;
    }
    expect_stdout: true
 }
@@ -162,7 +245,7 @@ dead_code_const_annotation: {
        var unused;
        var CONST_FOO_ANN = !1;
        var moo;
-        function bar() {}
+        var bar;
    }
    expect_stdout: true
 }
@@ -229,7 +312,7 @@ dead_code_const_annotation_complex_scope: {
        var CONST_FOO_ANN = !1;
        var unused_var_2;
        var moo;
-        function bar() {}
+        var bar;
        var beef = 'good';
        var meat = 'beef';
        var pork = 'bad';
--- a/test/compress/destructuring.js
+++ b/test/compress/destructuring.js
@@ -328,5 +328,218 @@ issue_1886: {
        let [a] = [1];
        console.log(a);
    }
-    expect_exact: "1"
+}
+
+destructuring_decl_of_numeric_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let { 3: x } = { [1 + 2]: 42 };
+        console.log(x);
+    }
+    expect: {
+        let { 3: x } = { [3]: 42 };
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+destructuring_decl_of_computed_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let four = 4;
+        let { [7 - four]: x } = { [1 + 2]: 42 };
+        console.log(x);
+    }
+    expect: {
+        let four = 4;
+        let { [7 - four]: x } = { [3]: 42 };
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+destructuring_assign_of_numeric_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let x;
+        ({ 3: x } = { [1 + 2]: 42 });
+        console.log(x);
+    }
+    expect: {
+        let x;
+        ({ 3: x } = { [3]: 42 });
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+destructuring_assign_of_computed_key: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    input: {
+        let x;
+        let four = 4;
+        ({ [(5 + 2) - four]: x } = { [1 + 2]: 42 });
+        console.log(x);
+    }
+    expect: {
+        let x;
+        let four = 4;
+        ({ [7 - four]: x } = { [3]: 42 });
+        console.log(x);
+    }
+    expect_stdout: "42"
+    node_version: ">=6"
+}
+
+mangle_destructuring_decl: {
+    options = {
+        evaluate: true,
+        unused: true,
+    }
+    mangle = {
+    }
+    input: {
+        function test(opts) {
+            let a = opts.a || { e: 7, n: 8 };
+            let { t, e, n, s =  5 + 4, o, r } = a;
+            console.log(t, e, n, s, o, r);
+        }
+        test({a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 }});
+        test({});
+    }
+    expect: {
+        function test(t) {
+            let e = t.a || { e: 7, n: 8 };
+            let {t: n,  e: o,  n: s,  s: a = 9,  o: c,  r: l} = e;
+            console.log(n, o, s, a, c, l);
+        }
+        test({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
+        test({});
+    }
+    expect_stdout: [
+        "1 2 3 4 5 6",
+        "undefined 7 8 9 undefined undefined",
+    ]
+    node_version: ">=6"
+}
+
+mangle_destructuring_assign_toplevel_true: {
+    options = {
+        toplevel: true,
+        evaluate: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        function test(opts) {
+            let s, o, r;
+            let a = opts.a || { e: 7, n: 8 };
+            ({ t, e, n, s =  5 + 4, o, r } = a);
+            console.log(t, e, n, s, o, r);
+        }
+        let t, e, n;
+        test({a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 }});
+        test({});
+    }
+    expect: {
+        function 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);
+        }
+        let o, e, s;
+        n({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
+        n({});
+    }
+    expect_stdout: [
+        "1 2 3 4 5 6",
+        "undefined 7 8 9 undefined undefined",
+    ]
+    node_version: ">=6"
+}
+
+mangle_destructuring_assign_toplevel_false: {
+    options = {
+        toplevel: false,
+        evaluate: true,
+        unused: true,
+    }
+    mangle = {
+        toplevel: false,
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        function test(opts) {
+            let s, o, r;
+            let a = opts.a || { e: 7, n: 8 };
+            ({ t, e, n, s = 9, o, r } = a);
+            console.log(t, e, n, s, o, r);
+        }
+        let t, e, n;
+        test({a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 }});
+        test({});
+    }
+    expect: {
+        function test(o) {
+            let s, 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 t, e, n;
+        test({ a: { t: 1, e: 2, n: 3, s: 4, o: 5, r: 6 } });
+        test({});
+    }
+    expect_stdout: [
+        "1 2 3 4 5 6",
+        "undefined 7 8 9 undefined undefined",
+    ]
+    node_version: ">=6"
+}
+
+mangle_destructuring_decl_array: {
+    options = {
+        evaluate: true,
+        unused: true,
+        toplevel: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        var [, t, e, n, s, o = 2, r = [ 1 + 2 ]] = [ 9, 8, 7, 6 ];
+        console.log(t, e, n, s, o, r);
+    }
+    expect: {
+        var [, o,  l,  a,  c,  e = 2,  g = [ 3 ]] = [ 9, 8, 7, 6 ];
+        console.log(o, l, a, c, e, g);
+    }
+    expect_stdout: "8 7 6 undefined 2 [ 3 ]"
+    node_version: ">=6"
 }
--- a/test/compress/drop-unused.js
+++ b/test/compress/drop-unused.js
@@ -1253,3 +1253,30 @@ reassign_const: {
    }
    expect_stdout: true
 }
+
+issue_1968: {
+    options = {
+        unused: true,
+    }
+    input: {
+        function f(c) {
+            var a;
+            if (c) {
+                let b;
+                return (a = 2) + (b = 3);
+            }
+        }
+        console.log(f(1));
+    }
+    expect: {
+        function f(c) {
+            if (c) {
+                let b;
+                return 2 + (b = 3);
+            }
+        }
+        console.log(f(1));
+    }
+    expect_stdout: "5"
+    node_version: ">=6"
+}
--- a/test/compress/evaluate.js
+++ b/test/compress/evaluate.js
@@ -1083,3 +1083,50 @@ Infinity_NaN_undefined_LHS: {
        "}",
    ]
 }
+
+issue_1964_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe_regexp: false,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect_stdout: "b"
+}
+
+issue_1964_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe_regexp: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            return "a b c".split(/\s/)[1];
+        }
+        console.log(f());
+    }
+    expect_stdout: "b"
+}
--- a/test/compress/functions.js
+++ b/test/compress/functions.js
@@ -167,3 +167,81 @@ function_returning_constant_literal: {
    }
    expect_stdout: "Hello there"
 }
+
+hoist_funs: {
+    options = {
+        hoist_funs: true,
+    }
+    input: {
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            function f() {}
+            console.log(5, typeof f, typeof g);
+        }
+        function g() {}
+        console.log(6, typeof f, typeof g);
+    }
+    expect: {
+        function g() {}
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            function f() {}
+            console.log(5, typeof f, typeof g);
+        }
+        console.log(6, typeof f, typeof g);
+    }
+    expect_stdout: [
+        "1 'undefined' 'function'",
+        "2 'undefined' 'function'",
+        "4 'function' 'function'",
+        "5 'function' 'function'",
+        "6 'function' 'function'",
+    ]
+    node_version: ">=6"
+}
+
+hoist_funs_strict: {
+    options = {
+        hoist_funs: true,
+    }
+    input: {
+        "use strict";
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            function f() {}
+            console.log(5, typeof f, typeof g);
+        }
+        function g() {}
+        console.log(6, typeof f, typeof g);
+    }
+    expect: {
+        "use strict";
+        function g() {}
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            function f() {}
+            console.log(5, typeof f, typeof g);
+        }
+        console.log(6, typeof f, typeof g);
+    }
+    expect_stdout: [
+        "1 'undefined' 'function'",
+        "2 'undefined' 'function'",
+        "4 'function' 'function'",
+        "5 'function' 'function'",
+        "6 'undefined' 'function'",
+    ]
+    node_version: ">=4"
+}
--- a/test/compress/global_defs.js
+++ b/test/compress/global_defs.js
@@ -160,3 +160,17 @@ issue_1801: {
        console.log(!0);
    }
 }
+
+issue_1986: {
+    options = {
+        global_defs: {
+            "@alert": "console.log",
+        },
+    }
+    input: {
+        alert(42);
+    }
+    expect: {
+        console.log(42);
+    }
+}
--- a/test/compress/harmony.js
+++ b/test/compress/harmony.js
@@ -241,6 +241,30 @@ export_default_array: {
    expect_exact: "export default[3,foo];"
 }

+export_default_anon_function: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        export default function(){
+            console.log(1 + 2);
+        }
+    }
+    expect_exact: "export default function(){console.log(3)};"
+}
+
+export_default_anon_class: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        export default class {
+            foo() { console.log(1 + 2); }
+        }
+    }
+    expect_exact: "export default class{foo(){console.log(3)}};"
+}
+
 export_module_statement: {
    input: {
        export * from "a.js";
@@ -509,3 +533,53 @@ issue_1753_disable: {
        }
    }
 }
+
+class_extends: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        function f() {
+            class foo extends bar {}
+            class pro extends some.prop {}
+            class arr extends stuff[1 - 1] {}
+            class bin extends (a || b) {}
+            class seq extends (a, b) {}
+            class ter extends (a ? b : c) {}
+            class uni extends (!0) {}
+        }
+    }
+    expect_exact: "function f(){class foo extends bar{}class pro extends some.prop{}class arr extends stuff[0]{}class bin extends(a||b){}class seq extends(a,b){}class ter extends(a?b:c){}class uni extends(!0){}}"
+}
+
+class_extends_class: {
+    options = {
+    }
+    input: {
+        class anon extends class {} {}
+        class named extends class base {} {}
+    }
+    expect_exact: "class anon extends class{}{}class named extends class base{}{}"
+}
+
+class_extends_function: {
+    options = {
+    }
+    input: {
+        class anon extends function(){} {}
+        class named extends function base(){} {}
+    }
+    expect_exact: "class anon extends function(){}{}class named extends function base(){}{}"
+}
+
+class_extends_regex: {
+    options = {
+    }
+    input: {
+        function f() {
+            class rx1 extends (/rx/) {}
+            // class rx2 extends /rx/ {}  // FIXME - parse error
+        }
+    }
+    expect_exact: "function f(){class rx1 extends(/rx/){}}"
+}
--- a/test/compress/if_return.js
+++ b/test/compress/if_return.js
@@ -302,3 +302,85 @@ issue_1437_conditionals: {
        }
    }
 }
+
+issue_512: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function a() {
+            if (b()) {
+                c();
+                return;
+            }
+            throw e;
+        }
+    }
+    expect: {
+        function a() {
+            if (!b()) throw e;
+            c();
+        }
+    }
+}
+
+issue_1317: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect: {
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect_stdout: "1"
+    node_version: ">=6"
+}
+
+issue_1317_strict: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect: {
+        "use strict";
+        !function(a) {
+            if (a) return;
+            let b = 1;
+            function g() {
+                return b;
+            }
+            console.log(g());
+        }();
+    }
+    expect_stdout: "1"
+    node_version: ">=4"
+}
--- a/test/compress/issue-1034.js
+++ b/test/compress/issue-1034.js
@@ -116,3 +116,137 @@ non_hoisted_function_after_return_2b: {
        "WARN: Dropping unreachable code [test/compress/issue-1034.js:101,12]",
    ]
 }
+
+non_hoisted_function_after_return_strict: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar();
+                not_called1();
+            } else {
+                return baz();
+                not_called2();
+            }
+            function bar() { return 7; }
+            return not_reached;
+            function UnusedFunction() {}
+            function baz() { return 8; }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return x ? bar() : baz();
+            function bar() { return 7 }
+            function baz() { return 8 }
+        }
+        console.log(foo(0), foo(1));
+    }
+    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]"
+    ]
+}
+
+non_hoisted_function_after_return_2a_strict: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        collapse_vars: false, passes: 2, warnings: "verbose"
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar(1);
+                var a = not_called(1);
+            } else {
+                return bar(2);
+                var b = not_called(2);
+            }
+            var c = bar(3);
+            function bar(x) { return 7 - x; }
+            function nope() {}
+            return b || c;
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return bar(x ? 1 : 2);
+            function bar(x) {
+                return 7 - x;
+            }
+        }
+        console.log(foo(0), foo(1));
+    }
+    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]",
+    ]
+}
+
+non_hoisted_function_after_return_2b_strict: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        collapse_vars: false
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar(1);
+            } else {
+                return bar(2);
+                var b;
+            }
+            var c = bar(3);
+            function bar(x) {
+                return 7 - x;
+            }
+            return b || c;
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return bar(x ? 1 : 2);
+            function bar(x) { return 7 - x; }
+        }
+        console.log(foo(0), foo(1));
+    }
+    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:231,12]",
+    ]
+}
--- a/test/compress/issue-1052.js
+++ b/test/compress/issue-1052.js
@@ -1,90 +1,91 @@
 multiple_functions: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
    input: {
        ( function() {
            if ( !window ) {
                return;
            }
-
            function f() {}
            function g() {}
        } )();
    }
    expect: {
        ( function() {
-            function f() {}
-            function g() {}
-
            // NOTE: other compression steps will reduce this
            // down to just `window`.
            if ( window );
+            function f() {}
+            function g() {}
        } )();
    }
 }

 single_function: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
    input: {
        ( function() {
            if ( !window ) {
                return;
            }
-
            function f() {}
        } )();
    }
    expect: {
        ( function() {
-            function f() {}
-
            if ( window );
+            function f() {}
        } )();
    }
 }

 deeply_nested: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
    input: {
        ( function() {
            if ( !window ) {
                return;
            }
-
            function f() {}
            function g() {}
-
            if ( !document ) {
                return;
            }
-
            function h() {}
        } )();
    }
    expect: {
        ( function() {
-            function f() {}
-            function g() {}
-
-            function h() {}
-
            // NOTE: other compression steps will reduce this
            // down to just `window`.
            if ( window )
                if (document);
+            function f() {}
+            function g() {}
+            function h() {}
        } )();
    }
 }

 not_hoisted_when_already_nested: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
    input: {
        ( function() {
            if ( !window ) {
                return;
            }
-
            if ( foo ) function f() {}
-
        } )();
    }
    expect: {
@@ -94,3 +95,69 @@ not_hoisted_when_already_nested: {
        } )();
    }
 }
+
+defun_if_return: {
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
+    input: {
+        function e() {
+            function f() {}
+            if (!window) return;
+            else function g() {}
+            function h() {}
+        }
+    }
+    expect: {
+        function e() {
+            function f() {}
+            if (window) function g() {}
+            function h() {}
+        }
+    }
+}
+
+defun_hoist_funs: {
+    options = {
+        hoist_funs: true,
+        if_return: true,
+    }
+    input: {
+        function e() {
+            function f() {}
+            if (!window) return;
+            else function g() {}
+            function h() {}
+        }
+    }
+    expect: {
+        function e() {
+            function f() {}
+            function h() {}
+            if (window) function g() {}
+        }
+    }
+}
+
+defun_else_if_return: {
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
+    input: {
+        function e() {
+            function f() {}
+            if (window) function g() {}
+            else return;
+            function h() {}
+        }
+    }
+    expect: {
+        function e() {
+            function f() {}
+            if (window) function g() {}
+            function h() {}
+        }
+    }
+}
--- a/test/compress/issue-2001.js
+++ b/test/compress/issue-2001.js
@@ -0,0 +1,281 @@
+export_func_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f(){};
+    }
+    expect_exact: "export function f(){};"
+}
+
+export_func_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f(){}(1);
+    }
+    expect_exact: "export function f(){};1;"
+}
+
+export_func_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export function f(){}(1);
+    }
+    expect_exact: "export function f(){};"
+}
+
+export_default_func_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){};
+    }
+    expect_exact: "export default function(){};"
+}
+
+export_default_func_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){}(1);
+    }
+    expect_exact: "export default function(){};1;"
+}
+
+export_default_func_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){}(1);
+    }
+    expect_exact: "export default function(){};"
+}
+
+export_class_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export class C {};
+    }
+    expect_exact: "export class C{};"
+}
+
+export_class_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export class C {}(1);
+    }
+    expect_exact: "export class C{};1;"
+}
+
+export_class_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export class C {}(1);
+    }
+    expect_exact: "export class C{};"
+}
+
+export_default_class_1: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class C {};
+    }
+    expect_exact: "export default class{};"
+}
+
+export_default_class_2: {
+    options = {
+        hoist_funs: true,
+        side_effects: false,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class C {}(1);
+    }
+    expect_exact: "export default class{};1;"
+}
+
+export_default_class_3: {
+    options = {
+        hoist_funs: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default class C {}(1);
+    }
+    expect_exact: "export default class{};"
+}
+
+export_mangle_1: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export function foo(one, two) {
+            return one - two;
+        };
+    }
+    expect_exact: "export function foo(n,o){return n-o};"
+}
+
+export_mangle_2: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default function foo(one, two) {
+            return one - two;
+        };
+    }
+    expect_exact: "export default function n(n,r){return n-r};"
+}
+
+export_mangle_3: {
+    options = {
+        collapse_vars: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export class C {
+            go(one, two) {
+                var z = one;
+                return one - two + z;
+            }
+        };
+    }
+    expect_exact: "export class C{go(n,r){return n-r+n}};"
+}
+
+export_mangle_4: {
+    options = {
+        collapse_vars: true,
+    }
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default class C {
+            go(one, two) {
+                var z = one;
+                return one - two + z;
+            }
+        };
+    }
+    expect_exact: "export default class n{go(n,r){return n-r+n}};"
+}
+
+export_mangle_5: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        export default {
+            prop: function(one, two) {
+                return one - two;
+            }
+        };
+    }
+    expect_exact: "export default{prop:function(n,r){return n-r}};"
+}
+
+export_mangle_6: {
+    mangle = {
+        toplevel: true,
+    }
+    input: {
+        var baz = 2;
+        export let foo = 1, bar = baz;
+    }
+    expect_exact: "var a=2;export let foo=1,bar=a;"
+}
+
+export_toplevel_1: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(){}
+        export function g(){};
+        export default function h(){};
+    }
+    expect: {
+        export function g(){};
+        export default function(){};
+    }
+}
+
+export_toplevel_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        class A {}
+        export class B {};
+        export default class C {};
+    }
+    expect: {
+        export class B {};
+        export default class {};
+    }
+}
+
+export_default_func_ref: {
+    options = {
+        hoist_funs: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        export default function f(){};
+        f();
+    }
+    expect_exact: "export default function f(){};f();"
+}
--- a/test/compress/node_version.js
+++ b/test/compress/node_version.js
@@ -0,0 +1,12 @@
+eval_let: {
+    input: {
+        eval("let a;");
+        console.log();
+    }
+    expect: {
+        eval("let a;");
+        console.log();
+    }
+    expect_stdout: ""
+    node_version: ">=6"
+}
--- a/test/compress/string-literal.js
+++ b/test/compress/string-literal.js
@@ -8,3 +8,12 @@ octal_escape_sequence: {
        var border_check = "\x20\x30\x38\x30\x00\x30\xc0\x30";
    }
 }
+
+issue_1929: {
+    input: {
+        function f(s) {
+            return s.split(/[\\/]/);
+        }
+    }
+    expect_exact: "function f(s){return s.split(/[\\\\/]/)}"
+}
--- a/test/compress/yield.js
+++ b/test/compress/yield.js
@@ -190,3 +190,12 @@ yield_sub: {
    }
    expect_exact: 'function*foo(){yield x["foo"];(yield x)["foo"];yield(yield obj.foo())["bar"]()}'
 }
+
+yield_as_ES5_property: {
+    input: {
+        "use strict";
+        console.log({yield: 42}.yield);
+    }
+    expect_exact: '"use strict";console.log({yield:42}.yield);'
+    expect_stdout: "42"
+}
--- a/test/input/issue-505/input.js
+++ b/test/input/issue-505/input.js
@@ -0,0 +1,5 @@
+function test(callback) {
+    'aaaaaaaaaaaaaaaa';
+    callback(err, data);
+    callback(err, data);
+}
--- a/test/input/issue-505/output.js
+++ b/test/input/issue-505/output.js
@@ -0,0 +1,5 @@
+function test(a){
+"aaaaaaaaaaaaaaaa"
+;a(err,data),a(err,data)
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsidGVzdCIsImNhbGxiYWNrIiwiZXJyIiwiZGF0YSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsS0FBS0M7QUFDVjtDQUNBQSxFQUFTQyxJQUFLQyxNQUNkRixFQUFTQyxJQUFLQyJ9
--- a/test/input/issue-520/output.js
+++ b/test/input/issue-520/output.js
@@ -1,2 +1,2 @@
 new function(){console.log(3)};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUErQyxHQUFyQyxZQUFnQkEsUUFBUUMsSUFBSSIsInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUErQyxJQUFyQyxXQUFnQkEsUUFBUUMsSUFBSSIsInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl19
--- a/test/jetstream.js
+++ b/test/jetstream.js
@@ -14,7 +14,7 @@ if (typeof phantom == "undefined") {
    if (!args.length) {
        args.push("-mc");
    }
-    args.push("--stats");
+    args.push("--timings");
    var child_process = require("child_process");
    try {
        require("phantomjs-prebuilt");
--- a/test/mocha/cli.js
+++ b/test/mocha/cli.js
@@ -19,7 +19,9 @@ describe("bin/uglifyjs", function () {
            eval(stdout);

            assert.strictEqual(typeof WrappedUglifyJS, 'object');
-            assert.strictEqual(WrappedUglifyJS.minify("foo([true,,2+3]);").code, "foo([!0,,5]);");
+            var result = WrappedUglifyJS.minify("foo([true,,2+3]);");
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, "foo([!0,,5]);");

            done();
        });
@@ -61,7 +63,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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=\n");
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DIn0=\n");
            done();
        });
    });
@@ -173,7 +175,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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=",
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DIn0=",
                "",
            ].join("\n"));
            assert.strictEqual(stderr, "WARN: inline source map not found\n");
@@ -527,7 +529,7 @@ describe("bin/uglifyjs", function () {

            assert.strictEqual(stdout, [
                '"use strict";var foo=function foo(x){return"foo "+x};console.log(foo("bar"));',
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImZvbyIsIngiLCJjb25zb2xlIiwibG9nIl0sIm1hcHBpbmdzIjoiWUFBQSxJQUFJQSxLQUFNLFFBQU5BLEtBQU1DLEdBQUEsTUFBSyxPQUFTQSxFQUN4QkMsU0FBUUMsSUFBSUgsSUFBSSJ9",
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImZvbyIsIngiLCJjb25zb2xlIiwibG9nIl0sIm1hcHBpbmdzIjoiYUFBQSxJQUFJQSxJQUFNLFNBQU5BLElBQU1DLEdBQUEsTUFBSyxPQUFTQSxHQUN4QkMsUUFBUUMsSUFBSUgsSUFBSSJ9",
                ""
            ].join("\n"));
            done();
@@ -550,4 +552,13 @@ describe("bin/uglifyjs", function () {
            done();
        });
    });
+    it("Should print supported options on invalid option syntax", function(done) {
+        var command = uglifyjscmd + " test/input/comments/filter.js -b ascii-only";
+        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);
+            done();
+        });
+    });
 });
--- a/test/mocha/minify.js
+++ b/test/mocha/minify.js
@@ -138,13 +138,25 @@ describe("minify", function() {
            });
            var code = result.code;
            assert.strictEqual(code, "var a=function(n){return n};\n" +
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsiYSIsImZvbyJdLCJtYXBwaW5ncyI6IkFBQUEsR0FBSUEsR0FBSSxTQUFTQyxHQUFPLE1BQU9BIn0=");
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsiYSIsImZvbyJdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSUEsRUFBSSxTQUFTQyxHQUFPLE9BQU9BIn0=");
        });
        it("should not append source map to output js when sourceMapInline is not enabled", function() {
            var result = Uglify.minify('var a = function(foo) { return foo; };');
            var code = result.code;
            assert.strictEqual(code, "var a=function(n){return n};");
        });
+        it("should work with max_line_len", function() {
+            var result = Uglify.minify(read("./test/input/issue-505/input.js"), {
+                output: {
+                    max_line_len: 20
+                },
+                sourceMap: {
+                    url: "inline"
+                }
+            });
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, read("./test/input/issue-505/output.js"));
+        });
    });

    describe("#__PURE__", function() {
@@ -181,4 +193,19 @@ describe("minify", function() {
            assert.strictEqual(err.col, 12);
        });
    });
+
+    describe("global_defs", function() {
+        it("should throw for non-trivial expressions", function() {
+            var result = Uglify.minify("alert(42);", {
+                compress: {
+                    global_defs: {
+                        "@alert": "debugger"
+                    }
+                }
+            });
+            var err = result.error;
+            assert.ok(err instanceof Error);
+            assert.strictEqual(err.stack.split(/\n/)[0], "Error: Can't handle expression: debugger");
+        });
+    });
 });
--- a/test/mocha/spidermonkey.js
+++ b/test/mocha/spidermonkey.js
@@ -15,7 +15,9 @@ describe("spidermonkey export/import sanity test", function() {

            eval(stdout);
            assert.strictEqual(typeof SpiderUglify, "object");
-            assert.strictEqual(SpiderUglify.minify("foo([true,,2+3]);").code, "foo([!0,,5]);");
+            var result = SpiderUglify.minify("foo([true,,2+3]);");
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, "foo([!0,,5]);");

            done();
        });
--- a/test/mocha/yield.js
+++ b/test/mocha/yield.js
@@ -65,9 +65,9 @@ describe("Yield", function() {
        );
    });

-    it("Should not allow yield to be used as symbol, identifier or property outside generators in strict mode", function() {
+    it("Should not allow yield to be used as symbol, identifier or shorthand property outside generators in strict mode", function() {
        var tests = [
-            // Fail as as_symbol
+            // Fail in as_symbol
            '"use strict"; import yield from "bar";',
            '"use strict"; yield = 123;',
            '"use strict"; yield: "123";',
@@ -79,13 +79,12 @@ describe("Yield", function() {
            '"use strict"; var yield = "foo";',
            '"use strict"; class yield {}',

-            // Fail as maybe_assign
+            // Fail in maybe_assign
            '"use strict"; var foo = yield;',
            '"use strict"; var foo = bar = yield',

-            // Fail as as_property_name
+            // Fail in as_property_name
            '"use strict"; var foo = {yield};',
-            '"use strict"; var bar = {yield: "foo"};'
        ];

        var fail = function(e) {
@@ -103,4 +102,4 @@ describe("Yield", function() {
            assert.throws(test(tests[i]), fail, tests[i]);
        }
    });
-});
+});
--- a/test/run-tests.js
+++ b/test/run-tests.js
@@ -5,6 +5,7 @@ var path = require("path");
 var fs = require("fs");
 var assert = require("assert");
 var sandbox = require("./sandbox");
+var semver = require("semver");

 var tests_dir = path.dirname(module.filename);
 var failures = 0;
@@ -164,7 +165,8 @@ function run_compress_tests() {
                        failed_files[file] = 1;
                    }
                }
-                if (test.expect_stdout) {
+                if (test.expect_stdout
+                    && (!test.node_version || semver.satisfies(process.version, test.node_version))) {
                    var stdout = sandbox.run_code(input_code);
                    if (test.expect_stdout === true) {
                        test.expect_stdout = stdout;
@@ -274,7 +276,14 @@ function parse_test(file) {
            if (node instanceof U.AST_LabeledStatement) {
                var label = node.label;
                assert.ok(
-                    ["input", "expect", "expect_exact", "expect_warnings", "expect_stdout"].indexOf(label.name) >= 0,
+                    [
+                        "input",
+                        "expect",
+                        "expect_exact",
+                        "expect_warnings",
+                        "expect_stdout",
+                        "node_version",
+                    ].indexOf(label.name) >= 0,
                    tmpl("Unsupported label {name} [{line},{col}]", {
                        name: label.name,
                        line: label.start.line,
@@ -282,7 +291,7 @@ function parse_test(file) {
                    })
                );
                var stat = node.body;
-                if (label.name == "expect_exact") {
+                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) {
--- a/test/sandbox.js
+++ b/test/sandbox.js
@@ -1,3 +1,4 @@
+var semver = require("semver");
 var vm = require("vm");

 function safe_log(arg, level) {
@@ -63,7 +64,7 @@ exports.run_code = function(code) {
        process.stdout.write = original_write;
    }
 };
-exports.same_stdout = ~process.version.lastIndexOf("v0.12.", 0) ? function(expected, actual) {
+exports.same_stdout = semver.satisfies(process.version, "0.12") ? function(expected, actual) {
    if (typeof expected != typeof actual) return false;
    if (typeof expected != "string") {
        if (expected.name != actual.name) return false;
--- a/test/sourcemaps.js
+++ b/test/sourcemaps.js
@@ -1,4 +1,4 @@
-var UglifyJS = require("./node");
+var UglifyJS = require("..");
 var ok = require("assert");

 module.exports = function () {
@@ -26,11 +26,11 @@ module.exports = function () {
 }

 function source_map(js) {
-    var source_map = UglifyJS.SourceMap();
-    var stream = UglifyJS.OutputStream({ source_map: source_map });
-    var parsed = UglifyJS.parse(js);
-    parsed.print(stream);
-    return JSON.parse(source_map.toString());
+    return JSON.parse(UglifyJS.minify(js, {
+        compress: false,
+        mangle: false,
+        sourceMap: true
+    }).map);
 }

 // Run standalone
--- a/test/ufuzz.js
+++ b/test/ufuzz.js
@@ -12,7 +12,7 @@
        stream._handle.setBlocking(true);
 });

-var UglifyJS = require("./node");
+var UglifyJS = require("..");
 var randomBytes = require("crypto").randomBytes;
 var sandbox = require("./sandbox");

@@ -962,32 +962,15 @@ function try_beautify(code, result) {
    console.log(code);
 }

-function infer_options(ctor) {
-    try {
-        ctor({ 0: 0 });
-    } catch (e) {
-        return e.defs;
-    }
-}
-
-var default_options = {
-    compress: infer_options(UglifyJS.Compressor),
-    mangle: {
-        "cache": null,
-        "eval": false,
-        "ie8": false,
-        "keep_fnames": false,
-        "toplevel": false,
-    },
-    output: infer_options(UglifyJS.OutputStream),
-};
+var default_options = UglifyJS.default_options();

 function log_suspects(minify_options, component) {
    var options = component in minify_options ? minify_options[component] : true;
    if (!options) return;
-    options = UglifyJS.defaults(options, default_options[component]);
-    var suspects = Object.keys(default_options[component]).filter(function(name) {
-        if (options[name]) {
+    if (typeof options != "object") options = {};
+    var defs = default_options[component];
+    var suspects = Object.keys(defs).filter(function(name) {
+        if ((name in options ? options : defs)[name]) {
            var m = JSON.parse(JSON.stringify(minify_options));
            var o = JSON.parse(JSON.stringify(options));
            o[name] = false;
--- a/tools/node.js
+++ b/tools/node.js
@@ -61,5 +61,22 @@ function describe_ast() {
        }
    };
    doitem(AST_Node);
-    return out + "";
+    return out + "\n";
 }
+
+function infer_options(options) {
+    var result = UglifyJS.minify("", options);
+    return result.error && result.error.defs;
+}
+
+UglifyJS.default_options = function() {
+    var defs = {};
+    Object.keys(infer_options({ 0: 0 })).forEach(function(component) {
+        var options = {};
+        options[component] = { 0: 0 };
+        if (options = infer_options(options)) {
+            defs[component] = options;
+        }
+    });
+    return defs;
+};
Author	SHA1	Message	Date
Alex Lam S.L	c2e471e3ad	fix `if_return` on block-scoped variables (#2021 ) fixes #1317	2017-05-29 18:08:08 +08:00
Alex Lam S.L	ee23a84e14	Merge pull request #2020 from alexlamsl/harmony-v3.0.13 Merging from master for 3.0.13	2017-05-29 12:24:38 +08:00
alexlamsl	520da57fdc	Merge branch 'master' into harmony-v3.0.13	2017-05-29 10:58:05 +08:00
Alex Lam S.L	4e0a22e5c8	v3.0.13	2017-05-29 10:52:13 +08:00
Alex Lam S.L	1aa38051fb	better fix for #512 & #2010 (#2019 ) - remove duplicated functionalities - fix similar issue with `else`	2017-05-29 10:51:41 +08:00
Alex Lam S.L	e62b879b48	display default values in `--help options` (#2018 )	2017-05-28 22:57:20 +08:00
Alex Lam S.L	c6c9f4f5a8	implement `--help options` (#2017 )	2017-05-28 18:21:44 +08:00
Alex Lam S.L	fec14379f6	improve CLI usability (#2016 ) Report supported options upon invalid option syntax. fixes #1883	2017-05-28 04:09:40 +08:00
Alex Lam S.L	e5e0ce0b42	Merge pull request #2014 from alexlamsl/harmony-v3.0.12 Merging from master for 3.0.12	2017-05-28 00:08:08 +08:00
Alex Lam S.L	79131cd647	extend `node_version` range on applicable tests (#2015 )	2017-05-27 22:18:28 +08:00
alexlamsl	94d2aeee89	fix block-scoped `function` for ES6 fixes #1903	2017-05-27 19:28:07 +08:00
alexlamsl	aa835eb0f6	Merge branch 'master' into harmony-v3.0.12	2017-05-27 18:12:10 +08:00
Alex Lam S.L	c3f14a1481	v3.0.12	2017-05-27 18:08:09 +08:00
Alex Lam S.L	7b13159cda	fix `hoist_funs` on block-scoped `function` under "use strict" (#2013 ) Technically not part of ES5, but commonly used code exists in the wild.	2017-05-27 17:44:59 +08:00
Alex Lam S.L	95094b9c22	fix `if_return` on `AST_Defun` (#2010 ) Previous fiix for #1052 perturbs declaration order of functions which leads to incorrect behaviour under "use strict".	2017-05-27 13:41:49 +08:00
kzc	1ff8e9dd38	clarify what --mangle-props does (#2012 )	2017-05-27 13:17:30 +08:00
kzc	78309a293d	better document mangle properties options (#2009 )	2017-05-27 02:28:43 +08:00
kzc	695e182d59	fix and expand --mangle-props documentation (#2008 ) fixes #2007	2017-05-27 01:25:51 +08:00
Alex Lam S.L	dc33facfcb	fix `dead_code` on block-scoped `function` under "use strict" (#2006 ) Technically not part of ES5, but commonly used code exists in the wild.	2017-05-26 16:08:51 +08:00
Alex Lam S.L	39d4d7e20a	fix `export` related issues (#2005 ) - `mangle` non-exported names - `unused` on `export` of `function` - `hoist_funs` on `export` - `export default` - prohibit definition statements - parse `AST_Defun` properly - drop only unused class and function names fixes #2001 fixes #2004	2017-05-26 13:35:40 +08:00
Alex Lam S.L	c70fb60384	clean up `lib/scope.js` (#2003 ) fixes #2004	2017-05-26 03:58:35 +08:00
Alex Lam S.L	02811ce35e	fix issues related to `export` & `function` (#2002 ) - `unused` function names - confusion with function call syntax fixes #2001	2017-05-26 03:12:52 +08:00
Alex Lam S.L	793d61499b	report timing breakdown (#2000 ) fix corner cases with `sourceMap` fixes #1998	2017-05-25 07:15:55 +08:00
Alex Lam S.L	a277fe168d	ensure new line after `describe_ast()` (#1999 )	2017-05-25 02:32:36 +08:00
Alex Lam S.L	c988e5f4d6	remove `AST_ArrowParametersOrSeq` (#1997 )	2017-05-24 17:45:18 +08:00
Alex Lam S.L	7d3b941e6e	reinstate `describe_ast()` on CLI (#1996 ) fixes #1995	2017-05-24 02:30:09 +08:00
Alex Lam S.L	075b648bb1	Merge pull request #1994 from alexlamsl/harmony-v3.0.11 Merging from master for 3.0.11	2017-05-24 00:04:47 +08:00
alexlamsl	37e549ff4f	Merge branch 'master' into harmony-v3.0.11	2017-05-23 22:29:04 +08:00
Alex Lam S.L	e95052a423	v3.0.11	2017-05-23 22:26:59 +08:00
Alex Lam S.L	e667f0acb8	fix source map offset (#1993 ) Account for whitespace insertions. fixes #505 fixes #890	2017-05-23 20:25:48 +08:00
kzc	7bcb442e4c	fix destructuring bugs in mangle and compress (#1992 ) - destructuring mangle - destructuring array default values fixes #1335	2017-05-23 02:53:01 +08:00
kzc	a658cd84a5	fix destructuring of non string keys (#1989 )	2017-05-22 16:38:03 +08:00
kzc	69ac794bc8	add another minify() options example (#1988 )	2017-05-22 12:19:07 +08:00
Alex Lam S.L	efdb65913b	improve usability of `global_defs` in `minify()` (#1987 ) Use `@key` to `parse()` string value as `AST_Node`. fixes #1986	2017-05-22 01:38:43 +08:00
kzc	a1dedeb3ce	more refinement of minify() documentation (#1983 )	2017-05-21 04:55:03 +08:00
Alex Lam S.L	5b22334f3b	Merge pull request #1982 from alexlamsl/harmony-v3.0.10 Merging from master for 3.0.10	2017-05-21 03:23:59 +08:00
alexlamsl	a3053c537a	Merge branch 'master' into harmony-v3.0.10	2017-05-21 01:36:38 +08:00
Alex Lam S.L	d3c4a8e9e7	v3.0.10	2017-05-21 01:30:17 +08:00
kzc	d6f77a6352	update keywords in package.json (#1981 )	2017-05-20 22:10:51 +08:00
kzc	7e164aba8f	add "es5" to package.json keywords (#1980 )	2017-05-20 22:09:50 +08:00
kzc	22aedef849	document minify() option `toplevel` (#1979 )	2017-05-20 22:09:21 +08:00
Alex Lam S.L	58fae7dc07	enhance `if_return` to handle `return void...` (#1977 ) fixes #512	2017-05-20 15:58:46 +08:00
Alex Lam S.L	a2172e1a99	fix parsing of `yield` as object key (#1976 ) fixes #1974	2017-05-20 13:11:37 +08:00
kzc	5bf8d7e949	document 3.x minify() does not throw errors (#1975 )	2017-05-20 10:49:35 +08:00
kzc	1df9d06f4a	document minify `warnings` and add an error example (#1973 )	2017-05-19 17:20:21 +08:00
Alex Lam S.L	9a074c2637	Merge pull request #1972 from alexlamsl/harmony-v3.0.9 Merging from master for 3.0.9	2017-05-19 10:38:45 +08:00
alexlamsl	02b14528fa	Merge branch 'master' into harmony-v3.0.9	2017-05-19 09:51:00 +08:00
Alex Lam S.L	3408fc9d32	v3.0.9	2017-05-19 09:35:26 +08:00
Alex Lam S.L	eae26756f1	introduce `unsafe_regexp` (#1970 ) fixes #1964	2017-05-19 09:06:29 +08:00
Alex Lam S.L	3db2001633	suppress `unused` on block variables (#1969 ) fixes #1968	2017-05-19 00:28:19 +08:00
Alex Lam S.L	aaba482e48	Merge pull request #1967 from alexlamsl/harmony-v3.0.8 Merging from master for 3.0.8	2017-05-18 16:02:29 +08:00
alexlamsl	5f29fced0a	Merge branch 'master' into harmony-v3.0.8	2017-05-18 14:54:18 +08:00
Alex Lam S.L	43add9416b	v3.0.8	2017-05-18 14:49:40 +08:00
Alex Lam S.L	efcf167e5e	make `expect_stdout` node version specific (#1963 ) ... via semver string on `node_version` label.	2017-05-18 11:28:35 +08:00
Kara	6ed90913ca	fix docs for side_effects flag to reflect current behavior (#1966 )	2017-05-18 10:51:49 +08:00
kzc	b1b918e6d6	better extends paren fix (#1962 )	2017-05-18 02:36:29 +08:00
Alex Lam S.L	569c21e952	improve `RegExp` handling (#1959 ) - remove `options.output.unescape_regexps` - preserve original pattern whenever possible fixes #54 fixes #1929	2017-05-17 20:10:50 +08:00
Alex Lam S.L	87c3a2c0ce	remove `space_colon` (#1960 ) Always emit space after colon when `options.output.beautify` is enabled.	2017-05-17 14:07:34 +08:00
Rob Garrison	baef8bf050	update output options in readme (#1958 )	2017-05-17 11:54:46 +08:00
alexlamsl	0813c5316f	remove Travis CI badge	2017-05-17 10:32:59 +08:00
kzc	ebb469e4cd	fix class extends expression (#1956 )	2017-05-17 03:29:25 +08:00
kzc	c22d26b483	support export default of anonymous functions and classes (#1954 )	2017-05-17 03:28:24 +08:00