v3.0.6

print package name alongside version in CLI (#1946 )
fixes #1945
2017-05-16 06:38:58 +08:00 · 2017-05-16 06:34:32 +08:00 · 2017-05-16 05:40:49 +08:00 · 2017-05-16 01:33:01 +08:00 · 2017-05-16 01:12:00 +08:00 · 2017-05-15 23:02:55 +08:00
50 changed files with 1399 additions and 1412 deletions
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -6,15 +6,15 @@

 <!-- Note: for ES6 see: https://github.com/mishoo/UglifyJS2/tree/harmony#harmony -->

-**`uglify-js` version (`uglifyjs -V`)**
+**Uglify version (`uglifyjs -V`)**

-**JavaScript input - ideally as small as possible.**
+**JavaScript input**  <!-- ideally as small as possible -->

 **The `uglifyjs` CLI command executed or `minify()` options used.**

-**JavaScript output produced and/or the error or warning.**
+**JavaScript output or error produced.**

 <!--
-    Note: the release version of uglify-js only supports ES5. Those wishing
-    to minify ES6 should use the experimental harmony branch.
+    Note: `uglify-js` only supports ES5. 
+    Those wishing to minify ES6 should use `uglify-es`.
 -->
--- a/README.md
+++ b/README.md
@@ -2,14 +2,14 @@ UglifyJS 3
 ==========
 [![Build Status](https://travis-ci.org/mishoo/UglifyJS2.svg)](https://travis-ci.org/mishoo/UglifyJS2)

-UglifyJS is a JavaScript parser, minifier, compressor or beautifier toolkit.
+UglifyJS is a JavaScript parser, minifier, compressor and beautifier toolkit.

 #### Note:
- **`uglify-js@3.x` has a new API and CLI and is not backwards compatible with [`uglify-js@2.x`](https://github.com/mishoo/UglifyJS2/tree/v2.x)**.
+- **`uglify-js@3` has a simplified [API](#api-reference) and [CLI](#command-line-usage) that is not backwards compatible with [`uglify-js@2`](https://github.com/mishoo/UglifyJS2/tree/v2.x)**.
 - **Documentation for UglifyJS `2.x` releases can be found [here](https://github.com/mishoo/UglifyJS2/tree/v2.x)**.
- Release versions of `uglify-js` only support ECMAScript 5 (ES5). If you wish to minify
-ES2015+ (ES6+) code then please use the [harmony](#harmony) development branch.
- Node 7 has a known performance regression and runs `uglify-js` twice as slow.
+- `uglify-js` only supports ECMAScript 5 (ES5).
+- Those wishing to minify
+ES2015+ (ES6+) should use the `npm` package [**uglify-es**](https://github.com/mishoo/UglifyJS2/tree/harmony).

 Install
 -------
@@ -25,14 +25,7 @@ From NPM for programmatic use:

    npm install uglify-js

-From Git:
-
-    git clone git://github.com/mishoo/UglifyJS2.git
-    cd UglifyJS2
-    npm link .
-
-Usage
-----
+# Command line usage

    uglifyjs [input files] [options]

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

    uglifyjs --compress --mangle -- input.js

-The available options are:
+### Command line options

 ```
    -h, --help                  Print usage information.
@@ -95,8 +88,9 @@ The available options are:
                                `wrap_iife`  Wrap IIFEs in parenthesis. Note: you may
                                             want to disable `negate_iife` under
                                             compressor options.
-    -o, --output <file>         Output file (default STDOUT). Specify "spidermonkey"
-                                to dump SpiderMonkey AST format (as JSON) to STDOUT.
+    -o, --output <file>         Output file path (default STDOUT). Specify `ast` or
+                                `spidermonkey` to write UglifyJS or SpiderMonkey AST
+                                as JSON to STDOUT respectively.
    --comments [filter]         Preserve copyright comments in the output. By
                                default this works like Google Closure, keeping
                                JSDoc-style comments that contain "@license" or
@@ -147,23 +141,28 @@ The available options are:
 Specify `--output` (`-o`) to declare the output file.  Otherwise the output
 goes to STDOUT.

-## Source map options
+## CLI source map options

 UglifyJS can generate a source map file, which is highly useful for
 debugging your compressed JavaScript.  To get a source map, pass
 `--source-map --output output.js` (source map will be written out to
 `output.js.map`).

-Additionally you might need `--source-map root=<URL>` to pass the URL where
-the original files can be found.  Use `--source-map url=<URL>` to specify
-the URL where the source map can be found.
+Additional options:
+
+- `--source-map filename=<NAME>` to specify the name of the source map.
+
+- `--source-map root=<URL>` to pass the URL where the original files can be found.
+  Otherwise UglifyJS assumes HTTP `X-SourceMap` is being used and will omit the
+  `//# sourceMappingURL=` directive.
+
+- `--source-map url=<URL>` to specify the URL where the source map can be found.

 For example:

-    uglifyjs /home/doe/work/foo/src/js/file1.js \
-             /home/doe/work/foo/src/js/file2.js \
+    uglifyjs js/file1.js js/file2.js \
             -o foo.min.js -c -m \
-             --source-map base="/home/doe/work/foo/src",root="http://foo.com/src"
+             --source-map root="http://foo.com/src",url=foo.min.js.map

 The above will compress and mangle `file1.js` and `file2.js`, will drop the
 output in `foo.min.js` and the source map in `foo.min.js.map`.  The source
@@ -182,13 +181,24 @@ CoffeeScript → compiled JS, UglifyJS can generate a map from CoffeeScript →
 compressed JS by mapping every token in the compiled JS to its original
 location.

-To use this feature you need to pass `--in-source-map
-/path/to/input/source.map` or `--in-source-map inline` if the source map is
-included inline with the sources. Normally the input source map should also
-point to the file containing the generated JS, so if that's correct you can
-omit input files from the command line.
+To use this feature pass `--source-map content="/path/to/input/source.map"`
+or `--source-map content=inline` if the source map is included inline with
+the sources.

-## Mangler options
+## CLI compress options
+
+You need to pass `--compress` (`-c`) to enable the compressor.  Optionally
+you can pass a comma-separated list of [compress options](#compress-options).
+
+Options are in the form `foo=bar`, or just `foo` (the latter implies
+a boolean option that you want to set `true`; it's effectively a
+shortcut for `foo=true`).
+
+Example:
+
+    uglifyjs file.js -c toplevel,sequences=false
+
+## CLI mangle options

 To enable the mangler you need to pass `--mangle` (`-m`).  The following
 (comma-separated) options are supported:
@@ -207,16 +217,16 @@ comma-separated list of names.  For example:

 to prevent the `require`, `exports` and `$` names from being changed.

-### Mangling property names (`--mangle-props`)
+### 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:

-```js
+```javascript
 var x = {
-  foo: 1
+    foo: 1
 };

 x.bar = 2;
@@ -245,10 +255,10 @@ mangled to the same name in all of them.  For this, pass `--name-cache filename.
 and UglifyJS will maintain these mappings in a file which can then be reused.
 It should be initially empty.  Example:

-```
-rm -f /tmp/cache.json  # start fresh
-uglifyjs file1.js file2.js --mangle-props --name-cache /tmp/cache.json -o part1.js
-uglifyjs file3.js file4.js --mangle-props --name-cache /tmp/cache.json -o part2.js
+```bash
+$ rm -f /tmp/cache.json  # start fresh
+$ uglifyjs file1.js file2.js --mangle-props --name-cache /tmp/cache.json -o part1.js
+$ uglifyjs file3.js file4.js --mangle-props --name-cache /tmp/cache.json -o part2.js
 ```

 Now, `part1.js` and `part2.js` will be consistent with each other in terms
@@ -257,18 +267,18 @@ of mangled property names.
 Using the name cache is not necessary if you compress all your files in a
 single call to UglifyJS.

-#### Mangling unquoted names (`--mangle-props keep_quoted`)
+### Mangling unquoted names (`--mangle-props keep_quoted`)

 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:

-```
+```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);
 ```

-#### Debugging property name mangling
+### Debugging property name mangling

 You can also pass `--mangle-props debug` in order to mangle property names
 without completely obscuring them. For example the property `o.foo`
@@ -283,12 +293,144 @@ random number on every compile to simulate mangling changing with different
 inputs (e.g. as you update the input script with new properties), and to help
 identify mistakes like writing mangled keys to storage.

-## Compressor options

-You need to pass `--compress` (`-c`) to enable the compressor.  Optionally
-you can pass a comma-separated list of options.  Options are in the form
-`foo=bar`, or just `foo` (the latter implies a boolean option that you want
-to set `true`; it's effectively a shortcut for `foo=true`).
+# API Reference
+
+Assuming installation via NPM, you can load UglifyJS in your application
+like this:
+```javascript
+var UglifyJS = require("uglify-js");
+```
+
+There is a single high level minification function, `minify(files, options)`, which will
+performs all the steps in a configurable manner.
+Example:
+```javascript
+var result = UglifyJS.minify("var b = function() {};");
+console.log(result.code);  // minified output
+console.log(result.error); // runtime error
+```
+
+You can also compress multiple files:
+```javascript
+var result = UglifyJS.minify({
+    "file1.js": "var a = function() {};",
+    "file2.js": "var b = function() {};"
+});
+console.log(result.code);
+```
+
+## Minify options
+
+- `warnings` (default `false`) — pass `true` to display compressor warnings.
+
+- `parse` (default `{}`) — pass an object if you wish to specify some
+  additional [parse options](#parse-options).
+
+- `compress` (default `{}`) — pass `false` to skip compressing entirely.
+  Pass an object to specify custom [compress options](#compress-options).
+
+- `mangle` (default `true`) — pass `false` to skip mangling names, or pass
+  an object to specify [mangle options](#mangle-options) (see below).
+
+  - `mangle.properties` (default `false`) — a subcategory of the mangle option.
+    Pass an object to specify custom [mangle property options](#mangle-properties-options).
+
+- `output` (default `null`) — pass an object if you wish to specify
+  additional [output options](#output-options).  The defaults are optimized
+  for best compression.
+
+- `sourceMap` (default `false`) - pass an object if you wish to specify
+  [source map options](#source-map-options).
+
+- `toplevel` (default `false`) - set to `true` if you wish to enable top level
+  variable and function name mangling and to drop unused variables and functions.
+
+- `ie8` (default `false`) - set to `true` to support IE8.
+
+## Minify option structure
+
+```javascript
+{
+    warnings: false,
+    parse: {
+        // parse options
+    },
+    compress: {
+        // compress options
+    },
+    mangle: {
+        // mangle options
+
+        properties: {
+            // mangle property options
+        }
+    },
+    output: {
+        // output options
+    },
+    sourceMap: {
+        // source map options
+    },
+    toplevel: false,
+    ie8: false,
+}
+```
+
+### Source map options
+
+To generate a source map:
+```javascript
+var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, {
+    sourceMap: {
+        filename: "out.js",
+        url: "out.js.map"
+    }
+});
+console.log(result.code); // minified output
+console.log(result.map);  // source map
+```
+
+Note that the source map is not saved in a file, it's just returned in
+`result.map`.  The value passed for `sourceMap.url` is only used to set
+`//# sourceMappingURL=out.js.map` in `result.code`. The value of
+`filename` is only used to set `file` attribute (see [the spec][sm-spec])
+in source map file.
+
+You can set option `sourceMap.url` to be `"inline"` and source map will
+be appended to code.
+
+You can also specify sourceRoot property to be included in source map:
+```javascript
+var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, {
+    sourceMap: {
+        root: "http://example.com/src",
+        url: "out.js.map"
+    }
+});
+```
+
+If you're compressing compiled JavaScript and have a source map for it, you
+can use `sourceMap.content`:
+```javascript
+var result = UglifyJS.minify({"compiled.js": "compiled code"}, {
+    sourceMap: {
+        content: "content from compiled.js.map",
+        url: "minified.js.map"
+    }
+});
+// same as before, it returns `code` and `map`
+```
+
+If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.url`.
+
+## Parse options
+
+- `bare_returns` (default `false`) -- support top level `return` statements
+- `html5_comments` (default `true`)
+- `shebang` (default `true`) -- support `#!command` as the first line
+
+## Compress options

 - `sequences` (default: true) -- join consecutive simple statements using the
  comma operator.  May be set to a positive integer to specify the maximum number
@@ -404,14 +546,139 @@ to set `true`; it's effectively a shortcut for `foo=true`).
  compressor from discarding function names.  Useful for code relying on
  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).

- `passes` -- default `1`. Number of times to run compress. Use an
-  integer argument larger than 1 to further reduce code size in some cases.
-  Note: raising the number of passes will increase uglify compress time.
+- `passes` -- default `1`. Number of times to run compress with a maximum of 3.
+  In some cases more than one pass leads to further compressed code.  Keep in
+  mind more passes will take more time.

 - `keep_infinity` -- default `false`. Pass `true` to prevent `Infinity` from
  being compressed into `1/0`, which may cause performance issues on Chrome.

-### The `unsafe` option
+- `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()`;
+
+## Mangle options
+
+- `reserved` - pass an array of identifiers that should be excluded from mangling
+
+- `toplevel` — mangle names declared in the toplevel scope (disabled by
+default).
+
+- `eval` — mangle names visible in scopes where eval or with are used
+(disabled by default).
+
+- `keep_fnames` -- default `false`.  Pass `true` to not mangle
+function names.  Useful for code relying on `Function.prototype.name`.
+See also: the `keep_fnames` [compress option](#compress-options).
+
+Examples:
+
+```javascript
+// test.js
+var globalVar;
+function funcName(firstLongName, anotherLongName) {
+    var myVariable = firstLongName +  anotherLongName;
+}
+```
+```javascript
+var code = fs.readFileSync("test.js", "utf8");
+
+UglifyJS.minify(code).code;
+// 'function funcName(a,n){}var globalVar;'
+
+UglifyJS.minify(code, { mangle: { reserved: ['firstLongName'] } }).code;
+// 'function funcName(firstLongName,a){}var globalVar;'
+
+UglifyJS.minify(code, { mangle: { toplevel: true } }).code;
+// 'function n(n,a){}var a;'
+```
+
+### 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.
+
+## Output options
+
+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:
+
+- `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).
+- `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.
+- `quote_style` (default `0`) -- preferred quote style for strings (affects
+  quoted property names and directives as well):
+  - `0` -- prefers double quotes, switches to single quotes when there are
+    more double quotes in the string itself.
+  - `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.
+
+
+# Miscellaneous
+
+### Keeping copyright notices or other comments
+
+You can pass `--comments` to retain certain comments in the output.  By
+default it will keep JSDoc-style comments that contain "@preserve",
+"@license" or "@cc_on" (conditional compilation for IE).  You can pass
+`--comments all` to keep all the comments, or a valid JavaScript regexp to
+keep only comments that match this regexp.  For example `--comments /^!/`
+will keep comments like `/*! Copyright Notice */`.
+
+Note, however, that there might be situations where comments are lost.  For
+example:
+```javascript
+function f() {
+    /** @preserve Foo Bar */
+    function g() {
+        // this function is never called
+    }
+    return something();
+}
+```
+
+Even though it has "@preserve", the comment will be lost because the inner
+function `g` (which is the AST node to which the comment is attached to) is
+discarded by the compressor as not referenced.
+
+The safest comments where to place copyright information (or other info that
+needs to be kept in the output) are comments attached to toplevel nodes.
+
+### The `unsafe` `compress` option

 It enables some transformations that *might* break code logic in certain
 contrived cases, but should be fine for most code.  You might want to try it
@@ -435,7 +702,7 @@ scope).  For example if you pass `--define DEBUG=false` then, coupled with
 dead code removal UglifyJS will discard the following from the output:
 ```javascript
 if (DEBUG) {
-	console.log("debug stuff");
+    console.log("debug stuff");
 }
 ```

@@ -464,12 +731,13 @@ code as usual.  The build will contain the `const` declarations if you use
 them. If you are targeting < ES6 environments which does not support `const`,
 using `var` with `reduce_vars` (enabled by default) should suffice.

-#### Conditional compilation, API
+### Conditional compilation API
+
 You can also use conditional compilation via the programmatic API. With the difference that the
 property name is `global_defs` and is a compressor property:

-```js
-uglifyJS.minify([ "input.js"], {
+```javascript
+var result = uglifyJS.minify(fs.readFileSync("input.js", "utf8"), {
    compress: {
        dead_code: true,
        global_defs: {
@@ -479,81 +747,40 @@ uglifyJS.minify([ "input.js"], {
 });
 ```

-## Beautifier options
-
-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:
-
- `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).
- `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.
- `quote_style` (default `0`) -- preferred quote style for strings (affects
-  quoted property names and directives as well):
-  - `0` -- prefers double quotes, switches to single quotes when there are
-    more double quotes in the string itself.
-  - `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.
-
-### Keeping copyright notices or other comments
-
-You can pass `--comments` to retain certain comments in the output.  By
-default it will keep JSDoc-style comments that contain "@preserve",
-"@license" or "@cc_on" (conditional compilation for IE).  You can pass
-`--comments all` to keep all the comments, or a valid JavaScript regexp to
-keep only comments that match this regexp.  For example `--comments /^!/`
-will keep comments like `/*! Copyright Notice */`.
-
-Note, however, that there might be situations where comments are lost.  For
-example:
+### Using native Uglify AST with `minify()`
 ```javascript
-function f() {
-	/** @preserve Foo Bar */
-	function g() {
-	  // this function is never called
-	}
-	return something();
-}
+// example: parse only, produce native Uglify AST
+
+var result = UglifyJS.minify(code, {
+    parse: {},
+    compress: false,
+    mangle: false,
+    output: {
+        ast: true,
+        code: false  // optional - faster if false
+    }
+});
+
+// result.ast contains native Uglify AST
+```
+```javascript
+// example: accept native Uglify AST input and then compress and mangle
+//          to produce both code and native AST.
+
+var result = UglifyJS.minify(ast, {
+    compress: {},
+    mangle: {},
+    output: {
+        ast: true,
+        code: true  // optional - faster if false
+    }
+});
+
+// result.ast contains native Uglify AST
+// result.code contains the minified code in string form.
 ```

-Even though it has "@preserve", the comment will be lost because the inner
-function `g` (which is the AST node to which the comment is attached to) is
-discarded by the compressor as not referenced.
-
-The safest comments where to place copyright information (or other info that
-needs to be kept in the output) are comments attached to toplevel nodes.
-
-## Support for the SpiderMonkey AST
+### ESTree / SpiderMonkey AST

 UglifyJS has its own abstract syntax tree format; for
 [practical reasons](http://lisperator.net/blog/uglifyjs-why-not-switching-to-spidermonkey-ast/)
@@ -581,154 +808,5 @@ Acorn is really fast (e.g. 250ms instead of 380ms on some 650K code), but
 converting the SpiderMonkey tree that Acorn produces takes another 150ms so
 in total it's a bit more than just using UglifyJS's own parser.

-API Reference
-------------
-
-Assuming installation via NPM, you can load UglifyJS in your application
-like this:
-```javascript
-var UglifyJS = require("uglify-js");
-```
-
-There is a single toplevel function, `minify(files, options)`, which will
-performs all the steps in a configurable manner.
-Example:
-```javascript
-var result = UglifyJS.minify("var b = function() {};");
-console.log(result.code); // minified output
-```
-
-You can also compress multiple files:
-```javascript
-var result = UglifyJS.minify({
-  "file1.js": "var a = function() {};",
-  "file2.js": "var b = function() {};"
-});
-console.log(result.code);
-```
-
-To generate a source map:
-```javascript
-var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, {
-  sourceMap: {
-    filename: "out.js",
-    url: "out.js.map"
-  }
-});
-console.log(result.code); // minified output
-console.log(result.map);  // source map
-```
-
-Note that the source map is not saved in a file, it's just returned in
-`result.map`.  The value passed for `sourceMap.url` is only used to set
-`//# sourceMappingURL=out.js.map` in `result.code`. The value of
-`filename` is only used to set `file` attribute (see [the spec][sm-spec])
-in source map file.
-
-You can set option `sourceMap.url` to be `"inline"` and source map will
-be appended to code.
-
-You can also specify sourceRoot property to be included in source map:
-```javascript
-var result = UglifyJS.minify({"file1.js": "var a = function() {};"}, {
-  sourceMap: {
-    root: "http://example.com/src",
-    url: "out.js.map"
-  }
-});
-```
-
-If you're compressing compiled JavaScript and have a source map for it, you
-can use `sourceMap.content`:
-```javascript
-var result = UglifyJS.minify({"compiled.js": "compiled code"}, {
-  sourceMap: {
-    content: "content from compiled.js.map",
-    url: "minified.js.map"
-  }
-});
-// same as before, it returns `code` and `map`
-```
-
-If you're using the `X-SourceMap` header instead, you can just omit `sourceMap.url`.
-
-Other options:
-
- `warnings` (default `false`) — pass `true` to display compressor warnings.
-
- `mangle` (default `true`) — pass `false` to skip mangling names, or pass
-  an object to specify mangling options (see below).
-
- `mangleProperties` (default `false`) — pass an object to specify custom
-  mangle property options.
-
- `output` (default `null`) — pass an object if you wish to specify
-  additional [output options](#beautifier-options).  The defaults are optimized
-  for best compression.
-
- `compress` (default `{}`) — pass `false` to skip compressing entirely.
-  Pass an object to specify custom [compressor options](#compressor-options).
-
- `parse` (default {}) — pass an object if you wish to specify some
-  additional [parser options](#the-parser).
-
-##### mangle
-
- - `reserved` - pass an array of identifiers that should be excluded from mangling
-
- - `toplevel` — mangle names declared in the toplevel scope (disabled by
-  default).
-
- - `eval` — mangle names visible in scopes where eval or with are used
-  (disabled by default).
-
- - `keep_fnames` -- default `false`.  Pass `true` to not mangle
-  function names.  Useful for code relying on `Function.prototype.name`.
-  See also: the `keep_fnames` [compress option](#compressor-options).
-
-  Examples:
-
-  ```javascript
-  //tst.js
-  var globalVar;
-  function funcName(firstLongName, anotherLongName)
-  {
-    var myVariable = firstLongName +  anotherLongName;
-  }
-
-  UglifyJS.minify("tst.js").code;
-  // 'function funcName(a,n){}var globalVar;'
-
-  UglifyJS.minify("tst.js", { mangle: { reserved: ['firstLongName'] } }).code;
-  // 'function funcName(firstLongName,a){}var globalVar;'
-
-  UglifyJS.minify("tst.js", { mangle: { toplevel: true } }).code;
-  // 'function n(n,a){}var a;'
-  ```
-
-##### 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.
-
-  [acorn]: https://github.com/ternjs/acorn
-  [sm-spec]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k
-
-#### Harmony
-
-If you wish to use the experimental [harmony](https://github.com/mishoo/UglifyJS2/commits/harmony)
-branch to minify ES2015+ (ES6+) code please use the following in your `package.json` file:
-
-```
-"uglify-js": "git+https://github.com/mishoo/UglifyJS2.git#harmony"
-```
-
-or to directly install the experimental harmony version of uglify:
-
-```
-npm install --save-dev uglify-js@github:mishoo/UglifyJS2#harmony
-```
-
-See [#448](https://github.com/mishoo/UglifyJS2/issues/448) for additional details.
+[acorn]: https://github.com/ternjs/acorn
+[sm-spec]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k
--- a/bin/uglifyjs
+++ b/bin/uglifyjs
@@ -15,13 +15,13 @@ var path = require("path");
 var program = require("commander");
 var UglifyJS = require("../tools/node");

+var skip_keys = [ "cname", "enclosed", "parent_scope", "scope", "thedef", "uses_eval", "uses_with" ];
 var files = {};
 var options = {
    compress: false,
    mangle: false
 };
-program._name = info.name;
-program.version(info.version);
+program.version(info.name + ' ' + info.version);
 program.parseArgv = program.parse;
 program.parse = undefined;
 program.option("-p, --parse <options>", "Specify parser options.", parse_js("parse", true));
@@ -89,7 +89,7 @@ if (program.mangleProps) {
        if (typeof program.mangleProps != "object") program.mangleProps = {};
        if (!Array.isArray(program.mangleProps.reserved)) program.mangleProps.reserved = [];
        require("../tools/domprops").forEach(function(name) {
-            UglifyJS.push_uniq(program.mangleProps.reserved, name);
+            UglifyJS._push_uniq(program.mangleProps.reserved, name);
        });
    }
    if (typeof options.mangle != "object") options.mangle = {};
@@ -107,6 +107,12 @@ if (program.nameCache) {
        }
    }
 }
+if (program.output == "ast") {
+    options.output = {
+        ast: true,
+        code: false
+    };
+}
 if (program.parse) {
    if (program.parse.acorn || program.parse.spidermonkey) {
        if (program.sourceMap) fatal("ERROR: inline source map only works with built-in parser");
@@ -165,7 +171,7 @@ function run() {
    UglifyJS.AST_Node.warn_function = function(msg) {
        console.error("WARN:", msg);
    };
-    if (program.stats)  program.stats = Date.now();
+    if (program.stats) program.stats = Date.now();
    try {
        if (program.parse) {
            if (program.parse.acorn) {
@@ -185,9 +191,13 @@ function run() {
                });
            }
        }
-        var result = UglifyJS.minify(files, options);
    } catch (ex) {
-        if (ex instanceof UglifyJS.JS_Parse_Error) {
+        fatal(ex);
+    }
+    var result = UglifyJS.minify(files, options);
+    if (result.error) {
+        var ex = result.error;
+        if (ex.name == "SyntaxError") {
            console.error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
            var col = ex.col;
            var lines = files[ex.filename].split(/\r?\n/);
@@ -209,10 +219,32 @@ function run() {
            console.error("Supported options:");
            console.error(ex.defs);
        }
-        fatal("ERROR: " + ex.message);
-    }
-    if (program.output == "spidermonkey") {
-        console.log(JSON.stringify(UglifyJS.parse(result.code).to_mozilla_ast(), null, 2));
+        fatal(ex);
+    } else if (program.output == "ast") {
+        console.log(JSON.stringify(result.ast, function(key, value) {
+            if (skip_key(key)) return;
+            if (value instanceof UglifyJS.AST_Token) return;
+            if (value instanceof UglifyJS.Dictionary) return;
+            if (value instanceof UglifyJS.AST_Node) {
+                var result = {
+                    _class: "AST_" + value.TYPE
+                };
+                value.CTOR.PROPS.forEach(function(prop) {
+                    result[prop] = value[prop];
+                });
+                return result;
+            }
+            return value;
+        }, 2));
+    } else if (program.output == "spidermonkey") {
+        console.log(JSON.stringify(UglifyJS.minify(result.code, {
+            compress: false,
+            mangle: false,
+            output: {
+                ast: true,
+                code: false
+            }
+        }).ast.to_mozilla_ast(), null, 2));
    } else if (program.output) {
        fs.writeFileSync(program.output, result.code);
        if (result.map) {
@@ -230,8 +262,9 @@ function run() {
 }

 function fatal(message) {
-  console.error(message);
-  process.exit(1);
+    if (message instanceof Error) message = message.stack.replace(/^\S*?Error:/, "ERROR:")
+    console.error(message);
+    process.exit(1);
 }

 // A file glob function that only supports "*" and "?" wildcards in the basename.
@@ -270,7 +303,7 @@ function read_file(path, default_value) {
        return fs.readFileSync(path, "utf8");
    } catch (ex) {
        if (ex.code == "ENOENT" && default_value != null) return default_value;
-        fatal("ERROR: " + ex.message);
+        fatal(ex);
    }
 }

@@ -278,9 +311,17 @@ function parse_js(flag, constants) {
    return function(value, options) {
        options = options || {};
        try {
-            UglifyJS.parse(value, {
-                expression: true
-            }).walk(new UglifyJS.TreeWalker(function(node) {
+            UglifyJS.minify(value, {
+                parse: {
+                    expression: true
+                },
+                compress: false,
+                mangle: false,
+                output: {
+                    ast: true,
+                    code: false
+                }
+            }).ast.walk(new UglifyJS.TreeWalker(function(node) {
                if (node instanceof UglifyJS.AST_Assign) {
                    var name = node.left.print_to_string();
                    var value = node.right;
@@ -337,3 +378,7 @@ function to_cache(key) {
    }
    return cache[key];
 }
+
+function skip_key(key) {
+    return skip_keys.indexOf(key) >= 0;
+}
--- a/lib/ast.js
+++ b/lib/ast.js
@@ -495,10 +495,10 @@ var AST_Finally = DEFNODE("Finally", null, {
    $documentation: "A `finally` node; only makes sense as part of a `try` statement"
 }, AST_Block);

-/* -----[ VAR/CONST ]----- */
+/* -----[ VAR ]----- */

 var AST_Definitions = DEFNODE("Definitions", "definitions", {
-    $documentation: "Base class for `var` or `const` nodes (variable declarations/initializations)",
+    $documentation: "Base class for `var` nodes (variable declarations/initializations)",
    $propdoc: {
        definitions: "[AST_VarDef*] array of variable definitions"
    },
@@ -516,14 +516,10 @@ var AST_Var = DEFNODE("Var", null, {
    $documentation: "A `var` statement"
 }, AST_Definitions);

-var AST_Const = DEFNODE("Const", null, {
-    $documentation: "A `const` statement"
-}, AST_Definitions);
-
 var AST_VarDef = DEFNODE("VarDef", "name value", {
    $documentation: "A variable declaration; only appears in a AST_Definitions node",
    $propdoc: {
-        name: "[AST_SymbolVar|AST_SymbolConst] name of the variable",
+        name: "[AST_SymbolVar] name of the variable",
        value: "[AST_Node?] initializer, or null of there's no initializer"
    },
    _walk: function(visitor) {
@@ -619,7 +615,7 @@ var AST_UnaryPostfix = DEFNODE("UnaryPostfix", null, {
    $documentation: "Unary postfix expression, i.e. `i++`"
 }, AST_Unary);

-var AST_Binary = DEFNODE("Binary", "left operator right", {
+var AST_Binary = DEFNODE("Binary", "operator left right", {
    $documentation: "Binary expression, i.e. `a + b`",
    $propdoc: {
        left: "[AST_Node] left-hand side expression",
@@ -689,8 +685,8 @@ var AST_Object = DEFNODE("Object", "properties", {
 var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
    $documentation: "Base class for literal object properties",
    $propdoc: {
-        key: "[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an arbitrary AST_Node.",
-        value: "[AST_Node] property value.  For setters and getters this is an AST_Function."
+        key: "[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an AST_SymbolAccessor.",
+        value: "[AST_Node] property value.  For setters and getters this is an AST_Accessor."
    },
    _walk: function(visitor) {
        return visitor._visit(this, function(){
@@ -728,17 +724,13 @@ var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
 }, AST_Symbol);

 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
-    $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
+    $documentation: "A declaration symbol (symbol in var, function name or argument, symbol in catch)",
 }, AST_Symbol);

 var AST_SymbolVar = DEFNODE("SymbolVar", null, {
    $documentation: "Symbol defining a variable",
 }, AST_SymbolDeclaration);

-var AST_SymbolConst = DEFNODE("SymbolConst", null, {
-    $documentation: "A constant declaration"
-}, AST_SymbolDeclaration);
-
 var AST_SymbolFunarg = DEFNODE("SymbolFunarg", null, {
    $documentation: "Symbol naming a function argument",
 }, AST_SymbolVar);
--- a/lib/compress.js
+++ b/lib/compress.js
@@ -354,16 +354,27 @@ merge(Compressor.prototype, {
                        // So existing transformation rules can work on them.
                        node.argnames.forEach(function(arg, i) {
                            var d = arg.definition();
-                            d.fixed = function() {
-                                return iife.args[i] || make_node(AST_Undefined, iife);
-                            };
-                            mark(d, true);
+                            if (!node.uses_arguments && d.fixed === undefined) {
+                                d.fixed = function() {
+                                    return iife.args[i] || make_node(AST_Undefined, iife);
+                                };
+                                mark(d, true);
+                            } else {
+                                d.fixed = false;
+                            }
                        });
                    }
                    descend();
                    pop();
                    return true;
                }
+                if (node instanceof AST_Accessor) {
+                    var save_ids = safe_ids;
+                    safe_ids = Object.create(null);
+                    descend();
+                    safe_ids = save_ids;
+                    return true;
+                }
                if (node instanceof AST_Binary
                    && (node.operator == "&&" || node.operator == "||")) {
                    node.left.walk(tw);
@@ -475,8 +486,7 @@ merge(Compressor.prototype, {
            if (def.fixed === false) return false;
            if (def.fixed != null && (!value || def.references.length > 0)) return false;
            return !def.orig.some(function(sym) {
-                return sym instanceof AST_SymbolConst
-                    || sym instanceof AST_SymbolDefun
+                return sym instanceof AST_SymbolDefun
                    || sym instanceof AST_SymbolLambda;
            });
        }
@@ -491,7 +501,9 @@ merge(Compressor.prototype, {

        function reset_def(def) {
            def.escaped = false;
-            if (!def.global || def.orig[0] instanceof AST_SymbolConst || compressor.toplevel(def)) {
+            if (def.scope.uses_eval) {
+                def.fixed = false;
+            } else if (!def.global || compressor.toplevel(def)) {
                def.fixed = undefined;
            } else {
                def.fixed = false;
@@ -1215,12 +1227,12 @@ merge(Compressor.prototype, {
                && !node.expression.has_side_effects(compressor);
    }

-    // may_eq_null()
-    // returns true if this node may evaluate to null or undefined
+    // may_throw_on_access()
+    // returns true if this node may be null, undefined or contain `AST_Accessor`
    (function(def) {
-        AST_Node.DEFMETHOD("may_eq_null", function(compressor) {
+        AST_Node.DEFMETHOD("may_throw_on_access", function(compressor) {
            var pure_getters = compressor.option("pure_getters");
-            return !pure_getters || this._eq_null(pure_getters);
+            return !pure_getters || this._throw_on_access(pure_getters);
        });

        function is_strict(pure_getters) {
@@ -1232,7 +1244,12 @@ merge(Compressor.prototype, {
        def(AST_Undefined, return_true);
        def(AST_Constant, return_false);
        def(AST_Array, return_false);
-        def(AST_Object, return_false);
+        def(AST_Object, function(pure_getters) {
+            if (!is_strict(pure_getters)) return false;
+            for (var i = this.properties.length; --i >=0;)
+                if (this.properties[i].value instanceof AST_Accessor) return true;
+            return false;
+        });
        def(AST_Function, return_false);
        def(AST_UnaryPostfix, return_false);
        def(AST_UnaryPrefix, function() {
@@ -1241,33 +1258,33 @@ merge(Compressor.prototype, {
        def(AST_Binary, function(pure_getters) {
            switch (this.operator) {
              case "&&":
-                return this.left._eq_null(pure_getters);
+                return this.left._throw_on_access(pure_getters);
              case "||":
-                return this.left._eq_null(pure_getters)
-                    && this.right._eq_null(pure_getters);
+                return this.left._throw_on_access(pure_getters)
+                    && this.right._throw_on_access(pure_getters);
              default:
                return false;
            }
        })
        def(AST_Assign, function(pure_getters) {
            return this.operator == "="
-                && this.right._eq_null(pure_getters);
+                && this.right._throw_on_access(pure_getters);
        })
        def(AST_Conditional, function(pure_getters) {
-            return this.consequent._eq_null(pure_getters)
-                || this.alternative._eq_null(pure_getters);
+            return this.consequent._throw_on_access(pure_getters)
+                || this.alternative._throw_on_access(pure_getters);
        })
        def(AST_Sequence, function(pure_getters) {
-            return this.expressions[this.expressions.length - 1]._eq_null(pure_getters);
+            return this.expressions[this.expressions.length - 1]._throw_on_access(pure_getters);
        });
        def(AST_SymbolRef, function(pure_getters) {
            if (this.is_undefined) return true;
            if (!is_strict(pure_getters)) return false;
            var fixed = this.fixed_value();
-            return !fixed || fixed._eq_null(pure_getters);
+            return !fixed || fixed._throw_on_access(pure_getters);
        });
    })(function(node, func) {
-        node.DEFMETHOD("_eq_null", func);
+        node.DEFMETHOD("_throw_on_access", func);
    });

    /* -----[ boolean/negation helpers ]----- */
@@ -1808,11 +1825,11 @@ merge(Compressor.prototype, {
            return any(this.elements, compressor);
        });
        def(AST_Dot, function(compressor){
-            return this.expression.may_eq_null(compressor)
+            return this.expression.may_throw_on_access(compressor)
                || this.expression.has_side_effects(compressor);
        });
        def(AST_Sub, function(compressor){
-            return this.expression.may_eq_null(compressor)
+            return this.expression.may_throw_on_access(compressor)
                || this.expression.has_side_effects(compressor)
                || this.property.has_side_effects(compressor);
        });
@@ -2365,6 +2382,7 @@ merge(Compressor.prototype, {
            var args = trim(this.args, compressor, first_in_statement);
            return args && make_sequence(this, args);
        });
+        def(AST_Accessor, return_null);
        def(AST_Function, return_null);
        def(AST_Binary, function(compressor, first_in_statement){
            var right = this.right.drop_side_effect_free(compressor);
@@ -2432,11 +2450,11 @@ merge(Compressor.prototype, {
            return values && make_sequence(this, values);
        });
        def(AST_Dot, function(compressor, first_in_statement){
-            if (this.expression.may_eq_null(compressor)) return this;
+            if (this.expression.may_throw_on_access(compressor)) return this;
            return this.expression.drop_side_effect_free(compressor, first_in_statement);
        });
        def(AST_Sub, function(compressor, first_in_statement){
-            if (this.expression.may_eq_null(compressor)) return this;
+            if (this.expression.may_throw_on_access(compressor)) return this;
            var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
            if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement);
            var property = this.property.drop_side_effect_free(compressor);
--- a/lib/minify.js
+++ b/lib/minify.js
@@ -108,38 +108,46 @@ function minify(files, options) {
                toplevel = mangle_properties(toplevel, options.mangle.properties);
            }
        }
-        if (options.sourceMap) {
-            if (typeof options.sourceMap.content == "string") {
-                options.sourceMap.content = JSON.parse(options.sourceMap.content);
-            }
-            options.output.source_map = SourceMap({
-                file: options.sourceMap.filename,
-                orig: options.sourceMap.content,
-                root: options.sourceMap.root
-            });
-            if (options.sourceMap.includeSources) {
-                for (var name in files) {
-                    options.output.source_map.get().setSourceContent(name, files[name]);
+        var result = {};
+        if (options.output.ast) {
+            result.ast = toplevel;
+        }
+        if (!HOP(options.output, "code") || options.output.code) {
+            if (options.sourceMap) {
+                if (typeof options.sourceMap.content == "string") {
+                    options.sourceMap.content = JSON.parse(options.sourceMap.content);
+                }
+                options.output.source_map = SourceMap({
+                    file: options.sourceMap.filename,
+                    orig: options.sourceMap.content,
+                    root: options.sourceMap.root
+                });
+                if (options.sourceMap.includeSources) {
+                    for (var name in files) {
+                        options.output.source_map.get().setSourceContent(name, files[name]);
+                    }
                }
            }
-        }
-        var stream = OutputStream(options.output);
-        toplevel.print(stream);
-        var result = {
-            code: stream.get()
-        };
-        if (options.sourceMap) {
-            result.map = options.output.source_map.toString();
-            if (options.sourceMap.url == "inline") {
-                result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(result.map);
-            } else if (options.sourceMap.url) {
-                result.code += "\n//# sourceMappingURL=" + options.sourceMap.url;
+            delete options.output.ast;
+            delete options.output.code;
+            var stream = OutputStream(options.output);
+            toplevel.print(stream);
+            result.code = stream.get();
+            if (options.sourceMap) {
+                result.map = options.output.source_map.toString();
+                if (options.sourceMap.url == "inline") {
+                    result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(result.map);
+                } else if (options.sourceMap.url) {
+                    result.code += "\n//# sourceMappingURL=" + options.sourceMap.url;
+                }
            }
        }
        if (warnings.length) {
            result.warnings = warnings;
        }
        return result;
+    } catch (ex) {
+        return { error: ex };
    } finally {
        AST_Node.warn_function = warn_function;
    }
--- a/lib/mozilla-ast.js
+++ b/lib/mozilla-ast.js
@@ -111,23 +111,19 @@
        },
        Property: function(M) {
            var key = M.key;
-            var name = key.type == "Identifier" ? key.name : key.value;
            var args = {
                start    : my_start_token(key),
                end      : my_end_token(M.value),
-                key      : name,
+                key      : key.type == "Identifier" ? key.name : key.value,
                value    : from_moz(M.value)
            };
-            switch (M.kind) {
-              case "init":
-                return new AST_ObjectKeyVal(args);
-              case "set":
-                args.value.name = from_moz(key);
-                return new AST_ObjectSetter(args);
-              case "get":
-                args.value.name = from_moz(key);
-                return new AST_ObjectGetter(args);
-            }
+            if (M.kind == "init") return new AST_ObjectKeyVal(args);
+            args.key = new AST_SymbolAccessor({
+                name: args.key
+            });
+            args.value = new AST_Accessor(args.value);
+            if (M.kind == "get") return new AST_ObjectGetter(args);
+            if (M.kind == "set") return new AST_ObjectSetter(args);
        },
        ArrayExpression: function(M) {
            return new AST_Array({
@@ -172,7 +168,7 @@
            });
        },
        VariableDeclaration: function(M) {
-            return new (M.kind === "const" ? AST_Const : AST_Var)({
+            return new AST_Var({
                start       : my_start_token(M),
                end         : my_end_token(M),
                definitions : M.declarations.map(from_moz)
@@ -208,7 +204,7 @@
        Identifier: function(M) {
            var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
            return new (  p.type == "LabeledStatement" ? AST_Label
-                        : p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : AST_SymbolVar)
+                        : p.type == "VariableDeclarator" && p.id === M ? AST_SymbolVar
                        : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
                        : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
                        : p.type == "CatchClause" ? AST_SymbolCatch
@@ -260,10 +256,7 @@
    map("CallExpression", AST_Call, "callee>expression, arguments@args");

    def_to_moz(AST_Toplevel, function To_Moz_Program(M) {
-        return {
-            type: "Program",
-            body: M.body.map(to_moz)
-        };
+        return to_moz_scope("Program", M);
    });

    def_to_moz(AST_Defun, function To_Moz_FunctionDeclaration(M) {
@@ -271,7 +264,7 @@
            type: "FunctionDeclaration",
            id: to_moz(M.name),
            params: M.argnames.map(to_moz),
-            body: to_moz_block(M)
+            body: to_moz_scope("BlockStatement", M)
        }
    });

@@ -280,7 +273,7 @@
            type: "FunctionExpression",
            id: to_moz(M.name),
            params: M.argnames.map(to_moz),
-            body: to_moz_block(M)
+            body: to_moz_scope("BlockStatement", M)
        }
    });

@@ -331,7 +324,7 @@
    def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
        return {
            type: "VariableDeclaration",
-            kind: M instanceof AST_Const ? "const" : "var",
+            kind: "var",
            declarations: M.definitions.map(to_moz)
        };
    });
@@ -386,11 +379,10 @@
    });

    def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
-        var key = (
-            is_identifier(M.key)
-            ? {type: "Identifier", name: M.key}
-            : {type: "Literal", value: M.key}
-        );
+        var key = {
+            type: "Literal",
+            value: M.key instanceof AST_SymbolAccessor ? M.key.name : M.key
+        };
        var kind;
        if (M instanceof AST_ObjectKeyVal) {
            kind = "init";
@@ -551,8 +543,8 @@
        moz_to_me = new Function("U2", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
            exports, my_start_token, my_end_token, from_moz
        );
-        me_to_moz = new Function("to_moz", "to_moz_block", "return(" + me_to_moz + ")")(
-            to_moz, to_moz_block
+        me_to_moz = new Function("to_moz", "to_moz_block", "to_moz_scope", "return(" + me_to_moz + ")")(
+            to_moz, to_moz_block, to_moz_scope
        );
        MOZ_TO_ME[moztype] = moz_to_me;
        def_to_moz(mytype, me_to_moz);
@@ -610,4 +602,14 @@
        };
    };

+    function to_moz_scope(type, node) {
+        var body = node.body.map(to_moz);
+        if (node.body[0] instanceof AST_SimpleStatement && node.body[0].body instanceof AST_String) {
+            body.unshift(to_moz(new AST_EmptyStatement(node.body[0])));
+        }
+        return {
+            type: type,
+            body: body
+        };
+    };
 })();
--- a/lib/output.js
+++ b/lib/output.js
@@ -1033,9 +1033,6 @@ function OutputStream(options) {
    DEFPRINT(AST_Var, function(self, output){
        self._do_print(output, "var");
    });
-    DEFPRINT(AST_Const, function(self, output){
-        self._do_print(output, "const");
-    });

    function parenthesize_for_noin(node, output, noin) {
        if (!noin) node.print(output);
--- a/lib/parse.js
+++ b/lib/parse.js
@@ -285,7 +285,11 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
        S.regex_allowed = ((type == "operator" && !UNARY_POSTFIX(value)) ||
                           (type == "keyword" && KEYWORDS_BEFORE_EXPRESSION(value)) ||
                           (type == "punc" && PUNC_BEFORE_EXPRESSION(value)));
-        prev_was_dot = (type == "punc" && value == ".");
+        if (type == "punc" && value == ".") {
+            prev_was_dot = true;
+        } else if (!is_comment) {
+            prev_was_dot = false;
+        }
        var ret = {
            type    : type,
            value   : value,
@@ -801,28 +805,23 @@ function parse($TEXT, options) {
    };

    var statement = embed_tokens(function() {
-        var tmp;
        handle_regexp();
        switch (S.token.type) {
          case "string":
-            var dir = false;
-            if (S.in_directives === true) {
-                if ((is_token(peek(), "punc", ";") || peek().nlb) && S.token.raw.indexOf("\\") === -1) {
+            if (S.in_directives) {
+                var token = peek();
+                if (S.token.raw.indexOf("\\") == -1
+                    && (token.nlb
+                        || is_token(token, "eof")
+                        || is_token(token, "punc", ";")
+                        || is_token(token, "punc", "}"))) {
                    S.input.add_directive(S.token.value);
                } else {
                    S.in_directives = false;
                }
            }
            var dir = S.in_directives, stat = simple_statement();
-            if (dir) {
-                return new AST_Directive({
-                    start : stat.body.start,
-                    end   : stat.body.end,
-                    quote : stat.body.quote,
-                    value : stat.body.value,
-                });
-            }
-            return stat;
+            return dir ? new AST_Directive(stat.body) : stat;
          case "num":
          case "regexp":
          case "operator":
@@ -854,75 +853,97 @@ function parse($TEXT, options) {
            }

          case "keyword":
-            switch (tmp = S.token.value, next(), tmp) {
+            switch (S.token.value) {
              case "break":
+                next();
                return break_cont(AST_Break);

              case "continue":
+                next();
                return break_cont(AST_Continue);

              case "debugger":
+                next();
                semicolon();
                return new AST_Debugger();

              case "do":
+                next();
+                var body = in_loop(statement);
+                expect_token("keyword", "while");
+                var condition = parenthesised();
+                semicolon(true);
                return new AST_Do({
-                    body      : in_loop(statement),
-                    condition : (expect_token("keyword", "while"), tmp = parenthesised(), semicolon(true), tmp)
+                    body      : body,
+                    condition : condition
                });

              case "while":
+                next();
                return new AST_While({
                    condition : parenthesised(),
                    body      : in_loop(statement)
                });

              case "for":
+                next();
                return for_();

              case "function":
+                next();
                return function_(AST_Defun);

              case "if":
+                next();
                return if_();

              case "return":
                if (S.in_function == 0 && !options.bare_returns)
                    croak("'return' outside of function");
+                next();
+                var value = null;
+                if (is("punc", ";")) {
+                    next();
+                } else if (!can_insert_semicolon()) {
+                    value = expression(true);
+                    semicolon();
+                }
                return new AST_Return({
-                    value: ( is("punc", ";")
-                             ? (next(), null)
-                             : can_insert_semicolon()
-                             ? null
-                             : (tmp = expression(true), semicolon(), tmp) )
+                    value: value
                });

              case "switch":
+                next();
                return new AST_Switch({
                    expression : parenthesised(),
                    body       : in_loop(switch_body_)
                });

              case "throw":
+                next();
                if (S.token.nlb)
                    croak("Illegal newline after 'throw'");
+                var value = expression(true);
+                semicolon();
                return new AST_Throw({
-                    value: (tmp = expression(true), semicolon(), tmp)
+                    value: value
                });

              case "try":
+                next();
                return try_();

              case "var":
-                return tmp = var_(), semicolon(), tmp;
-
-              case "const":
-                return tmp = const_(), semicolon(), tmp;
+                next();
+                var node = var_();
+                semicolon();
+                return node;

              case "with":
                if (S.input.has_directive("use strict")) {
                    croak("Strict mode may not include a with statement");
                }
+                next();
                return new AST_With({
                    expression : parenthesised(),
                    body       : statement()
@@ -1153,16 +1174,13 @@ function parse($TEXT, options) {
        });
    };

-    function vardefs(no_in, in_const) {
+    function vardefs(no_in) {
        var a = [];
        for (;;) {
            a.push(new AST_VarDef({
                start : S.token,
-                name  : as_symbol(in_const ? AST_SymbolConst : AST_SymbolVar),
-                value : is("operator", "=")
-                    ? (next(), expression(false, no_in))
-                    : in_const && S.input.has_directive("use strict")
-                        ? croak("Missing initializer in const declaration") : null,
+                name  : as_symbol(AST_SymbolVar),
+                value : is("operator", "=") ? (next(), expression(false, no_in)) : null,
                end   : prev()
            }));
            if (!is("punc", ","))
@@ -1175,15 +1193,7 @@ function parse($TEXT, options) {
    var var_ = function(no_in) {
        return new AST_Var({
            start       : prev(),
-            definitions : vardefs(no_in, false),
-            end         : prev()
-        });
-    };
-
-    var const_ = function() {
-        return new AST_Const({
-            start       : prev(),
-            definitions : vardefs(false, true),
+            definitions : vardefs(no_in),
            end         : prev()
        });
    };
@@ -1324,10 +1334,15 @@ function parse($TEXT, options) {
            var type = start.type;
            var name = as_property_name();
            if (type == "name" && !is("punc", ":")) {
+                var key = new AST_SymbolAccessor({
+                    start: S.token,
+                    name: as_property_name(),
+                    end: prev()
+                });
                if (name == "get") {
                    a.push(new AST_ObjectGetter({
                        start : start,
-                        key   : as_atom_node(),
+                        key   : key,
                        value : create_accessor(),
                        end   : prev()
                    }));
@@ -1336,7 +1351,7 @@ function parse($TEXT, options) {
                if (name == "set") {
                    a.push(new AST_ObjectSetter({
                        start : start,
-                        key   : as_atom_node(),
+                        key   : key,
                        value : create_accessor(),
                        end   : prev()
                    }));
--- a/lib/scope.js
+++ b/lib/scope.js
@@ -156,8 +156,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
            // later.
            (node.scope = defun.parent_scope).def_function(node);
        }
-        else if (node instanceof AST_SymbolVar
-            || node instanceof AST_SymbolConst) {
+        else if (node instanceof AST_SymbolVar) {
            defun.def_variable(node);
            if (defun !== scope) {
                node.mark_enclosed(options);
@@ -268,7 +267,7 @@ AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
    AST_Scope.prototype.init_scope_vars.apply(this, arguments);
    this.uses_arguments = false;
-    this.def_variable(new AST_SymbolConst({
+    this.def_variable(new AST_SymbolFunarg({
        name: "arguments",
        start: this.start,
        end: this.end
@@ -361,11 +360,6 @@ AST_Symbol.DEFMETHOD("unmangleable", function(options){
    return this.definition().unmangleable(options);
 });

-// property accessors are not mangleable
-AST_SymbolAccessor.DEFMETHOD("unmangleable", function(){
-    return true;
-});
-
 // labels are always mangleable
 AST_Label.DEFMETHOD("unmangleable", function(){
    return false;
@@ -491,8 +485,6 @@ AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
        }
        else if (node instanceof AST_Var)
            base54.consider("var");
-        else if (node instanceof AST_Const)
-            base54.consider("const");
        else if (node instanceof AST_Lambda)
            base54.consider("function");
        else if (node instanceof AST_For)
--- a/package.json
+++ b/package.json
@@ -4,7 +4,7 @@
  "homepage": "http://lisperator.net/uglifyjs",
  "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
  "license": "BSD-2-Clause",
-  "version": "3.0.0",
+  "version": "3.0.6",
  "engines": {
    "node": ">=0.8.0"
  },
@@ -33,20 +33,9 @@
    "source-map": "~0.5.1"
  },
  "devDependencies": {
-    "acorn": "~0.6.0",
-    "escodegen": "~1.3.3",
-    "esfuzz": "~0.3.1",
-    "estraverse": "~1.5.1",
+    "acorn": "~5.0.3",
    "mocha": "~2.3.4"
  },
-  "optionalDependencies": {
-    "uglify-to-browserify": "~1.0.0"
-  },
-  "browserify": {
-    "transform": [
-      "uglify-to-browserify"
-    ]
-  },
  "scripts": {
    "test": "node test/run-tests.js"
  },
--- a/test/compress/collapse_vars.js
+++ b/test/compress/collapse_vars.js
@@ -583,8 +583,8 @@ collapse_vars_assignment: {
            return a = a;
        }
        function f1(c) {
-            const a = 3 / c;
-            const b = 1 - a;
+            var a = 3 / c;
+            var b = 1 - a;
            return b;
        }
        function f2(c) {
@@ -724,10 +724,10 @@ collapse_vars_misc1: {
            return t;
        }
        function f1(x) { var y = 5 - x; return y; }
-        function f2(x) { const z = foo(), y = z / (5 - x); return y; }
+        function f2(x) { var z = foo(), y = z / (5 - x); return y; }
        function f3(x) { var z = foo(), y = (5 - x) / z; return y; }
        function f4(x) { var z = foo(), y = (5 - u) / z; return y; }
-        function f5(x) { const z = foo(), y = (5 - window.x) / z; return y; }
+        function f5(x) { var z = foo(), y = (5 - window.x) / z; return y; }
        function f6() { var b = window.a * window.z; return b && zap(); }
        function f7() { var b = window.a * window.z; return b + b; }
        function f8() { var b = window.a * window.z; var c = b + 5; return b + c; }
@@ -744,7 +744,7 @@ collapse_vars_misc1: {
        function f2(x) { return foo() / (5 - x) }
        function f3(x) { return (5 - x) / foo() }
        function f4(x) { var z = foo(); return (5 - u) / z }
-        function f5(x) { const z = foo(); return (5 - window.x) / z }
+        function f5(x) { var z = foo(); return (5 - window.x) / z }
        function f6() { return window.a * window.z && zap() }
        function f7() { var b = window.a * window.z; return b + b }
        function f8() { var b = window.a * window.z; return b + (b + 5) }
--- a/test/compress/const.js
+++ b/test/compress/const.js
@@ -1,166 +0,0 @@
-issue_1191: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        function foo(rot) {
-            const rotTol = 5;
-            if (rot < -rotTol || rot > rotTol)
-                bar();
-            baz();
-        }
-    }
-    expect: {
-        function foo(rot) {
-            (rot < -5 || rot > 5) && bar();
-            baz();
-        }
-    }
-}
-
-issue_1194: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        function f1() {const a = "X"; return a + a;}
-        function f2() {const aa = "X"; return aa + aa;}
-        function f3() {const aaa = "X"; return aaa + aaa;}
-    }
-    expect: {
-        function f1(){return"XX"}
-        function f2(){return"XX"}
-        function f3(){return"XX"}
-    }
-}
-
-issue_1396: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        function foo(a) {
-            const VALUE = 1;
-            console.log(2 | VALUE);
-            console.log(VALUE + 1);
-            console.log(VALUE);
-            console.log(a & VALUE);
-        }
-        function bar() {
-            const s = "01234567890123456789";
-            console.log(s + s + s + s + s);
-
-            const CONSTANT = "abc";
-            console.log(CONSTANT + CONSTANT + CONSTANT + CONSTANT + CONSTANT);
-        }
-    }
-    expect: {
-        function foo(a) {
-            console.log(3);
-            console.log(2);
-            console.log(1);
-            console.log(1 & a);
-        }
-        function bar() {
-            const s = "01234567890123456789";
-            console.log(s + s + s + s + s);
-
-            console.log("abcabcabcabcabc");
-        }
-    }
-}
-
-unused_regexp_literal: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-    }
-    input: {
-        function f(){ var a = /b/; }
-    }
-    expect: {
-        function f(){}
-    }
-}
-
-regexp_literal_not_const: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        (function(){
-            var result;
-            const s = 'acdabcdeabbb';
-            const REGEXP_LITERAL = /ab*/g;
-            while (result = REGEXP_LITERAL.exec(s)) {
-                console.log(result[0]);
-            }
-        })();
-    }
-    expect: {
-        (function() {
-            var result;
-            const REGEXP_LITERAL = /ab*/g;
-            while (result = REGEXP_LITERAL.exec("acdabcdeabbb")) console.log(result[0]);
-        })();
-    }
-    expect_stdout: true
-}
--- a/test/compress/dead-code.js
+++ b/test/compress/dead-code.js
@@ -90,131 +90,6 @@ dead_code_constant_boolean_should_warn_more: {
    expect_stdout: true
 }

-dead_code_const_declaration: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true,
-        reduce_vars  : true,
-    };
-    input: {
-        var unused;
-        const CONST_FOO = false;
-        if (CONST_FOO) {
-            console.log("unreachable");
-            var moo;
-            function bar() {}
-        }
-    }
-    expect: {
-        var unused;
-        const CONST_FOO = !1;
-        var moo;
-        function bar() {}
-    }
-    expect_stdout: true
-}
-
-dead_code_const_annotation: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true,
-        reduce_vars  : true,
-        toplevel     : true,
-    };
-    input: {
-        var unused;
-        /** @const */ var CONST_FOO_ANN = false;
-        if (CONST_FOO_ANN) {
-            console.log("unreachable");
-            var moo;
-            function bar() {}
-        }
-    }
-    expect: {
-        var unused;
-        var CONST_FOO_ANN = !1;
-        var moo;
-        function bar() {}
-    }
-    expect_stdout: true
-}
-
-dead_code_const_annotation_regex: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true
-    };
-    input: {
-        var unused;
-        // @constraint this shouldn't be a constant
-        var CONST_FOO_ANN = false;
-        if (CONST_FOO_ANN) {
-            console.log("reachable");
-        }
-    }
-    expect: {
-        var unused;
-        var CONST_FOO_ANN = !1;
-        CONST_FOO_ANN && console.log('reachable');
-    }
-    expect_stdout: true
-}
-
-dead_code_const_annotation_complex_scope: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true,
-        reduce_vars  : true,
-        toplevel     : true,
-    };
-    input: {
-        var unused_var;
-        /** @const */ var test = 'test';
-        // @const
-        var CONST_FOO_ANN = false;
-        var unused_var_2;
-        if (CONST_FOO_ANN) {
-            console.log("unreachable");
-            var moo;
-            function bar() {}
-        }
-        if (test === 'test') {
-            var beef = 'good';
-            /** @const */ var meat = 'beef';
-            var pork = 'bad';
-            if (meat === 'pork') {
-                console.log('also unreachable');
-            } else if (pork === 'good') {
-                console.log('reached, not const');
-            }
-        }
-    }
-    expect: {
-        var unused_var;
-        var test = 'test';
-        var CONST_FOO_ANN = !1;
-        var unused_var_2;
-        var moo;
-        function bar() {}
-        var beef = 'good';
-        var meat = 'beef';
-        var pork = 'bad';
-    }
-    expect_stdout: true
-}
-
 try_catch_finally: {
    options = {
        conditionals: true,
@@ -256,3 +131,19 @@ try_catch_finally: {
        "1",
    ]
 }
+
+accessor: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            get a() {},
+            set a(v){
+                this.b = 2;
+            },
+            b: 1
+        });
+    }
+    expect: {}
+}
--- a/test/compress/drop-unused.js
+++ b/test/compress/drop-unused.js
@@ -649,37 +649,6 @@ drop_value: {
    }
 }

-const_assign: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            const b = 2;
-            return 1 + b;
-        }
-
-        function g() {
-            const b = 2;
-            b = 3;
-            return 1 + b;
-        }
-    }
-    expect: {
-        function f() {
-            return 3;
-        }
-
-        function g() {
-            const b = 2;
-            b = 3;
-            return 1 + b;
-        }
-    }
-}
-
 issue_1539: {
    options = {
        cascade: true,
@@ -816,10 +785,6 @@ issue_1709: {
                var x = 1;
                return x;
            }(),
-            function y() {
-                const y = 2;
-                return y;
-            }(),
            function z() {
                function z() {}
                return z;
@@ -832,10 +797,6 @@ issue_1709: {
                var x = 1;
                return x;
            }(),
-            function() {
-                const y = 2;
-                return y;
-            }(),
            function() {
                function z() {}
                return z;
--- a/test/compress/evaluate.js
+++ b/test/compress/evaluate.js
@@ -645,16 +645,17 @@ call_args: {
    options = {
        evaluate: true,
        reduce_vars: true,
+        toplevel: true,
    }
    input: {
-        const a = 1;
+        var a = 1;
        console.log(a);
        +function(a) {
            return a;
        }(a);
    }
    expect: {
-        const a = 1;
+        var a = 1;
        console.log(1);
        +(1, 1);
    }
@@ -666,17 +667,17 @@ call_args_drop_param: {
        evaluate: true,
        keep_fargs: false,
        reduce_vars: true,
+        toplevel: true,
        unused: true,
    }
    input: {
-        const a = 1;
+        var a = 1;
        console.log(a);
        +function(a) {
            return a;
        }(a, b);
    }
    expect: {
-        const a = 1;
        console.log(1);
        +(b, 1);
    }
--- a/test/compress/global_defs.js
+++ b/test/compress/global_defs.js
@@ -120,7 +120,7 @@ mixed: {
        properties: true,
    }
    input: {
-        const FOO = { BAR: 0 };
+        var FOO = { BAR: 0 };
        console.log(FOO.BAR);
        console.log(++CONFIG.DEBUG);
        console.log(++CONFIG.VALUE);
@@ -130,7 +130,7 @@ mixed: {
        console.log(CONFIG);
    }
    expect: {
-        const FOO = { BAR: 0 };
+        var FOO = { BAR: 0 };
        console.log("moo");
        console.log(++CONFIG.DEBUG);
        console.log(++CONFIG.VALUE);
--- a/test/compress/issue-1041.js
+++ b/test/compress/issue-1041.js
@@ -1,16 +1,3 @@
-const_declaration: {
-    options = {
-        evaluate: true
-    };
-
-    input: {
-        const goog = goog || {};
-    }
-    expect: {
-        const goog = goog || {};
-    }
-}
-
 const_pragma: {
    options = {
        evaluate: true,
--- a/test/compress/issue-1588.js
+++ b/test/compress/issue-1588.js
@@ -85,15 +85,3 @@ unsafe_undefined: {
    }
    expect_stdout: true
 }
-
-runtime_error: {
-    input: {
-        const a = 1;
-        console.log(a++);
-    }
-    expect: {
-        const a = 1;
-        console.log(a++);
-    }
-    expect_stdout: true
-}
--- a/test/compress/issue-1943.js
+++ b/test/compress/issue-1943.js
@@ -0,0 +1,31 @@
+operator: {
+    input: {
+        a. //comment
+        typeof
+    }
+    expect_exact: "a.typeof;"
+}
+
+name: {
+    input: {
+        a. //comment
+        b
+    }
+    expect_exact: "a.b;"
+}
+
+keyword: {
+    input: {
+        a. //comment
+        default
+    }
+    expect_exact: "a.default;"
+}
+
+atom: {
+    input: {
+        a. //comment
+        true
+    }
+    expect_exact: "a.true;"
+}
--- a/test/compress/issue-208.js
+++ b/test/compress/issue-208.js
@@ -38,7 +38,7 @@ mixed: {
        }
    }
    input: {
-        const ENV = 3;
+        var ENV = 3;
        var FOO = 4;
        f(ENV * 10);
        --FOO;
@@ -49,7 +49,7 @@ mixed: {
        x = DEBUG;
    }
    expect: {
-        const ENV = 3;
+        var ENV = 3;
        var FOO = 4;
        f(10);
        --FOO;
@@ -60,7 +60,7 @@ mixed: {
        x = 0;
    }
    expect_warnings: [
-        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,14]',
+        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,12]',
        'WARN: global_defs FOO redefined [test/compress/issue-208.js:42,12]',
        'WARN: global_defs FOO redefined [test/compress/issue-208.js:44,10]',
        'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:45,8]',
--- a/test/compress/loops.js
+++ b/test/compress/loops.js
@@ -146,50 +146,6 @@ parse_do_while_without_semicolon: {
    }
 }

-
-keep_collapse_const_in_own_block_scope: {
-    options = {
-        join_vars: true,
-        loops: true
-    }
-    input: {
-        var i=2;
-        const c=5;
-        while(i--)
-            console.log(i);
-        console.log(c);
-    }
-    expect: {
-        var i=2;
-        const c=5;
-        for(;i--;)
-            console.log(i);
-        console.log(c);
-    }
-    expect_stdout: true
-}
-
-keep_collapse_const_in_own_block_scope_2: {
-    options = {
-        join_vars: true,
-        loops: true
-    }
-    input: {
-        const c=5;
-        var i=2; // Moves to loop, while it did not in previous test
-        while(i--)
-            console.log(i);
-        console.log(c);
-    }
-    expect: {
-        const c=5;
-        for(var i=2;i--;)
-            console.log(i);
-        console.log(c);
-    }
-    expect_stdout: true
-}
-
 evaluate: {
    options = {
        loops: true,
--- a/test/compress/pure_getters.js
+++ b/test/compress/pure_getters.js
@@ -119,3 +119,62 @@ chained: {
        a.b.c;
    }
 }
+
+impure_getter_1: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).a;
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).b;
+    }
+    expect: {
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).a;
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).b;
+    }
+    expect_stdout: "1"
+}
+
+impure_getter_2: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        // will produce incorrect output because getter is not pure
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).a;
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).b;
+    }
+    expect: {}
+}
--- a/test/compress/reduce_vars.js
+++ b/test/compress/reduce_vars.js
@@ -41,20 +41,20 @@ reduce_vars: {
        var A = 1;
        (function() {
            console.log(-3);
-            console.log(-4);
+            console.log(A - 5);
        })();
        (function f1() {
            var a = 2;
-            console.log(-3);
+            console.log(a - 5);
            eval("console.log(a);");
        })();
        (function f2(eval) {
            var a = 2;
-            console.log(-3);
+            console.log(a - 5);
            eval("console.log(a);");
        })(eval);
        "yes";
-        console.log(2);
+        console.log(A + 1);
    }
    expect_stdout: true
 }
@@ -1749,7 +1749,10 @@ redefine_arguments_3: {
        console.log(function() {
            var arguments;
            return typeof arguments;
-        }(), "number", "undefined");
+        }(), "number", function(x) {
+            var arguments = x;
+            return typeof arguments;
+        }());
    }
    expect_stdout: "object number undefined"
 }
@@ -2187,10 +2190,11 @@ issue_1814_1: {
    options = {
        evaluate: true,
        reduce_vars: true,
+        toplevel: true,
        unused: true,
    }
    input: {
-        const a = 42;
+        var a = 42;
        !function() {
            var b = a;
            !function(a) {
@@ -2199,7 +2203,6 @@ issue_1814_1: {
        }();
    }
    expect: {
-        const a = 42;
        !function() {
            !function(a) {
                console.log(a++, 42);
@@ -2213,10 +2216,11 @@ issue_1814_2: {
    options = {
        evaluate: true,
        reduce_vars: true,
+        toplevel: true,
        unused: true,
    }
    input: {
-        const a = "32";
+        var a = "32";
        !function() {
            var b = a + 1;
            !function(a) {
@@ -2225,7 +2229,6 @@ issue_1814_2: {
        }();
    }
    expect: {
-        const a = "32";
        !function() {
            !function(a) {
                console.log(a++, "321");
@@ -2461,3 +2464,76 @@ issue_1865: {
    }
    expect_stdout: true
 }
+
+issue_1922_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            arguments[0] = 2;
+            return a;
+        }(1));
+    }
+    expect: {
+        console.log(function(a) {
+            arguments[0] = 2;
+            return a;
+        }(1));
+    }
+    expect_stdout: "2"
+}
+
+issue_1922_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a;
+            eval("a = 1");
+            return a;
+        }(1));
+    }
+    expect: {
+        console.log(function() {
+            var a;
+            eval("a = 1");
+            return a;
+        }(1));
+    }
+    expect_stdout: "1"
+}
+
+accessor: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        console.log({
+            get a() {
+                a = 2;
+                return a;
+            },
+            b: 1
+        }.b, a);
+    }
+    expect: {
+        var a = 1;
+        console.log({
+            get a() {
+                a = 2;
+                return a;
+            },
+            b: 1
+        }.b, a);
+    }
+    expect_stdout: "1 1"
+}
--- a/test/exports.js
+++ b/test/exports.js
@@ -0,0 +1,13 @@
+exports["Compressor"] = Compressor;
+exports["JS_Parse_Error"] = JS_Parse_Error;
+exports["OutputStream"] = OutputStream;
+exports["SourceMap"] = SourceMap;
+exports["TreeWalker"] = TreeWalker;
+exports["base54"] = base54;
+exports["defaults"] = defaults;
+exports["mangle_properties"] = mangle_properties;
+exports["minify"] = minify;
+exports["parse"] = parse;
+exports["string_template"] = string_template;
+exports["tokenizer"] = tokenizer;
+exports["is_identifier"] = is_identifier;
--- a/test/input/invalid/const.js
+++ b/test/input/invalid/const.js
@@ -1,8 +0,0 @@
-function f() {
-    const a;
-}
-
-function g() {
-    "use strict";
-    const a;
-}
--- a/test/input/invalid/else.js
+++ b/test/input/invalid/else.js
@@ -0,0 +1 @@
+if (0) else 1;
--- a/test/input/invalid/return.js
+++ b/test/input/invalid/return.js
@@ -0,0 +1 @@
+return 42;
--- a/test/mocha/accessorTokens-1492.js
+++ b/test/mocha/accessorTokens-1492.js
@@ -1,4 +1,4 @@
-var UglifyJS = require('../../');
+var UglifyJS = require("../node");
 var assert = require("assert");

 describe("Accessor tokens", function() {
@@ -16,7 +16,7 @@ describe("Accessor tokens", function() {
                assert.equal(node.start.pos, 12);
                assert.equal(node.end.endpos, 46);

-                assert(node.key instanceof UglifyJS.AST_SymbolRef);
+                assert(node.key instanceof UglifyJS.AST_SymbolAccessor);
                assert.equal(node.key.start.pos, 16);
                assert.equal(node.key.end.endpos, 22);

--- a/test/mocha/arguments.js
+++ b/test/mocha/arguments.js
@@ -1,4 +1,4 @@
-var UglifyJS = require('../../');
+var UglifyJS = require("../node");
 var assert = require("assert");

 describe("arguments", function() {
--- a/test/mocha/cli.js
+++ b/test/mocha/cli.js
@@ -19,7 +19,7 @@ describe("bin/uglifyjs", function () {
            eval(stdout);

            assert.strictEqual(typeof WrappedUglifyJS, 'object');
-            assert.strictEqual(true, WrappedUglifyJS.parse('foo;') instanceof WrappedUglifyJS.AST_Node);
+            assert.strictEqual(WrappedUglifyJS.minify("foo([true,,2+3]);").code, "foo([!0,,5]);");

            done();
        });
@@ -55,15 +55,15 @@ describe("bin/uglifyjs", function () {
        });
    });
    it("Should append source map to output when using --source-map url=inline", function (done) {
-       var command = uglifyjscmd + " test/input/issue-1323/sample.js --source-map url=inline";
+        var command = uglifyjscmd + " test/input/issue-1323/sample.js --source-map url=inline";

-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            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");
-           done();
-       });
+            assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n" +
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=\n");
+            done();
+        });
    });
    it("should not append source map to output when not using --source-map url=inline", function (done) {
        var command = uglifyjscmd + ' test/input/issue-1323/sample.js';
@@ -76,84 +76,84 @@ describe("bin/uglifyjs", function () {
        });
    });
    it("Should work with --keep-fnames (mangle only)", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m';
+        var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m';

-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;

-           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
+            done();
+        });
    });
    it("Should work with --keep-fnames (mangle & compress)", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m -c unused=false';
+        var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m -c unused=false';

-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;

-           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(5==f(g)());\n");
-           done();
-       });
+            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(5==f(g)());\n");
+            done();
+        });
    });
    it("Should work with keep_fnames under mangler options", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep_fnames=true';
+        var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep_fnames=true';

-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;

-           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
+            done();
+        });
    });
    it("Should work with --define (simple)", function (done) {
-       var command = uglifyjscmd + ' test/input/global_defs/simple.js --define D=5 -c';
+        var command = uglifyjscmd + ' test/input/global_defs/simple.js --define D=5 -c';

-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;

-           assert.strictEqual(stdout, "console.log(5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "console.log(5);\n");
+            done();
+        });
    });
    it("Should work with --define (nested)", function (done) {
-       var command = uglifyjscmd + ' test/input/global_defs/nested.js --define C.D=5,C.V=3 -c';
+        var command = uglifyjscmd + ' test/input/global_defs/nested.js --define C.D=5,C.V=3 -c';

-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;

-           assert.strictEqual(stdout, "console.log(3,5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "console.log(3,5);\n");
+            done();
+        });
    });
    it("Should work with --define (AST_Node)", function (done) {
-       var command = uglifyjscmd + ' test/input/global_defs/simple.js --define console.log=stdout.println -c';
+        var command = uglifyjscmd + ' test/input/global_defs/simple.js --define console.log=stdout.println -c';

-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;

-           assert.strictEqual(stdout, "stdout.println(D);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "stdout.println(D);\n");
+            done();
+        });
    });
    it("Should work with `--beautify`", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1482/input.js -b';
+        var command = uglifyjscmd + ' test/input/issue-1482/input.js -b';

-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;

-           assert.strictEqual(stdout, read("test/input/issue-1482/default.js"));
-           done();
-       });
+            assert.strictEqual(stdout, read("test/input/issue-1482/default.js"));
+            done();
+        });
    });
    it("Should work with `--beautify bracketize`", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1482/input.js -b bracketize';
+        var command = uglifyjscmd + ' test/input/issue-1482/input.js -b bracketize';

-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;

-           assert.strictEqual(stdout, read("test/input/issue-1482/bracketize.js"));
-           done();
-       });
+            assert.strictEqual(stdout, read("test/input/issue-1482/bracketize.js"));
+            done();
+        });
    });
    it("Should process inline source map", function(done) {
        var command = uglifyjscmd + " test/input/issue-520/input.js -mc toplevel --source-map content=inline,url=inline";
@@ -185,7 +185,7 @@ describe("bin/uglifyjs", function () {

        exec(command, function (err, stdout, stderr) {
            assert.ok(err);
-            assert.strictEqual(stderr, "ERROR: inline source map only works with singular input\n");
+            assert.strictEqual(stderr.split(/\n/)[0], "ERROR: inline source map only works with singular input");
            done();
        });
    });
@@ -260,229 +260,244 @@ describe("bin/uglifyjs", function () {
        });
    });
    it("Should throw syntax error (5--)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_1.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_1.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_1.js:1,18",
-               "console.log(1 || 5--);",
-               "                  ^",
-               "ERROR: Invalid use of -- operator"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_1.js:1,18",
+                "console.log(1 || 5--);",
+                "                  ^",
+                "ERROR: Invalid use of -- operator"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (Math.random() /= 2)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_2.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_2.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_2.js:1,32",
-               "console.log(2 || (Math.random() /= 2));",
-               "                                ^",
-               "ERROR: Invalid assignment"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_2.js:1,32",
+                "console.log(2 || (Math.random() /= 2));",
+                "                                ^",
+                "ERROR: Invalid assignment"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (++this)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_3.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_3.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_3.js:1,17",
-               "console.log(3 || ++this);",
-               "                 ^",
-               "ERROR: Invalid use of ++ operator"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_3.js:1,17",
+                "console.log(3 || ++this);",
+                "                 ^",
+                "ERROR: Invalid use of ++ operator"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (++null)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_4.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_4.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_4.js:1,0",
-               "++null",
-               "^",
-               "ERROR: Invalid use of ++ operator"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_4.js:1,0",
+                "++null",
+                "^",
+                "ERROR: Invalid use of ++ operator"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (a.=)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/dot_1.js';
+        var command = uglifyjscmd + ' test/input/invalid/dot_1.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/dot_1.js:1,2",
-               "a.=",
-               "  ^",
-               "ERROR: Unexpected token: operator (=)"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/dot_1.js:1,2",
+                "a.=",
+                "  ^",
+                "ERROR: Unexpected token: operator (=)"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (%.a)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/dot_2.js';
+        var command = uglifyjscmd + ' test/input/invalid/dot_2.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/dot_2.js:1,0",
-               "%.a;",
-               "^",
-               "ERROR: Unexpected token: operator (%)"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/dot_2.js:1,0",
+                "%.a;",
+                "^",
+                "ERROR: Unexpected token: operator (%)"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (a./();)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/dot_3.js';
+        var command = uglifyjscmd + ' test/input/invalid/dot_3.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/dot_3.js:1,2",
-               "a./();",
-               "  ^",
-               "ERROR: Unexpected token: operator (/)"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/dot_3.js:1,2",
+                "a./();",
+                "  ^",
+                "ERROR: Unexpected token: operator (/)"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error ({%: 1})", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/object.js';
+        var command = uglifyjscmd + ' test/input/invalid/object.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/object.js:1,13",
-               "console.log({%: 1});",
-               "             ^",
-               "ERROR: Unexpected token: operator (%)"
-           ].join("\n"));
-           done();
-       });
-    });
-    it("Should throw syntax error (const a)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/const.js';
-
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/const.js:7,11",
-               "    const a;",
-               "           ^",
-               "ERROR: Missing initializer in const declaration"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/object.js:1,13",
+                "console.log({%: 1});",
+                "             ^",
+                "ERROR: Unexpected token: operator (%)"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (delete x)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/delete.js';
+        var command = uglifyjscmd + ' test/input/invalid/delete.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/delete.js:13,11",
-               "    delete x;",
-               "           ^",
-               "ERROR: Calling delete on expression not allowed in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/delete.js:13,11",
+                "    delete x;",
+                "           ^",
+                "ERROR: Calling delete on expression not allowed in strict mode"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (function g(arguments))", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/function_1.js';
+        var command = uglifyjscmd + ' test/input/invalid/function_1.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/function_1.js:4,11",
-               "function g(arguments) {",
-               "           ^",
-               "ERROR: Unexpected arguments in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/function_1.js:4,11",
+                "function g(arguments) {",
+                "           ^",
+                "ERROR: Unexpected arguments in strict mode"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (function eval())", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/function_2.js';
+        var command = uglifyjscmd + ' test/input/invalid/function_2.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/function_2.js:4,9",
-               "function eval() {",
-               "         ^",
-               "ERROR: Unexpected eval in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/function_2.js:4,9",
+                "function eval() {",
+                "         ^",
+                "ERROR: Unexpected eval in strict mode"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (iife arguments())", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/function_3.js';
+        var command = uglifyjscmd + ' test/input/invalid/function_3.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/function_3.js:4,10",
-               "!function arguments() {",
-               "          ^",
-               "ERROR: Unexpected arguments in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/function_3.js:4,10",
+                "!function arguments() {",
+                "          ^",
+                "ERROR: Unexpected arguments in strict mode"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (catch(eval))", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/try.js';
+        var command = uglifyjscmd + ' test/input/invalid/try.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/try.js:7,18",
-               "    try {} catch (eval) {}",
-               "                  ^",
-               "ERROR: Unexpected eval in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/try.js:7,18",
+                "    try {} catch (eval) {}",
+                "                  ^",
+                "ERROR: Unexpected eval in strict mode"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should throw syntax error (var eval)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/var.js';
+        var command = uglifyjscmd + ' test/input/invalid/var.js';

-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/var.js:7,8",
-               "    var eval;",
-               "        ^",
-               "ERROR: Unexpected eval in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/var.js:7,8",
+                "    var eval;",
+                "        ^",
+                "ERROR: Unexpected eval in strict mode"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (else)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/else.js';
+
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/else.js:1,7",
+                "if (0) else 1;",
+                "       ^",
+                "ERROR: Unexpected token: keyword (else)"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (return)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/return.js';
+
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/return.js:1,0",
+                "return 42;",
+                "^",
+                "ERROR: 'return' outside of function"
+            ].join("\n"));
+            done();
+        });
    });
    it("Should handle literal string as source map input", function(done) {
        var command = [
@@ -509,4 +524,15 @@ describe("bin/uglifyjs", function () {
            return JSON.stringify(map).replace(/"/g, '\\"');
        }
    });
+    it("Should dump AST as JSON", function(done) {
+        var command = uglifyjscmd + " test/input/global_defs/simple.js -mco ast";
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            var ast = JSON.parse(stdout);
+            assert.strictEqual(ast._class, "AST_Toplevel");
+            assert.ok(Array.isArray(ast.body));
+            done();
+        });
+    });
 });
--- a/test/mocha/comment-filter.js
+++ b/test/mocha/comment-filter.js
@@ -1,4 +1,4 @@
-var UglifyJS = require('../../');
+var UglifyJS = require("../node");
 var assert = require("assert");

 describe("comment filters", function() {
--- a/test/mocha/comment.js
+++ b/test/mocha/comment.js
@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../../");
+var uglify = require("../node");

 describe("Comment", function() {
    it("Should recognize eol of single line comments", function() {
--- a/test/mocha/directives.js
+++ b/test/mocha/directives.js
@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../../");
+var uglify = require("../node");

 describe("Directives", function() {
    it ("Should allow tokenizer to store directives state", function() {
@@ -351,18 +351,28 @@ describe("Directives", function() {
        var tests = [
            [
                '"use strict";"use strict";"use strict";"use foo";"use strict";;"use sloppy";doSomething("foo");',
-                '"use strict";"use foo";doSomething("foo");'
+                '"use strict";"use foo";doSomething("foo");',
+                'function f(){ "use strict" }',
+                'function f(){ "use asm" }',
+                'function f(){ "use nondirective" }',
+                'function f(){ ;"use strict" }',
+                'function f(){ "use \n"; }',
            ],
            [
                 // Nothing gets optimised in the compressor because "use asm" is the first statement
                '"use asm";"use\\x20strict";1+1;',
-                '"use asm";;"use strict";1+1;' // Yet, the parser noticed that "use strict" wasn't a directive
+                '"use asm";;"use strict";1+1;', // Yet, the parser noticed that "use strict" wasn't a directive
+                'function f(){"use strict"}',
+                'function f(){"use asm"}',
+                'function f(){"use nondirective"}',
+                'function f(){}',
+                'function f(){}',
            ]
        ];

        for (var i = 0; i < tests.length; i++) {
            assert.strictEqual(
-                uglify.minify(tests[i][0], {compress: {collapse_vars: true, side_effects: true}}).code,
+                uglify.minify(tests[i][0]).code,
                tests[i][1],
                tests[i][0]
            );
--- a/test/mocha/getter-setter.js
+++ b/test/mocha/getter-setter.js
@@ -1,4 +1,4 @@
-var UglifyJS = require('../../');
+var UglifyJS = require("../node");
 var assert = require("assert");

 describe("Getters and setters", function() {
@@ -71,7 +71,7 @@ describe("Getters and setters", function() {
        var fail = function(data) {
            return function (e) {
                return e instanceof UglifyJS.JS_Parse_Error &&
-                    e.message === "Invalid getter/setter name: " + data.operator;
+                    e.message === "Unexpected token: operator (" + data.operator + ")";
            };
        };

--- a/test/mocha/line-endings.js
+++ b/test/mocha/line-endings.js
@@ -1,4 +1,4 @@
-var Uglify = require('../../');
+var Uglify = require("../node");
 var assert = require("assert");

 describe("line-endings", function() {
--- a/test/mocha/minify.js
+++ b/test/mocha/minify.js
@@ -114,17 +114,18 @@ describe("minify", function() {
            }
        });
        it("Should fail with multiple input and inline source map", function() {
-            assert.throws(function() {
-                Uglify.minify([
-                    read("./test/input/issue-520/input.js"),
-                    read("./test/input/issue-520/output.js")
-                ], {
-                    sourceMap: {
-                        content: "inline",
-                        url: "inline"
-                    }
-                });
+            var result = Uglify.minify([
+                read("./test/input/issue-520/input.js"),
+                read("./test/input/issue-520/output.js")
+            ], {
+                sourceMap: {
+                    content: "inline",
+                    url: "inline"
+                }
            });
+            var err = result.error;
+            assert.ok(err instanceof Error);
+            assert.strictEqual(err.stack.split(/\n/)[0], "Error: inline source map only works with singular input");
        });
    });

@@ -170,26 +171,14 @@ describe("minify", function() {
    });

    describe("JS_Parse_Error", function() {
-        it("should throw syntax error", function() {
-            assert.throws(function() {
-                Uglify.minify("function f(a{}");
-            }, function(err) {
-                assert.ok(err instanceof Error);
-                assert.strictEqual(err.stack.split(/\n/)[0], "SyntaxError: Unexpected token punc «{», expected punc «,»");
-                assert.strictEqual(err.filename, "0");
-                assert.strictEqual(err.line, 1);
-                assert.strictEqual(err.col, 12);
-                return true;
-            });
+        it("should return syntax error", function() {
+            var result = Uglify.minify("function f(a{}");
+            var err = result.error;
+            assert.ok(err instanceof Error);
+            assert.strictEqual(err.stack.split(/\n/)[0], "SyntaxError: Unexpected token punc «{», expected punc «,»");
+            assert.strictEqual(err.filename, "0");
+            assert.strictEqual(err.line, 1);
+            assert.strictEqual(err.col, 12);
        });
    });
-
-    describe("Compressor", function() {
-        it("should be backward compatible with ast.transform(compressor)", function() {
-            var ast = Uglify.parse("function f(a){for(var i=0;i<a;i++)console.log(i)}");
-            ast.figure_out_scope();
-            ast = ast.transform(Uglify.Compressor());
-            assert.strictEqual(ast.print_to_string(), "function f(a){for(var i=0;i<a;i++)console.log(i)}");
-        });
-    })
 });
--- a/test/mocha/number-literal.js
+++ b/test/mocha/number-literal.js
@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../../");
+var uglify = require("../node");

 describe("Number literals", function () {
    it("Should not allow legacy octal literals in strict mode", function() {
--- a/test/mocha/operator.js
+++ b/test/mocha/operator.js
@@ -1,4 +1,4 @@
-var UglifyJS = require("../../");
+var UglifyJS = require("../node");
 var assert = require("assert");

 describe("operator", function() {
--- a/test/mocha/spidermonkey.js
+++ b/test/mocha/spidermonkey.js
@@ -1,10 +1,10 @@
 var assert = require("assert");
 var exec = require("child_process").exec;
-var uglify = require("../../");
+var uglify = require("../node");

 describe("spidermonkey export/import sanity test", function() {
    it("should produce a functional build when using --self with spidermonkey", function(done) {
-        this.timeout(20000);
+        this.timeout(30000);

        var uglifyjs = '"' + process.argv[0] + '" bin/uglifyjs';
        var command = uglifyjs + " --self -cm --wrap SpiderUglify -o spidermonkey | " +
@@ -15,18 +15,7 @@ describe("spidermonkey export/import sanity test", function() {

            eval(stdout);
            assert.strictEqual(typeof SpiderUglify, "object");
-
-            var ast = SpiderUglify.parse("foo([true,,2+3]);");
-            assert.strictEqual(true, ast instanceof SpiderUglify.AST_Node);
-
-            ast.figure_out_scope();
-            ast = SpiderUglify.Compressor({}).compress(ast);
-            assert.strictEqual(true, ast instanceof SpiderUglify.AST_Node);
-
-            var stream = SpiderUglify.OutputStream({});
-            ast.print(stream);
-            var code = stream.toString();
-            assert.strictEqual(code, "foo([!0,,5]);");
+            assert.strictEqual(SpiderUglify.minify("foo([true,,2+3]);").code, "foo([!0,,5]);");

            done();
        });
--- a/test/mocha/string-literal.js
+++ b/test/mocha/string-literal.js
@@ -1,4 +1,4 @@
-var UglifyJS = require('../../');
+var UglifyJS = require("../node");
 var assert = require("assert");

 describe("String literals", function() {
--- a/test/mocha/with.js
+++ b/test/mocha/with.js
@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../../");
+var uglify = require("../node");

 describe("With", function() {
    it("Should throw syntaxError when using with statement in strict mode", function() {
--- a/test/mozilla-ast.js
+++ b/test/mozilla-ast.js
@@ -1,103 +1,73 @@
 // Testing UglifyJS <-> SpiderMonkey AST conversion
-// through generative testing.
+"use strict";

-var UglifyJS = require(".."),
-    escodegen = require("escodegen"),
-    esfuzz = require("esfuzz"),
-    estraverse = require("estraverse"),
-    prefix = "\r    ";
+var acorn = require("acorn");
+var ufuzz = require("./ufuzz");
+var UglifyJS = require("..");

-// Normalizes input AST for UglifyJS in order to get correct comparison.
-
-function normalizeInput(ast) {
-    return estraverse.replace(ast, {
-        enter: function(node, parent) {
-            switch (node.type) {
-                // Internally mark all the properties with semi-standard type "Property".
-                case "ObjectExpression":
-                    node.properties.forEach(function (property) {
-                        property.type = "Property";
-                    });
-                    break;
-
-                // Since UglifyJS doesn"t recognize different types of property keys,
-                // decision on SpiderMonkey node type is based on check whether key
-                // can be valid identifier or not - so we do in input AST.
-                case "Property":
-                    var key = node.key;
-                    if (key.type === "Literal" && typeof key.value === "string" && UglifyJS.is_identifier(key.value)) {
-                        node.key = {
-                            type: "Identifier",
-                            name: key.value
-                        };
-                    } else if (key.type === "Identifier" && !UglifyJS.is_identifier(key.name)) {
-                        node.key = {
-                            type: "Literal",
-                            value: key.name
-                        };
-                    }
-                    break;
-
-                // UglifyJS internally flattens all the expression sequences - either
-                // to one element (if sequence contains only one element) or flat list.
-                case "SequenceExpression":
-                    node.expressions = node.expressions.reduce(function flatten(list, expr) {
-                        return list.concat(expr.type === "SequenceExpression" ? expr.expressions.reduce(flatten, []) : [expr]);
-                    }, []);
-                    if (node.expressions.length === 1) {
-                        return node.expressions[0];
-                    }
-                    break;
-            }
+function try_beautify(code) {
+    var beautified = UglifyJS.minify(code, {
+        compress: false,
+        mangle: false,
+        output: {
+            beautify: true,
+            bracketize: true
        }
    });
+    if (beautified.error) {
+        console.log("// !!! beautify failed !!!");
+        console.log(beautified.error.stack);
+        console.log(code);
+    } else {
+        console.log("// (beautified)");
+        console.log(beautified.code);
+    }
 }

-module.exports = function(options) {
-    console.log("--- UglifyJS <-> Mozilla AST conversion");
-
-    for (var counter = 0; counter < options.iterations; counter++) {
-        process.stdout.write(prefix + counter + "/" + options.iterations);
-
-        var ast1 = normalizeInput(esfuzz.generate({
-            maxDepth: options.maxDepth
-        }));
-
-        var ast2 =
-            UglifyJS
-            .AST_Node
-            .from_mozilla_ast(ast1)
-            .to_mozilla_ast();
-
-        var astPair = [
-            {name: 'expected', value: ast1},
-            {name: 'actual', value: ast2}
-        ];
-
-        var jsPair = astPair.map(function(item) {
-            return {
-                name: item.name,
-                value: escodegen.generate(item.value)
-            }
-        });
-
-        if (jsPair[0].value !== jsPair[1].value) {
-            var fs = require("fs");
-            var acorn = require("acorn");
-
-            fs.existsSync("tmp") || fs.mkdirSync("tmp");
-
-            jsPair.forEach(function (item) {
-                var fileName = "tmp/dump_" + item.name;
-                var ast = acorn.parse(item.value);
-                fs.writeFileSync(fileName + ".js", item.value);
-                fs.writeFileSync(fileName + ".json", JSON.stringify(ast, null, 2));
-            });
-
-            process.stdout.write("\n");
-            throw new Error("Got different outputs, check out tmp/dump_*.{js,json} for codes and ASTs.");
+function test(original, estree, description) {
+    var transformed = UglifyJS.minify(UglifyJS.AST_Node.from_mozilla_ast(estree), {
+        compress: false,
+        mangle: false
+    });
+    if (transformed.error || original !== transformed.code) {
+        console.log("//=============================================================");
+        console.log("// !!!!!! Failed... round", round);
+        console.log("// original code");
+        try_beautify(original);
+        console.log();
+        console.log();
+        console.log("//-------------------------------------------------------------");
+        console.log("//", description);
+        if (transformed.error) {
+            console.log(transformed.error.stack);
+        } else {
+            try_beautify(transformed.code);
        }
+        console.log("!!!!!! Failed... round", round);
+        process.exit(1);
    }
+}

-    process.stdout.write(prefix + "Probability of error is less than " + (100 / options.iterations) + "%, stopping.\n");
-};
+var num_iterations = ufuzz.num_iterations;
+for (var round = 1; round <= num_iterations; round++) {
+    process.stdout.write(round + " of " + num_iterations + "\r");
+    var code = ufuzz.createTopLevelCode();
+    var uglified = UglifyJS.minify(code, {
+        compress: false,
+        mangle: false,
+        output: {
+            ast: true
+        }
+    });
+    test(uglified.code, uglified.ast.to_mozilla_ast(), "AST_Node.to_mozilla_ast()");
+    try {
+        test(uglified.code, acorn.parse(code), "acorn.parse()");
+    } catch (e) {
+        console.log("//=============================================================");
+        console.log("// acorn parser failed... round", round);
+        console.log(e);
+        console.log("// original code");
+        console.log(code);
+    }
+}
+console.log();
--- a/test/node.js
+++ b/test/node.js
@@ -0,0 +1,6 @@
+var fs = require("fs");
+
+new Function("MOZ_SourceMap", "exports", require("../tools/node").FILES.map(function(file) {
+    if (/exports\.js$/.test(file)) file = require.resolve("./exports");
+    return fs.readFileSync(file, "utf8");
+}).join("\n\n"))(require("source-map"), exports);
--- a/test/run-tests.js
+++ b/test/run-tests.js
@@ -1,6 +1,6 @@
 #! /usr/bin/env node

-var U = require("../tools/node");
+var U = require("./node");
 var path = require("path");
 var fs = require("fs");
 var assert = require("assert");
@@ -23,12 +23,6 @@ mocha_tests();
 var run_sourcemaps_tests = require('./sourcemaps');
 run_sourcemaps_tests();

-var run_ast_conversion_tests = require("./mozilla-ast");
-
-run_ast_conversion_tests({
-    iterations: 1000
-});
-
 /* -----[ utils ]----- */

 function tmpl() {
--- a/test/sandbox.js
+++ b/test/sandbox.js
@@ -1,14 +1,16 @@
 var vm = require("vm");

-function safe_log(arg) {
+function safe_log(arg, level) {
    if (arg) switch (typeof arg) {
      case "function":
        return arg.toString();
      case "object":
        if (/Error$/.test(arg.name)) return arg.toString();
        arg.constructor.toString();
-        for (var key in arg) {
-            arg[key] = safe_log(arg[key]);
+        if (level--) for (var key in arg) {
+            if (!Object.getOwnPropertyDescriptor(arg, key).get) {
+                arg[key] = safe_log(arg[key], level);
+            }
        }
    }
    return arg;
@@ -48,7 +50,9 @@ exports.run_code = function(code) {
        ].join("\n"), {
            console: {
                log: function() {
-                    return console.log.apply(console, [].map.call(arguments, safe_log));
+                    return console.log.apply(console, [].map.call(arguments, function(arg) {
+                        return safe_log(arg, 3);
+                    }));
                }
            }
        }, { timeout: 5000 });
--- a/test/sourcemaps.js
+++ b/test/sourcemaps.js
@@ -1,4 +1,4 @@
-var UglifyJS = require("..");
+var UglifyJS = require("./node");
 var ok = require("assert");

 module.exports = function () {
--- a/test/ufuzz.js
+++ b/test/ufuzz.js
@@ -12,7 +12,7 @@
        stream._handle.setBlocking(true);
 });

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

@@ -48,8 +48,9 @@ var STMT_COUNT_FROM_GLOBAL = true; // count statement depth from nearest functio
 var num_iterations = +process.argv[2] || 1/0;
 var verbose = false; // log every generated test
 var verbose_interval = false; // log every 100 generated tests
-var verbose_error = false;
 var use_strict = false;
+var catch_redef = require.main === module;
+var generate_directive = require.main === module;
 for (var i = 2; i < process.argv.length; ++i) {
    switch (process.argv[i]) {
      case '-v':
@@ -58,9 +59,6 @@ for (var i = 2; i < process.argv.length; ++i) {
      case '-V':
        verbose_interval = true;
        break;
-      case '-E':
-        verbose_error = true;
-        break;
      case '-t':
        MAX_GENERATED_TOPLEVELS_PER_RUN = +process.argv[++i];
        if (!MAX_GENERATED_TOPLEVELS_PER_RUN) throw new Error('Must generate at least one toplevel per run');
@@ -79,6 +77,12 @@ for (var i = 2; i < process.argv.length; ++i) {
        STMT_SECOND_LEVEL_OVERRIDE = STMT_ARG_TO_ID[name];
        if (!(STMT_SECOND_LEVEL_OVERRIDE >= 0)) throw new Error('Unknown statement name; use -? to get a list');
        break;
+      case '--no-catch-redef':
+        catch_redef = false;
+        break;
+      case '--no-directive':
+        generate_directive = false;
+        break;
      case '--use-strict':
        use_strict = true;
        break;
@@ -103,11 +107,12 @@ for (var i = 2; i < process.argv.length; ++i) {
        console.log('<number>: generate this many cases (if used must be first arg)');
        console.log('-v: print every generated test case');
        console.log('-V: print every 100th generated test case');
-        console.log('-E: print generated test case with runtime error');
        console.log('-t <int>: generate this many toplevels per run (more take longer)');
        console.log('-r <int>: maximum recursion depth for generator (higher takes longer)');
        console.log('-s1 <statement name>: force the first level statement to be this one (see list below)');
        console.log('-s2 <statement name>: force the second level statement to be this one (see list below)');
+        console.log('--no-catch-redef: do not redefine catch variables');
+        console.log('--no-directive: do not generate directives');
        console.log('--use-strict: generate "use strict"');
        console.log('--stmt-depth-from-func: reset statement depth counter at each function, counts from global otherwise');
        console.log('--only-stmt <statement names>: a comma delimited white list of statements that may be generated');
@@ -192,12 +197,33 @@ var ASSIGNMENTS = [
    '=',
    '=',
    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',

-    '==',
-    '!=',
-    '===',
-    '!==',
    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+
    '-=',
    '*=',
    '/=',
@@ -207,7 +233,8 @@ var ASSIGNMENTS = [
    '<<=',
    '>>=',
    '>>>=',
-    '%=' ];
+    '%=',
+];

 var UNARY_SAFE = [
    '+',
@@ -276,6 +303,7 @@ var TYPEOF_OUTCOMES = [
    'symbol',
    'crap' ];

+var unique_vars = [];
 var loops = 0;
 var funcs = 0;
 var labels = 10000;
@@ -290,6 +318,10 @@ function strictMode() {
 }

 function createTopLevelCode() {
+    VAR_NAMES.length = INITIAL_NAMES_LEN; // prune any previous names still in the list
+    unique_vars.length = 0;
+    loops = 0;
+    funcs = 0;
    return [
        strictMode(),
        'var a = 100, b = 10, c = 0;',
@@ -325,33 +357,36 @@ function createArgs() {
    return args.join(', ');
 }

+function filterDirective(s) {
+    if (!generate_directive && !s[1] && /\("/.test(s[2])) s[2] = ';' + s[2];
+    return s;
+}
+
 function createFunction(recurmax, inGlobal, noDecl, canThrow, stmtDepth) {
    if (--recurmax < 0) { return ';'; }
    if (!STMT_COUNT_FROM_GLOBAL) stmtDepth = 0;
    var func = funcs++;
    var namesLenBefore = VAR_NAMES.length;
-    var name = (inGlobal || rng(5) > 0) ? 'f' + func : createVarName(MANDATORY, noDecl);
-    if (name === 'a' || name === 'b' || name === 'c') name = 'f' + func; // quick hack to prevent assignment to func names of being called
-    var s = '';
+    var name;
+    if (inGlobal || rng(5) > 0) name = 'f' + func;
+    else {
+        unique_vars.push('a', 'b', 'c');
+        name = createVarName(MANDATORY, noDecl);
+        unique_vars.length -= 3;
+    }
+    var s = [
+        'function ' + name + '(' + createParams() + '){',
+        strictMode()
+    ];
    if (rng(5) === 0) {
        // functions with functions. lower the recursion to prevent a mess.
-        s = [
-            'function ' + name + '(' + createParams() + '){',
-            strictMode(),
-            createFunctions(rng(5) + 1, Math.ceil(recurmax * 0.7), NOT_GLOBAL, ANY_TYPE, canThrow, stmtDepth),
-            '}',
-            ''
-        ].join('\n');
+        s.push(createFunctions(rng(5) + 1, Math.ceil(recurmax * 0.7), NOT_GLOBAL, ANY_TYPE, canThrow, stmtDepth));
    } else {
        // functions with statements
-        s = [
-            'function ' + name + '(' + createParams() + '){',
-            strictMode(),
-            createStatements(3, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
-            '}',
-            ''
-        ].join('\n');
+        s.push(createStatements(3, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth));
    }
+    s.push('}', '');
+    s = filterDirective(s).join('\n');

    VAR_NAMES.length = namesLenBefore;

@@ -359,7 +394,6 @@ function createFunction(recurmax, inGlobal, noDecl, canThrow, stmtDepth) {
    // avoid "function statements" (decl inside statements)
    else if (inGlobal || rng(10) > 0) s += 'var ' + createVarName(MANDATORY) + ' = ' + name + '(' + createArgs() + ');';

-
    return s;
 }

@@ -406,7 +440,7 @@ function getLabel(label) {
    return label && " L" + label;
 }

-function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) {
+function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth, target) {
    ++stmtDepth;
    var loop = ++loops;
    if (--recurmax < 0) {
@@ -414,10 +448,11 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
    }

    // allow to forcefully generate certain structures at first or second recursion level
-    var target = 0;
-    if (stmtDepth === 1 && STMT_FIRST_LEVEL_OVERRIDE >= 0) target = STMT_FIRST_LEVEL_OVERRIDE;
-    else if (stmtDepth === 2 && STMT_SECOND_LEVEL_OVERRIDE >= 0) target = STMT_SECOND_LEVEL_OVERRIDE;
-    else target = STMTS_TO_USE[rng(STMTS_TO_USE.length)];
+    if (target === undefined) {
+        if (stmtDepth === 1 && STMT_FIRST_LEVEL_OVERRIDE >= 0) target = STMT_FIRST_LEVEL_OVERRIDE;
+        else if (stmtDepth === 2 && STMT_SECOND_LEVEL_OVERRIDE >= 0) target = STMT_SECOND_LEVEL_OVERRIDE;
+        else target = STMTS_TO_USE[rng(STMTS_TO_USE.length)];
+    }

    switch (target) {
      case STMT_BLOCK:
@@ -460,20 +495,22 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
      case STMT_VAR:
        switch (rng(3)) {
          case 0:
+            unique_vars.push('c');
            var name = createVarName(MANDATORY);
-            if (name === 'c') name = 'a';
+            unique_vars.pop();
            return 'var ' + name + ';';
          case 1:
            // initializer can only have one expression
+            unique_vars.push('c');
            var name = createVarName(MANDATORY);
-            if (name === 'c') name = 'b';
+            unique_vars.pop();
            return 'var ' + name + ' = ' + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + ';';
          default:
            // initializer can only have one expression
+            unique_vars.push('c');
            var n1 = createVarName(MANDATORY);
-            if (n1 === 'c') n1 = 'b';
            var n2 = createVarName(MANDATORY);
-            if (n2 === 'c') n2 = 'b';
+            unique_vars.pop();
            return 'var ' + n1 + ' = ' + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + ', ' + n2 + ' = ' + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + ';';
        }
      case STMT_RETURN_ETC:
@@ -514,8 +551,11 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
            var nameLenBefore = VAR_NAMES.length;
            var catchName = createVarName(MANDATORY);
            var freshCatchName = VAR_NAMES.length !== nameLenBefore;
+            if (!catch_redef) unique_vars.push(catchName);
            s += ' catch (' + catchName + ') { ' + createStatements(3, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + ' }';
-            if (freshCatchName) VAR_NAMES.splice(nameLenBefore, 1); // remove catch name
+            // remove catch name
+            if (!catch_redef) unique_vars.pop();
+            if (freshCatchName) VAR_NAMES.splice(nameLenBefore, 1);
        }
        if (n !== 0) s += ' finally { ' + createStatements(3, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + ' }';
        return s;
@@ -593,8 +633,9 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
      case p++:
      case p++:
        var nameLenBefore = VAR_NAMES.length;
+        unique_vars.push('c');
        var name = createVarName(MAYBE); // note: this name is only accessible from _within_ the function. and immutable at that.
-        if (name == 'c') name = 'a';
+        unique_vars.pop();
        var s = [];
        switch (rng(5)) {
          case 0:
@@ -636,7 +677,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
                strictMode()
            );
            if (instantiate) for (var i = rng(4); --i >= 0;) {
-                if (rng(2)) s.push('this.' + getDotKey() + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ';');
+                if (rng(2)) s.push('this.' + getDotKey(true) + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ';');
                else  s.push('this[' + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']' + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ';');
            }
            s.push(
@@ -646,7 +687,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
            break;
        }
        VAR_NAMES.length = nameLenBefore;
-        return s.join('\n');
+        return filterDirective(s).join('\n');
      case p++:
      case p++:
        return createTypeofExpr(recurmax, stmtDepth, canThrow);
@@ -689,19 +730,19 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
            ") || " + rng(10) + ").toString()[" +
            createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "] ";
      case p++:
-        return createArrayLiteral(recurmax, COMMA_OK, stmtDepth, canThrow);
+        return createArrayLiteral(recurmax, stmtDepth, canThrow);
      case p++:
-        return createObjectLiteral(recurmax, COMMA_OK, stmtDepth, canThrow);
+        return createObjectLiteral(recurmax, stmtDepth, canThrow);
      case p++:
-        return createArrayLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '[' +
+        return createArrayLiteral(recurmax, stmtDepth, canThrow) + '[' +
            createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']';
      case p++:
-        return createObjectLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '[' +
+        return createObjectLiteral(recurmax, stmtDepth, canThrow) + '[' +
            createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']';
      case p++:
-        return createArrayLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '.' + getDotKey();
+        return createArrayLiteral(recurmax, stmtDepth, canThrow) + '.' + getDotKey();
      case p++:
-        return createObjectLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '.' + getDotKey();
+        return createObjectLiteral(recurmax, stmtDepth, canThrow) + '.' + getDotKey();
      case p++:
        var name = getVarName();
        return name + ' && ' + name + '[' + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']';
@@ -713,7 +754,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
    return _createExpression(recurmax, noComma, stmtDepth, canThrow);
 }

-function createArrayLiteral(recurmax, noComma, stmtDepth, canThrow) {
+function createArrayLiteral(recurmax, stmtDepth, canThrow) {
    recurmax--;
    var arr = "[";
    for (var i = rng(6); --i >= 0;) {
@@ -746,18 +787,56 @@ var KEYS = [
    "3",
 ].concat(SAFE_KEYS);

-function getDotKey() {
-    return SAFE_KEYS[rng(SAFE_KEYS.length)];
+function getDotKey(assign) {
+    var key;
+    do {
+        key = SAFE_KEYS[rng(SAFE_KEYS.length)];
+    } while (assign && key == "length");
+    return key;
 }

-function createObjectLiteral(recurmax, noComma, stmtDepth, canThrow) {
-    recurmax--;
-    var obj = "({";
-    for (var i = rng(6); --i >= 0;) {
-        var key = KEYS[rng(KEYS.length)];
-        obj += key + ":(" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "), ";
+function createAccessor(recurmax, stmtDepth, canThrow) {
+    var namesLenBefore = VAR_NAMES.length;
+    var s;
+    var prop1 = getDotKey();
+    if (rng(2) == 0) {
+        s = [
+            'get ' + prop1 + '(){',
+            strictMode(),
+            createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
+            createStatement(recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth, STMT_RETURN_ETC),
+            '},'
+        ];
+    } else {
+        var prop2;
+        do {
+            prop2 = getDotKey();
+        } while (prop1 == prop2);
+        s = [
+            'set ' + prop1 + '(' + createVarName(MANDATORY) + '){',
+            strictMode(),
+            createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
+            'this.' + prop2 + createAssignment() + _createBinaryExpr(recurmax, COMMA_OK, stmtDepth, canThrow) + ';',
+            '},'
+        ];
    }
-    return obj + "})";
+    VAR_NAMES.length = namesLenBefore;
+    return filterDirective(s).join('\n');
+}
+
+function createObjectLiteral(recurmax, stmtDepth, canThrow) {
+    recurmax--;
+    var obj = ['({'];
+    for (var i = rng(6); --i >= 0;) {
+        if (rng(20) == 0) {
+            obj.push(createAccessor(recurmax, stmtDepth, canThrow));
+        } else {
+            var key = KEYS[rng(KEYS.length)];
+            obj.push(key + ':(' + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + '),');
+        }
+    }
+    obj.push('})');
+    return obj.join('\n');
 }

 function createNestedBinaryExpr(recurmax, noComma, stmtDepth, canThrow) {
@@ -787,7 +866,7 @@ function _createSimpleBinaryExpr(recurmax, noComma, stmtDepth, canThrow) {
        return canThrow && rng(10) == 0 ? expr : '(' + assignee + ' && ' + expr + ')';
      case 4:
        assignee = getVarName();
-        expr = '(' + assignee + '.' + getDotKey() + createAssignment()
+        expr = '(' + assignee + '.' + getDotKey(true) + createAssignment()
            + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ')';
        return canThrow && rng(10) == 0 ? expr : '(' + assignee + ' && ' + expr + ')';
      default:
@@ -844,35 +923,40 @@ function getVarName() {

 function createVarName(maybe, dontStore) {
    if (!maybe || rng(2)) {
-        var name = VAR_NAMES[rng(VAR_NAMES.length)];
        var suffix = rng(3);
-        if (suffix) {
-            name += '_' + suffix;
-            if (!dontStore) VAR_NAMES.push(name);
-        }
+        var name;
+        do {
+            name = VAR_NAMES[rng(VAR_NAMES.length)];
+            if (suffix) name += '_' + suffix;
+        } while (unique_vars.indexOf(name) >= 0);
+        if (suffix && !dontStore) VAR_NAMES.push(name);
        return name;
    }
    return '';
 }

+if (require.main !== module) {
+    exports.createTopLevelCode = createTopLevelCode;
+    exports.num_iterations = num_iterations;
+    return;
+}
+
 function try_beautify(code, result) {
-    try {
-        var beautified = UglifyJS.minify(code, {
-            compress: false,
-            mangle: false,
-            output: {
-                beautify: true,
-                bracketize: true,
-            },
-        }).code;
-        if (sandbox.same_stdout(sandbox.run_code(beautified), result)) {
-            console.log("// (beautified)");
-            console.log(beautified);
-            return;
-        }
-    } catch (e) {
+    var beautified = UglifyJS.minify(code, {
+        compress: false,
+        mangle: false,
+        output: {
+            beautify: true,
+            bracketize: true,
+        },
+    });
+    if (beautified.error) {
        console.log("// !!! beautify failed !!!");
-        console.log(e.stack);
+        console.log(beautified.error.stack);
+    } else if (sandbox.same_stdout(sandbox.run_code(beautified.code), result)) {
+        console.log("// (beautified)");
+        console.log(beautified.code);
+        return;
    }
    console.log("//");
    console.log(code);
@@ -908,12 +992,13 @@ function log_suspects(minify_options, component) {
            var o = JSON.parse(JSON.stringify(options));
            o[name] = false;
            m[component] = o;
-            try {
-                var r = sandbox.run_code(UglifyJS.minify(original_code, m).code);
-                return sandbox.same_stdout(original_result, r);
-            } catch (e) {
+            var result = UglifyJS.minify(original_code, m);
+            if (result.error) {
                console.log("Error testing options." + component + "." + name);
-                console.log(e);
+                console.log(result.error);
+            } else {
+                var r = sandbox.run_code(result.code);
+                return sandbox.same_stdout(original_result, r);
            }
        }
    });
@@ -974,28 +1059,22 @@ var uglify_code, uglify_result, ok;
 for (var round = 1; round <= num_iterations; round++) {
    process.stdout.write(round + " of " + num_iterations + "\r");

-    VAR_NAMES.length = INITIAL_NAMES_LEN; // prune any previous names still in the list
-    loops = 0;
-    funcs = 0;
-
    original_code = createTopLevelCode();
    original_result = sandbox.run_code(original_code);
    (typeof original_result != "string" ? fallback_options : minify_options).forEach(function(options) {
-        try {
-            uglify_code = UglifyJS.minify(original_code, JSON.parse(options)).code;
-        } catch (e) {
-            uglify_code = e;
-        }
-
-        ok = typeof uglify_code == "string";
-        if (ok) {
+        uglify_code = UglifyJS.minify(original_code, JSON.parse(options));
+        if (!uglify_code.error) {
+            uglify_code = uglify_code.code;
            uglify_result = sandbox.run_code(uglify_code);
            ok = sandbox.same_stdout(original_result, uglify_result);
-        } else if (typeof original_result != "string") {
-            ok = uglify_code.name == original_result.name;
+        } else {
+            uglify_code = uglify_code.error;
+            if (typeof original_result != "string") {
+                ok = uglify_code.name == original_result.name;
+            }
        }
        if (verbose || (verbose_interval && !(round % INTERVAL_COUNT)) || !ok) log(options);
-        else if (verbose_error && typeof original_result != "string") {
+        else if (typeof original_result != "string") {
            console.log("//=============================================================");
            console.log("// original code");
            try_beautify(original_code, original_result);
--- a/tools/exports.js
+++ b/tools/exports.js
@@ -1,15 +1,4 @@
-exports["Compressor"] = Compressor;
 exports["Dictionary"] = Dictionary;
-exports["JS_Parse_Error"] = JS_Parse_Error;
-exports["OutputStream"] = OutputStream;
-exports["SourceMap"] = SourceMap;
 exports["TreeWalker"] = TreeWalker;
-exports["base54"] = base54;
-exports["defaults"] = defaults;
-exports["mangle_properties"] = mangle_properties;
 exports["minify"] = minify;
-exports["parse"] = parse;
-exports["push_uniq"] = push_uniq;
-exports["string_template"] = string_template;
-exports["tokenizer"] = tokenizer;
-exports["is_identifier"] = is_identifier;
+exports["_push_uniq"] = push_uniq;
--- a/tools/node.js
+++ b/tools/node.js
@@ -18,15 +18,19 @@ var FILES = UglifyJS.FILES = [
    return require.resolve(file);
 });

-new Function("MOZ_SourceMap", "exports", FILES.map(function(file){
-    return fs.readFileSync(file, "utf8");
-}).join("\n\n"))(
+new Function("MOZ_SourceMap", "exports", function() {
+    var code = FILES.map(function(file) {
+        return fs.readFileSync(file, "utf8");
+    });
+    code.push("exports.describe_ast = " + describe_ast.toString());
+    return code.join("\n\n");
+}())(
    require("source-map"),
    UglifyJS
 );

-UglifyJS.describe_ast = function() {
-    var out = UglifyJS.OutputStream({ beautify: true });
+function describe_ast() {
+    var out = OutputStream({ beautify: true });
    function doitem(ctor) {
        out.print("AST_" + ctor.TYPE);
        var props = ctor.SELF_PROPS.filter(function(prop){
@@ -56,6 +60,6 @@ UglifyJS.describe_ast = function() {
            });
        }
    };
-    doitem(UglifyJS.AST_Node);
+    doitem(AST_Node);
    return out + "";
-};
+}
Author	SHA1	Message	Date
Alex Lam S.L	050474ab44	v3.0.6	2017-05-16 06:38:58 +08:00
Alex Lam S.L	f6c805ae1d	print package name alongside version in CLI (#1946 ) fixes #1945	2017-05-16 06:34:32 +08:00
Alex Lam S.L	9464d3c20f	fix parsing of property access after new line (#1944 ) Account for comments when detecting property access in `tokenizer`. fixes #1943	2017-05-16 05:40:49 +08:00
alexlamsl	f18abd1b9c	minor fixes to README.md	2017-05-16 01:33:01 +08:00
kzc	3be06ad085	reorg README for 3.x (#1942 )	2017-05-16 01:12:00 +08:00
Alex Lam S.L	265008c948	improve keyword-related parser errors (#1941 ) fixes #1937	2017-05-15 23:02:55 +08:00
Alex Lam S.L	ff526be61d	v3.0.5	2017-05-15 11:37:14 +08:00
Alex Lam S.L	e005099fb1	fix & improve coverage of `estree` (#1935 ) - fix `estree` conversion of getter/setter - fix non-directive literal in `to_mozilla_ast()` - revamp `test/mozilla-ast.js` - reuse `test/ufuzz.js` for code generation - use `acorn.parse()` for creating `estree` - extend `test/ufuzz.js` for `acorn` workaround - catch variable redefinition - non-trivial literal as directive - adjust options for tolerance Miscellaneous - optional semi-colon when parsing directives fixes #1914 closes #1915	2017-05-15 02:37:53 +08:00
kzc	504a436e9d	Tweak README Notes (#1934 )	2017-05-14 02:12:14 +08:00
Alex Lam S.L	3ca902258c	fix bugs with getter/setter (#1926 ) - `reduce_vars` - `side_effects` - property access for object - `AST_SymbolAccessor` as key names enhance `test/ufuzz.js` - add object getter & setter - property assignment to setter - avoid infinite recursion in setter - fix & adjust assignment operators - 50% `=` - 25% `+=` - 2.5% each for the rest - avoid "Invalid array length" - fix `console.log()` - bypass getter - curb recursive reference - deprecate `-E`, always report runtime errors	2017-05-14 02:10:34 +08:00
olsonpm	fd0951231c	document 3 max passes (#1928 )	2017-05-13 12:54:32 +08:00
olsonpm	9e29b6dad2	clarify wording (#1931 )	2017-05-13 12:54:01 +08:00
Alex Lam S.L	c391576d52	remove support for `const` (#1910 ) As this is not part of ES5.	2017-05-12 14:57:41 +08:00
Alex Lam S.L	ac73c5d421	avoid `arguments` and `eval` in `reduce_vars` (#1924 ) fixes #1922	2017-05-12 12:34:55 +08:00
olsonpm	547f41beba	add documentation for `side_effects` & `[#@]__PURE__` (#1925 )	2017-05-12 12:29:55 +08:00
Alex Lam S.L	daaefc17b9	v3.0.4	2017-05-12 04:52:39 +08:00
Alex Lam S.L	1d407e761e	fix invalid transform on `const` (#1919 ) - preserve (re)assignment to `const` for runtime error - suppress `cascade` on `const`, as runtime behaviour is ill-defined	2017-05-12 04:51:44 +08:00
kzc	2b44f4ae30	update README (#1918 )	2017-05-12 03:36:33 +08:00
Alexis Tyler	e51c3541da	fix typo (#1913 )	2017-05-11 20:24:33 +08:00
Alex Lam S.L	3bf194684b	update documentation (#1909 ) - clarify options on `--source-map` - fix `minify()` examples fixes #1905	2017-05-11 17:50:50 +08:00
Alex Lam S.L	aae7d49d0c	v3.0.3	2017-05-10 11:45:03 +08:00
kzc	0459af2ecc	Update issue template: change harmony to uglify-es (#1900 )	2017-05-10 11:07:54 +08:00
kzc	04f2344efc	Remove unnecessary `git clone` instructions in README (#1897 )	2017-05-10 11:06:50 +08:00
kzc	bad9d5cf88	Change `harmony` to `uglify-es` in master README (#1895 )	2017-05-10 05:07:45 +08:00
Alex Lam S.L	a0f5f862df	gracefully handle non-`Error` being thrown (#1893 )	2017-05-10 04:20:59 +08:00
Alex Lam S.L	41996be86f	extend test timeout Travis has gone a lot slower recently, and most test failures are due to time-out on this particular test.	2017-05-10 02:43:12 +08:00
Alex Lam S.L	5fd8244a2e	v3.0.2	2017-05-10 01:52:00 +08:00
Alex Lam S.L	c14e280585	print error stack in CLI (#1890 )	2017-05-09 16:36:44 +08:00
Alex Lam S.L	bc3fa78e8c	mention `minify().error`	2017-05-09 16:09:48 +08:00
Alex Lam S.L	8c7c107765	update `minify()` usage in `test/ufuzz.js` (#1888 ) fixes #1887	2017-05-09 15:58:46 +08:00
kzc	3dd328dce3	[3.x] fix documentation for beautify options (#1882 ) - use underscores rather than dashes.	2017-05-08 23:06:56 +08:00
Alex Lam S.L	014f428153	v3.0.1	2017-05-08 07:05:57 +08:00
Alex Lam S.L	a3b2eb75bd	return `Error` from `minify()` (#1880 ) Have `minify()` return `Error` in `result.error` rather than throwing it.	2017-05-08 07:05:19 +08:00
Alex Lam S.L	da295de82b	support dumping AST (#1879 ) Re-order `AST_Binary` properties to make dump more readable. closes #769	2017-05-08 06:23:01 +08:00
Alex Lam S.L	4f8ca4626e	deprecate low level API (#1877 ) fixes #1872	2017-05-08 03:24:42 +08:00
Alex Lam S.L	e54748365c	support `minify()` output as AST (#1878 ) - `options.output.ast` (default `false`) - `options.output.code` (default `true`)	2017-05-08 02:11:45 +08:00