v3.0.0

Determine if variables with non-constant values can escape and be modified.

fixes #1865

.gitattributes

@@ -0,0 +1 @@
+*.js    text eol=lf

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,20 @@
+**Bug report or feature request?** 
+
+<!-- Note: sub-optimal but correct code is not a bug -->
+
+**ES5 or ES6+ input?** 
+
+<!-- Note: for ES6 see: https://github.com/mishoo/UglifyJS2/tree/harmony#harmony -->
+
+**`uglify-js` version (`uglifyjs -V`)**
+
+**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.**
+
+<!--
+    Note: the release version of uglify-js only supports ES5. Those wishing
+    to minify ES6 should use the experimental harmony branch.
+-->

.gitignore

@@ -1,2 +1,3 @@
+/node_modules/
+/npm-debug.log
 tmp/
-node_modules/

.travis.yml

@@ -1,7 +1,12 @@
 language: node_js
+before_install: "npm install -g npm"
 node_js:
-    - "0.4"
-    - "0.6"
-    - "0.8"
     - "0.10"
-    - "0.11"
+    - "0.12"
+    - "4"
+    - "6"
+env:
+    - UGLIFYJS_TEST_ALL=1
+matrix:
+  fast_finish: true
+sudo: false

README.md

@@ -1,14 +1,15 @@
-UglifyJS 2
+UglifyJS 3
 ==========
-[![Build Status](https://travis-ci.org/mishoo/UglifyJS2.png)](https://travis-ci.org/mishoo/UglifyJS2)
+[![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.
 
-This page documents the command line utility.  For
-[API and internals documentation see my website](http://lisperator.net/uglifyjs/).
-There's also an
-[in-browser online demo](http://lisperator.net/uglifyjs/#demo) (for Firefox,
-Chrome and probably Safari).
+#### 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)**.
+- **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.
 
 Install
 -------
@@ -35,7 +36,7 @@ Usage
 
     uglifyjs [input files] [options]
 
-UglifyJS2 can take multiple input files.  It's recommended that you pass the
+UglifyJS can take multiple input files.  It's recommended that you pass the
 input files first, then pass the options.  UglifyJS will parse input files
 in sequence and apply any compression options.  The files are parsed in the
 same global scope, that is, a reference from a file to some
@@ -44,82 +45,126 @@ variable/function declared in another file will be matched properly.
 If you want to read from STDIN instead, pass a single dash instead of input
 files.
 
+If you wish to pass your options before the input files, separate the two with
+a double dash to prevent input files being used as option arguments:
+
+    uglifyjs --compress --mangle -- input.js
+
 The available options are:
 
-    --source-map       Specify an output file where to generate source map.
-                                                                          [string]
-    --source-map-root  The path to the original source to be included in the
-                       source map.                                        [string]
-    --source-map-url   The path to the source map to be added in //@
-                       sourceMappingURL.  Defaults to the value passed with
-                       --source-map.                                      [string]
-    --in-source-map    Input source map, useful if you're compressing JS that was
-                       generated from some other original code.
-    --screw-ie8        Pass this flag if you don't care about full compliance with
-                       Internet Explorer 6-8 quirks (by default UglifyJS will try
-                       to be IE-proof).
-    -p, --prefix       Skip prefix for original filenames that appear in source
-                       maps. For example -p 3 will drop 3 directories from file
-                       names and ensure they are relative paths.
-    -o, --output       Output file (default STDOUT).
-    -b, --beautify     Beautify output/specify output options.            [string]
-    -m, --mangle       Mangle names/pass mangler options.                 [string]
-    -r, --reserved     Reserved names to exclude from mangling.
-    -c, --compress     Enable compressor/pass compressor options. Pass options
-                       like -c hoist_vars=false,if_return=false. Use -c with no
-                       argument to use the default compression options.   [string]
-    -d, --define       Global definitions                                 [string]
-    --comments         Preserve copyright comments in the output. By default this
-                       works like Google Closure, keeping JSDoc-style comments
-                       that contain "@license" or "@preserve". You can optionally
-                       pass one of the following arguments to this flag:
-                       - "all" to keep all comments
-                       - a valid JS regexp (needs to start with a slash) to keep
-                       only comments that match.
-                       Note that currently not *all* comments can be kept when
-                       compression is on, because of dead code removal or
-                       cascading statements into sequences.               [string]
-    --stats            Display operations run time on STDERR.            [boolean]
-    --acorn            Use Acorn for parsing.                            [boolean]
-    --spidermonkey     Assume input files are SpiderMonkey AST format (as JSON).
-                                                                         [boolean]
-    --self             Build itself (UglifyJS2) as a library (implies
-                       --wrap=UglifyJS --export-all)                     [boolean]
-    --wrap             Embed everything in a big function, making the “exports”
-                       and “global” variables available. You need to pass an
-                       argument to this option to specify the name that your
-                       module will take when included in, say, a browser.
-                                                                          [string]
-    --export-all       Only used when --wrap, this tells UglifyJS to add code to
-                       automatically export all globals.                 [boolean]
-    --lint             Display some scope warnings                       [boolean]
-    -v, --verbose      Verbose                                           [boolean]
-    -V, --version      Print version number and exit.                    [boolean]
+```
+    -h, --help                  Print usage information.
+    -V, --version               Print version number.
+    -p, --parse <options>       Specify parser options:
+                                `acorn`  Use Acorn for parsing.
+                                `bare_returns`  Allow return outside of functions.
+                                                Useful when minifying CommonJS
+                                                modules and Userscripts that may
+                                                be anonymous function wrapped (IIFE)
+                                                by the .user.js engine `caller`.
+                                `expression`  Parse a single expression, rather than
+                                              a program (for parsing JSON).
+                                `spidermonkey`  Assume input files are SpiderMonkey
+                                                AST format (as JSON).
+    -c, --compress [options]    Enable compressor/specify compressor options:
+                                `pure_funcs`  List of functions that can be safely
+                                              removed when their return values are
+                                              not used.
+    -m, --mangle [options]      Mangle names/specify mangler options:
+                                `reserved`  List of names that should not be mangled.
+    --mangle-props [options]    Mangle properties/specify mangler options:
+                                `builtins`  Mangle property names that overlaps
+                                            with standard JavaScript globals.
+                                `debug`  Add debug prefix and suffix.
+                                `domprops`  Mangle property names that overlaps
+                                            with DOM properties.
+                                `keep_quoted`  Only mangle unquoted properies.
+                                `regex`  Only mangle matched property names.
+                                `reserved`  List of names that should not be mangled.
+    -b, --beautify [options]    Beautify output/specify output options:
+                                `beautify`  Enabled with `--beautify` by default.
+                                `preamble`  Preamble to prepend to the output. You
+                                            can use this to insert a comment, for
+                                            example for licensing information.
+                                            This will not be parsed, but the source
+                                            map will adjust for its presence.
+                                `quote_style`  Quote style:
+                                               0 - auto
+                                               1 - single
+                                               2 - double
+                                               3 - original
+                                `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.
+    --comments [filter]         Preserve copyright comments in the output. By
+                                default this works like Google Closure, keeping
+                                JSDoc-style comments that contain "@license" or
+                                "@preserve". You can optionally pass one of the
+                                following arguments to this flag:
+                                - "all" to keep all comments
+                                - a valid JS RegExp like `/foo/` or `/^!/` to
+                                keep only matching comments.
+                                Note that currently not *all* comments can be
+                                kept when compression is on, because of dead
+                                code removal or cascading statements into
+                                sequences.
+    --config-file <file>        Read `minify()` options from JSON file.
+    -d, --define <expr>[=value] Global definitions.
+    --ie8                       Support non-standard Internet Explorer 8.
+                                Equivalent to setting `ie8: true` in `minify()`
+                                for `compress`, `mangle` and `output` options.
+                                By default UglifyJS will not try to be IE-proof.
+    --keep-fnames               Do not mangle/drop function names.  Useful for
+                                code relying on Function.prototype.name.
+    --name-cache                File to hold mangled name mappings.
+    --self                      Build UglifyJS as a library (implies --wrap UglifyJS)
+    --source-map [options]      Enable source map/specify source map options:
+                                `base`  Path to compute relative paths from input files.
+                                `content`  Input source map, useful if you're compressing
+                                           JS that was generated from some other original
+                                           code. Specify "inline" if the source map is
+                                           included within the sources.
+                                `filename`  Name and/or location of the output source.
+                                `includeSources`  Pass this flag if you want to include
+                                                  the content of source files in the
+                                                  source map as sourcesContent property.
+                                `root`  Path to the original source to be included in
+                                        the source map.
+                                `url`  If specified, path to the source map to append in
+                                       `//# sourceMappingURL`.
+    --stats                     Display operations run time on STDERR.
+    --toplevel                  Compress and/or mangle variables in toplevel scope.
+    --verbose                   Print diagnostic messages.
+    --warn                      Print warning messages.
+    --wrap <name>               Embed everything in a big function, making the
+                                “exports” and “global” variables available. You
+                                need to pass an argument to this option to
+                                specify the name that your module will take
+                                when included in, say, a browser.
+```
 
 Specify `--output` (`-o`) to declare the output file.  Otherwise the output
 goes to STDOUT.
 
 ## Source map options
 
-UglifyJS2 can generate a source map file, which is highly useful for
+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.js.map` (full path to the file where you want the
-source map dumped).
+`--source-map --output output.js` (source map will be written out to
+`output.js.map`).
 
-Additionally you might need `--source-map-root` to pass the URL where the
-original files can be found.  In case you are passing full paths to input
-files to UglifyJS, you can use `--prefix` (`-p`) to specify the number of
-directories to drop from the path prefix when declaring files in the source
-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.
 
 For example:
 
     uglifyjs /home/doe/work/foo/src/js/file1.js \
              /home/doe/work/foo/src/js/file2.js \
-             -o foo.min.js \
-             --source-map foo.min.js.map \
-             --source-map-root http://foo.com/src \
-             -p 5 -c -m
+             -o foo.min.js -c -m \
+             --source-map base="/home/doe/work/foo/src",root="http://foo.com/src"
 
 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
@@ -139,34 +184,106 @@ 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`.  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.
+/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.
 
 ## Mangler options
 
 To enable the mangler you need to pass `--mangle` (`-m`).  The following
 (comma-separated) options are supported:
 
-- `sort` — to assign shorter names to most frequently used variables.  This
-  saves a few hundred bytes on jQuery before gzip, but the output is
-  _bigger_ after gzip (and seems to happen for other libraries I tried it
-  on) therefore it's not enabled by default.
-
 - `toplevel` — mangle names declared in the toplevel scope (disabled by
   default).
 
-- `eval` — mangle names visible in scopes where `eval` or `when` are used
+- `eval` — mangle names visible in scopes where `eval` or `with` are used
   (disabled by default).
 
 When mangling is enabled but you want to prevent certain names from being
-mangled, you can declare those names with `--reserved` (`-r`) — pass a
+mangled, you can declare those names with `--mangle reserved` — pass a
 comma-separated list of names.  For example:
 
-    uglifyjs ... -m -r '$,require,exports'
+    uglifyjs ... -m reserved=[$,require,exports]
 
 to prevent the `require`, `exports` and `$` names from being changed.
 
+### 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
+var x = {
+  foo: 1
+};
+
+x.bar = 2;
+x["baz"] = 3;
+x[condition ? "moo" : "boo"] = 4;
+console.log(x.something());
+```
+
+In the above code, `foo`, `bar`, `baz`, `moo` and `boo` will be replaced
+with single characters, while `something()` will be left as is.
+
+In order for this to be of any use, we avoid mangling standard JS names by
+default (`--mangle-props builtins` to override).
+
+A default exclusion file is provided in `tools/domprops.json` which should
+cover most standard JS and DOM properties defined in various browsers.  Pass
+`--mangle-props domprops` to disable this feature.
+
+You can also use a regular expression to define which property names should be
+mangled.  For example, `--mangle-props regex=/^_/` will only mangle property
+names that start with an underscore.
+
+When you compress multiple files using this option, in order for them to
+work together in the end we need to ensure somehow that one property gets
+mangled to the same name in all of them.  For this, pass `--name-cache filename.json`
+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
+```
+
+Now, `part1.js` and `part2.js` will be consistent with each other in terms
+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`)
+
+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:
+
+```
+$ 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
+
+You can also pass `--mangle-props debug` in order to mangle property names
+without completely obscuring them. For example the property `o.foo`
+would mangle to `o._$foo$_` with this option. This allows property mangling
+of a large codebase while still being able to debug the code and identify
+where mangling is breaking things.
+
+You can also pass a custom suffix using `--mangle-props debug=XYZ`. This would then
+mangle `o.foo` to `o._$foo$XYZ_`. You can change this each time you compile a
+script to identify how a property got mangled. One technique is to pass a
+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
@@ -174,33 +291,127 @@ 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`).
 
-- `sequences` -- join consecutive simple statements using the comma operator
+- `sequences` (default: true) -- join consecutive simple statements using the
+  comma operator.  May be set to a positive integer to specify the maximum number
+  of consecutive comma sequences that will be generated. If this option is set to
+  `true` then the default `sequences` limit is `200`. Set option to `false` or `0`
+  to disable. The smallest `sequences` length is `2`. A `sequences` value of `1`
+  is grandfathered to be equivalent to `true` and as such means `200`. On rare
+  occasions the default sequences limit leads to very slow compress times in which
+  case a value of `20` or less is recommended.
+
 - `properties` -- rewrite property access using the dot notation, for
   example `foo["bar"] → foo.bar`
+
 - `dead_code` -- remove unreachable code
+
 - `drop_debugger` -- remove `debugger;` statements
+
 - `unsafe` (default: false) -- apply "unsafe" transformations (discussion below)
+
+- `unsafe_comps` (default: false) -- Reverse `<` and `<=` to `>` and `>=` to
+  allow improved compression. This might be unsafe when an at least one of two
+  operands is an object with computed values due the use of methods like `get`,
+  or `valueOf`. This could cause change in execution order after operands in the
+  comparison are switching. Compression only works if both `comparisons` and
+  `unsafe_comps` are both set to true.
+
+- `unsafe_math` (default: false) -- optimize numerical expressions like
+  `2 * x * 3` into `6 * x`, which may give imprecise floating point results.
+
+- `unsafe_proto` (default: false) -- optimize expressions like
+  `Array.prototype.slice.call(a)` into `[].slice.call(a)`
+
 - `conditionals` -- apply optimizations for `if`-s and conditional
   expressions
+
 - `comparisons` -- apply certain optimizations to binary nodes, for example:
-  `!(a <= b) → a > b` (only when `unsafe`), attempts to negate binary nodes,
-  e.g. `a = !b && !c && !d && !e → a=!(b||c||d||e)` etc.
+  `!(a <= b) → a > b` (only when `unsafe_comps`), attempts to negate binary
+  nodes, e.g. `a = !b && !c && !d && !e → a=!(b||c||d||e)` etc.
+
 - `evaluate` -- attempt to evaluate constant expressions
+
 - `booleans` -- various optimizations for boolean context, for example `!!a
   ? b : c → a ? b : c`
+
 - `loops` -- optimizations for `do`, `while` and `for` loops when we can
   statically determine the condition
-- `unused` -- drop unreferenced functions and variables
+
+- `unused` -- drop unreferenced functions and variables (simple direct variable
+  assignments do not count as references unless set to `"keep_assign"`)
+
+- `toplevel` -- drop unreferenced functions (`"funcs"`) and/or variables (`"vars"`)
+  in the toplevel scope (`false` by default, `true` to drop both unreferenced
+  functions and variables)
+
+- `top_retain` -- prevent specific toplevel functions and variables from `unused`
+  removal (can be array, comma-separated, RegExp or function. Implies `toplevel`)
+
 - `hoist_funs` -- hoist function declarations
+
 - `hoist_vars` (default: false) -- hoist `var` declarations (this is `false`
   by default because it seems to increase the size of the output in general)
+
 - `if_return` -- optimizations for if/return and if/continue
+
 - `join_vars` -- join consecutive `var` statements
+
 - `cascade` -- small optimization for sequences, transform `x, x` into `x`
   and `x = something(), x` into `x = something()`
+
+- `collapse_vars` -- Collapse single-use `var` and `const` definitions
+  when possible.
+
+- `reduce_vars` -- Improve optimization on variables assigned with and
+  used as constant values.
+
 - `warnings` -- display warnings when dropping unreachable code or unused
   declarations etc.
 
+- `negate_iife` -- negate "Immediately-Called Function Expressions"
+  where the return value is discarded, to avoid the parens that the
+  code generator would insert.
+
+- `pure_getters` -- the default is `false`.  If you pass `true` for
+  this, UglifyJS will assume that object property access
+  (e.g. `foo.bar` or `foo["bar"]`) doesn't have any side effects.
+  Specify `"strict"` to treat `foo.bar` as side-effect-free only when
+  `foo` is certain to not throw, i.e. not `null` or `undefined`.
+
+- `pure_funcs` -- default `null`.  You can pass an array of names and
+  UglifyJS will assume that those functions do not produce side
+  effects.  DANGER: will not check if the name is redefined in scope.
+  An example case here, for instance `var q = Math.floor(a/b)`.  If
+  variable `q` is not used elsewhere, UglifyJS will drop it, but will
+  still keep the `Math.floor(a/b)`, not knowing what it does.  You can
+  pass `pure_funcs: [ 'Math.floor' ]` to let it know that this
+  function won't produce any side effect, in which case the whole
+  statement would get discarded.  The current implementation adds some
+  overhead (compression will be slower).
+
+- `drop_console` -- default `false`.  Pass `true` to discard calls to
+  `console.*` functions. If you wish to drop a specific function call
+  such as `console.info` and/or retain side effects from function arguments
+  after dropping the function call then use `pure_funcs` instead.
+
+- `expression` -- default `false`.  Pass `true` to preserve completion values
+  from terminal statements without `return`, e.g. in bookmarklets.
+
+- `keep_fargs` -- default `true`.  Prevents the
+  compressor from discarding unused function arguments.  You need this
+  for code which relies on `Function.length`.
+
+- `keep_fnames` -- default `false`.  Pass `true` to prevent the
+  compressor from discarding function names.  Useful for code relying on
+  `Function.prototype.name`. See also: the `keep_fnames` [mangle option](#mangle).
+
+- `passes` -- default `1`. Number of times to run compress. 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.
+
+- `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
 
 It enables some transformations that *might* break code logic in certain
@@ -208,14 +419,14 @@ contrived cases, but should be fine for most code.  You might want to try it
 on your own code, it should reduce the minified size.  Here's what happens
 when this flag is on:
 
-- `new Array(1, 2, 3)` or `Array(1, 2, 3)` → `[1, 2, 3 ]`
+- `new Array(1, 2, 3)` or `Array(1, 2, 3)` → `[ 1, 2, 3 ]`
 - `new Object()` → `{}`
 - `String(exp)` or `exp.toString()` → `"" + exp`
 - `new Object/RegExp/Function/Error/Array (...)` → we discard the `new`
 - `typeof foo == "undefined"` → `foo === void 0`
-- `void 0` → `"undefined"` (if there is a variable named "undefined" in
+- `void 0` → `undefined` (if there is a variable named "undefined" in
   scope; we do it because the variable name will be mangled, typically
-  reduced to a single character).
+  reduced to a single character)
 
 ### Conditional compilation
 
@@ -229,6 +440,8 @@ if (DEBUG) {
 }
 ```
 
+You can specify nested constants in the form of `--define env.DEBUG=false`.
+
 UglifyJS will warn about the condition being always false and about dropping
 unreachable code; for now there is no option to turn off only this specific
 warning, you can pass `warnings=false` to turn off *all* warnings.
@@ -248,10 +461,25 @@ and build your code like this:
 
 UglifyJS will notice the constants and, since they cannot be altered, it
 will evaluate references to them to the value itself and drop unreachable
-code as usual.  The possible downside of this approach is that the build
-will contain the `const` declarations.
+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
+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"], {
+    compress: {
+        dead_code: true,
+        global_defs: {
+            DEBUG: false
+        }
+    }
+});
+```
 
-<a name="codegen-options"></a>
 ## Beautifier options
 
 The code generator tries to output shortest code possible by default.  In
@@ -268,7 +496,7 @@ can pass additional arguments that control the code output:
   objects
 - `space-colon` (default `true`) -- insert a space after the colon signs
 - `ascii-only` (default `false`) -- escape Unicode characters in strings and
-  regexps
+  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
@@ -277,9 +505,6 @@ can pass additional arguments that control the code output:
   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)
-- `ie-proof` (default `true`) -- generate “IE-proof” code (for now this
-  means add brackets around the do/while in code like this: `if (foo) do
-  something(); while (bar); else ...`.
 - `bracketize` (default `false`) -- always insert brackets in `if`, `for`,
   `do`, `while` or `with` statements, even if their body is a single
   statement.
@@ -287,6 +512,19 @@ can pass additional arguments that control the code output:
   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
 
@@ -294,8 +532,8 @@ 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
-'/foo|bar/'` will keep only comments that contain "foo" or "bar".
+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:
@@ -318,7 +556,7 @@ needs to be kept in the output) are comments attached to toplevel nodes.
 
 ## Support for the SpiderMonkey AST
 
-UglifyJS2 has its own abstract syntax tree format; for
+UglifyJS has its own abstract syntax tree format; for
 [practical reasons](http://lisperator.net/blog/uglifyjs-why-not-switching-to-spidermonkey-ast/)
 we can't easily change to using the SpiderMonkey AST internally.  However,
 UglifyJS now has a converter which can import a SpiderMonkey AST.
@@ -328,16 +566,16 @@ SpiderMonkey AST.  It has a small CLI utility that parses one file and dumps
 the AST in JSON on the standard output.  To use UglifyJS to mangle and
 compress that:
 
-    acorn file.js | uglifyjs --spidermonkey -m -c
+    acorn file.js | uglifyjs -p spidermonkey -m -c
 
-The `--spidermonkey` option tells UglifyJS that all input files are not
+The `-p spidermonkey` option tells UglifyJS that all input files are not
 JavaScript, but JS code described in SpiderMonkey AST in JSON.  Therefore we
 don't use our own parser in this case, but just transform that AST into our
 internal AST.
 
 ### Use Acorn for parsing
 
-More for fun, I added the `--acorn` option which will use Acorn to do all
+More for fun, I added the `-p acorn` option which will use Acorn to do all
 the parsing.  If you pass this option, UglifyJS will `require("acorn")`.
 
 Acorn is really fast (e.g. 250ms instead of 380ms on some 650K code), but
@@ -353,232 +591,145 @@ like this:
 var UglifyJS = require("uglify-js");
 ```
 
-It exports a lot of names, but I'll discuss here the basics that are needed
-for parsing, mangling and compressing a piece of code.  The sequence is (1)
-parse, (2) compress, (3) mangle, (4) generate output code.
-
-### The simple way
-
-There's a single toplevel function which combines all the steps.  If you
-don't need additional customization, you might want to go with `minify`.
+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("/path/to/file.js");
+var result = UglifyJS.minify("var b = function() {};");
 console.log(result.code); // minified output
-// if you need to pass code instead of file name
-var result = UglifyJS.minify("var b = function () {};", {fromString: true});
 ```
 
 You can also compress multiple files:
 ```javascript
-var result = UglifyJS.minify([ "file1.js", "file2.js", "file3.js" ]);
+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", "file2.js", "file3.js" ], {
-	outSourceMap: "out.js.map"
+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);
+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 `outSourceMap` is only used to set the
-`file` attribute in the source map (see [the spec][sm-spec]).
+`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", "file2.js", "file3.js" ], {
-	outSourceMap: "out.js.map",
-	sourceRoot: "http://example.com/src"
+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 the `inSourceMap` argument:
+can use `sourceMap.content`:
 ```javascript
-var result = UglifyJS.minify("compiled.js", {
-	inSourceMap: "compiled.js.map",
-	outSourceMap: "minified.js.map"
+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`
 ```
 
-The `inSourceMap` is only used if you also request `outSourceMap` (it makes
-no sense otherwise).
+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.
 
-- `fromString` (default `false`) — if you pass `true` then you can pass
-  JavaScript source code, rather than file names.
+- `mangle` (default `true`) — pass `false` to skip mangling names, or pass
+  an object to specify mangling options (see below).
 
-- `mangle` — pass `false` to skip mangling names.
+- `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][codegen].  The defaults are optimized
+  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].
+  Pass an object to specify custom [compressor options](#compressor-options).
 
-We could add more options to `UglifyJS.minify` — if you need additional
-functionality please suggest!
+- `parse` (default {}) — pass an object if you wish to specify some
+  additional [parser options](#the-parser).
 
-### The hard way
+##### mangle
 
-Following there's more detailed API info, in case the `minify` function is
-too simple for your needs.
+ - `reserved` - pass an array of identifiers that should be excluded from mangling
 
-#### The parser
-```javascript
-var toplevel_ast = UglifyJS.parse(code, options);
+ - `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"
 ```
 
-`options` is optional and if present it must be an object.  The following
-properties are available:
+or to directly install the experimental harmony version of uglify:
 
-- `strict` — disable automatic semicolon insertion and support for trailing
-  comma in arrays and objects
-- `filename` — the name of the file where this code is coming from
-- `toplevel` — a `toplevel` node (as returned by a previous invocation of
-  `parse`)
-
-The last two options are useful when you'd like to minify multiple files and
-get a single file as the output and a proper source map.  Our CLI tool does
-something like this:
-```javascript
-var toplevel = null;
-files.forEach(function(file){
-	var code = fs.readFileSync(file);
-	toplevel = UglifyJS.parse(code, {
-		filename: file,
-		toplevel: toplevel
-	});
-});
+```
+npm install --save-dev uglify-js@github:mishoo/UglifyJS2#harmony
 ```
 
-After this, we have in `toplevel` a big AST containing all our files, with
-each token having proper information about where it came from.
-
-#### Scope information
-
-UglifyJS contains a scope analyzer that you need to call manually before
-compressing or mangling.  Basically it augments various nodes in the AST
-with information about where is a name defined, how many times is a name
-referenced, if it is a global or not, if a function is using `eval` or the
-`with` statement etc.  I will discuss this some place else, for now what's
-important to know is that you need to call the following before doing
-anything with the tree:
-```javascript
-toplevel.figure_out_scope()
-```
-
-#### Compression
-
-Like this:
-```javascript
-var compressor = UglifyJS.Compressor(options);
-var compressed_ast = toplevel.transform(compressor);
-```
-
-The `options` can be missing.  Available options are discussed above in
-“Compressor options”.  Defaults should lead to best compression in most
-scripts.
-
-The compressor is destructive, so don't rely that `toplevel` remains the
-original tree.
-
-#### Mangling
-
-After compression it is a good idea to call again `figure_out_scope` (since
-the compressor might drop unused variables / unreachable code and this might
-change the number of identifiers or their position).  Optionally, you can
-call a trick that helps after Gzip (counting character frequency in
-non-mangleable words).  Example:
-```javascript
-compressed_ast.figure_out_scope();
-compressed_ast.compute_char_frequency();
-compressed_ast.mangle_names();
-```
-
-#### Generating output
-
-AST nodes have a `print` method that takes an output stream.  Essentially,
-to generate code you do this:
-```javascript
-var stream = UglifyJS.OutputStream(options);
-compressed_ast.print(stream);
-var code = stream.toString(); // this is your minified code
-```
-
-or, for a shortcut you can do:
-```javascript
-var code = compressed_ast.print_to_string(options);
-```
-
-As usual, `options` is optional.  The output stream accepts a lot of otions,
-most of them documented above in section “Beautifier options”.  The two
-which we care about here are `source_map` and `comments`.
-
-#### Keeping comments in the output
-
-In order to keep certain comments in the output you need to pass the
-`comments` option.  Pass a RegExp or a function.  If you pass a RegExp, only
-those comments whose body matches the regexp will be kept.  Note that body
-means without the initial `//` or `/*`.  If you pass a function, it will be
-called for every comment in the tree and will receive two arguments: the
-node that the comment is attached to, and the comment token itself.
-
-The comment token has these properties:
-
-- `type`: "comment1" for single-line comments or "comment2" for multi-line
-  comments
-- `value`: the comment body
-- `pos` and `endpos`: the start/end positions (zero-based indexes) in the
-  original code where this comment appears
-- `line` and `col`: the line and column where this comment appears in the
-  original code
-- `file` — the file name of the original file
-- `nlb` — true if there was a newline before this comment in the original
-  code, or if this comment contains a newline.
-
-Your function should return `true` to keep the comment, or a falsy value
-otherwise.
-
-#### Generating a source mapping
-
-You need to pass the `source_map` argument when calling `print`.  It needs
-to be a `SourceMap` object (which is a thin wrapper on top of the
-[source-map][source-map] library).
-
-Example:
-```javascript
-var source_map = UglifyJS.SourceMap(source_map_options);
-var stream = UglifyJS.OutputStream({
-	...
-	source_map: source_map
-});
-compressed_ast.print(stream);
-
-var code = stream.toString();
-var map = source_map.toString(); // json output for your source map
-```
-
-The `source_map_options` (optional) can contain the following properties:
-
-- `file`: the name of the JavaScript output file that this mapping refers to
-- `root`: the `sourceRoot` property (see the [spec][sm-spec])
-- `orig`: the "original source map", handy when you compress generated JS
-  and want to map the minified output back to the original code where it
-  came from.  It can be simply a string in JSON, or a JSON object containing
-  the original source map.
-
-  [acorn]: https://github.com/marijnh/acorn
-  [source-map]: https://github.com/mozilla/source-map
-  [sm-spec]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
-  [codegen]: http://lisperator.net/uglifyjs/codegen
-  [compressor]: http://lisperator.net/uglifyjs/compress
+See [#448](https://github.com/mishoo/UglifyJS2/issues/448) for additional details.

appveyor.yml

@@ -0,0 +1,24 @@
+environment:
+  matrix:
+  - nodejs_version: "0.10"
+  - nodejs_version: "0.12"
+  - nodejs_version: "4.0"
+  - nodejs_version: "6.0"
+
+matrix:
+  fast_finish: true
+
+platform:
+  - x86
+  - x64
+
+install:
+  - ps: Install-Product node $env:nodejs_version $env:platform
+  - npm install
+
+test_script:
+  - node --version
+  - npm --version
+  - npm test
+
+build: off

bin/uglifyjs

@@ -3,400 +3,337 @@
 
 "use strict";
 
-var UglifyJS = require("../tools/node");
-var sys = require("util");
-var optimist = require("optimist");
-var fs = require("fs");
-var async = require("async");
-var acorn;
-var ARGS = optimist
-    .usage("$0 input1.js [input2.js ...] [options]\n\
-Use a single dash to read input from the standard input.\
-\n\n\
-NOTE: by default there is no mangling/compression.\n\
-Without [options] it will simply parse input files and dump the AST\n\
-with whitespace and comments discarded.  To achieve compression and\n\
-mangling you need to use `-c` and `-m`.\
-")
-    .describe("source-map", "Specify an output file where to generate source map.")
-    .describe("source-map-root", "The path to the original source to be included in the source map.")
-    .describe("source-map-url", "The path to the source map to be added in //@ sourceMappingURL.  Defaults to the value passed with --source-map.")
-    .describe("in-source-map", "Input source map, useful if you're compressing JS that was generated from some other original code.")
-    .describe("screw-ie8", "Pass this flag if you don't care about full compliance with Internet Explorer 6-8 quirks (by default UglifyJS will try to be IE-proof).")
-    .describe("expr", "Parse a single expression, rather than a program (for parsing JSON)")
-    .describe("p", "Skip prefix for original filenames that appear in source maps. \
-For example -p 3 will drop 3 directories from file names and ensure they are relative paths.")
-    .describe("o", "Output file (default STDOUT).")
-    .describe("b", "Beautify output/specify output options.")
-    .describe("m", "Mangle names/pass mangler options.")
-    .describe("r", "Reserved names to exclude from mangling.")
-    .describe("c", "Enable compressor/pass compressor options. \
-Pass options like -c hoist_vars=false,if_return=false. \
-Use -c with no argument to use the default compression options.")
-    .describe("d", "Global definitions")
-    .describe("e", "Embed everything in a big function, with a configurable parameter/argument list.")
-
-    .describe("comments", "Preserve copyright comments in the output. \
-By default this works like Google Closure, keeping JSDoc-style comments that contain \"@license\" or \"@preserve\". \
-You can optionally pass one of the following arguments to this flag:\n\
-- \"all\" to keep all comments\n\
-- a valid JS regexp (needs to start with a slash) to keep only comments that match.\n\
-\
-Note that currently not *all* comments can be kept when compression is on, \
-because of dead code removal or cascading statements into sequences.")
-
-    .describe("stats", "Display operations run time on STDERR.")
-    .describe("acorn", "Use Acorn for parsing.")
-    .describe("spidermonkey", "Assume input files are SpiderMonkey AST format (as JSON).")
-    .describe("self", "Build itself (UglifyJS2) as a library (implies --wrap=UglifyJS --export-all)")
-    .describe("wrap", "Embed everything in a big function, making the “exports” and “global” variables available. \
-You need to pass an argument to this option to specify the name that your module will take when included in, say, a browser.")
-    .describe("export-all", "Only used when --wrap, this tells UglifyJS to add code to automatically export all globals.")
-    .describe("lint", "Display some scope warnings")
-    .describe("v", "Verbose")
-    .describe("V", "Print version number and exit.")
-
-    .alias("p", "prefix")
-    .alias("o", "output")
-    .alias("v", "verbose")
-    .alias("b", "beautify")
-    .alias("m", "mangle")
-    .alias("c", "compress")
-    .alias("d", "define")
-    .alias("r", "reserved")
-    .alias("V", "version")
-    .alias("e", "enclose")
-
-    .string("source-map")
-    .string("source-map-root")
-    .string("source-map-url")
-    .string("b")
-    .string("m")
-    .string("c")
-    .string("d")
-    .string("e")
-    .string("comments")
-    .string("wrap")
-
-    .boolean("expr")
-    .boolean("screw-ie8")
-    .boolean("export-all")
-    .boolean("self")
-    .boolean("v")
-    .boolean("stats")
-    .boolean("acorn")
-    .boolean("spidermonkey")
-    .boolean("lint")
-    .boolean("V")
-
-    .wrap(80)
-
-    .argv
-;
-
-normalize(ARGS);
-
-if (ARGS.version || ARGS.V) {
-    var json = require("../package.json");
-    sys.puts(json.name + ' ' + json.version);
-    process.exit(0);
-}
-
-if (ARGS.ast_help) {
-    var desc = UglifyJS.describe_ast();
-    sys.puts(typeof desc == "string" ? desc : JSON.stringify(desc, null, 2));
-    process.exit(0);
-}
-
-if (ARGS.h || ARGS.help) {
-    sys.puts(optimist.help());
-    process.exit(0);
-}
-
-if (ARGS.acorn) {
-    acorn = require("acorn");
-}
-
-var COMPRESS = getOptions("c", true);
-var MANGLE = getOptions("m", true);
-var BEAUTIFY = getOptions("b", true);
-
-if (ARGS.d) {
-    if (COMPRESS) COMPRESS.global_defs = getOptions("d");
-}
-
-if (ARGS.screw_ie8) {
-    if (COMPRESS) COMPRESS.screw_ie8 = true;
-    if (MANGLE) MANGLE.screw_ie8 = true;
-}
-
-if (ARGS.r) {
-    if (MANGLE) MANGLE.except = ARGS.r.replace(/^\s+|\s+$/g).split(/\s*,+\s*/);
-}
-
-var OUTPUT_OPTIONS = {
-    beautify: BEAUTIFY ? true : false
-};
-
-if (BEAUTIFY)
-    UglifyJS.merge(OUTPUT_OPTIONS, BEAUTIFY);
-
-if (ARGS.comments) {
-    if (/^\//.test(ARGS.comments)) {
-        OUTPUT_OPTIONS.comments = new Function("return(" + ARGS.comments + ")")();
-    } else if (ARGS.comments == "all") {
-        OUTPUT_OPTIONS.comments = true;
-    } else {
-        OUTPUT_OPTIONS.comments = function(node, comment) {
-            var text = comment.value;
-            var type = comment.type;
-            if (type == "comment2") {
-                // multiline comment
-                return /@preserve|@license|@cc_on/i.test(text);
-            }
-        }
-    }
-}
-
-var files = ARGS._.slice();
-
-if (ARGS.self) {
-    if (files.length > 0) {
-        sys.error("WARN: Ignoring input files since --self was passed");
-    }
-    files = UglifyJS.FILES;
-    if (!ARGS.wrap) ARGS.wrap = "UglifyJS";
-    ARGS.export_all = true;
-}
-
-var ORIG_MAP = ARGS.in_source_map;
-
-if (ORIG_MAP) {
-    ORIG_MAP = JSON.parse(fs.readFileSync(ORIG_MAP));
-    if (files.length == 0) {
-        sys.error("INFO: Using file from the input source map: " + ORIG_MAP.file);
-        files = [ ORIG_MAP.file ];
-    }
-    if (ARGS.source_map_root == null) {
-        ARGS.source_map_root = ORIG_MAP.sourceRoot;
-    }
-}
-
-if (files.length == 0) {
-    files = [ "-" ];
-}
-
-if (files.indexOf("-") >= 0 && ARGS.source_map) {
-    sys.error("ERROR: Source map doesn't work with input from STDIN");
-    process.exit(1);
-}
-
-if (files.filter(function(el){ return el == "-" }).length > 1) {
-    sys.error("ERROR: Can read a single file from STDIN (two or more dashes specified)");
-    process.exit(1);
-}
-
-var STATS = {};
-var OUTPUT_FILE = ARGS.o;
-var TOPLEVEL = null;
-
-var SOURCE_MAP = ARGS.source_map ? UglifyJS.SourceMap({
-    file: OUTPUT_FILE,
-    root: ARGS.source_map_root,
-    orig: ORIG_MAP,
-}) : null;
-
-OUTPUT_OPTIONS.source_map = SOURCE_MAP;
-
-try {
-    var output = UglifyJS.OutputStream(OUTPUT_OPTIONS);
-    var compressor = COMPRESS && UglifyJS.Compressor(COMPRESS);
-} catch(ex) {
-    if (ex instanceof UglifyJS.DefaultsError) {
-        sys.error(ex.msg);
-        sys.error("Supported options:");
-        sys.error(sys.inspect(ex.defs));
-        process.exit(1);
-    }
-}
-
-async.eachLimit(files, 1, function (file, cb) {
-    read_whole_file(file, function (err, code) {
-        if (err) {
-            sys.error("ERROR: can't read file: " + filename);
-            process.exit(1);
-        }
-        if (ARGS.p != null) {
-            file = file.replace(/^\/+/, "").split(/\/+/).slice(ARGS.p).join("/");
-        }
-        time_it("parse", function(){
-            if (ARGS.spidermonkey) {
-                var program = JSON.parse(code);
-                if (!TOPLEVEL) TOPLEVEL = program;
-                else TOPLEVEL.body = TOPLEVEL.body.concat(program.body);
-            }
-            else if (ARGS.acorn) {
-                TOPLEVEL = acorn.parse(code, {
-                    locations     : true,
-                    trackComments : true,
-                    sourceFile    : file,
-                    program       : TOPLEVEL
-                });
-            }
-            else {
-                TOPLEVEL = UglifyJS.parse(code, {
-                    filename   : file,
-                    toplevel   : TOPLEVEL,
-                    expression : ARGS.expr,
-                });
-            };
-        });
-        cb();
-    });
-}, function () {
-    if (ARGS.acorn || ARGS.spidermonkey) time_it("convert_ast", function(){
-        TOPLEVEL = UglifyJS.AST_Node.from_mozilla_ast(TOPLEVEL);
-    });
-
-    if (ARGS.wrap) {
-        TOPLEVEL = TOPLEVEL.wrap_commonjs(ARGS.wrap, ARGS.export_all);
-    }
-
-    if (ARGS.enclose) {
-        var arg_parameter_list = ARGS.enclose;
-
-        if (!(arg_parameter_list instanceof Array)) {
-            arg_parameter_list = [arg_parameter_list];
-        }
-
-        TOPLEVEL = TOPLEVEL.wrap_enclose(arg_parameter_list);
-    }
-
-    var SCOPE_IS_NEEDED = COMPRESS || MANGLE || ARGS.lint;
-
-    if (SCOPE_IS_NEEDED) {
-        time_it("scope", function(){
-            TOPLEVEL.figure_out_scope({ screw_ie8: ARGS.screw_ie8 });
-            if (ARGS.lint) {
-                TOPLEVEL.scope_warnings();
-            }
-        });
-    }
-
-    if (COMPRESS) {
-        time_it("squeeze", function(){
-            TOPLEVEL = TOPLEVEL.transform(compressor);
-        });
-    }
-
-    if (SCOPE_IS_NEEDED) {
-        time_it("scope", function(){
-            TOPLEVEL.figure_out_scope({ screw_ie8: ARGS.screw_ie8 });
-            if (MANGLE) {
-                TOPLEVEL.compute_char_frequency(MANGLE);
-            }
-        });
-    }
-
-    if (MANGLE) time_it("mangle", function(){
-        TOPLEVEL.mangle_names(MANGLE);
-    });
-    time_it("generate", function(){
-        TOPLEVEL.print(output);
-    });
-
-    output = output.get();
-
-    if (SOURCE_MAP) {
-        fs.writeFileSync(ARGS.source_map, SOURCE_MAP, "utf8");
-        output += "\n/*\n//@ sourceMappingURL=" + (ARGS.source_map_url || ARGS.source_map) + "\n*/";
-    }
-
-    if (OUTPUT_FILE) {
-        fs.writeFileSync(OUTPUT_FILE, output, "utf8");
-    } else {
-        sys.print(output);
-        sys.error("\n");
-    }
-
-    if (ARGS.stats) {
-        sys.error(UglifyJS.string_template("Timing information (compressed {count} files):", {
-            count: files.length
-        }));
-        for (var i in STATS) if (STATS.hasOwnProperty(i)) {
-            sys.error(UglifyJS.string_template("- {name}: {time}s", {
-                name: i,
-                time: (STATS[i] / 1000).toFixed(3)
-            }));
-        }
-    }
+// workaround for tty output truncation upon process.exit()
+[process.stdout, process.stderr].forEach(function(stream){
+    if (stream._handle && stream._handle.setBlocking)
+        stream._handle.setBlocking(true);
 });
 
-/* -----[ functions ]----- */
+var fs = require("fs");
+var info = require("../package.json");
+var path = require("path");
+var program = require("commander");
+var UglifyJS = require("../tools/node");
 
-function normalize(o) {
-    for (var i in o) if (o.hasOwnProperty(i) && /-/.test(i)) {
-        o[i.replace(/-/g, "_")] = o[i];
-        delete o[i];
+var files = {};
+var options = {
+    compress: false,
+    mangle: false
+};
+program._name = info.name;
+program.version(info.version);
+program.parseArgv = program.parse;
+program.parse = undefined;
+program.option("-p, --parse <options>", "Specify parser options.", parse_js("parse", true));
+program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js("compress", true));
+program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js("mangle", true));
+program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js("mangle-props", true));
+program.option("-b, --beautify [options]", "Beautify output/specify output options.", parse_js("beautify", true));
+program.option("-o, --output <file>", "Output file (default STDOUT).");
+program.option("--comments [filter]", "Preserve copyright comments in the output.");
+program.option("--config-file <file>", "Read minify() options from JSON file.");
+program.option("-d, --define <expr>[=value]", "Global definitions.", parse_js("define"));
+program.option("--ie8", "Support non-standard Internet Explorer 8.");
+program.option("--keep-fnames", "Do not mangle/drop function names. Useful for code relying on Function.prototype.name.");
+program.option("--name-cache <file>", "File to hold mangled name mappings.");
+program.option("--self", "Build UglifyJS as a library (implies --wrap UglifyJS)");
+program.option("--source-map [options]", "Enable source map/specify source map options.", parse_source_map());
+program.option("--stats", "Display operations run time on STDERR.")
+program.option("--toplevel", "Compress and/or mangle variables in toplevel scope.");
+program.option("--verbose", "Print diagnostic messages.");
+program.option("--warn", "Print warning messages.");
+program.option("--wrap <name>", "Embed everything as a function with “exports” corresponding to “name” globally.");
+program.arguments("[files...]").parseArgv(process.argv);
+if (program.configFile) {
+    options = JSON.parse(read_file(program.configFile));
+}
+if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
+    fatal("ERROR: cannot write source map to STDOUT");
+}
+[
+    "compress",
+    "ie8",
+    "mangle",
+    "sourceMap",
+    "toplevel",
+    "wrap"
+].forEach(function(name) {
+    if (name in program) {
+        options[name] = program[name];
+    }
+});
+if (program.beautify) {
+    options.output = typeof program.beautify == "object" ? program.beautify : {};
+    if (!("beautify" in options.output)) {
+        options.output.beautify = true;
     }
 }
+if (program.comments) {
+    if (typeof options.output != "object") options.output = {};
+    options.output.comments = typeof program.comments == "string" ? program.comments : "some";
+}
+if (program.define) {
+    if (typeof options.compress != "object") options.compress = {};
+    if (typeof options.compress.global_defs != "object") options.compress.global_defs = {};
+    for (var expr in program.define) {
+        options.compress.global_defs[expr] = program.define[expr];
+    }
+}
+if (program.keepFnames) {
+    options.keep_fnames = true;
+}
+if (program.mangleProps) {
+    if (program.mangleProps.domprops) {
+        delete program.mangleProps.domprops;
+    } else {
+        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);
+        });
+    }
+    if (typeof options.mangle != "object") options.mangle = {};
+    options.mangle.properties = program.mangleProps;
+}
+var cache;
+if (program.nameCache) {
+    cache = JSON.parse(read_file(program.nameCache, "{}"));
+    if (options.mangle) {
+        if (typeof options.mangle != "object") options.mangle = {};
+        options.mangle.cache = to_cache("vars");
+        if (options.mangle.properties) {
+            if (typeof options.mangle.properties != "object") options.mangle.properties = {};
+            options.mangle.properties.cache = to_cache("props");
+        }
+    }
+}
+if (program.parse) {
+    if (program.parse.acorn || program.parse.spidermonkey) {
+        if (program.sourceMap) fatal("ERROR: inline source map only works with built-in parser");
+    } else {
+        options.parse = program.parse;
+    }
+}
+var convert_path = function(name) {
+    return name;
+};
+if (typeof program.sourceMap == "object" && "base" in program.sourceMap) {
+    convert_path = function() {
+        var base = program.sourceMap.base;
+        delete options.sourceMap.base;
+        return function(name) {
+            return path.relative(base, name);
+        };
+    }();
+}
+if (program.verbose) {
+    options.warnings = "verbose";
+} else if (program.warn) {
+    options.warnings = true;
+}
+if (program.self) {
+    if (program.args.length) {
+        console.error("WARN: Ignoring input files since --self was passed");
+    }
+    if (!options.wrap) options.wrap = "UglifyJS";
+    simple_glob(UglifyJS.FILES).forEach(function(name) {
+        files[convert_path(name)] = read_file(name);
+    });
+    run();
+} else if (program.args.length) {
+    simple_glob(program.args).forEach(function(name) {
+        files[convert_path(name)] = read_file(name);
+    });
+    run();
+} else {
+    var chunks = [];
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", function(chunk) {
+        chunks.push(chunk);
+    }).on("end", function() {
+        files = [ chunks.join("") ];
+        run();
+    });
+    process.stdin.resume();
+}
 
-function getOptions(x, constants) {
-    x = ARGS[x];
-    if (!x) return null;
-    var ret = {};
-    if (x !== true) {
-        var ast;
-        try {
-            ast = UglifyJS.parse(x);
-        } catch(ex) {
-            if (ex instanceof UglifyJS.JS_Parse_Error) {
-                sys.error("Error parsing arguments in: " + x);
-                process.exit(1);
+function convert_ast(fn) {
+    return UglifyJS.AST_Node.from_mozilla_ast(Object.keys(files).reduce(fn, null));
+}
+
+function run() {
+    UglifyJS.AST_Node.warn_function = function(msg) {
+        console.error("WARN:", msg);
+    };
+    if (program.stats)  program.stats = Date.now();
+    try {
+        if (program.parse) {
+            if (program.parse.acorn) {
+                files = convert_ast(function(toplevel, name) {
+                    return require("acorn").parse(files[name], {
+                        locations: true,
+                        program: toplevel,
+                        sourceFile: name
+                    });
+                });
+            } else if (program.parse.spidermonkey) {
+                files = convert_ast(function(toplevel, name) {
+                    var obj = JSON.parse(files[name]);
+                    if (!toplevel) return obj;
+                    toplevel.body = toplevel.body.concat(obj.body);
+                    return toplevel;
+                });
             }
         }
-        ast.walk(new UglifyJS.TreeWalker(function(node){
-            if (node instanceof UglifyJS.AST_Toplevel) return; // descend
-            if (node instanceof UglifyJS.AST_SimpleStatement) return; // descend
-            if (node instanceof UglifyJS.AST_Seq) return; // descend
-            if (node instanceof UglifyJS.AST_Assign) {
-                var name = node.left.print_to_string({ beautify: false }).replace(/-/g, "_");
-                var value = node.right;
-                if (constants)
-                    value = new Function("return (" + value.print_to_string() + ")")();
-                ret[name] = value;
-                return true;    // no descend
+        var result = UglifyJS.minify(files, options);
+    } catch (ex) {
+        if (ex instanceof UglifyJS.JS_Parse_Error) {
+            console.error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
+            var col = ex.col;
+            var lines = files[ex.filename].split(/\r?\n/);
+            var line = lines[ex.line - 1];
+            if (!line && !col) {
+                line = lines[ex.line - 2];
+                col = line.length;
             }
-            sys.error(node.TYPE)
-            sys.error("Error parsing arguments in: " + x);
-            process.exit(1);
+            if (line) {
+                if (col > 40) {
+                    line = line.slice(col - 40);
+                    col = 40;
+                }
+                console.error(line.slice(0, 80));
+                console.error(line.slice(0, col).replace(/\S/g, " ") + "^");
+            }
+        }
+        if (ex.defs) {
+            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));
+    } else if (program.output) {
+        fs.writeFileSync(program.output, result.code);
+        if (result.map) {
+            fs.writeFileSync(program.output + ".map", result.map);
+        }
+    } else {
+        console.log(result.code);
+    }
+    if (program.nameCache) {
+        fs.writeFileSync(program.nameCache, JSON.stringify(cache, function(key, value) {
+            return value instanceof UglifyJS.Dictionary ? value.toObject() : value;
         }));
     }
-    return ret;
+    if (program.stats) console.error("Elapsed:", Date.now() - program.stats);
 }
 
-function read_whole_file(filename, cb) {
-    if (filename == "-") {
-        var chunks = [];
-        process.stdin.setEncoding('utf-8');
-        process.stdin.on('data', function (chunk) {
-            chunks.push(chunk);
-        }).on('end', function () {
-            cb(null, chunks.join(""));
-        });
-        process.openStdin();
+function fatal(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+// A file glob function that only supports "*" and "?" wildcards in the basename.
+// Example: "foo/bar/*baz??.*.js"
+// Argument `glob` may be a string or an array of strings.
+// Returns an array of strings. Garbage in, garbage out.
+function simple_glob(glob) {
+    if (Array.isArray(glob)) {
+        return [].concat.apply([], glob.map(simple_glob));
+    }
+    if (glob.match(/\*|\?/)) {
+        var dir = path.dirname(glob);
+        try {
+            var entries = fs.readdirSync(dir);
+        } catch (ex) {}
+        if (entries) {
+            var pattern = "^" + path.basename(glob)
+                .replace(/[.+^$[\]\\(){}]/g, "\\$&")
+                .replace(/\*/g, "[^/\\\\]*")
+                .replace(/\?/g, "[^/\\\\]") + "$";
+            var mod = process.platform === "win32" ? "i" : "";
+            var rx = new RegExp(pattern, mod);
+            var results = entries.filter(function(name) {
+                return rx.test(name);
+            }).map(function(name) {
+                return path.join(dir, name);
+            });
+            if (results.length) return results;
+        }
+    }
+    return [ glob ];
+}
+
+function read_file(path, default_value) {
+    try {
+        return fs.readFileSync(path, "utf8");
+    } catch (ex) {
+        if (ex.code == "ENOENT" && default_value != null) return default_value;
+        fatal("ERROR: " + ex.message);
+    }
+}
+
+function parse_js(flag, constants) {
+    return function(value, options) {
+        options = options || {};
+        try {
+            UglifyJS.parse(value, {
+                expression: true
+            }).walk(new UglifyJS.TreeWalker(function(node) {
+                if (node instanceof UglifyJS.AST_Assign) {
+                    var name = node.left.print_to_string();
+                    var value = node.right;
+                    if (!constants) {
+                        options[name] = value;
+                    } else if (value instanceof UglifyJS.AST_Array) {
+                        options[name] = value.elements.map(to_string);
+                    } else {
+                        options[name] = to_string(value);
+                    }
+                    return true;
+                }
+                if (node instanceof UglifyJS.AST_Symbol || node instanceof UglifyJS.AST_PropAccess) {
+                    var name = node.print_to_string();
+                    options[name] = true;
+                    return true;
+                }
+                if (!(node instanceof UglifyJS.AST_Sequence)) throw node;
+
+                function to_string(value) {
+                    return value instanceof UglifyJS.AST_Constant ? value.getValue() : value.print_to_string({
+                        quote_keys: true
+                    });
+                }
+            }));
+        } catch(ex) {
+            fatal("Error parsing arguments for '" + flag + "': " + value);
+        }
+        return options;
+    }
+}
+
+function parse_source_map() {
+    var parse = parse_js("sourceMap", true);
+    return function(value, options) {
+        var hasContent = options && options.sourceMap && "content" in options.sourceMap;
+        var settings = parse(value, options);
+        if (!hasContent && settings.content && settings.content != "inline") {
+            console.error("INFO: Using input source map:", settings.content);
+            settings.content = read_file(settings.content, settings.content);
+        }
+        return settings;
+    }
+}
+
+function to_cache(key) {
+    if (cache[key]) {
+        cache[key].props = UglifyJS.Dictionary.fromObject(cache[key].props);
     } else {
-        fs.readFile(filename, "utf-8", cb);
+        cache[key] = {
+            cname: -1,
+            props: new UglifyJS.Dictionary()
+        };
     }
-}
-
-function time_it(name, cont) {
-    var t1 = new Date().getTime();
-    var ret = cont();
-    if (ARGS.stats) {
-        var spent = new Date().getTime() - t1;
-        if (STATS[name]) STATS[name] += spent;
-        else STATS[name] = spent;
-    }
-    return ret;
+    return cache[key];
 }

lib/ast.js

@@ -71,7 +71,7 @@ function DEFNODE(type, props, methods, base) {
     if (type) {
         ctor.prototype.TYPE = ctor.TYPE = type;
     }
-    if (methods) for (i in methods) if (methods.hasOwnProperty(i)) {
+    if (methods) for (i in methods) if (HOP(methods, i)) {
         if (/^\$/.test(i)) {
             ctor[i.substr(1)] = methods[i];
         } else {
@@ -81,16 +81,30 @@ function DEFNODE(type, props, methods, base) {
     ctor.DEFMETHOD = function(name, method) {
         this.prototype[name] = method;
     };
+    if (typeof exports !== "undefined") {
+        exports["AST_" + type] = ctor;
+    }
     return ctor;
 };
 
-var AST_Token = DEFNODE("Token", "type value line col pos endpos nlb comments_before file", {
+var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before file raw", {
 }, null);
 
 var AST_Node = DEFNODE("Node", "start end", {
-    clone: function() {
+    _clone: function(deep) {
+        if (deep) {
+            var self = this.clone();
+            return self.transform(new TreeTransformer(function(node) {
+                if (node !== self) {
+                    return node.clone(true);
+                }
+            }));
+        }
         return new this.CTOR(this);
     },
+    clone: function(deep) {
+        return this._clone(deep);
+    },
     $documentation: "Base class of all AST nodes",
     $propdoc: {
         start: "[AST_Token] The first token of this node",
@@ -120,11 +134,12 @@ var AST_Debugger = DEFNODE("Debugger", null, {
     $documentation: "Represents a debugger statement",
 }, AST_Statement);
 
-var AST_Directive = DEFNODE("Directive", "value scope", {
+var AST_Directive = DEFNODE("Directive", "value scope quote", {
     $documentation: "Represents a directive, like \"use strict\";",
     $propdoc: {
         value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
-        scope: "[AST_Scope/S] The scope that this directive affects"
+        scope: "[AST_Scope/S] The scope that this directive affects",
+        quote: "[string] the original quote character"
     },
 }, AST_Statement);
 
@@ -141,12 +156,13 @@ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
 }, AST_Statement);
 
 function walk_body(node, visitor) {
-    if (node.body instanceof AST_Statement) {
-        node.body._walk(visitor);
+    var body = node.body;
+    if (body instanceof AST_Statement) {
+        body._walk(visitor);
+    }
+    else for (var i = 0, len = body.length; i < len; i++) {
+        body[i]._walk(visitor);
     }
-    else node.body.forEach(function(stat){
-        stat._walk(visitor);
-    });
 };
 
 var AST_Block = DEFNODE("Block", "body", {
@@ -166,21 +182,13 @@ var AST_BlockStatement = DEFNODE("BlockStatement", null, {
 }, AST_Block);
 
 var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
-    $documentation: "The empty statement (empty block or simply a semicolon)",
-    _walk: function(visitor) {
-        return visitor._visit(this);
-    }
+    $documentation: "The empty statement (empty block or simply a semicolon)"
 }, AST_Statement);
 
 var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", {
     $documentation: "Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`",
     $propdoc: {
         body: "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"
-    },
-    _walk: function(visitor) {
-        return visitor._visit(this, function(){
-            this.body._walk(visitor);
-        });
     }
 }, AST_Statement);
 
@@ -194,28 +202,53 @@ var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", {
             this.label._walk(visitor);
             this.body._walk(visitor);
         });
+    },
+    clone: function(deep) {
+        var node = this._clone(deep);
+        if (deep) {
+            var label = node.label;
+            var def = this.label;
+            node.walk(new TreeWalker(function(node) {
+                if (node instanceof AST_LoopControl
+                    && node.label && node.label.thedef === def) {
+                    node.label.thedef = label;
+                    label.references.push(node);
+                }
+            }));
+        }
+        return node;
     }
 }, AST_StatementWithBody);
 
+var AST_IterationStatement = DEFNODE("IterationStatement", null, {
+    $documentation: "Internal class.  All loops inherit from it."
+}, AST_StatementWithBody);
+
 var AST_DWLoop = DEFNODE("DWLoop", "condition", {
     $documentation: "Base class for do/while statements",
     $propdoc: {
         condition: "[AST_Node] the loop condition.  Should not be instanceof AST_Statement"
-    },
+    }
+}, AST_IterationStatement);
+
+var AST_Do = DEFNODE("Do", null, {
+    $documentation: "A `do` statement",
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.body._walk(visitor);
+            this.condition._walk(visitor);
+        });
+    }
+}, AST_DWLoop);
+
+var AST_While = DEFNODE("While", null, {
+    $documentation: "A `while` statement",
     _walk: function(visitor) {
         return visitor._visit(this, function(){
             this.condition._walk(visitor);
             this.body._walk(visitor);
         });
     }
-}, AST_StatementWithBody);
-
-var AST_Do = DEFNODE("Do", null, {
-    $documentation: "A `do` statement",
-}, AST_DWLoop);
-
-var AST_While = DEFNODE("While", null, {
-    $documentation: "A `while` statement",
 }, AST_DWLoop);
 
 var AST_For = DEFNODE("For", "init condition step", {
@@ -233,7 +266,7 @@ var AST_For = DEFNODE("For", "init condition step", {
             this.body._walk(visitor);
         });
     }
-}, AST_StatementWithBody);
+}, AST_IterationStatement);
 
 var AST_ForIn = DEFNODE("ForIn", "init name object", {
     $documentation: "A `for ... in` statement",
@@ -249,7 +282,7 @@ var AST_ForIn = DEFNODE("ForIn", "init name object", {
             this.body._walk(visitor);
         });
     }
-}, AST_StatementWithBody);
+}, AST_IterationStatement);
 
 var AST_With = DEFNODE("With", "expression", {
     $documentation: "A `with` statement",
@@ -285,63 +318,13 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
     $propdoc: {
         globals: "[Object/S] a map of name -> SymbolDef for all undeclared names",
     },
-    wrap_enclose: function(arg_parameter_pairs) {
-        var self = this;
-        var args = [];
-        var parameters = [];
-
-        arg_parameter_pairs.forEach(function(pair) {
-            var split = pair.split(":");
-
-            args.push(split[0]);
-            parameters.push(split[1]);
-        });
-
-        var wrapped_tl = "(function(" + parameters.join(",") + "){ '$ORIG'; })(" + args.join(",") + ")";
+    wrap_commonjs: function(name) {
+        var body = this.body;
+        var wrapped_tl = "(function(exports){'$ORIG';})(typeof " + name + "=='undefined'?(" + name + "={}):" + name + ");";
         wrapped_tl = parse(wrapped_tl);
         wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node){
             if (node instanceof AST_Directive && node.value == "$ORIG") {
-                return MAP.splice(self.body);
-            }
-        }));
-        return wrapped_tl;
-    },
-    wrap_commonjs: function(name, export_all) {
-        var self = this;
-        var to_export = [];
-        if (export_all) {
-            self.figure_out_scope();
-            self.walk(new TreeWalker(function(node){
-                if (node instanceof AST_SymbolDeclaration && node.definition().global) {
-                    if (!find_if(function(n){ return n.name == node.name }, to_export))
-                        to_export.push(node);
-                }
-            }));
-        }
-        var wrapped_tl = "(function(exports, global){ global['" + name + "'] = exports; '$ORIG'; '$EXPORTS'; }({}, (function(){return this}())))";
-        wrapped_tl = parse(wrapped_tl);
-        wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node){
-            if (node instanceof AST_SimpleStatement) {
-                node = node.body;
-                if (node instanceof AST_String) switch (node.getValue()) {
-                  case "$ORIG":
-                    return MAP.splice(self.body);
-                  case "$EXPORTS":
-                    var body = [];
-                    to_export.forEach(function(sym){
-                        body.push(new AST_SimpleStatement({
-                            body: new AST_Assign({
-                                left: new AST_Sub({
-                                    expression: new AST_SymbolRef({ name: "exports" }),
-                                    property: new AST_String({ value: sym.name }),
-                                }),
-                                operator: "=",
-                                right: new AST_SymbolRef(sym),
-                            }),
-                        }));
-                    });
-                    return MAP.splice(body);
-                }
+                return MAP.splice(body);
             }
         }));
         return wrapped_tl;
@@ -358,16 +341,17 @@ var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments", {
     _walk: function(visitor) {
         return visitor._visit(this, function(){
             if (this.name) this.name._walk(visitor);
-            this.argnames.forEach(function(arg){
-                arg._walk(visitor);
-            });
+            var argnames = this.argnames;
+            for (var i = 0, len = argnames.length; i < len; i++) {
+                argnames[i]._walk(visitor);
+            }
             walk_body(this, visitor);
         });
     }
 }, AST_Scope);
 
 var AST_Accessor = DEFNODE("Accessor", null, {
-    $documentation: "A setter/getter function"
+    $documentation: "A setter/getter function.  The `name` property is always null."
 }, AST_Lambda);
 
 var AST_Function = DEFNODE("Function", null, {
@@ -494,12 +478,6 @@ var AST_Try = DEFNODE("Try", "bcatch bfinally", {
     }
 }, AST_Block);
 
-// XXX: this is wrong according to ECMA-262 (12.4).  the catch block
-// should introduce another scope, as the argname should be visible
-// only inside the catch block.  However, doing it this way because of
-// IE which simply introduces the name in the surrounding scope.  If
-// we ever want to fix this then AST_Catch should inherit from
-// AST_Scope.
 var AST_Catch = DEFNODE("Catch", "argname", {
     $documentation: "A `catch` node; only makes sense as part of a `try` statement",
     $propdoc: {
@@ -526,9 +504,10 @@ var AST_Definitions = DEFNODE("Definitions", "definitions", {
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            this.definitions.forEach(function(def){
-                def._walk(visitor);
-            });
+            var definitions = this.definitions;
+            for (var i = 0, len = definitions.length; i < len; i++) {
+                definitions[i]._walk(visitor);
+            }
         });
     }
 }, AST_Statement);
@@ -565,10 +544,11 @@ var AST_Call = DEFNODE("Call", "expression args", {
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
+            var args = this.args;
+            for (var i = 0, len = args.length; i < len; i++) {
+                args[i]._walk(visitor);
+            }
             this.expression._walk(visitor);
-            this.args.forEach(function(arg){
-                arg._walk(visitor);
-            });
         });
     }
 });
@@ -577,61 +557,16 @@ var AST_New = DEFNODE("New", null, {
     $documentation: "An object instantiation.  Derives from a function call since it has exactly the same properties"
 }, AST_Call);
 
-var AST_Seq = DEFNODE("Seq", "car cdr", {
-    $documentation: "A sequence expression (two comma-separated expressions)",
+var AST_Sequence = DEFNODE("Sequence", "expressions", {
+    $documentation: "A sequence expression (comma-separated expressions)",
     $propdoc: {
-        car: "[AST_Node] first element in sequence",
-        cdr: "[AST_Node] second element in sequence"
-    },
-    $cons: function(x, y) {
-        var seq = new AST_Seq(x);
-        seq.car = x;
-        seq.cdr = y;
-        return seq;
-    },
-    $from_array: function(array) {
-        if (array.length == 0) return null;
-        if (array.length == 1) return array[0].clone();
-        var list = null;
-        for (var i = array.length; --i >= 0;) {
-            list = AST_Seq.cons(array[i], list);
-        }
-        var p = list;
-        while (p) {
-            if (p.cdr && !p.cdr.cdr) {
-                p.cdr = p.cdr.car;
-                break;
-            }
-            p = p.cdr;
-        }
-        return list;
-    },
-    to_array: function() {
-        var p = this, a = [];
-        while (p) {
-            a.push(p.car);
-            if (p.cdr && !(p.cdr instanceof AST_Seq)) {
-                a.push(p.cdr);
-                break;
-            }
-            p = p.cdr;
-        }
-        return a;
-    },
-    add: function(node) {
-        var p = this;
-        while (p) {
-            if (!(p.cdr instanceof AST_Seq)) {
-                var cell = AST_Seq.cons(p.cdr, node);
-                return p.cdr = cell;
-            }
-            p = p.cdr;
-        }
+        expressions: "[AST_Node*] array of expressions (at least two)"
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            this.car._walk(visitor);
-            if (this.cdr) this.cdr._walk(visitor);
+            this.expressions.forEach(function(node) {
+                node._walk(visitor);
+            });
         });
     }
 });
@@ -728,9 +663,10 @@ var AST_Array = DEFNODE("Array", "elements", {
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            this.elements.forEach(function(el){
-                el._walk(visitor);
-            });
+            var elements = this.elements;
+            for (var i = 0, len = elements.length; i < len; i++) {
+                elements[i]._walk(visitor);
+            }
         });
     }
 });
@@ -742,9 +678,10 @@ var AST_Object = DEFNODE("Object", "properties", {
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            this.properties.forEach(function(prop){
-                prop._walk(visitor);
-            });
+            var properties = this.properties;
+            for (var i = 0, len = properties.length; i < len; i++) {
+                properties[i]._walk(visitor);
+            }
         });
     }
 });
@@ -752,7 +689,7 @@ 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; it's always a plain string in our AST, no matter if it was a string, number or identifier in original code",
+        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."
     },
     _walk: function(visitor) {
@@ -762,8 +699,11 @@ var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
     }
 });
 
-var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", null, {
+var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", {
     $documentation: "A key: value object property",
+    $propdoc: {
+        quote: "[string] the original quote character"
+    }
 }, AST_ObjectProperty);
 
 var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
@@ -789,9 +729,6 @@ var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
 
 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
     $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
-    $propdoc: {
-        init: "[AST_Node*/S] array of initializers for this declaration."
-    }
 }, AST_Symbol);
 
 var AST_SymbolVar = DEFNODE("SymbolVar", null, {
@@ -821,7 +758,11 @@ var AST_SymbolCatch = DEFNODE("SymbolCatch", null, {
 var AST_Label = DEFNODE("Label", "references", {
     $documentation: "Symbol naming a label (declaration)",
     $propdoc: {
-        references: "[AST_LabelRef*] a list of nodes referring to this label"
+        references: "[AST_LoopControl*] a list of nodes referring to this label"
+    },
+    initialize: function() {
+        this.references = [];
+        this.thedef = this;
     }
 }, AST_Symbol);
 
@@ -844,17 +785,19 @@ var AST_Constant = DEFNODE("Constant", null, {
     }
 });
 
-var AST_String = DEFNODE("String", "value", {
+var AST_String = DEFNODE("String", "value quote", {
     $documentation: "A string literal",
     $propdoc: {
-        value: "[string] the contents of this string"
+        value: "[string] the contents of this string",
+        quote: "[string] the original quote character"
     }
 }, AST_Constant);
 
-var AST_Number = DEFNODE("Number", "value", {
+var AST_Number = DEFNODE("Number", "value literal", {
     $documentation: "A number literal",
     $propdoc: {
-        value: "[number] the numeric value"
+        value: "[number] the numeric value",
+        literal: "[string] numeric value as string (optional)"
     }
 }, AST_Constant);
 
@@ -913,27 +856,36 @@ var AST_True = DEFNODE("True", null, {
 function TreeWalker(callback) {
     this.visit = callback;
     this.stack = [];
+    this.directives = Object.create(null);
 };
 TreeWalker.prototype = {
     _visit: function(node, descend) {
-        this.stack.push(node);
+        this.push(node);
         var ret = this.visit(node, descend ? function(){
             descend.call(node);
         } : noop);
         if (!ret && descend) {
             descend.call(node);
         }
-        this.stack.pop();
+        this.pop(node);
         return ret;
     },
     parent: function(n) {
         return this.stack[this.stack.length - 2 - (n || 0)];
     },
-    push: function (node) {
+    push: function(node) {
+        if (node instanceof AST_Lambda) {
+            this.directives = Object.create(this.directives);
+        } else if (node instanceof AST_Directive && !this.directives[node.value]) {
+            this.directives[node.value] = node;
+        }
         this.stack.push(node);
     },
-    pop: function() {
-        return this.stack.pop();
+    pop: function(node) {
+        this.stack.pop();
+        if (node instanceof AST_Lambda) {
+            this.directives = Object.getPrototypeOf(this.directives);
+        }
     },
     self: function() {
         return this.stack[this.stack.length - 1];
@@ -945,6 +897,18 @@ TreeWalker.prototype = {
             if (x instanceof type) return x;
         }
     },
+    has_directive: function(type) {
+        var dir = this.directives[type];
+        if (dir) return dir;
+        var node = this.stack[this.stack.length - 1];
+        if (node instanceof AST_Scope) {
+            for (var i = 0; i < node.body.length; ++i) {
+                var st = node.body[i];
+                if (!(st instanceof AST_Directive)) break;
+                if (st.value == type) return st;
+            }
+        }
+    },
     in_boolean_context: function() {
         var stack = this.stack;
         var i = stack.length, self = stack[--i];
@@ -963,23 +927,17 @@ TreeWalker.prototype = {
             self = p;
         }
     },
-    loopcontrol_target: function(label) {
+    loopcontrol_target: function(node) {
         var stack = this.stack;
-        if (label) {
-            for (var i = stack.length; --i >= 0;) {
-                var x = stack[i];
-                if (x instanceof AST_LabeledStatement && x.label.name == label.name) {
-                    return x.body;
-                }
-            }
-        } else {
-            for (var i = stack.length; --i >= 0;) {
-                var x = stack[i];
-                if (x instanceof AST_Switch
-                    || x instanceof AST_For
-                    || x instanceof AST_ForIn
-                    || x instanceof AST_DWLoop) return x;
-            }
+        if (node.label) for (var i = stack.length; --i >= 0;) {
+            var x = stack[i];
+            if (x instanceof AST_LabeledStatement && x.label.name == node.label.name)
+                return x.body;
+        } else for (var i = stack.length; --i >= 0;) {
+            var x = stack[i];
+            if (x instanceof AST_IterationStatement
+                || node instanceof AST_Break && x instanceof AST_Switch)
+                return x;
         }
     }
 };

lib/minify.js

@@ -0,0 +1,146 @@
+"use strict";
+
+var to_ascii = typeof atob == "undefined" ? function(b64) {
+    return new Buffer(b64, "base64").toString();
+} : atob;
+var to_base64 = typeof btoa == "undefined" ? function(str) {
+    return new Buffer(str).toString("base64");
+} : btoa;
+
+function read_source_map(code) {
+    var match = /\n\/\/# sourceMappingURL=data:application\/json(;.*?)?;base64,(.*)/.exec(code);
+    if (!match) {
+        AST_Node.warn("inline source map not found");
+        return null;
+    }
+    return to_ascii(match[2]);
+}
+
+function set_shorthand(name, options, keys) {
+    if (options[name]) {
+        keys.forEach(function(key) {
+            if (options[key]) {
+                if (typeof options[key] != "object") options[key] = {};
+                if (!(name in options[key])) options[key][name] = options[name];
+            }
+        });
+    }
+}
+
+function minify(files, options) {
+    var warn_function = AST_Node.warn_function;
+    try {
+        if (typeof files == "string") {
+            files = [ files ];
+        }
+        options = defaults(options, {
+            compress: {},
+            ie8: false,
+            keep_fnames: false,
+            mangle: {},
+            output: {},
+            parse: {},
+            sourceMap: false,
+            toplevel: false,
+            warnings: false,
+            wrap: false,
+        }, true);
+        set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
+        set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
+        set_shorthand("toplevel", options, [ "compress", "mangle" ]);
+        set_shorthand("warnings", options, [ "compress" ]);
+        if (options.mangle) {
+            options.mangle = defaults(options.mangle, {
+                cache: null,
+                eval: false,
+                ie8: false,
+                keep_fnames: false,
+                properties: false,
+                reserved: [],
+                toplevel: false,
+            }, true);
+        }
+        if (options.sourceMap) {
+            options.sourceMap = defaults(options.sourceMap, {
+                content: null,
+                filename: null,
+                includeSources: false,
+                root: null,
+                url: null,
+            }, true);
+        }
+        var warnings = [];
+        if (options.warnings && !AST_Node.warn_function) {
+            AST_Node.warn_function = function(warning) {
+                warnings.push(warning);
+            };
+        }
+        var toplevel;
+        if (files instanceof AST_Toplevel) {
+            toplevel = files;
+        } else {
+            options.parse = options.parse || {};
+            options.parse.toplevel = null;
+            for (var name in files) {
+                options.parse.filename = name;
+                options.parse.toplevel = parse(files[name], options.parse);
+                if (options.sourceMap && options.sourceMap.content == "inline") {
+                    if (Object.keys(files).length > 1)
+                        throw new Error("inline source map only works with singular input");
+                    options.sourceMap.content = read_source_map(files[name]);
+                }
+            }
+            toplevel = options.parse.toplevel;
+        }
+        if (options.wrap) {
+            toplevel = toplevel.wrap_commonjs(options.wrap);
+        }
+        if (options.compress) {
+            toplevel.figure_out_scope(options.mangle);
+            toplevel = new Compressor(options.compress).compress(toplevel);
+        }
+        if (options.mangle) {
+            toplevel.figure_out_scope(options.mangle);
+            base54.reset();
+            toplevel.compute_char_frequency(options.mangle);
+            toplevel.mangle_names(options.mangle);
+            if (options.mangle.properties) {
+                toplevel = mangle_properties(toplevel, options.mangle.properties);
+            }
+        }
+        if (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;
+            }
+        }
+        if (warnings.length) {
+            result.warnings = warnings;
+        }
+        return result;
+    } finally {
+        AST_Node.warn_function = warn_function;
+    }
+}

lib/mozilla-ast.js

@@ -45,54 +45,117 @@
 
 (function(){
 
+    var normalize_directives = function(body) {
+        var in_directive = true;
+
+        for (var i = 0; i < body.length; i++) {
+            if (in_directive && body[i] instanceof AST_Statement && body[i].body instanceof AST_String) {
+                body[i] = new AST_Directive({
+                    start: body[i].start,
+                    end: body[i].end,
+                    value: body[i].body.value
+                });
+            } else if (in_directive && !(body[i] instanceof AST_Statement && body[i].body instanceof AST_String)) {
+                in_directive = false;
+            }
+        }
+
+        return body;
+    };
+
     var MOZ_TO_ME = {
-        TryStatement : function(M) {
+        Program: function(M) {
+            return new AST_Toplevel({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                body: normalize_directives(M.body.map(from_moz))
+            });
+        },
+        FunctionDeclaration: function(M) {
+            return new AST_Defun({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                name: from_moz(M.id),
+                argnames: M.params.map(from_moz),
+                body: normalize_directives(from_moz(M.body).body)
+            });
+        },
+        FunctionExpression: function(M) {
+            return new AST_Function({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                name: from_moz(M.id),
+                argnames: M.params.map(from_moz),
+                body: normalize_directives(from_moz(M.body).body)
+            });
+        },
+        ExpressionStatement: function(M) {
+            return new AST_SimpleStatement({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                body: from_moz(M.expression)
+            });
+        },
+        TryStatement: function(M) {
+            var handlers = M.handlers || [M.handler];
+            if (handlers.length > 1 || M.guardedHandlers && M.guardedHandlers.length) {
+                throw new Error("Multiple catch clauses are not supported.");
+            }
             return new AST_Try({
                 start    : my_start_token(M),
                 end      : my_end_token(M),
                 body     : from_moz(M.block).body,
-                bcatch   : from_moz(M.handlers[0]),
+                bcatch   : from_moz(handlers[0]),
                 bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null
             });
         },
-        CatchClause : function(M) {
-            return new AST_Catch({
-                start   : my_start_token(M),
-                end     : my_end_token(M),
-                argname : from_moz(M.param),
-                body    : from_moz(M.body).body
+        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,
+                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);
+            }
+        },
+        ArrayExpression: function(M) {
+            return new AST_Array({
+                start    : my_start_token(M),
+                end      : my_end_token(M),
+                elements : M.elements.map(function(elem){
+                    return elem === null ? new AST_Hole() : from_moz(elem);
+                })
             });
         },
-        ObjectExpression : function(M) {
+        ObjectExpression: function(M) {
             return new AST_Object({
                 start      : my_start_token(M),
                 end        : my_end_token(M),
                 properties : M.properties.map(function(prop){
-                    var key = prop.key;
-                    var name = key.type == "Identifier" ? key.name : key.value;
-                    var args = {
-                        start    : my_start_token(key),
-                        end      : my_end_token(prop.value),
-                        key      : name,
-                        value    : from_moz(prop.value)
-                    };
-                    switch (prop.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);
-                    }
+                    prop.type = "Property";
+                    return from_moz(prop)
                 })
             });
         },
-        SequenceExpression : function(M) {
-            return AST_Seq.from_array(M.expressions.map(from_moz));
+        SequenceExpression: function(M) {
+            return new AST_Sequence({
+                start      : my_start_token(M),
+                end        : my_end_token(M),
+                expressions: M.expressions.map(from_moz)
+            });
         },
-        MemberExpression : function(M) {
+        MemberExpression: function(M) {
             return new (M.computed ? AST_Sub : AST_Dot)({
                 start      : my_start_token(M),
                 end        : my_end_token(M),
@@ -100,7 +163,7 @@
                 expression : from_moz(M.object)
             });
         },
-        SwitchCase : function(M) {
+        SwitchCase: function(M) {
             return new (M.test ? AST_Case : AST_Default)({
                 start      : my_start_token(M),
                 end        : my_end_token(M),
@@ -108,7 +171,14 @@
                 body       : M.consequent.map(from_moz)
             });
         },
-        Literal : function(M) {
+        VariableDeclaration: function(M) {
+            return new (M.kind === "const" ? AST_Const : AST_Var)({
+                start       : my_start_token(M),
+                end         : my_end_token(M),
+                definitions : M.declarations.map(from_moz)
+            });
+        },
+        Literal: function(M) {
             var val = M.value, args = {
                 start  : my_start_token(M),
                 end    : my_end_token(M)
@@ -124,16 +194,20 @@
               case "boolean":
                 return new (val ? AST_True : AST_False)(args);
               default:
-                args.value = val;
+                var rx = M.regex;
+                if (rx && rx.pattern) {
+                    // RegExpLiteral as per ESTree AST spec
+                    args.value = new RegExp(rx.pattern, rx.flags).toString();
+                } else {
+                    // support legacy RegExp
+                    args.value = M.regex && M.raw ? M.raw : val;
+                }
                 return new AST_RegExp(args);
             }
         },
-        UnaryExpression: From_Moz_Unary,
-        UpdateExpression: From_Moz_Unary,
         Identifier: function(M) {
             var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
-            return new (M.name == "this" ? AST_This
-                        : p.type == "LabeledStatement" ? AST_Label
+            return new (  p.type == "LabeledStatement" ? AST_Label
                         : p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : AST_SymbolVar)
                         : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
                         : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
@@ -147,7 +221,8 @@
         }
     };
 
-    function From_Moz_Unary(M) {
+    MOZ_TO_ME.UpdateExpression =
+    MOZ_TO_ME.UnaryExpression = function To_Moz_Unary(M) {
         var prefix = "prefix" in M ? M.prefix
             : M.type == "UnaryExpression" ? true : false;
         return new (prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({
@@ -158,14 +233,8 @@
         });
     };
 
-    var ME_TO_MOZ = {};
-
-    map("Node", AST_Node);
-    map("Program", AST_Toplevel, "body@body");
-    map("Function", AST_Function, "id>name, params@argnames, body%body");
     map("EmptyStatement", AST_EmptyStatement);
     map("BlockStatement", AST_BlockStatement, "body@body");
-    map("ExpressionStatement", AST_SimpleStatement, "expression>body");
     map("IfStatement", AST_If, "test>condition, consequent>body, alternate>alternative");
     map("LabeledStatement", AST_LabeledStatement, "label>label, body>body");
     map("BreakStatement", AST_Break, "label>label");
@@ -179,72 +248,314 @@
     map("ForStatement", AST_For, "init>init, test>condition, update>step, body>body");
     map("ForInStatement", AST_ForIn, "left>init, right>object, body>body");
     map("DebuggerStatement", AST_Debugger);
-    map("FunctionDeclaration", AST_Defun, "id>name, params@argnames, body%body");
-    map("VariableDeclaration", AST_Var, "declarations@definitions");
     map("VariableDeclarator", AST_VarDef, "id>name, init>value");
+    map("CatchClause", AST_Catch, "param>argname, body%body");
 
     map("ThisExpression", AST_This);
-    map("ArrayExpression", AST_Array, "elements@elements");
-    map("FunctionExpression", AST_Function, "id>name, params@argnames, body%body");
     map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right");
-    map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
     map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right");
+    map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
     map("ConditionalExpression", AST_Conditional, "test>condition, consequent>consequent, alternate>alternative");
     map("NewExpression", AST_New, "callee>expression, arguments@args");
     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)
+        };
+    });
+
+    def_to_moz(AST_Defun, function To_Moz_FunctionDeclaration(M) {
+        return {
+            type: "FunctionDeclaration",
+            id: to_moz(M.name),
+            params: M.argnames.map(to_moz),
+            body: to_moz_block(M)
+        }
+    });
+
+    def_to_moz(AST_Function, function To_Moz_FunctionExpression(M) {
+        return {
+            type: "FunctionExpression",
+            id: to_moz(M.name),
+            params: M.argnames.map(to_moz),
+            body: to_moz_block(M)
+        }
+    });
+
+    def_to_moz(AST_Directive, function To_Moz_Directive(M) {
+        return {
+            type: "ExpressionStatement",
+            expression: {
+                type: "Literal",
+                value: M.value
+            }
+        };
+    });
+
+    def_to_moz(AST_SimpleStatement, function To_Moz_ExpressionStatement(M) {
+        return {
+            type: "ExpressionStatement",
+            expression: to_moz(M.body)
+        };
+    });
+
+    def_to_moz(AST_SwitchBranch, function To_Moz_SwitchCase(M) {
+        return {
+            type: "SwitchCase",
+            test: to_moz(M.expression),
+            consequent: M.body.map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_Try, function To_Moz_TryStatement(M) {
+        return {
+            type: "TryStatement",
+            block: to_moz_block(M),
+            handler: to_moz(M.bcatch),
+            guardedHandlers: [],
+            finalizer: to_moz(M.bfinally)
+        };
+    });
+
+    def_to_moz(AST_Catch, function To_Moz_CatchClause(M) {
+        return {
+            type: "CatchClause",
+            param: to_moz(M.argname),
+            guard: null,
+            body: to_moz_block(M)
+        };
+    });
+
+    def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
+        return {
+            type: "VariableDeclaration",
+            kind: M instanceof AST_Const ? "const" : "var",
+            declarations: M.definitions.map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_Sequence, function To_Moz_SequenceExpression(M) {
+        return {
+            type: "SequenceExpression",
+            expressions: M.expressions.map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) {
+        var isComputed = M instanceof AST_Sub;
+        return {
+            type: "MemberExpression",
+            object: to_moz(M.expression),
+            computed: isComputed,
+            property: isComputed ? to_moz(M.property) : {type: "Identifier", name: M.property}
+        };
+    });
+
+    def_to_moz(AST_Unary, function To_Moz_Unary(M) {
+        return {
+            type: M.operator == "++" || M.operator == "--" ? "UpdateExpression" : "UnaryExpression",
+            operator: M.operator,
+            prefix: M instanceof AST_UnaryPrefix,
+            argument: to_moz(M.expression)
+        };
+    });
+
+    def_to_moz(AST_Binary, function To_Moz_BinaryExpression(M) {
+        return {
+            type: M.operator == "&&" || M.operator == "||" ? "LogicalExpression" : "BinaryExpression",
+            left: to_moz(M.left),
+            operator: M.operator,
+            right: to_moz(M.right)
+        };
+    });
+
+    def_to_moz(AST_Array, function To_Moz_ArrayExpression(M) {
+        return {
+            type: "ArrayExpression",
+            elements: M.elements.map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_Object, function To_Moz_ObjectExpression(M) {
+        return {
+            type: "ObjectExpression",
+            properties: M.properties.map(to_moz)
+        };
+    });
+
+    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 kind;
+        if (M instanceof AST_ObjectKeyVal) {
+            kind = "init";
+        } else
+        if (M instanceof AST_ObjectGetter) {
+            kind = "get";
+        } else
+        if (M instanceof AST_ObjectSetter) {
+            kind = "set";
+        }
+        return {
+            type: "Property",
+            kind: kind,
+            key: key,
+            value: to_moz(M.value)
+        };
+    });
+
+    def_to_moz(AST_Symbol, function To_Moz_Identifier(M) {
+        var def = M.definition();
+        return {
+            type: "Identifier",
+            name: def ? def.mangled_name || def.name : M.name
+        };
+    });
+
+    def_to_moz(AST_RegExp, function To_Moz_RegExpLiteral(M) {
+        var value = M.value;
+        return {
+            type: "Literal",
+            value: value,
+            raw: value.toString(),
+            regex: {
+                pattern: value.source,
+                flags: value.toString().match(/[gimuy]*$/)[0]
+            }
+        };
+    });
+
+    def_to_moz(AST_Constant, function To_Moz_Literal(M) {
+        var value = M.value;
+        if (typeof value === 'number' && (value < 0 || (value === 0 && 1 / value < 0))) {
+            return {
+                type: "UnaryExpression",
+                operator: "-",
+                prefix: true,
+                argument: {
+                    type: "Literal",
+                    value: -value,
+                    raw: M.start.raw
+                }
+            };
+        }
+        return {
+            type: "Literal",
+            value: value,
+            raw: M.start.raw
+        };
+    });
+
+    def_to_moz(AST_Atom, function To_Moz_Atom(M) {
+        return {
+            type: "Identifier",
+            name: String(M.value)
+        };
+    });
+
+    AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
+    AST_Null.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
+    AST_Hole.DEFMETHOD("to_mozilla_ast", function To_Moz_ArrayHole() { return null });
+
+    AST_Block.DEFMETHOD("to_mozilla_ast", AST_BlockStatement.prototype.to_mozilla_ast);
+    AST_Lambda.DEFMETHOD("to_mozilla_ast", AST_Function.prototype.to_mozilla_ast);
+
     /* -----[ tools ]----- */
 
+    function raw_token(moznode) {
+        if (moznode.type == "Literal") {
+            return moznode.raw != null ? moznode.raw : moznode.value + "";
+        }
+    }
+
     function my_start_token(moznode) {
+        var loc = moznode.loc, start = loc && loc.start;
+        var range = moznode.range;
         return new AST_Token({
-            file   : moznode.loc && moznode.loc.source,
-            line   : moznode.loc && moznode.loc.start.line,
-            col    : moznode.loc && moznode.loc.start.column,
-            pos    : moznode.start,
-            endpos : moznode.start
+            file    : loc && loc.source,
+            line    : start && start.line,
+            col     : start && start.column,
+            pos     : range ? range[0] : moznode.start,
+            endline : start && start.line,
+            endcol  : start && start.column,
+            endpos  : range ? range[0] : moznode.start,
+            raw     : raw_token(moznode),
         });
     };
 
     function my_end_token(moznode) {
+        var loc = moznode.loc, end = loc && loc.end;
+        var range = moznode.range;
         return new AST_Token({
-            file   : moznode.loc && moznode.loc.source,
-            line   : moznode.loc && moznode.loc.end.line,
-            col    : moznode.loc && moznode.loc.end.column,
-            pos    : moznode.end,
-            endpos : moznode.end
+            file    : loc && loc.source,
+            line    : end && end.line,
+            col     : end && end.column,
+            pos     : range ? range[1] : moznode.end,
+            endline : end && end.line,
+            endcol  : end && end.column,
+            endpos  : range ? range[1] : moznode.end,
+            raw     : raw_token(moznode),
         });
     };
 
     function map(moztype, mytype, propmap) {
         var moz_to_me = "function From_Moz_" + moztype + "(M){\n";
-        moz_to_me += "return new mytype({\n" +
+        moz_to_me += "return new U2." + mytype.name + "({\n" +
             "start: my_start_token(M),\n" +
             "end: my_end_token(M)";
 
+        var me_to_moz = "function To_Moz_" + moztype + "(M){\n";
+        me_to_moz += "return {\n" +
+            "type: " + JSON.stringify(moztype);
+
         if (propmap) propmap.split(/\s*,\s*/).forEach(function(prop){
             var m = /([a-z0-9$_]+)(=|@|>|%)([a-z0-9$_]+)/i.exec(prop);
             if (!m) throw new Error("Can't understand property map: " + prop);
-            var moz = "M." + m[1], how = m[2], my = m[3];
+            var moz = m[1], how = m[2], my = m[3];
             moz_to_me += ",\n" + my + ": ";
-            if (how == "@") {
-                moz_to_me += moz + ".map(from_moz)";
-            } else if (how == ">") {
-                moz_to_me += "from_moz(" + moz + ")";
-            } else if (how == "=") {
-                moz_to_me += moz;
-            } else if (how == "%") {
-                moz_to_me += "from_moz(" + moz + ").body";
-            } else throw new Error("Can't understand operator in propmap: " + prop);
+            me_to_moz += ",\n" + moz + ": ";
+            switch (how) {
+                case "@":
+                    moz_to_me += "M." + moz + ".map(from_moz)";
+                    me_to_moz += "M." +  my + ".map(to_moz)";
+                    break;
+                case ">":
+                    moz_to_me += "from_moz(M." + moz + ")";
+                    me_to_moz += "to_moz(M." + my + ")";
+                    break;
+                case "=":
+                    moz_to_me += "M." + moz;
+                    me_to_moz += "M." + my;
+                    break;
+                case "%":
+                    moz_to_me += "from_moz(M." + moz + ").body";
+                    me_to_moz += "to_moz_block(M)";
+                    break;
+                default:
+                    throw new Error("Can't understand operator in propmap: " + prop);
+            }
         });
-        moz_to_me += "\n})}";
 
-        // moz_to_me = parse(moz_to_me).print_to_string({ beautify: true });
-        // console.log(moz_to_me);
+        moz_to_me += "\n})\n}";
+        me_to_moz += "\n}\n}";
 
-        moz_to_me = new Function("mytype", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
-            mytype, my_start_token, my_end_token, from_moz
+        //moz_to_me = parse(moz_to_me).print_to_string({ beautify: true });
+        //me_to_moz = parse(me_to_moz).print_to_string({ beautify: true });
+        //console.log(moz_to_me);
+
+        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
         );
-        return MOZ_TO_ME[moztype] = moz_to_me;
+        me_to_moz = new Function("to_moz", "to_moz_block", "return(" + me_to_moz + ")")(
+            to_moz, to_moz_block
+        );
+        MOZ_TO_ME[moztype] = moz_to_me;
+        def_to_moz(mytype, me_to_moz);
     };
 
     var FROM_MOZ_STACK = null;
@@ -264,4 +575,39 @@
         return ast;
     };
 
+    function set_moz_loc(mynode, moznode, myparent) {
+        var start = mynode.start;
+        var end = mynode.end;
+        if (start.pos != null && end.endpos != null) {
+            moznode.range = [start.pos, end.endpos];
+        }
+        if (start.line) {
+            moznode.loc = {
+                start: {line: start.line, column: start.col},
+                end: end.endline ? {line: end.endline, column: end.endcol} : null
+            };
+            if (start.file) {
+                moznode.loc.source = start.file;
+            }
+        }
+        return moznode;
+    };
+
+    function def_to_moz(mytype, handler) {
+        mytype.DEFMETHOD("to_mozilla_ast", function() {
+            return set_moz_loc(this, handler(this));
+        });
+    };
+
+    function to_moz(node) {
+        return node != null ? node.to_mozilla_ast() : null;
+    };
+
+    function to_moz_block(node) {
+        return {
+            type: "BlockStatement",
+            body: node.body.map(to_moz)
+        };
+    };
+
 })();

lib/parse.js

@@ -46,7 +46,7 @@
 
 var KEYWORDS = 'break case catch const continue debugger default delete do else finally for function if in instanceof new return switch throw try typeof var void while with';
 var KEYWORDS_ATOM = 'false null true';
-var RESERVED_WORDS = 'abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized this throws transient volatile'
+var RESERVED_WORDS = 'abstract boolean byte char class double enum export extends final float goto implements import int interface let long native package private protected public short static super synchronized this throws transient volatile yield'
     + " " + KEYWORDS_ATOM + " " + KEYWORDS;
 var KEYWORDS_BEFORE_EXPRESSION = 'return new delete throw else case';
 
@@ -59,7 +59,6 @@ var OPERATOR_CHARS = makePredicate(characters("+-*&%=<>!?|~^"));
 
 var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
 var RE_OCT_NUMBER = /^0[0-7]+$/;
-var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i;
 
 var OPERATORS = makePredicate([
     "in",
@@ -108,9 +107,11 @@ var OPERATORS = makePredicate([
     "||"
 ]);
 
-var WHITESPACE_CHARS = makePredicate(characters(" \u00a0\n\r\t\f\u000b\u200b\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000"));
+var WHITESPACE_CHARS = makePredicate(characters(" \u00a0\n\r\t\f\u000b\u200b\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000\uFEFF"));
 
-var PUNC_BEFORE_EXPRESSION = makePredicate(characters("[{(,.;:"));
+var NEWLINE_CHARS = makePredicate(characters("\n\r\u2028\u2029"));
+
+var PUNC_BEFORE_EXPRESSION = makePredicate(characters("[{(,;:"));
 
 var PUNC_CHARS = makePredicate(characters("[]{}(),;:"));
 
@@ -120,7 +121,8 @@ var REGEXP_MODIFIERS = makePredicate(characters("gmsiy"));
 
 // regexps adapted from http://xregexp.com/plugins/#unicode
 var UNICODE = {
-    letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971\\u0972\\u097B-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D3D\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC\\u0EDD\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8B\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10D0-\\u10FA\\u10FC\\u1100-\\u1159\\u115F-\\u11A2\\u11A8-\\u11F9\\u1200-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u1676\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19A9\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u2094\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2C6F\\u2C71-\\u2C7D\\u2C80-\\u2CE4\\u2D00-\\u2D25\\u2D30-\\u2D65\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31B7\\u31F0-\\u31FF\\u3400\\u4DB5\\u4E00\\u9FC3\\uA000-\\uA48C\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA65F\\uA662-\\uA66E\\uA67F-\\uA697\\uA717-\\uA71F\\uA722-\\uA788\\uA78B\\uA78C\\uA7FB-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA90A-\\uA925\\uA930-\\uA946\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAC00\\uD7A3\\uF900-\\uFA2D\\uFA30-\\uFA6A\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"),
+    letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B2\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FCC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA78E\\uA790-\\uA7AD\\uA7B0\\uA7B1\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB5F\\uAB64\\uAB65\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"),
+    digit: new RegExp("[\\u0030-\\u0039\\u0660-\\u0669\\u06F0-\\u06F9\\u07C0-\\u07C9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE6-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0DE6-\\u0DEF\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29\\u1040-\\u1049\\u1090-\\u1099\\u17E0-\\u17E9\\u1810-\\u1819\\u1946-\\u194F\\u19D0-\\u19D9\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1B50-\\u1B59\\u1BB0-\\u1BB9\\u1C40-\\u1C49\\u1C50-\\u1C59\\uA620-\\uA629\\uA8D0-\\uA8D9\\uA900-\\uA909\\uA9D0-\\uA9D9\\uA9F0-\\uA9F9\\uAA50-\\uAA59\\uABF0-\\uABF9\\uFF10-\\uFF19]"),
     non_spacing_mark: new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065E\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0900-\\u0902\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F90-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1DC0-\\u1DE6\\u1DFD-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA67C\\uA67D\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"),
     space_combining_mark: new RegExp("[\\u0903\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u0982\\u0983\\u09BE-\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u09D7\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B3E\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0B57\\u0BBE\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD7\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0-\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D57\\u0D82\\u0D83\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0F3E\\u0F3F\\u0F7F\\u102B\\u102C\\u1031\\u1038\\u103B\\u103C\\u1056\\u1057\\u1062-\\u1064\\u1067-\\u106D\\u1083\\u1084\\u1087-\\u108C\\u108F\\u109A-\\u109C\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A19-\\u1A1B\\u1A55\\u1A57\\u1A61\\u1A63\\u1A64\\u1A6D-\\u1A72\\u1B04\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF2\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BD-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAA7B\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]"),
     connector_punctuation: new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]")
@@ -133,13 +135,17 @@ function is_letter(code) {
 };
 
 function is_digit(code) {
-    return code >= 48 && code <= 57; //XXX: find out if "UnicodeDigit" means something else than 0..9
+    return code >= 48 && code <= 57;
 };
 
 function is_alphanumeric_char(code) {
     return is_digit(code) || is_letter(code);
 };
 
+function is_unicode_digit(code) {
+    return UNICODE.digit.test(String.fromCharCode(code));
+}
+
 function is_unicode_combining_mark(ch) {
     return UNICODE.non_spacing_mark.test(ch) || UNICODE.space_combining_mark.test(ch);
 };
@@ -164,18 +170,12 @@ function is_identifier_char(ch) {
         || code == 8205 // \u200d: zero-width joiner <ZWJ> (in my ECMA-262 PDF, this is also 200c)
         || is_unicode_combining_mark(ch)
         || is_unicode_connector_punctuation(ch)
+        || is_unicode_digit(code)
     ;
 };
 
 function is_identifier_string(str){
-    var i = str.length;
-    if (i == 0) return false;
-    if (is_digit(str.charCodeAt(0))) return false;
-    while (--i >= 0) {
-        if (!is_identifier_char(str.charAt(i)))
-            return false;
-    }
-    return true;
+    return /^[a-z_$][a-z0-9_$]*$/i.test(str);
 };
 
 function parse_js_number(num) {
@@ -183,25 +183,26 @@ function parse_js_number(num) {
         return parseInt(num.substr(2), 16);
     } else if (RE_OCT_NUMBER.test(num)) {
         return parseInt(num.substr(1), 8);
-    } else if (RE_DEC_NUMBER.test(num)) {
-        return parseFloat(num);
+    } else {
+        var val = parseFloat(num);
+        if (val == num) return val;
     }
 };
 
-function JS_Parse_Error(message, line, col, pos) {
+function JS_Parse_Error(message, filename, line, col, pos) {
     this.message = message;
+    this.filename = filename;
     this.line = line;
     this.col = col;
     this.pos = pos;
-    this.stack = new Error().stack;
-};
-
-JS_Parse_Error.prototype.toString = function() {
-    return this.message + " (line: " + this.line + ", col: " + this.col + ", pos: " + this.pos + ")" + "\n\n" + this.stack;
 };
+JS_Parse_Error.prototype = Object.create(Error.prototype);
+JS_Parse_Error.prototype.constructor = JS_Parse_Error;
+JS_Parse_Error.prototype.name = "SyntaxError";
+configure_error_stack(JS_Parse_Error);
 
 function js_error(message, filename, line, col, pos) {
-    throw new JS_Parse_Error(message, line, col, pos);
+    throw new JS_Parse_Error(message, filename, line, col, pos);
 };
 
 function is_token(token, type, val) {
@@ -210,10 +211,10 @@ function is_token(token, type, val) {
 
 var EX_EOF = {};
 
-function tokenizer($TEXT, filename) {
+function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     var S = {
-        text            : $TEXT.replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/\uFEFF/g, ''),
+        text            : $TEXT,
         filename        : filename,
         pos             : 0,
         tokpos          : 0,
@@ -223,7 +224,9 @@ function tokenizer($TEXT, filename) {
         tokcol          : 0,
         newline_before  : false,
         regex_allowed   : false,
-        comments_before : []
+        comments_before : [],
+        directives      : {},
+        directive_stack : []
     };
 
     function peek() { return S.text.charAt(S.pos); };
@@ -232,16 +235,39 @@ function tokenizer($TEXT, filename) {
         var ch = S.text.charAt(S.pos++);
         if (signal_eof && !ch)
             throw EX_EOF;
-        if (ch == "\n") {
+        if (NEWLINE_CHARS(ch)) {
             S.newline_before = S.newline_before || !in_string;
             ++S.line;
             S.col = 0;
+            if (!in_string && ch == "\r" && peek() == "\n") {
+                // treat a \r\n sequence as a single \n
+                ++S.pos;
+                ch = "\n";
+            }
         } else {
             ++S.col;
         }
         return ch;
     };
 
+    function forward(i) {
+        while (i-- > 0) next();
+    };
+
+    function looking_at(str) {
+        return S.text.substr(S.pos, str.length) == str;
+    };
+
+    function find_eol() {
+        var text = S.text;
+        for (var i = S.pos, n = S.text.length; i < n; ++i) {
+            var ch = text[i];
+            if (NEWLINE_CHARS(ch))
+                return i;
+        }
+        return -1;
+    };
+
     function find(what, signal_eof) {
         var pos = S.text.indexOf(what, S.pos);
         if (signal_eof && pos == -1) throw EX_EOF;
@@ -254,20 +280,27 @@ function tokenizer($TEXT, filename) {
         S.tokpos = S.pos;
     };
 
+    var prev_was_dot = false;
     function token(type, value, is_comment) {
-        S.regex_allowed = ((type == "operator" && !UNARY_POSTFIX[value]) ||
+        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 == ".");
         var ret = {
-            type   : type,
-            value  : value,
-            line   : S.tokline,
-            col    : S.tokcol,
-            pos    : S.tokpos,
-            endpos : S.pos,
-            nlb    : S.newline_before,
-            file   : filename
+            type    : type,
+            value   : value,
+            line    : S.tokline,
+            col     : S.tokcol,
+            pos     : S.tokpos,
+            endline : S.line,
+            endcol  : S.col,
+            endpos  : S.pos,
+            nlb     : S.newline_before,
+            file    : filename
         };
+        if (/^(?:num|string|regexp)$/i.test(type)) {
+            ret.raw = $TEXT.substring(ret.pos, ret.endpos);
+        }
         if (!is_comment) {
             ret.comments_before = S.comments_before;
             S.comments_before = [];
@@ -315,6 +348,9 @@ function tokenizer($TEXT, filename) {
             return is_alphanumeric_char(code);
         });
         if (prefix) num = prefix + num;
+        if (RE_OCT_NUMBER.test(num) && next_token.has_directive("use strict")) {
+            parse_error("Legacy octal literals are not allowed in strict mode");
+        }
         var valid = parse_js_number(num);
         if (!isNaN(valid)) {
             return token("num", valid);
@@ -332,14 +368,36 @@ function tokenizer($TEXT, filename) {
           case 98  : return "\b";
           case 118 : return "\u000b"; // \v
           case 102 : return "\f";
-          case 48  : return "\0";
           case 120 : return String.fromCharCode(hex_bytes(2)); // \x
           case 117 : return String.fromCharCode(hex_bytes(4)); // \u
           case 10  : return ""; // newline
-          default  : return ch;
+          case 13  :            // \r
+            if (peek() == "\n") { // DOS newline
+                next(true, in_string);
+                return "";
+            }
         }
+        if (ch >= "0" && ch <= "7")
+            return read_octal_escape_sequence(ch);
+        return ch;
     };
 
+    function read_octal_escape_sequence(ch) {
+        // Read
+        var p = peek();
+        if (p >= "0" && p <= "7") {
+            ch += next(true);
+            if (ch[0] <= "3" && (p = peek()) >= "0" && p <= "7")
+                ch += next(true);
+        }
+
+        // Parse
+        if (ch === "0") return "\0";
+        if (ch.length > 0 && next_token.has_directive("use strict"))
+            parse_error("Legacy octal escape sequences are not allowed in strict mode");
+        return String.fromCharCode(parseInt(ch, 8));
+    }
+
     function hex_bytes(n) {
         var num = 0;
         for (; n > 0; --n) {
@@ -351,37 +409,23 @@ function tokenizer($TEXT, filename) {
         return num;
     };
 
-    var read_string = with_eof_error("Unterminated string constant", function(){
+    var read_string = with_eof_error("Unterminated string constant", function(quote_char){
         var quote = next(), ret = "";
         for (;;) {
-            var ch = next(true);
-            if (ch == "\\") {
-                // read OctalEscapeSequence (XXX: deprecated if "strict mode")
-                // https://github.com/mishoo/UglifyJS/issues/178
-                var octal_len = 0, first = null;
-                ch = read_while(function(ch){
-                    if (ch >= "0" && ch <= "7") {
-                        if (!first) {
-                            first = ch;
-                            return ++octal_len;
-                        }
-                        else if (first <= "3" && octal_len <= 2) return ++octal_len;
-                        else if (first >= "4" && octal_len <= 1) return ++octal_len;
-                    }
-                    return false;
-                });
-                if (octal_len > 0) ch = String.fromCharCode(parseInt(ch, 8));
-                else ch = read_escaped_char(true);
-            }
+            var ch = next(true, true);
+            if (ch == "\\") ch = read_escaped_char(true);
+            else if (NEWLINE_CHARS(ch)) parse_error("Unterminated string constant");
             else if (ch == quote) break;
             ret += ch;
         }
-        return token("string", ret);
+        var tok = token("string", ret);
+        tok.quote = quote_char;
+        return tok;
     });
 
-    function read_line_comment() {
-        next();
-        var i = find("\n"), ret;
+    function skip_line_comment(type) {
+        var regex_allowed = S.regex_allowed;
+        var i = find_eol(), ret;
         if (i == -1) {
             ret = S.text.substr(S.pos);
             S.pos = S.text.length;
@@ -389,22 +433,21 @@ function tokenizer($TEXT, filename) {
             ret = S.text.substring(S.pos, i);
             S.pos = i;
         }
-        return token("comment1", ret, true);
+        S.col = S.tokcol + (S.pos - S.tokpos);
+        S.comments_before.push(token(type, ret, true));
+        S.regex_allowed = regex_allowed;
+        return next_token;
     };
 
-    var read_multiline_comment = with_eof_error("Unterminated multiline comment", function(){
-        next();
+    var skip_multiline_comment = with_eof_error("Unterminated multiline comment", function(){
+        var regex_allowed = S.regex_allowed;
         var i = find("*/", true);
-        var text = S.text.substring(S.pos, i);
-        var a = text.split("\n"), n = a.length;
+        var text = S.text.substring(S.pos, i).replace(/\r\n|\r|\u2028|\u2029/g, '\n');
         // update stream position
-        S.pos = i + 2;
-        S.line += n - 1;
-        if (n > 1) S.col = a[n - 1].length;
-        else S.col += a[n - 1].length;
-        S.col += 2;
-        S.newline_before = S.newline_before || text.indexOf("\n") >= 0;
-        return token("comment2", text, true);
+        forward(text.length /* doesn't count \r\n as 2 char while S.pos - i does */ + 2);
+        S.comments_before.push(token("comment2", text, true));
+        S.regex_allowed = regex_allowed;
+        return next_token;
     });
 
     function read_name() {
@@ -432,7 +475,9 @@ function tokenizer($TEXT, filename) {
 
     var read_regexp = with_eof_error("Unterminated regular expression", function(regexp){
         var prev_backslash = false, ch, in_class = false;
-        while ((ch = next(true))) if (prev_backslash) {
+        while ((ch = next(true))) if (NEWLINE_CHARS(ch)) {
+            parse_error("Unexpected line terminator");
+        } else if (prev_backslash) {
             regexp += "\\" + ch;
             prev_backslash = false;
         } else if (ch == "[") {
@@ -449,7 +494,11 @@ function tokenizer($TEXT, filename) {
             regexp += ch;
         }
         var mods = read_name();
-        return token("regexp", new RegExp(regexp, mods));
+        try {
+          return token("regexp", new RegExp(regexp, mods));
+        } catch(e) {
+          parse_error(e.message);
+        }
     });
 
     function read_operator(prefix) {
@@ -468,16 +517,13 @@ function tokenizer($TEXT, filename) {
 
     function handle_slash() {
         next();
-        var regex_allowed = S.regex_allowed;
         switch (peek()) {
           case "/":
-            S.comments_before.push(read_line_comment());
-            S.regex_allowed = regex_allowed;
-            return next_token();
+            next();
+            return skip_line_comment("comment1");
           case "*":
-            S.comments_before.push(read_multiline_comment());
-            S.regex_allowed = regex_allowed;
-            return next_token();
+            next();
+            return skip_multiline_comment();
         }
         return S.regex_allowed ? read_regexp("") : read_operator("/");
     };
@@ -491,6 +537,7 @@ function tokenizer($TEXT, filename) {
 
     function read_word() {
         var word = read_name();
+        if (prev_was_dot) return token("name", word);
         return KEYWORDS_ATOM(word) ? token("atom", word)
             : !KEYWORDS(word) ? token("name", word)
             : OPERATORS(word) ? token("operator", word)
@@ -511,20 +558,44 @@ function tokenizer($TEXT, filename) {
     function next_token(force_regexp) {
         if (force_regexp != null)
             return read_regexp(force_regexp);
-        skip_whitespace();
-        start_token();
-        var ch = peek();
-        if (!ch) return token("eof");
-        var code = ch.charCodeAt(0);
-        switch (code) {
-          case 34: case 39: return read_string();
-          case 46: return handle_dot();
-          case 47: return handle_slash();
+        if (shebang && S.pos == 0 && looking_at("#!")) {
+            start_token();
+            forward(2);
+            skip_line_comment("comment5");
+        }
+        for (;;) {
+            skip_whitespace();
+            start_token();
+            if (html5_comments) {
+                if (looking_at("<!--")) {
+                    forward(4);
+                    skip_line_comment("comment3");
+                    continue;
+                }
+                if (looking_at("-->") && S.newline_before) {
+                    forward(3);
+                    skip_line_comment("comment4");
+                    continue;
+                }
+            }
+            var ch = peek();
+            if (!ch) return token("eof");
+            var code = ch.charCodeAt(0);
+            switch (code) {
+              case 34: case 39: return read_string(ch);
+              case 46: return handle_dot();
+              case 47: {
+                  var tok = handle_slash();
+                  if (tok === next_token) continue;
+                  return tok;
+              }
+            }
+            if (is_digit(code)) return read_num();
+            if (PUNC_CHARS(ch)) return token("punc", next());
+            if (OPERATOR_CHARS(ch)) return read_operator();
+            if (code == 92 || is_identifier_start(code)) return read_word();
+            break;
         }
-        if (is_digit(code)) return read_num();
-        if (PUNC_CHARS(ch)) return token("punc", next());
-        if (OPERATOR_CHARS(ch)) return read_operator();
-        if (code == 92 || is_identifier_start(code)) return read_word();
         parse_error("Unexpected character '" + ch + "'");
     };
 
@@ -533,6 +604,34 @@ function tokenizer($TEXT, filename) {
         return S;
     };
 
+    next_token.add_directive = function(directive) {
+        S.directive_stack[S.directive_stack.length - 1].push(directive);
+
+        if (S.directives[directive] === undefined) {
+            S.directives[directive] = 1;
+        } else {
+            S.directives[directive]++;
+        }
+    }
+
+    next_token.push_directives_stack = function() {
+        S.directive_stack.push([]);
+    }
+
+    next_token.pop_directives_stack = function() {
+        var directives = S.directive_stack[S.directive_stack.length - 1];
+
+        for (var i = 0; i < directives.length; i++) {
+            S.directives[directives[i]]--;
+        }
+
+        S.directive_stack.pop();
+    }
+
+    next_token.has_directive = function(directive) {
+        return S.directives[directive] > 0;
+    }
+
     return next_token;
 
 };
@@ -556,10 +655,10 @@ var UNARY_POSTFIX = makePredicate([ "--", "++" ]);
 var ASSIGNMENT = makePredicate([ "=", "+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&=" ]);
 
 var PRECEDENCE = (function(a, ret){
-    for (var i = 0, n = 1; i < a.length; ++i, ++n) {
+    for (var i = 0; i < a.length; ++i) {
         var b = a[i];
         for (var j = 0; j < b.length; ++j) {
-            ret[b[j]] = n;
+            ret[b[j]] = i + 1;
         }
     }
     return ret;
@@ -588,14 +687,20 @@ var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "nam
 function parse($TEXT, options) {
 
     options = defaults(options, {
-        strict     : false,
-        filename   : null,
-        toplevel   : null,
-        expression : false
+        bare_returns   : false,
+        expression     : false,
+        filename       : null,
+        html5_comments : true,
+        shebang        : true,
+        strict         : false,
+        toplevel       : null,
     });
 
     var S = {
-        input         : typeof $TEXT == "string" ? tokenizer($TEXT, options.filename) : $TEXT,
+        input         : (typeof $TEXT == "string"
+                         ? tokenizer($TEXT, options.filename,
+                                     options.html5_comments, options.shebang)
+                         : $TEXT),
         token         : null,
         prev          : null,
         peeked        : null,
@@ -665,9 +770,9 @@ function parse($TEXT, options) {
         );
     };
 
-    function semicolon() {
+    function semicolon(optional) {
         if (is("punc", ";")) next();
-        else if (!can_insert_semicolon()) unexpected();
+        else if (!optional && !can_insert_semicolon()) unexpected();
     };
 
     function parenthesised() {
@@ -688,18 +793,35 @@ function parse($TEXT, options) {
         };
     };
 
-    var statement = embed_tokens(function() {
-        var tmp;
+    function handle_regexp() {
         if (is("operator", "/") || is("operator", "/=")) {
             S.peeked = null;
             S.token = S.input(S.token.value.substr(1)); // force regexp
         }
+    };
+
+    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) {
+                    S.input.add_directive(S.token.value);
+                } else {
+                    S.in_directives = false;
+                }
+            }
             var dir = S.in_directives, stat = simple_statement();
-            // XXXv2: decide how to fix directives
-            if (dir && stat.body instanceof AST_String && !is("punc", ","))
-                return new AST_Directive({ value: stat.body.value });
+            if (dir) {
+                return new AST_Directive({
+                    start : stat.body.start,
+                    end   : stat.body.end,
+                    quote : stat.body.quote,
+                    value : stat.body.value,
+                });
+            }
             return stat;
           case "num":
           case "regexp":
@@ -724,6 +846,7 @@ function parse($TEXT, options) {
               case "(":
                 return simple_statement();
               case ";":
+                S.in_directives = false;
                 next();
                 return new AST_EmptyStatement();
               default:
@@ -745,7 +868,7 @@ function parse($TEXT, options) {
               case "do":
                 return new AST_Do({
                     body      : in_loop(statement),
-                    condition : (expect_token("keyword", "while"), tmp = parenthesised(), semicolon(), tmp)
+                    condition : (expect_token("keyword", "while"), tmp = parenthesised(), semicolon(true), tmp)
                 });
 
               case "while":
@@ -758,13 +881,13 @@ function parse($TEXT, options) {
                 return for_();
 
               case "function":
-                return function_(true);
+                return function_(AST_Defun);
 
               case "if":
                 return if_();
 
               case "return":
-                if (S.in_function == 0)
+                if (S.in_function == 0 && !options.bare_returns)
                     croak("'return' outside of function");
                 return new AST_Return({
                     value: ( is("punc", ";")
@@ -797,15 +920,16 @@ function parse($TEXT, options) {
                 return tmp = const_(), semicolon(), tmp;
 
               case "with":
+                if (S.input.has_directive("use strict")) {
+                    croak("Strict mode may not include a with statement");
+                }
                 return new AST_With({
                     expression : parenthesised(),
                     body       : statement()
                 });
-
-              default:
-                unexpected();
             }
         }
+        unexpected();
     });
 
     function labeled_statement() {
@@ -821,6 +945,18 @@ function parse($TEXT, options) {
         S.labels.push(label);
         var stat = statement();
         S.labels.pop();
+        if (!(stat instanceof AST_IterationStatement)) {
+            // check for `continue` that refers to this label.
+            // those should be reported as syntax errors.
+            // https://github.com/mishoo/UglifyJS2/issues/287
+            label.references.forEach(function(ref){
+                if (ref instanceof AST_Continue) {
+                    ref = ref.label.start;
+                    croak("Continue label `" + label.name + "` refers to non-IterationStatement.",
+                          ref.line, ref.col, ref.pos);
+                }
+            });
+        }
         return new AST_LabeledStatement({ body: stat, label: label });
     };
 
@@ -829,18 +965,22 @@ function parse($TEXT, options) {
     };
 
     function break_cont(type) {
-        var label = null;
+        var label = null, ldef;
         if (!can_insert_semicolon()) {
             label = as_symbol(AST_LabelRef, true);
         }
         if (label != null) {
-            if (!find_if(function(l){ return l.name == label.name }, S.labels))
+            ldef = find_if(function(l){ return l.name == label.name }, S.labels);
+            if (!ldef)
                 croak("Undefined label " + label.name);
+            label.thedef = ldef;
         }
         else if (S.in_loop == 0)
             croak(type.TYPE + " not inside a loop or switch");
         semicolon();
-        return new type({ label: label });
+        var stat = new type({ label: label });
+        if (ldef) ldef.references.push(stat);
+        return stat;
     };
 
     function for_() {
@@ -886,40 +1026,38 @@ function parse($TEXT, options) {
         });
     };
 
-    var function_ = function(in_statement, ctor) {
-        var is_accessor = ctor === AST_Accessor;
-        var name = (is("name") ? as_symbol(in_statement
-                                           ? AST_SymbolDefun
-                                           : is_accessor
-                                           ? AST_SymbolAccessor
-                                           : AST_SymbolLambda)
-                    : is_accessor && (is("string") || is("num")) ? as_atom_node()
-                    : null);
+    var function_ = function(ctor) {
+        var in_statement = ctor === AST_Defun;
+        var name = is("name") ? as_symbol(in_statement ? AST_SymbolDefun : AST_SymbolLambda) : null;
         if (in_statement && !name)
             unexpected();
         expect("(");
-        if (!ctor) ctor = in_statement ? AST_Defun : AST_Function;
+        var argnames = [];
+        for (var first = true; !is("punc", ")");) {
+            if (first) first = false; else expect(",");
+            argnames.push(as_symbol(AST_SymbolFunarg));
+        }
+        next();
+        var loop = S.in_loop;
+        var labels = S.labels;
+        ++S.in_function;
+        S.in_directives = true;
+        S.input.push_directives_stack();
+        S.in_loop = 0;
+        S.labels = [];
+        var body = block_();
+        if (S.input.has_directive("use strict")) {
+            if (name) strict_verify_symbol(name);
+            argnames.forEach(strict_verify_symbol);
+        }
+        S.input.pop_directives_stack();
+        --S.in_function;
+        S.in_loop = loop;
+        S.labels = labels;
         return new ctor({
             name: name,
-            argnames: (function(first, a){
-                while (!is("punc", ")")) {
-                    if (first) first = false; else expect(",");
-                    a.push(as_symbol(AST_SymbolFunarg));
-                }
-                next();
-                return a;
-            })(true, []),
-            body: (function(loop, labels){
-                ++S.in_function;
-                S.in_directives = true;
-                S.in_loop = 0;
-                S.labels = [];
-                var a = block_();
-                --S.in_function;
-                S.in_loop = loop;
-                S.labels = labels;
-                return a;
-            })(S.in_loop, S.labels)
+            argnames: argnames,
+            body: body
         });
     };
 
@@ -1021,7 +1159,10 @@ function parse($TEXT, options) {
             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)) : null,
+                value : is("operator", "=")
+                    ? (next(), expression(false, no_in))
+                    : in_const && S.input.has_directive("use strict")
+                        ? croak("Missing initializer in const declaration") : null,
                 end   : prev()
             }));
             if (!is("punc", ","))
@@ -1047,7 +1188,7 @@ function parse($TEXT, options) {
         });
     };
 
-    var new_ = function() {
+    var new_ = function(allow_calls) {
         var start = S.token;
         expect_token("operator", "new");
         var newexp = expr_atom(false), args;
@@ -1062,19 +1203,26 @@ function parse($TEXT, options) {
             expression : newexp,
             args       : args,
             end        : prev()
-        }), true);
+        }), allow_calls);
     };
 
     function as_atom_node() {
         var tok = S.token, ret;
         switch (tok.type) {
           case "name":
-            return as_symbol(AST_SymbolRef);
+          case "keyword":
+            ret = _make_symbol(AST_SymbolRef);
+            break;
           case "num":
             ret = new AST_Number({ start: tok, end: tok, value: tok.value });
             break;
           case "string":
-            ret = new AST_String({ start: tok, end: tok, value: tok.value });
+            ret = new AST_String({
+                start : tok,
+                end   : tok,
+                value : tok.value,
+                quote : tok.quote
+            });
             break;
           case "regexp":
             ret = new AST_RegExp({ start: tok, end: tok, value: tok.value });
@@ -1092,6 +1240,13 @@ function parse($TEXT, options) {
                 break;
             }
             break;
+          case "operator":
+            if (!is_identifier_string(tok.value)) {
+                croak("Invalid getter/setter name: " + tok.value,
+                    tok.line, tok.col, tok.pos);
+            }
+            ret = _make_symbol(AST_SymbolRef);
+            break;
         }
         next();
         return ret;
@@ -1099,7 +1254,7 @@ function parse($TEXT, options) {
 
     var expr_atom = function(allow_calls) {
         if (is("operator", "new")) {
-            return new_();
+            return new_(allow_calls);
         }
         var start = S.token;
         if (is("punc")) {
@@ -1120,7 +1275,7 @@ function parse($TEXT, options) {
         }
         if (is("keyword", "function")) {
             next();
-            var func = function_(false);
+            var func = function_(AST_Function);
             func.start = start;
             func.end = prev();
             return subscripts(func, allow_calls);
@@ -1153,6 +1308,10 @@ function parse($TEXT, options) {
         });
     });
 
+    var create_accessor = embed_tokens(function() {
+        return function_(AST_Accessor);
+    });
+
     var object_ = embed_tokens(function() {
         expect("{");
         var first = true, a = [];
@@ -1168,8 +1327,8 @@ function parse($TEXT, options) {
                 if (name == "get") {
                     a.push(new AST_ObjectGetter({
                         start : start,
-                        key   : name,
-                        value : function_(false, AST_Accessor),
+                        key   : as_atom_node(),
+                        value : create_accessor(),
                         end   : prev()
                     }));
                     continue;
@@ -1177,8 +1336,8 @@ function parse($TEXT, options) {
                 if (name == "set") {
                     a.push(new AST_ObjectSetter({
                         start : start,
-                        key   : name,
-                        value : function_(false, AST_Accessor),
+                        key   : as_atom_node(),
+                        value : create_accessor(),
                         end   : prev()
                     }));
                     continue;
@@ -1187,6 +1346,7 @@ function parse($TEXT, options) {
             expect(":");
             a.push(new AST_ObjectKeyVal({
                 start : start,
+                quote : start.quote,
                 key   : name,
                 value : expression(false),
                 end   : prev()
@@ -1198,14 +1358,15 @@ function parse($TEXT, options) {
 
     function as_property_name() {
         var tmp = S.token;
-        next();
         switch (tmp.type) {
+          case "operator":
+            if (!KEYWORDS(tmp.value)) unexpected();
           case "num":
           case "string":
           case "name":
-          case "operator":
           case "keyword":
           case "atom":
+            next();
             return tmp.value;
           default:
             unexpected();
@@ -1214,29 +1375,34 @@ function parse($TEXT, options) {
 
     function as_name() {
         var tmp = S.token;
+        if (tmp.type != "name") unexpected();
         next();
-        switch (tmp.type) {
-          case "name":
-          case "operator":
-          case "keyword":
-          case "atom":
-            return tmp.value;
-          default:
-            unexpected();
-        }
+        return tmp.value;
     };
 
+    function _make_symbol(type) {
+        var name = S.token.value;
+        return new (name == "this" ? AST_This : type)({
+            name  : String(name),
+            start : S.token,
+            end   : S.token
+        });
+    };
+
+    function strict_verify_symbol(sym) {
+        if (sym.name == "arguments" || sym.name == "eval")
+            croak("Unexpected " + sym.name + " in strict mode", sym.start.line, sym.start.col, sym.start.pos);
+    }
+
     function as_symbol(type, noerror) {
         if (!is("name")) {
             if (!noerror) croak("Name expected");
             return null;
         }
-        var name = S.token.value;
-        var sym = new (name == "this" ? AST_This : type)({
-            name  : String(S.token.value),
-            start : S.token,
-            end   : S.token
-        });
+        var sym = _make_symbol(type);
+        if (S.input.has_directive("use strict") && sym instanceof AST_SymbolDeclaration) {
+            strict_verify_symbol(sym);
+        }
         next();
         return sym;
     };
@@ -1279,14 +1445,15 @@ function parse($TEXT, options) {
         var start = S.token;
         if (is("operator") && UNARY_PREFIX(start.value)) {
             next();
-            var ex = make_unary(AST_UnaryPrefix, start.value, maybe_unary(allow_calls));
+            handle_regexp();
+            var ex = make_unary(AST_UnaryPrefix, start, maybe_unary(allow_calls));
             ex.start = start;
             ex.end = prev();
             return ex;
         }
         var val = expr_atom(allow_calls);
         while (is("operator") && UNARY_POSTFIX(S.token.value) && !S.token.nlb) {
-            val = make_unary(AST_UnaryPostfix, S.token.value, val);
+            val = make_unary(AST_UnaryPostfix, S.token, val);
             val.start = start;
             val.end = S.token;
             next();
@@ -1294,9 +1461,19 @@ function parse($TEXT, options) {
         return val;
     };
 
-    function make_unary(ctor, op, expr) {
-        if ((op == "++" || op == "--") && !is_assignable(expr))
-            croak("Invalid use of " + op + " operator");
+    function make_unary(ctor, token, expr) {
+        var op = token.value;
+        switch (op) {
+          case "++":
+          case "--":
+            if (!is_assignable(expr))
+                croak("Invalid use of " + op + " operator", token.line, token.col, token.pos);
+            break;
+          case "delete":
+            if (expr instanceof AST_SymbolRef && S.input.has_directive("use strict"))
+                croak("Calling delete on expression not allowed in strict mode", expr.start.line, expr.start.col, expr.start.pos);
+            break;
+        }
         return new ctor({ operator: op, expression: expr });
     };
 
@@ -1334,16 +1511,14 @@ function parse($TEXT, options) {
                 condition   : expr,
                 consequent  : yes,
                 alternative : expression(false, no_in),
-                end         : peek()
+                end         : prev()
             });
         }
         return expr;
     };
 
     function is_assignable(expr) {
-        if (!options.strict) return true;
-        if (expr instanceof AST_This) return false;
-        return (expr instanceof AST_PropAccess || expr instanceof AST_Symbol);
+        return expr instanceof AST_PropAccess || expr instanceof AST_SymbolRef;
     };
 
     var maybe_assign = function(no_in) {
@@ -1367,17 +1542,18 @@ function parse($TEXT, options) {
 
     var expression = function(commas, no_in) {
         var start = S.token;
-        var expr = maybe_assign(no_in);
-        if (commas && is("punc", ",")) {
+        var exprs = [];
+        while (true) {
+            exprs.push(maybe_assign(no_in));
+            if (!commas || !is("punc", ",")) break;
             next();
-            return new AST_Seq({
-                start  : start,
-                car    : expr,
-                cdr    : expression(true, no_in),
-                end    : peek()
-            });
+            commas = true;
         }
-        return expr;
+        return exprs.length == 1 ? exprs[0] : new AST_Sequence({
+            start       : start,
+            expressions : exprs,
+            end         : peek()
+        });
     };
 
     function in_loop(cont) {
@@ -1394,8 +1570,10 @@ function parse($TEXT, options) {
     return (function(){
         var start = S.token;
         var body = [];
+        S.input.push_directives_stack();
         while (!is("eof"))
             body.push(statement());
+        S.input.pop_directives_stack();
         var end = prev();
         var toplevel = options.toplevel;
         if (toplevel) {

lib/propmangle.js

@@ -0,0 +1,263 @@
+/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+
+"use strict";
+
+function find_builtins(reserved) {
+    // NaN will be included due to Number.NaN
+    [
+        "null",
+        "true",
+        "false",
+        "Infinity",
+        "-Infinity",
+        "undefined",
+    ].forEach(add);
+    [ Object, Array, Function, Number,
+      String, Boolean, Error, Math,
+      Date, RegExp
+    ].forEach(function(ctor){
+        Object.getOwnPropertyNames(ctor).map(add);
+        if (ctor.prototype) {
+            Object.getOwnPropertyNames(ctor.prototype).map(add);
+        }
+    });
+    function add(name) {
+        push_uniq(reserved, name);
+    }
+}
+
+function mangle_properties(ast, options) {
+    options = defaults(options, {
+        builtins: false,
+        cache: null,
+        debug: false,
+        keep_quoted: false,
+        only_cache: false,
+        regex: null,
+        reserved: null,
+    });
+
+    var reserved = options.reserved || [];
+    if (!options.builtins) find_builtins(reserved);
+
+    var cache = options.cache;
+    if (cache == null) {
+        cache = {
+            cname: -1,
+            props: new Dictionary()
+        };
+    }
+
+    var regex = options.regex;
+    var keep_quoted = options.keep_quoted;
+
+    // note debug is either false (disabled), or a string of the debug suffix to use (enabled).
+    // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
+    // the same as passing an empty string.
+    var debug = options.debug !== false;
+    var debug_name_suffix;
+    if (debug) {
+        debug_name_suffix = (options.debug === true ? "" : options.debug);
+    }
+
+    var names_to_mangle = [];
+    var unmangleable = [];
+    var to_keep = {};
+
+    // step 1: find candidates to mangle
+    ast.walk(new TreeWalker(function(node){
+        if (node instanceof AST_ObjectKeyVal) {
+            add(node.key, keep_quoted && node.quote);
+        }
+        else if (node instanceof AST_ObjectProperty) {
+            // setter or getter, since KeyVal is handled above
+            add(node.key.name);
+        }
+        else if (node instanceof AST_Dot) {
+            add(node.property);
+        }
+        else if (node instanceof AST_Sub) {
+            addStrings(node.property, keep_quoted);
+        }
+    }));
+
+    // step 2: transform the tree, renaming properties
+    return ast.transform(new TreeTransformer(function(node){
+        if (node instanceof AST_ObjectKeyVal) {
+            if (!(keep_quoted && node.quote))
+                node.key = mangle(node.key);
+        }
+        else if (node instanceof AST_ObjectProperty) {
+            // setter or getter
+            node.key.name = mangle(node.key.name);
+        }
+        else if (node instanceof AST_Dot) {
+            node.property = mangle(node.property);
+        }
+        else if (node instanceof AST_Sub) {
+            if (!keep_quoted)
+                node.property = mangleStrings(node.property);
+        }
+        // else if (node instanceof AST_String) {
+        //     if (should_mangle(node.value)) {
+        //         AST_Node.warn(
+        //             "Found \"{prop}\" property candidate for mangling in an arbitrary string [{file}:{line},{col}]", {
+        //                 file : node.start.file,
+        //                 line : node.start.line,
+        //                 col  : node.start.col,
+        //                 prop : node.value
+        //             }
+        //         );
+        //     }
+        // }
+    }));
+
+    // only function declarations after this line
+
+    function can_mangle(name) {
+        if (unmangleable.indexOf(name) >= 0) return false;
+        if (reserved.indexOf(name) >= 0) return false;
+        if (options.only_cache) {
+            return cache.props.has(name);
+        }
+        if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false;
+        return true;
+    }
+
+    function should_mangle(name) {
+        if (keep_quoted && name in to_keep) return false;
+        if (regex && !regex.test(name)) return false;
+        if (reserved.indexOf(name) >= 0) return false;
+        return cache.props.has(name)
+            || names_to_mangle.indexOf(name) >= 0;
+    }
+
+    function add(name, keep) {
+        if (keep) {
+            to_keep[name] = true;
+            return;
+        }
+
+        if (can_mangle(name))
+            push_uniq(names_to_mangle, name);
+
+        if (!should_mangle(name)) {
+            push_uniq(unmangleable, name);
+        }
+    }
+
+    function mangle(name) {
+        if (!should_mangle(name)) {
+            return name;
+        }
+
+        var mangled = cache.props.get(name);
+        if (!mangled) {
+            if (debug) {
+                // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_.
+                var debug_mangled = "_$" + name + "$" + debug_name_suffix + "_";
+
+                if (can_mangle(debug_mangled) && !(keep_quoted && debug_mangled in to_keep)) {
+                    mangled = debug_mangled;
+                }
+            }
+
+            // either debug mode is off, or it is on and we could not use the mangled name
+            if (!mangled) {
+                // Note: `can_mangle()` does not check if the name collides with the `to_keep` set
+                // (filled with quoted properties when `keep_quoted` is set). Make sure we add this
+                // check so we don't collide with a quoted name.
+                do {
+                    mangled = base54(++cache.cname);
+                } while (!can_mangle(mangled) || keep_quoted && mangled in to_keep);
+            }
+
+            cache.props.set(name, mangled);
+        }
+        return mangled;
+    }
+
+    function addStrings(node, keep) {
+        var out = {};
+        try {
+            (function walk(node){
+                node.walk(new TreeWalker(function(node){
+                    if (node instanceof AST_Sequence) {
+                        walk(node.expressions[node.expressions.length - 1]);
+                        return true;
+                    }
+                    if (node instanceof AST_String) {
+                        add(node.value, keep);
+                        return true;
+                    }
+                    if (node instanceof AST_Conditional) {
+                        walk(node.consequent);
+                        walk(node.alternative);
+                        return true;
+                    }
+                    throw out;
+                }));
+            })(node);
+        } catch(ex) {
+            if (ex !== out) throw ex;
+        }
+    }
+
+    function mangleStrings(node) {
+        return node.transform(new TreeTransformer(function(node){
+            if (node instanceof AST_Sequence) {
+                var last = node.expressions.length - 1;
+                node.expressions[last] = mangleStrings(node.expressions[last]);
+            }
+            else if (node instanceof AST_String) {
+                node.value = mangle(node.value);
+            }
+            else if (node instanceof AST_Conditional) {
+                node.consequent = mangleStrings(node.consequent);
+                node.alternative = mangleStrings(node.alternative);
+            }
+            return node;
+        }));
+    }
+}

lib/scope.js

@@ -51,81 +51,102 @@ function SymbolDef(scope, index, orig) {
     this.global = false;
     this.mangled_name = null;
     this.undeclared = false;
-    this.constant = false;
     this.index = index;
+    this.id = SymbolDef.next_id++;
 };
 
+SymbolDef.next_id = 1;
+
 SymbolDef.prototype = {
     unmangleable: function(options) {
-        return (this.global && !(options && options.toplevel))
+        if (!options) options = {};
+
+        return (this.global && !options.toplevel)
             || this.undeclared
-            || (!(options && options.eval) && (this.scope.uses_eval || this.scope.uses_with));
+            || (!options.eval && (this.scope.uses_eval || this.scope.uses_with))
+            || (options.keep_fnames
+                && (this.orig[0] instanceof AST_SymbolLambda
+                    || this.orig[0] instanceof AST_SymbolDefun));
     },
     mangle: function(options) {
-        if (!this.mangled_name && !this.unmangleable(options)) {
+        var cache = options.cache && options.cache.props;
+        if (this.global && cache && cache.has(this.name)) {
+            this.mangled_name = cache.get(this.name);
+        }
+        else if (!this.mangled_name && !this.unmangleable(options)) {
             var s = this.scope;
-            if (this.orig[0] instanceof AST_SymbolLambda && !options.screw_ie8)
+            var sym = this.orig[0];
+            if (options.ie8 && sym instanceof AST_SymbolLambda)
                 s = s.parent_scope;
-            this.mangled_name = s.next_mangled(options);
+            var def;
+            if (this.defun && (def = this.defun.variables.get(this.name))) {
+                this.mangled_name = def.mangled_name || def.name;
+            } else
+                this.mangled_name = s.next_mangled(options, this);
+            if (this.global && cache) {
+                cache.set(this.name, this.mangled_name);
+            }
         }
     }
 };
 
-AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
-    // This does what ast_add_scope did in UglifyJS v1.
-    //
-    // Part of it could be done at parse time, but it would complicate
-    // the parser (and it's already kinda complex).  It's also worth
-    // having it separated because we might need to call it multiple
-    // times on the same tree.
+AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
+    options = defaults(options, {
+        cache: null,
+        ie8: false,
+    });
 
     // pass 1: setup scope chaining and handle definitions
     var self = this;
     var scope = self.parent_scope = null;
     var labels = new Dictionary();
-    var nesting = 0;
+    var defun = null;
     var tw = new TreeWalker(function(node, descend){
+        if (node instanceof AST_Catch) {
+            var save_scope = scope;
+            scope = new AST_Scope(node);
+            scope.init_scope_vars(save_scope);
+            descend();
+            scope = save_scope;
+            return true;
+        }
         if (node instanceof AST_Scope) {
-            node.init_scope_vars(nesting);
-            var save_scope = node.parent_scope = scope;
+            node.init_scope_vars(scope);
+            var save_scope = scope;
+            var save_defun = defun;
             var save_labels = labels;
-            ++nesting;
-            scope = node;
+            defun = scope = node;
             labels = new Dictionary();
             descend();
-            labels = save_labels;
             scope = save_scope;
-            --nesting;
+            defun = save_defun;
+            labels = save_labels;
             return true;        // don't descend again in TreeWalker
         }
-        if (node instanceof AST_Directive) {
-            node.scope = scope;
-            push_uniq(scope.directives, node.value);
-            return true;
+        if (node instanceof AST_LabeledStatement) {
+            var l = node.label;
+            if (labels.has(l.name)) {
+                throw new Error(string_template("Label {name} defined twice", l));
+            }
+            labels.set(l.name, l);
+            descend();
+            labels.del(l.name);
+            return true;        // no descend again
         }
         if (node instanceof AST_With) {
             for (var s = scope; s; s = s.parent_scope)
                 s.uses_with = true;
             return;
         }
-        if (node instanceof AST_LabeledStatement) {
-            var l = node.label;
-            if (labels.has(l.name))
-                throw new Error(string_template("Label {name} defined twice", l));
-            labels.set(l.name, l);
-            descend();
-            labels.del(l.name);
-            return true;        // no descend again
-        }
         if (node instanceof AST_Symbol) {
             node.scope = scope;
         }
         if (node instanceof AST_Label) {
             node.thedef = node;
-            node.init_scope_vars();
+            node.references = [];
         }
         if (node instanceof AST_SymbolLambda) {
-            scope.def_function(node);
+            defun.def_function(node);
         }
         else if (node instanceof AST_SymbolDefun) {
             // Careful here, the scope where this should be defined is
@@ -133,24 +154,24 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
             // scope when we encounter the AST_Defun node (which is
             // instanceof AST_Scope) but we get to the symbol a bit
             // later.
-            (node.scope = scope.parent_scope).def_function(node);
+            (node.scope = defun.parent_scope).def_function(node);
         }
         else if (node instanceof AST_SymbolVar
-                 || node instanceof AST_SymbolConst) {
-            var def = scope.def_variable(node);
-            def.constant = node instanceof AST_SymbolConst;
-            def.init = tw.parent().value;
+            || node instanceof AST_SymbolConst) {
+            defun.def_variable(node);
+            if (defun !== scope) {
+                node.mark_enclosed(options);
+                var def = scope.find_variable(node);
+                if (node.thedef !== def) {
+                    node.thedef = def;
+                    node.reference(options);
+                }
+            }
         }
         else if (node instanceof AST_SymbolCatch) {
-            // XXX: this is wrong according to ECMA-262 (12.4).  the
-            // `catch` argument name should be visible only inside the
-            // catch block.  For a quick fix AST_Catch should inherit
-            // from AST_Scope.  Keeping it this way because of IE,
-            // which doesn't obey the standard. (it introduces the
-            // identifier in the enclosing scope)
-            scope.def_variable(node);
+            scope.def_variable(node).defun = defun;
         }
-        if (node instanceof AST_LabelRef) {
+        else if (node instanceof AST_LabelRef) {
             var sym = labels.get(node.name);
             if (!sym) throw new Error(string_template("Undefined label {name} [{line},{col}]", {
                 name: node.name,
@@ -173,79 +194,105 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
             func = prev_func;
             return true;
         }
-        if (node instanceof AST_LabelRef) {
-            node.reference();
+        if (node instanceof AST_LoopControl && node.label) {
+            node.label.thedef.references.push(node);
             return true;
         }
         if (node instanceof AST_SymbolRef) {
             var name = node.name;
-            var sym = node.scope.find_variable(name);
-            if (!sym) {
-                var g;
-                if (globals.has(name)) {
-                    g = globals.get(name);
-                } else {
-                    g = new SymbolDef(self, globals.size(), node);
-                    g.undeclared = true;
-                    globals.set(name, g);
+            if (name == "eval" && tw.parent() instanceof AST_Call) {
+                for (var s = node.scope; s && !s.uses_eval; s = s.parent_scope) {
+                    s.uses_eval = true;
                 }
-                node.thedef = g;
-                if (name == "eval" && tw.parent() instanceof AST_Call) {
-                    for (var s = node.scope; s && !s.uses_eval; s = s.parent_scope)
-                        s.uses_eval = true;
-                }
-                if (name == "arguments") {
-                    func.uses_arguments = true;
-                }
-            } else {
-                node.thedef = sym;
             }
-            node.reference();
+            var sym = node.scope.find_variable(name);
+            if (node.scope instanceof AST_Lambda && name == "arguments") {
+                node.scope.uses_arguments = true;
+            }
+            if (!sym) {
+                sym = self.def_global(node);
+            }
+            node.thedef = sym;
+            node.reference(options);
             return true;
         }
     });
     self.walk(tw);
+
+    // pass 3: fix up any scoping issue with IE8
+    if (options.ie8) {
+        self.walk(new TreeWalker(function(node, descend) {
+            if (node instanceof AST_SymbolCatch) {
+                var name = node.name;
+                var refs = node.thedef.references;
+                var scope = node.thedef.defun;
+                var def = scope.find_variable(name) || self.globals.get(name) || scope.def_variable(node);
+                refs.forEach(function(ref) {
+                    ref.thedef = def;
+                    ref.reference(options);
+                });
+                node.thedef = def;
+                return true;
+            }
+        }));
+    }
+
+    if (options.cache) {
+        this.cname = options.cache.cname;
+    }
 });
 
-AST_Scope.DEFMETHOD("init_scope_vars", function(nesting){
-    this.directives = [];     // contains the directives defined in this scope, i.e. "use strict"
-    this.variables = new Dictionary(); // map name to AST_SymbolVar (variables defined in this scope; includes functions)
-    this.functions = new Dictionary(); // map name to AST_SymbolDefun (functions defined in this scope)
-    this.uses_with = false;   // will be set to true if this or some nested scope uses the `with` statement
-    this.uses_eval = false;   // will be set to true if this or nested scope uses the global `eval`
-    this.parent_scope = null; // the parent scope
-    this.enclosed = [];       // a list of variables from this or outer scope(s) that are referenced from this or inner scopes
-    this.cname = -1;          // the current index for mangling functions/variables
-    this.nesting = nesting;   // the nesting level of this scope (0 means toplevel)
+AST_Toplevel.DEFMETHOD("def_global", function(node){
+    var globals = this.globals, name = node.name;
+    if (globals.has(name)) {
+        return globals.get(name);
+    } else {
+        var g = new SymbolDef(this, globals.size(), node);
+        g.undeclared = true;
+        g.global = true;
+        globals.set(name, g);
+        return g;
+    }
 });
 
-AST_Scope.DEFMETHOD("strict", function(){
-    return this.has_directive("use strict");
+AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
+    this.variables = new Dictionary();  // map name to AST_SymbolVar (variables defined in this scope; includes functions)
+    this.functions = new Dictionary();  // map name to AST_SymbolDefun (functions defined in this scope)
+    this.uses_with = false;             // will be set to true if this or some nested scope uses the `with` statement
+    this.uses_eval = false;             // will be set to true if this or nested scope uses the global `eval`
+    this.parent_scope = parent_scope;   // the parent scope
+    this.enclosed = [];                 // a list of variables from this or outer scope(s) that are referenced from this or inner scopes
+    this.cname = -1;                    // the current index for mangling functions/variables
 });
 
 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({
+        name: "arguments",
+        start: this.start,
+        end: this.end
+    }));
 });
 
-AST_SymbolRef.DEFMETHOD("reference", function() {
+AST_Symbol.DEFMETHOD("mark_enclosed", function(options) {
     var def = this.definition();
-    def.references.push(this);
     var s = this.scope;
     while (s) {
         push_uniq(s.enclosed, def);
+        if (options.keep_fnames) {
+            s.functions.each(function(d) {
+                push_uniq(def.scope.enclosed, d);
+            });
+        }
         if (s === def.scope) break;
         s = s.parent_scope;
     }
-    this.frame = this.scope.nesting - def.scope.nesting;
 });
 
-AST_Label.DEFMETHOD("init_scope_vars", function(){
-    this.references = [];
-});
-
-AST_LabelRef.DEFMETHOD("reference", function(){
-    this.thedef.references.push(this);
+AST_Symbol.DEFMETHOD("reference", function(options) {
+    this.definition().references.push(this);
+    this.mark_enclosed(options);
 });
 
 AST_Scope.DEFMETHOD("find_variable", function(name){
@@ -254,11 +301,6 @@ AST_Scope.DEFMETHOD("find_variable", function(name){
         || (this.parent_scope && this.parent_scope.find_variable(name));
 });
 
-AST_Scope.DEFMETHOD("has_directive", function(value){
-    return this.parent_scope && this.parent_scope.has_directive(value)
-        || (this.directives.indexOf(value) >= 0 ? this : null);
-});
-
 AST_Scope.DEFMETHOD("def_function", function(symbol){
     this.functions.set(symbol.name, this.def_variable(symbol));
 });
@@ -281,6 +323,11 @@ AST_Scope.DEFMETHOD("next_mangled", function(options){
     out: while (true) {
         var m = base54(++this.cname);
         if (!is_identifier(m)) continue; // skip over "do"
+
+        // https://github.com/mishoo/UglifyJS2/issues/242 -- do not
+        // shadow a name reserved from mangling.
+        if (options.reserved.indexOf(m) >= 0) continue;
+
         // we must ensure that the mangled name does not shadow a name
         // from some parent scope that is referenced in this or in
         // inner scopes.
@@ -293,9 +340,21 @@ AST_Scope.DEFMETHOD("next_mangled", function(options){
     }
 });
 
-AST_Scope.DEFMETHOD("references", function(sym){
-    if (sym instanceof AST_Symbol) sym = sym.definition();
-    return this.enclosed.indexOf(sym) < 0 ? null : sym;
+AST_Function.DEFMETHOD("next_mangled", function(options, def){
+    // #179, #326
+    // in Safari strict mode, something like (function x(x){...}) is a syntax error;
+    // a function expression's argument cannot shadow the function expression's name
+
+    var tricky_def = def.orig[0] instanceof AST_SymbolFunarg && this.name && this.name.definition();
+
+    // the function's mangled_name is null when keep_fnames is true
+    var tricky_name = tricky_def ? tricky_def.mangled_name || tricky_def.name : null;
+
+    while (true) {
+        var name = AST_Lambda.prototype.next_mangled.call(this, options, def);
+        if (!tricky_name || tricky_name != name)
+            return name;
+    }
 });
 
 AST_Symbol.DEFMETHOD("unmangleable", function(options){
@@ -339,22 +398,35 @@ AST_Symbol.DEFMETHOD("global", function(){
 
 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
     return defaults(options, {
-        except   : [],
-        eval     : false,
-        sort     : false,
-        toplevel : false,
-        screw_ie8 : false
+        eval        : false,
+        ie8         : false,
+        keep_fnames : false,
+        reserved    : [],
+        toplevel    : false,
     });
 });
 
 AST_Toplevel.DEFMETHOD("mangle_names", function(options){
     options = this._default_mangler_options(options);
+
+    // Never mangle arguments
+    options.reserved.push('arguments');
+
     // We only need to mangle declaration nodes.  Special logic wired
     // into the code generator will display the mangled name if it's
     // present (and for AST_SymbolRef-s it'll use the mangled name of
     // the AST_SymbolDeclaration that it points to).
     var lname = -1;
     var to_mangle = [];
+
+    if (options.cache) {
+        this.globals.each(function(symbol){
+            if (options.reserved.indexOf(symbol.name) < 0) {
+                to_mangle.push(symbol);
+            }
+        });
+    }
+
     var tw = new TreeWalker(function(node, descend){
         if (node instanceof AST_LabeledStatement) {
             // lname is incremented when we get to the AST_Label
@@ -366,13 +438,10 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
         if (node instanceof AST_Scope) {
             var p = tw.parent(), a = [];
             node.variables.each(function(symbol){
-                if (options.except.indexOf(symbol.name) < 0) {
+                if (options.reserved.indexOf(symbol.name) < 0) {
                     a.push(symbol);
                 }
             });
-            if (options.sort) a.sort(function(a, b){
-                return b.references.length - a.references.length;
-            });
             to_mangle.push.apply(to_mangle, a);
             return;
         }
@@ -382,9 +451,17 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
             node.mangled_name = name;
             return true;
         }
+        if (!options.ie8 && node instanceof AST_SymbolCatch) {
+            to_mangle.push(node.definition());
+            return;
+        }
     });
     this.walk(tw);
     to_mangle.forEach(function(def){ def.mangle(options) });
+
+    if (options.cache) {
+        options.cache.cname = this.cname;
+    }
 });
 
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
@@ -484,7 +561,9 @@ var base54 = (function() {
     base54.freq = function(){ return frequency };
     function base54(num) {
         var ret = "", base = 54;
+        num++;
         do {
+            num--;
             ret += String.fromCharCode(chars[num % base]);
             num = Math.floor(num / base);
             base = 64;
@@ -493,88 +572,3 @@ var base54 = (function() {
     };
     return base54;
 })();
-
-AST_Toplevel.DEFMETHOD("scope_warnings", function(options){
-    options = defaults(options, {
-        undeclared       : false, // this makes a lot of noise
-        unreferenced     : true,
-        assign_to_global : true,
-        func_arguments   : true,
-        nested_defuns    : true,
-        eval             : true
-    });
-    var tw = new TreeWalker(function(node){
-        if (options.undeclared
-            && node instanceof AST_SymbolRef
-            && node.undeclared())
-        {
-            // XXX: this also warns about JS standard names,
-            // i.e. Object, Array, parseInt etc.  Should add a list of
-            // exceptions.
-            AST_Node.warn("Undeclared symbol: {name} [{file}:{line},{col}]", {
-                name: node.name,
-                file: node.start.file,
-                line: node.start.line,
-                col: node.start.col
-            });
-        }
-        if (options.assign_to_global)
-        {
-            var sym = null;
-            if (node instanceof AST_Assign && node.left instanceof AST_SymbolRef)
-                sym = node.left;
-            else if (node instanceof AST_ForIn && node.init instanceof AST_SymbolRef)
-                sym = node.init;
-            if (sym
-                && (sym.undeclared()
-                    || (sym.global() && sym.scope !== sym.definition().scope))) {
-                AST_Node.warn("{msg}: {name} [{file}:{line},{col}]", {
-                    msg: sym.undeclared() ? "Accidental global?" : "Assignment to global",
-                    name: sym.name,
-                    file: sym.start.file,
-                    line: sym.start.line,
-                    col: sym.start.col
-                });
-            }
-        }
-        if (options.eval
-            && node instanceof AST_SymbolRef
-            && node.undeclared()
-            && node.name == "eval") {
-            AST_Node.warn("Eval is used [{file}:{line},{col}]", node.start);
-        }
-        if (options.unreferenced
-            && (node instanceof AST_SymbolDeclaration || node instanceof AST_Label)
-            && node.unreferenced()) {
-            AST_Node.warn("{type} {name} is declared but not referenced [{file}:{line},{col}]", {
-                type: node instanceof AST_Label ? "Label" : "Symbol",
-                name: node.name,
-                file: node.start.file,
-                line: node.start.line,
-                col: node.start.col
-            });
-        }
-        if (options.func_arguments
-            && node instanceof AST_Lambda
-            && node.uses_arguments) {
-            AST_Node.warn("arguments used in function {name} [{file}:{line},{col}]", {
-                name: node.name ? node.name.name : "anonymous",
-                file: node.start.file,
-                line: node.start.line,
-                col: node.start.col
-            });
-        }
-        if (options.nested_defuns
-            && node instanceof AST_Defun
-            && !(tw.parent() instanceof AST_Scope)) {
-            AST_Node.warn("Function {name} declared in nested statement \"{type}\" [{file}:{line},{col}]", {
-                name: node.name.name,
-                type: tw.parent().TYPE,
-                file: node.start.file,
-                line: node.start.line,
-                col: node.start.col
-            });
-        }
-    });
-    this.walk(tw);
-});

lib/sourcemap.js

@@ -49,26 +49,42 @@ function SourceMap(options) {
         file : null,
         root : null,
         orig : null,
+
+        orig_line_diff : 0,
+        dest_line_diff : 0,
     });
     var generator = new MOZ_SourceMap.SourceMapGenerator({
         file       : options.file,
         sourceRoot : options.root
     });
     var orig_map = options.orig && new MOZ_SourceMap.SourceMapConsumer(options.orig);
+
+    if (orig_map && Array.isArray(options.orig.sources)) {
+        orig_map._sources.toArray().forEach(function(source) {
+            var sourceContent = orig_map.sourceContentFor(source, true);
+            if (sourceContent) {
+                generator.setSourceContent(source, sourceContent);
+            }
+        });
+    }
+
     function add(source, gen_line, gen_col, orig_line, orig_col, name) {
         if (orig_map) {
             var info = orig_map.originalPositionFor({
                 line: orig_line,
                 column: orig_col
             });
+            if (info.source === null) {
+                return;
+            }
             source = info.source;
             orig_line = info.line;
             orig_col = info.column;
-            name = info.name;
+            name = info.name || name;
         }
         generator.addMapping({
-            generated : { line: gen_line, column: gen_col },
-            original  : { line: orig_line, column: orig_col },
+            generated : { line: gen_line + options.dest_line_diff, column: gen_col },
+            original  : { line: orig_line + options.orig_line_diff, column: orig_col },
             source    : source,
             name      : name
         });
@@ -76,6 +92,6 @@ function SourceMap(options) {
     return {
         add        : add,
         get        : function() { return generator },
-        toString   : function() { return generator.toString() }
+        toString   : function() { return JSON.stringify(generator.toJSON()); }
     };
 };

lib/transform.js

@@ -64,13 +64,13 @@ TreeTransformer.prototype = new TreeWalker;
                     x = this;
                     descend(x, tw);
                 } else {
-                    tw.stack[tw.stack.length - 1] = x = this.clone();
+                    tw.stack[tw.stack.length - 1] = x = this;
                     descend(x, tw);
                     y = tw.after(x, in_list);
                     if (y !== undefined) x = y;
                 }
             }
-            tw.pop();
+            tw.pop(this);
             return x;
         });
     };
@@ -159,6 +159,7 @@ TreeTransformer.prototype = new TreeWalker;
     });
 
     _(AST_VarDef, function(self, tw){
+        self.name = self.name.transform(tw);
         if (self.value) self.value = self.value.transform(tw);
     });
 
@@ -173,9 +174,8 @@ TreeTransformer.prototype = new TreeWalker;
         self.args = do_list(self.args, tw);
     });
 
-    _(AST_Seq, function(self, tw){
-        self.car = self.car.transform(tw);
-        self.cdr = self.cdr.transform(tw);
+    _(AST_Sequence, function(self, tw){
+        self.expressions = do_list(self.expressions, tw);
     });
 
     _(AST_Dot, function(self, tw){

lib/utils.js

@@ -59,10 +59,7 @@ function characters(str) {
 };
 
 function member(name, array) {
-    for (var i = array.length; --i >= 0;)
-        if (array[i] == name)
-            return true;
-    return false;
+    return array.indexOf(name) >= 0;
 };
 
 function find_if(func, array) {
@@ -81,31 +78,59 @@ function repeat_string(str, i) {
     return d;
 };
 
+function configure_error_stack(fn) {
+    Object.defineProperty(fn.prototype, "stack", {
+        get: function() {
+            var err = new Error(this.message);
+            err.name = this.name;
+            try {
+                throw err;
+            } catch(e) {
+                return e.stack;
+            }
+        }
+    });
+}
+
 function DefaultsError(msg, defs) {
-    this.msg = msg;
+    this.message = msg;
     this.defs = defs;
 };
+DefaultsError.prototype = Object.create(Error.prototype);
+DefaultsError.prototype.constructor = DefaultsError;
+DefaultsError.prototype.name = "DefaultsError";
+configure_error_stack(DefaultsError);
+
+DefaultsError.croak = function(msg, defs) {
+    throw new DefaultsError(msg, defs);
+};
 
 function defaults(args, defs, croak) {
     if (args === true)
         args = {};
     var ret = args || {};
-    if (croak) for (var i in ret) if (ret.hasOwnProperty(i) && !defs.hasOwnProperty(i))
-        throw new DefaultsError("`" + i + "` is not a supported option", defs);
-    for (var i in defs) if (defs.hasOwnProperty(i)) {
-        ret[i] = (args && args.hasOwnProperty(i)) ? args[i] : defs[i];
+    if (croak) for (var i in ret) if (HOP(ret, i) && !HOP(defs, i))
+        DefaultsError.croak("`" + i + "` is not a supported option", defs);
+    for (var i in defs) if (HOP(defs, i)) {
+        ret[i] = (args && HOP(args, i)) ? args[i] : defs[i];
     }
     return ret;
 };
 
 function merge(obj, ext) {
-    for (var i in ext) if (ext.hasOwnProperty(i)) {
+    var count = 0;
+    for (var i in ext) if (HOP(ext, i)) {
         obj[i] = ext[i];
+        count++;
     }
-    return obj;
+    return count;
 };
 
-function noop() {};
+function noop() {}
+function return_false() { return false; }
+function return_true() { return true; }
+function return_this() { return this; }
+function return_null() { return null; }
 
 var MAP = (function(){
     function MAP(a, f, backwards) {
@@ -141,7 +166,7 @@ var MAP = (function(){
             }
         }
         else {
-            for (i in a) if (a.hasOwnProperty(i)) if (doit()) break;
+            for (i in a) if (HOP(a, i)) if (doit()) break;
         }
         return top.concat(ret);
     };
@@ -162,7 +187,7 @@ function push_uniq(array, el) {
 
 function string_template(text, props) {
     return text.replace(/\{(.+?)\}/g, function(str, p){
-        return props[p];
+        return props && props[p];
     });
 };
 
@@ -221,10 +246,19 @@ function makePredicate(words) {
             }
         cats.push([words[i]]);
     }
+    function quote(word) {
+        return JSON.stringify(word).replace(/[\u2028\u2029]/g, function(s) {
+            switch (s) {
+                case "\u2028": return "\\u2028";
+                case "\u2029": return "\\u2029";
+            }
+            return s;
+        });
+    }
     function compareTo(arr) {
-        if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";";
+        if (arr.length == 1) return f += "return str === " + quote(arr[0]) + ";";
         f += "switch(str){";
-        for (var i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":";
+        for (var i = 0; i < arr.length; ++i) f += "case " + quote(arr[i]) + ":";
         f += "return true}return false;";
     }
     // When there are more than three length categories, an outer
@@ -291,5 +325,38 @@ Dictionary.prototype = {
         for (var i in this._values)
             ret.push(f(this._values[i], i.substr(1)));
         return ret;
-    }
+    },
+    toObject: function() { return this._values }
 };
+Dictionary.fromObject = function(obj) {
+    var dict = new Dictionary();
+    dict._size = merge(dict._values, obj);
+    return dict;
+};
+
+function HOP(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+// return true if the node at the top of the stack (that means the
+// innermost node in the current output) is lexically the first in
+// a statement.
+function first_in_statement(stack) {
+    var node = stack.parent(-1);
+    for (var i = 0, p; p = stack.parent(i); i++) {
+        if (p instanceof AST_Statement && p.body === node)
+            return true;
+        if ((p instanceof AST_Sequence      && p.expressions[0] === node) ||
+            (p instanceof AST_Call          && p.expression === node && !(p instanceof AST_New) ) ||
+            (p instanceof AST_Dot           && p.expression === node ) ||
+            (p instanceof AST_Sub           && p.expression === node ) ||
+            (p instanceof AST_Conditional   && p.condition === node  ) ||
+            (p instanceof AST_Binary        && p.left === node       ) ||
+            (p instanceof AST_UnaryPostfix  && p.expression === node ))
+        {
+            node = p;
+        } else {
+            return false;
+        }
+    }
+}

package.json

@@ -1,26 +1,54 @@
 {
-    "name": "uglify-js",
-    "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
-    "homepage": "http://lisperator.net/uglifyjs",
-    "main": "tools/node.js",
-    "version": "2.3.4",
-    "engines": { "node" : ">=0.4.0" },
-    "maintainers": [{
-        "name": "Mihai Bazon",
-        "email": "mihai.bazon@gmail.com",
-        "web": "http://lisperator.net/"
-    }],
-    "repositories": [{
-        "type": "git",
-        "url": "https://github.com/mishoo/UglifyJS2.git"
-    }],
-    "dependencies": {
-        "async"      : "~0.2.6",
-        "source-map" : "~0.1.7",
-        "optimist"   : "~0.3.5"
-    },
-    "bin": {
-        "uglifyjs" : "bin/uglifyjs"
-    },
-    "scripts": {"test": "node test/run-tests.js"}
+  "name": "uglify-js",
+  "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
+  "homepage": "http://lisperator.net/uglifyjs",
+  "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
+  "license": "BSD-2-Clause",
+  "version": "3.0.0",
+  "engines": {
+    "node": ">=0.8.0"
+  },
+  "maintainers": [
+    "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mishoo/UglifyJS2.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mishoo/UglifyJS2/issues"
+  },
+  "main": "tools/node.js",
+  "bin": {
+    "uglifyjs": "bin/uglifyjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "tools",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "commander": "~2.9.0",
+    "source-map": "~0.5.1"
+  },
+  "devDependencies": {
+    "acorn": "~0.6.0",
+    "escodegen": "~1.3.3",
+    "esfuzz": "~0.3.1",
+    "estraverse": "~1.5.1",
+    "mocha": "~2.3.4"
+  },
+  "optionalDependencies": {
+    "uglify-to-browserify": "~1.0.0"
+  },
+  "browserify": {
+    "transform": [
+      "uglify-to-browserify"
+    ]
+  },
+  "scripts": {
+    "test": "node test/run-tests.js"
+  },
+  "keywords": ["uglify", "uglify-js", "minify", "minifier"]
 }

test/benchmark.js

@@ -0,0 +1,80 @@
+#! /usr/bin/env node
+// -*- js -*-
+
+"use strict";
+
+var createHash = require("crypto").createHash;
+var fork = require("child_process").fork;
+var args = process.argv.slice(2);
+if (!args.length) {
+    args.push("-mc");
+}
+args.push("--stats");
+var urls = [
+    "https://code.jquery.com/jquery-3.2.1.js",
+    "https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.4/angular.js",
+    "https://cdnjs.cloudflare.com/ajax/libs/mathjs/3.9.0/math.js",
+    "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.js",
+    "https://unpkg.com/react@15.3.2/dist/react.js",
+    "http://builds.emberjs.com/tags/v2.11.0/ember.prod.js",
+    "https://cdn.jsdelivr.net/lodash/4.17.4/lodash.js",
+    "https://cdnjs.cloudflare.com/ajax/libs/d3/4.5.0/d3.js",
+];
+var results = {};
+var remaining = 2 * urls.length;
+function done() {
+    if (!--remaining) {
+        var failures = [];
+        urls.forEach(function(url) {
+            var info = results[url];
+            console.log();
+            console.log(url);
+            var elapsed = 0;
+            console.log(info.log.replace(/Elapsed: ([0-9]+)\s*/g, function(match, time) {
+                elapsed += 1e-3 * parseInt(time);
+                return "";
+            }));
+            console.log("Run-time:", elapsed.toFixed(3), "s");
+            console.log("Original:", info.input, "bytes");
+            console.log("Uglified:", info.output, "bytes");
+            console.log("SHA1 sum:", info.sha1);
+            if (info.code) {
+                failures.push(url);
+            }
+        });
+        if (failures.length) {
+            console.error("Benchmark failed:");
+            failures.forEach(function(url) {
+                console.error(url);
+            });
+            process.exit(1);
+        }
+    }
+}
+urls.forEach(function(url) {
+    results[url] = {
+        input: 0,
+        output: 0,
+        log: ""
+    };
+    require(url.slice(0, url.indexOf(":"))).get(url, function(res) {
+        var uglifyjs = fork("bin/uglifyjs", args, { silent: true });
+        res.on("data", function(data) {
+            results[url].input += data.length;
+        }).pipe(uglifyjs.stdin);
+        uglifyjs.stdout.on("data", function(data) {
+            results[url].output += data.length;
+        }).pipe(createHash("sha1")).on("data", function(data) {
+            results[url].sha1 = data.toString("hex");
+            done();
+        });
+        uglifyjs.stderr.setEncoding("utf8");
+        uglifyjs.stderr.on("data", function(data) {
+            results[url].log += data;
+        });
+        uglifyjs.on("exit", function(code) {
+            results[url].code = code;
+            done();
+        });
+    });
+});

test/compress/arrays.js

@@ -1,12 +1,177 @@
 holes_and_undefined: {
     input: {
+        w = [1,,];
         x = [1, 2, undefined];
         y = [1, , 2, ];
         z = [1, undefined, 3];
     }
     expect: {
+        w=[1,,];
         x=[1,2,void 0];
         y=[1,,2];
         z=[1,void 0,3];
     }
 }
+
+constant_join: {
+    options = {
+        unsafe   : true,
+        evaluate : true
+    };
+    input: {
+        var a = [ "foo", "bar", "baz" ].join("");
+        var a1 = [ "foo", "bar", "baz" ].join();
+        var a2 = [ "foo", "bar", "baz" ].join(null);
+        var a3 = [ "foo", "bar", "baz" ].join(void 0);
+        var a4 = [ "foo", , "baz" ].join();
+        var a5 = [ "foo", null, "baz" ].join();
+        var a6 = [ "foo", void 0, "baz" ].join();
+        var b = [ "foo", 1, 2, 3, "bar" ].join("");
+        var c = [ boo(), "foo", 1, 2, 3, "bar", bar() ].join("");
+        var c1 = [ boo(), bar(), "foo", 1, 2, 3, "bar", bar() ].join("");
+        var c2 = [ 1, 2, "foo", "bar", baz() ].join("");
+        var c3 = [ boo() + bar() + "foo", 1, 2, 3, "bar", bar() + "foo" ].join("");
+        var c4 = [ 1, 2, null, undefined, "foo", "bar", baz() ].join("");
+        var c5 = [ boo() + bar() + "foo", 1, 2, 3, "bar", bar() + "foo" ].join();
+        var c6 = [ 1, 2, null, undefined, "foo", "bar", baz() ].join();
+        var d = [ "foo", 1 + 2 + "bar", "baz" ].join("-");
+        var e = [].join(foo + bar);
+        var f = [].join("");
+        var g = [].join("foo");
+    }
+    expect: {
+        var a = "foobarbaz";
+        var a1 = "foo,bar,baz";
+        var a2 = "foonullbarnullbaz";
+        var a3 = "foo,bar,baz";
+        var a4 = "foo,,baz";
+        var a5 = "foo,,baz";
+        var a6 = "foo,,baz";
+        var b = "foo123bar";
+        var c = boo() + "foo123bar" + bar();
+        var c1 = "" + boo() + bar() + "foo123bar" + bar();
+        var c2 = "12foobar" + baz();
+        var c3 = boo() + bar() + "foo123bar" + bar() + "foo";
+        var c4 = "12foobar" + baz();
+        var c5 = [ boo() + bar() + "foo", 1, 2, 3, "bar", bar() + "foo" ].join();
+        var c6 = [ "1,2,,,foo,bar", baz() ].join();
+        var d = "foo-3bar-baz";
+        var e = [].join(foo + bar);
+        var f = "";
+        var g = "";
+    }
+}
+
+constant_join_2: {
+    options = {
+        unsafe   : true,
+        evaluate : true
+    };
+    input: {
+        var a = [ "foo", "bar", boo(), "baz", "x", "y" ].join("");
+        var b = [ "foo", "bar", boo(), "baz", "x", "y" ].join("-");
+        var c = [ "foo", "bar", boo(), "baz", "x", "y" ].join("really-long-separator");
+        var d = [ "foo", "bar", boo(),
+                  [ "foo", 1, 2, 3, "bar" ].join("+"),
+                  "baz", "x", "y" ].join("-");
+        var e = [ "foo", "bar", boo(),
+                  [ "foo", 1, 2, 3, "bar" ].join("+"),
+                  "baz", "x", "y" ].join("really-long-separator");
+        var f = [ "str", "str" + variable, "foo", "bar", "moo" + foo ].join("");
+    }
+    expect: {
+        var a = "foobar" + boo() + "bazxy";
+        var b = [ "foo-bar", boo(), "baz-x-y" ].join("-");
+        var c = [ "foo", "bar", boo(), "baz", "x", "y" ].join("really-long-separator");
+        var d = [ "foo-bar", boo(), "foo+1+2+3+bar-baz-x-y" ].join("-");
+        var e = [ "foo", "bar", boo(),
+                  "foo+1+2+3+bar",
+                  "baz", "x", "y" ].join("really-long-separator");
+        var f = "strstr" + variable + "foobarmoo" + foo;
+    }
+}
+
+constant_join_3: {
+    options = {
+        unsafe: true,
+        evaluate: true,
+    };
+    input: {
+        var a = [ null ].join();
+        var b = [ , ].join();
+        var c = [ , 1, , 3 ].join();
+        var d = [ foo ].join();
+        var e = [ foo, null, undefined, bar ].join("-");
+        var f = [ foo, bar ].join("");
+        var g = [ null, "foo", null, bar + "baz" ].join("");
+        var h = [ null, "foo", null, bar + "baz" ].join("-");
+        var i = [ "foo" + bar, null, baz + "moo" ].join("");
+        var j = [ foo + "bar", baz ].join("");
+        var k = [ foo, "bar" + baz ].join("");
+        var l = [ foo, bar + "baz" ].join("");
+    }
+    expect: {
+        var a = "";
+        var b = "";
+        var c = ",1,,3";
+        var d = "" + foo;
+        var e = [ foo, "-", bar ].join("-");
+        var f = "" + foo + bar;
+        var g = "foo" + bar + "baz";
+        var h = [ "-foo-", bar + "baz" ].join("-");
+        var i = "foo" + bar + baz + "moo";
+        var j = foo + "bar" + baz;
+        var k = foo + "bar" + baz;
+        var l = foo + (bar + "baz");
+    }
+}
+
+for_loop: {
+    options = {
+        unsafe      : true,
+        unused      : true,
+        evaluate    : true,
+        reduce_vars : true
+    };
+    input: {
+        function f0() {
+            var a = [1, 2, 3];
+            for (var i = 0; i < a.length; i++) {
+                console.log(a[i]);
+            }
+        }
+
+        function f1() {
+            var a = [1, 2, 3];
+            for (var i = 0, len = a.length; i < len; i++) {
+                console.log(a[i]);
+            }
+        }
+
+        function f2() {
+            var a = [1, 2, 3];
+            for (var i = 0; i < a.length; i++) {
+                a[i]++;
+            }
+        }
+    }
+    expect: {
+        function f0() {
+            var a = [1, 2, 3];
+            for (var i = 0; i < 3; i++)
+                console.log(a[i]);
+        }
+
+        function f1() {
+            var a = [1, 2, 3];
+            for (var i = 0; i < 3; i++)
+                console.log(a[i]);
+        }
+
+        function f2() {
+            var a = [1, 2, 3];
+            for (var i = 0; i < a.length; i++)
+                a[i]++;
+        }
+    }
+}

test/compress/ascii.js

@@ -0,0 +1,35 @@
+ascii_only_true: {
+    options = {}
+    beautify = {
+        ascii_only : true,
+        ie8        : false,
+        beautify   : false,
+    }
+    input: {
+        function f() {
+            return "\x000\x001\x007\x008\x00" +
+                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" +
+                   "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" +
+                   "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
+        }
+    }
+    expect_exact: 'function f(){return"\\x000\\x001\\x007\\08\\0"+"\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\b\\t\\n\\v\\f\\r\\x0e\\x0f"+"\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f"+\' !"# ... }~\\x7f\\x80\\x81 ... \\xfe\\xff\\u0fff\\uffff\'}'
+}
+
+ascii_only_false: {
+    options = {}
+    beautify = {
+        ascii_only : false,
+        ie8        : false,
+        beautify   : false,
+    }
+    input: {
+        function f() {
+            return "\x000\x001\x007\x008\x00" +
+                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" +
+                   "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" +
+                   "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
+        }
+    }
+    expect_exact: 'function f(){return"\\x000\\x001\\x007\\08\\0"+"\\0\x01\x02\x03\x04\x05\x06\x07\\b\\t\\n\\v\\f\\r\x0e\x0f"+"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"+\' !"# ... }~\x7f\x80\x81 ... \xfe\xff\u0fff\uffff\'}'
+}

test/compress/asm.js

@@ -0,0 +1,106 @@
+asm_mixed: {
+    options = {
+        sequences     : true,
+        properties    : true,
+        dead_code     : true,
+        drop_debugger : true,
+        conditionals  : true,
+        comparisons   : true,
+        evaluate      : true,
+        booleans      : true,
+        loops         : true,
+        unused        : true,
+        hoist_funs    : true,
+        keep_fargs    : true,
+        keep_fnames   : false,
+        hoist_vars    : true,
+        if_return     : true,
+        join_vars     : true,
+        cascade       : true,
+        side_effects  : true,
+        negate_iife   : true
+    };
+    input: {
+        // adapted from http://asmjs.org/spec/latest/
+        function asm_GeometricMean(stdlib, foreign, buffer) {
+          "use asm";
+          var exp = stdlib.Math.exp;
+          var log = stdlib.Math.log;
+          var values = new stdlib.Float64Array(buffer);
+          function logSum(start, end) {
+            start = start|0;
+            end = end|0;
+            var sum = 0.0, p = 0, q = 0;
+            // asm.js forces byte addressing of the heap by requiring shifting by 3
+            for (p = start << 3, q = end << 3; (p|0) < (q|0); p = (p + 8)|0) {
+              sum = sum + +log(values[p>>3]);
+            }
+            return +sum;
+          }
+          function geometricMean(start, end) {
+            start = start|0;
+            end = end|0;
+            return +exp(+logSum(start, end) / +((end - start)|0));
+          }
+          return { geometricMean: geometricMean };
+        }
+        function no_asm_GeometricMean(stdlib, foreign, buffer) {
+          var exp = stdlib.Math.exp;
+          var log = stdlib.Math.log;
+          var values = new stdlib.Float64Array(buffer);
+          function logSum(start, end) {
+            start = start|0;
+            end = end|0;
+            var sum = 0.0, p = 0, q = 0;
+            // asm.js forces byte addressing of the heap by requiring shifting by 3
+            for (p = start << 3, q = end << 3; (p|0) < (q|0); p = (p + 8)|0) {
+              sum = sum + +log(values[p>>3]);
+            }
+            return +sum;
+          }
+          function geometricMean(start, end) {
+            start = start|0;
+            end = end|0;
+            return +exp(+logSum(start, end) / +((end - start)|0));
+          }
+          return { geometricMean: geometricMean };
+        }
+    }
+    expect: {
+        function asm_GeometricMean(stdlib, foreign, buffer) {
+            "use asm";
+            var exp = stdlib.Math.exp;
+            var log = stdlib.Math.log;
+            var values = new stdlib.Float64Array(buffer);
+            function logSum(start, end) {
+                start = start | 0;
+                end = end | 0;
+                var sum = 0.0, p = 0, q = 0;
+                for (p = start << 3, q = end << 3; (p | 0) < (q | 0); p = p + 8 | 0) {
+                    sum = sum + +log(values[p >> 3]);
+                }
+                return +sum;
+            }
+            function geometricMean(start, end) {
+                start = start | 0;
+                end = end | 0;
+                return +exp(+logSum(start, end) / +(end - start | 0));
+            }
+            return { geometricMean: geometricMean };
+        }
+        function no_asm_GeometricMean(stdlib, foreign, buffer) {
+            function logSum(start, end) {
+                start |= 0, end |= 0;
+                var sum = 0, p = 0, q = 0;
+                for (p = start << 3, q = end << 3; (0 | p) < (0 | q); p = p + 8 | 0) sum += +log(values[p >> 3]);
+                return +sum;
+            }
+            function geometricMean(start, end) {
+                return start |= 0, end |= 0, +exp(+logSum(start, end) / +(end - start | 0));
+            }
+            var exp = stdlib.Math.exp, log = stdlib.Math.log, values = new stdlib.Float64Array(buffer);
+            return { geometricMean: geometricMean };
+        }
+    }
+}
+

test/compress/assignment.js

@@ -0,0 +1,238 @@
+op_equals_left_local_var: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var x;
+
+        x = x +   3;
+        x = x -   3;
+        x = x /   3;
+        x = x *   3;
+        x = x >>  3;
+        x = x <<  3;
+        x = x >>> 3;
+        x = x |   3;
+        x = x ^   3;
+        x = x %   3;
+        x = x &   3;
+
+        x = x +   g();
+        x = x -   g();
+        x = x /   g();
+        x = x *   g();
+        x = x >>  g();
+        x = x <<  g();
+        x = x >>> g();
+        x = x |   g();
+        x = x ^   g();
+        x = x %   g();
+        x = x &   g();
+    }
+    expect: {
+        var x;
+
+        x   += 3;
+        x   -= 3;
+        x   /= 3;
+        x   *= 3;
+        x  >>= 3;
+        x  <<= 3;
+        x >>>= 3;
+        x   |= 3;
+        x   ^= 3;
+        x   %= 3;
+        x   &= 3;
+
+        x   += g();
+        x   -= g();
+        x   /= g();
+        x   *= g();
+        x  >>= g();
+        x  <<= g();
+        x >>>= g();
+        x   |= g();
+        x   ^= g();
+        x   %= g();
+        x   &= g();
+    }
+}
+
+op_equals_right_local_var: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var x;
+
+        x = (x -= 2) ^ x;
+
+        x = 3 +   x;
+        x = 3 -   x;
+        x = 3 /   x;
+        x = 3 *   x;
+        x = 3 >>  x;
+        x = 3 <<  x;
+        x = 3 >>> x;
+        x = 3 |   x;
+        x = 3 ^   x;
+        x = 3 %   x;
+        x = 3 &   x;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+    expect: {
+        var x;
+
+        x = (x -= 2) ^ x;
+
+        x = 3 + x;
+        x = 3 - x;
+        x = 3 / x;
+        x *= 3;
+        x = 3 >> x;
+        x = 3 << x;
+        x = 3 >>> x;
+        x |= 3;
+        x ^= 3;
+        x = 3 % x;
+        x &= 3;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+}
+op_equals_left_global_var: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        x = x +   3;
+        x = x -   3;
+        x = x /   3;
+        x = x *   3;
+        x = x >>  3;
+        x = x <<  3;
+        x = x >>> 3;
+        x = x |   3;
+        x = x ^   3;
+        x = x %   3;
+        x = x &   3;
+
+        x = x +   g();
+        x = x -   g();
+        x = x /   g();
+        x = x *   g();
+        x = x >>  g();
+        x = x <<  g();
+        x = x >>> g();
+        x = x |   g();
+        x = x ^   g();
+        x = x %   g();
+        x = x &   g();
+    }
+    expect: {
+        x   += 3;
+        x   -= 3;
+        x   /= 3;
+        x   *= 3;
+        x  >>= 3;
+        x  <<= 3;
+        x >>>= 3;
+        x   |= 3;
+        x   ^= 3;
+        x   %= 3;
+        x   &= 3;
+
+        x   += g();
+        x   -= g();
+        x   /= g();
+        x   *= g();
+        x  >>= g();
+        x  <<= g();
+        x >>>= g();
+        x   |= g();
+        x   ^= g();
+        x   %= g();
+        x   &= g();
+    }
+}
+
+op_equals_right_global_var: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        x = (x -= 2) ^ x;
+
+        x = 3 +   x;
+        x = 3 -   x;
+        x = 3 /   x;
+        x = 3 *   x;
+        x = 3 >>  x;
+        x = 3 <<  x;
+        x = 3 >>> x;
+        x = 3 |   x;
+        x = 3 ^   x;
+        x = 3 %   x;
+        x = 3 &   x;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+    expect: {
+        x = (x -= 2) ^ x;
+
+        x = 3 +   x;
+        x = 3 -   x;
+        x = 3 /   x;
+        x *= 3;
+        x = 3 >>  x;
+        x = 3 <<  x;
+        x = 3 >>> x;
+        x |= 3;
+        x ^= 3;
+        x = 3 %   x;
+        x &= 3;
+
+        x = g() +   x;
+        x = g() -   x;
+        x = g() /   x;
+        x = g() *   x;
+        x = g() >>  x;
+        x = g() <<  x;
+        x = g() >>> x;
+        x = g() |   x;
+        x = g() ^   x;
+        x = g() %   x;
+        x = g() &   x;
+    }
+}

test/compress/comparing.js

@@ -0,0 +1,76 @@
+keep_comparisons: {
+    options = {
+        comparisons: true,
+        unsafe_comps: false
+    }
+    input: {
+        var obj1 = {
+            valueOf: function() {triggeredFirst();}
+        }
+        var obj2 = {
+            valueOf: function() {triggeredSecond();}
+        }
+        var result1 = obj1 <= obj2;
+        var result2 = obj1 <  obj2;
+        var result3 = obj1 >= obj2;
+        var result4 = obj1 >  obj2;
+    }
+    expect: {
+        var obj1 = {
+            valueOf: function() {triggeredFirst();}
+        }
+        var obj2 = {
+            valueOf: function() {triggeredSecond();}
+        }
+        var result1 = obj1 <= obj2;
+        var result2 = obj1 <  obj2;
+        var result3 = obj1 >= obj2;
+        var result4 = obj1 >  obj2;
+    }
+}
+
+keep_comparisons_with_unsafe_comps: {
+    options = {
+        comparisons: true,
+        unsafe_comps: true
+    }
+    input: {
+        var obj1 = {
+            valueOf: function() {triggeredFirst();}
+        }
+        var obj2 = {
+            valueOf: function() {triggeredSecond();}
+        }
+        var result1 = obj1 <= obj2;
+        var result2 = obj1 <  obj2;
+        var result3 = obj1 >= obj2;
+        var result4 = obj1 >  obj2;
+    }
+    expect: {
+        var obj1 = {
+            valueOf: function() {triggeredFirst();}
+        }
+        var obj2 = {
+            valueOf: function() {triggeredSecond();}
+        }
+        var result1 = obj2 >= obj1;
+        var result2 = obj2 >  obj1;
+        var result3 = obj1 >= obj2;
+        var result4 = obj1 >  obj2;
+    }
+}
+
+dont_change_in_or_instanceof_expressions: {
+    input: {
+        1 in 1;
+        null in null;
+        1 instanceof 1;
+        null instanceof null;
+    }
+    expect: {
+        1 in 1;
+        null in null;
+        1 instanceof 1;
+        null instanceof null;
+    }
+}

test/compress/concat-strings.js

@@ -0,0 +1,223 @@
+concat_1: {
+    options = {
+        evaluate: true
+    };
+    input: {
+        var a = "foo" + "bar" + x() + "moo" + "foo" + y() + "x" + "y" + "z" + q();
+        var b = "foo" + 1 + x() + 2 + "boo";
+        var c = 1 + x() + 2 + "boo";
+
+        // this CAN'T safely be shortened to 1 + x() + "5boo"
+        var d = 1 + x() + 2 + 3 + "boo";
+
+        var e = 1 + x() + 2 + "X" + 3 + "boo";
+
+        // be careful with concatentation with "\0" with octal-looking strings.
+        var f = "\0" + 360 + "\0" + 8 + "\0";
+    }
+    expect: {
+        var a = "foobar" + x() + "moofoo" + y() + "xyz" + q();
+        var b = "foo1" + x() + "2boo";
+        var c = 1 + x() + 2 + "boo";
+        var d = 1 + x() + 2 + 3 + "boo";
+        var e = 1 + x() + 2 + "X3boo";
+        var f = "\x00360\08\0";
+    }
+}
+
+concat_2: {
+    options = {};
+    input: {
+        console.log(
+            1 + (2 + 3),
+            1 + (2 + "3"),
+            1 + ("2" + 3),
+            1 + ("2" + "3"),
+            "1" + (2 + 3),
+            "1" + (2 + "3"),
+            "1" + ("2" + 3),
+            "1" + ("2" + "3")
+        );
+    }
+    expect: {
+        console.log(
+            1 + (2 + 3),
+            1 + (2 + "3"),
+            1 + "2" + 3,
+            1 + "2" + "3",
+            "1" + (2 + 3),
+            "1" + 2 + "3",
+            "1" + "2" + 3,
+            "1" + "2" + "3"
+        );
+    }
+    expect_stdout: true
+}
+
+concat_3: {
+    options = {};
+    input: {
+        console.log(
+            1 + 2 + (3 + 4 + 5),
+            1 + 2 + (3 + 4 + "5"),
+            1 + 2 + (3 + "4" + 5),
+            1 + 2 + (3 + "4" + "5"),
+            1 + 2 + ("3" + 4 + 5),
+            1 + 2 + ("3" + 4 + "5"),
+            1 + 2 + ("3" + "4" + 5),
+            1 + 2 + ("3" + "4" + "5")
+        );
+    }
+    expect: {
+        console.log(
+            1 + 2 + (3 + 4 + 5),
+            1 + 2 + (3 + 4 + "5"),
+            1 + 2 + (3 + "4") + 5,
+            1 + 2 + (3 + "4") + "5",
+            1 + 2 + "3" + 4 + 5,
+            1 + 2 + "3" + 4 + "5",
+            1 + 2 + "3" + "4" + 5,
+            1 + 2 + "3" + "4" + "5"
+        );
+    }
+    expect_stdout: true
+}
+
+concat_4: {
+    options = {};
+    input: {
+        console.log(
+            1 + "2" + (3 + 4 + 5),
+            1 + "2" + (3 + 4 + "5"),
+            1 + "2" + (3 + "4" + 5),
+            1 + "2" + (3 + "4" + "5"),
+            1 + "2" + ("3" + 4 + 5),
+            1 + "2" + ("3" + 4 + "5"),
+            1 + "2" + ("3" + "4" + 5),
+            1 + "2" + ("3" + "4" + "5")
+        );
+    }
+    expect: {
+        console.log(
+            1 + "2" + (3 + 4 + 5),
+            1 + "2" + (3 + 4) + "5",
+            1 + "2" + 3 + "4" + 5,
+            1 + "2" + 3 + "4" + "5",
+            1 + "2" + "3" + 4 + 5,
+            1 + "2" + "3" + 4 + "5",
+            1 + "2" + "3" + "4" + 5,
+            1 + "2" + "3" + "4" + "5"
+        );
+    }
+    expect_stdout: true
+}
+
+concat_5: {
+    options = {};
+    input: {
+        console.log(
+            "1" + 2 + (3 + 4 + 5),
+            "1" + 2 + (3 + 4 + "5"),
+            "1" + 2 + (3 + "4" + 5),
+            "1" + 2 + (3 + "4" + "5"),
+            "1" + 2 + ("3" + 4 + 5),
+            "1" + 2 + ("3" + 4 + "5"),
+            "1" + 2 + ("3" + "4" + 5),
+            "1" + 2 + ("3" + "4" + "5")
+        );
+    }
+    expect: {
+        console.log(
+            "1" + 2 + (3 + 4 + 5),
+            "1" + 2 + (3 + 4) + "5",
+            "1" + 2 + 3 + "4" + 5,
+            "1" + 2 + 3 + "4" + "5",
+            "1" + 2 + "3" + 4 + 5,
+            "1" + 2 + "3" + 4 + "5",
+            "1" + 2 + "3" + "4" + 5,
+            "1" + 2 + "3" + "4" + "5"
+        );
+    }
+    expect_stdout: true
+}
+
+concat_6: {
+    options = {};
+    input: {
+        console.log(
+            "1" + "2" + (3 + 4 + 5),
+            "1" + "2" + (3 + 4 + "5"),
+            "1" + "2" + (3 + "4" + 5),
+            "1" + "2" + (3 + "4" + "5"),
+            "1" + "2" + ("3" + 4 + 5),
+            "1" + "2" + ("3" + 4 + "5"),
+            "1" + "2" + ("3" + "4" + 5),
+            "1" + "2" + ("3" + "4" + "5")
+        );
+    }
+    expect: {
+        console.log(
+            "1" + "2" + (3 + 4 + 5),
+            "1" + "2" + (3 + 4) + "5",
+            "1" + "2" + 3 + "4" + 5,
+            "1" + "2" + 3 + "4" + "5",
+            "1" + "2" + "3" + 4 + 5,
+            "1" + "2" + "3" + 4 + "5",
+            "1" + "2" + "3" + "4" + 5,
+            "1" + "2" + "3" + "4" + "5"
+        );
+    }
+    expect_stdout: true
+}
+
+concat_7: {
+    input: {
+        console.log(
+            "" + 1,
+            "" + "1",
+            "" + 1 + 2,
+            "" + 1 + "2",
+            "" + "1" + 2,
+            "" + "1" + "2",
+            "" + (x += "foo")
+        );
+    }
+    expect: {
+        console.log(
+            "" + 1,
+            "1",
+            "" + 1 + 2,
+            1 + "2",
+            "1" + 2,
+            "1" + "2",
+            x += "foo"
+        );
+    }
+    expect_stdout: true
+}
+
+concat_8: {
+    input: {
+        console.log(
+            1 + "",
+            "1" + "",
+            1 + 2 + "",
+            1 + "2" + "",
+            "1" + 2 + "",
+            "1" + "2" + "",
+            (x += "foo") + ""
+        );
+    }
+    expect: {
+        console.log(
+            1 + "",
+            "1",
+            1 + 2 + "",
+            1 + "2",
+            "1" + 2,
+            "1" + "2",
+            x += "foo"
+        );
+    }
+    expect_stdout: true
+}

test/compress/conditionals.js

@@ -50,9 +50,11 @@ ifs_3_should_warn: {
         conditionals : true,
         dead_code    : true,
         evaluate     : true,
-        booleans     : true
+        booleans     : true,
+        side_effects : true,
     };
     input: {
+        var x, y;
         if (x && !(x + "1") && y) { // 1
             var qq;
             foo();
@@ -68,6 +70,7 @@ ifs_3_should_warn: {
         }
     }
     expect: {
+        var x, y;
         var qq; bar();          // 1
         var jj; foo();          // 2
     }
@@ -84,7 +87,9 @@ ifs_4: {
             x(foo)[10].bar.baz = something_else();
     }
     expect: {
-        x(foo)[10].bar.baz = (foo && bar) ? something() : something_else();
+        foo && bar
+            ? x(foo)[10].bar.baz = something()
+            : x(foo)[10].bar.baz = something_else();
     }
 }
 
@@ -131,13 +136,882 @@ ifs_6: {
         comparisons: true
     };
     input: {
+        var x, y;
         if (!foo && !bar && !baz && !boo) {
             x = 10;
         } else {
             x = 20;
         }
+        if (y) {
+            x[foo] = 10;
+        } else {
+            x[foo] = 20;
+        }
+        if (foo) {
+            x[bar] = 10;
+        } else {
+            x[bar] = 20;
+        }
     }
     expect: {
+        var x, y;
         x = foo || bar || baz || boo ? 20 : 10;
+        x[foo] = y ? 10 : 20;
+        foo ? x[bar] = 10 : x[bar] = 20;
     }
 }
+
+cond_1: {
+    options = {
+        conditionals: true
+    };
+    input: {
+        var do_something; // if undeclared it's assumed to have side-effects
+        if (some_condition()) {
+            do_something(x);
+        } else {
+            do_something(y);
+        }
+        if (some_condition()) {
+            side_effects(x);
+        } else {
+            side_effects(y);
+        }
+    }
+    expect: {
+        var do_something;
+        do_something(some_condition() ? x : y);
+        some_condition() ? side_effects(x) : side_effects(y);
+    }
+}
+
+cond_2: {
+    options = {
+        conditionals: true
+    };
+    input: {
+        var x, FooBar;
+        if (some_condition()) {
+            x = new FooBar(1);
+        } else {
+            x = new FooBar(2);
+        }
+    }
+    expect: {
+        var x, FooBar;
+        x = new FooBar(some_condition() ? 1 : 2);
+    }
+}
+
+cond_3: {
+    options = {
+        conditionals: true
+    };
+    input: {
+        var FooBar;
+        if (some_condition()) {
+            new FooBar(1);
+        } else {
+            FooBar(2);
+        }
+    }
+    expect: {
+        var FooBar;
+        some_condition() ? new FooBar(1) : FooBar(2);
+    }
+}
+
+cond_4: {
+    options = {
+        conditionals: true
+    };
+    input: {
+        var do_something;
+        if (some_condition()) {
+            do_something();
+        } else {
+            do_something();
+        }
+        if (some_condition()) {
+            side_effects();
+        } else {
+            side_effects();
+        }
+    }
+    expect: {
+        var do_something;
+        some_condition(), do_something();
+        some_condition(), side_effects();
+    }
+}
+
+cond_5: {
+    options = {
+        conditionals: true
+    };
+    input: {
+        if (some_condition()) {
+            if (some_other_condition()) {
+                do_something();
+            } else {
+                alternate();
+            }
+        } else {
+            alternate();
+        }
+
+        if (some_condition()) {
+            if (some_other_condition()) {
+                do_something();
+            }
+        }
+    }
+    expect: {
+        some_condition() && some_other_condition() ? do_something() : alternate();
+        some_condition() && some_other_condition() && do_something();
+    }
+}
+
+cond_7: {
+    options = {
+        conditionals: true,
+        evaluate    : true,
+        side_effects: true,
+    };
+    input: {
+        var x, y, z, a, b;
+        // compress these
+        if (y) {
+            x = 1+1;
+        } else {
+            x = 2;
+        }
+
+        if (y) {
+            x = 1+1;
+        } else if (z) {
+            x = 2;
+        } else {
+            x = 3-1;
+        }
+
+        x = y ? 'foo' : 'fo'+'o';
+
+        x = y ? 'foo' : y ? 'foo' : 'fo'+'o';
+
+        // Compress conditions that have side effects
+        if (condition()) {
+            x = 10+10;
+        } else {
+            x = 20;
+        }
+
+        if (z) {
+            x = 'fuji';
+        } else if (condition()) {
+            x = 'fu'+'ji';
+        } else {
+            x = 'fuji';
+        }
+
+        x = condition() ? 'foobar' : 'foo'+'bar';
+
+        // don't compress these
+        x = y ? a : b;
+
+        x = y ? 'foo' : 'fo';
+    }
+    expect: {
+        var x, y, z, a, b;
+        x = 2;
+        x = 2;
+        x = 'foo';
+        x = 'foo';
+        x = (condition(), 20);
+        x = z ? 'fuji' : (condition(), 'fuji');
+        x = (condition(), 'foobar');
+        x = y ? a : b;
+        x = y ? 'foo' : 'fo';
+    }
+}
+
+cond_7_1: {
+    options = {
+        conditionals: true,
+        evaluate    : true
+    };
+    input: {
+        var x;
+        // access to global should be assumed to have side effects
+        if (y) {
+            x = 1+1;
+        } else {
+            x = 2;
+        }
+    }
+    expect: {
+        var x;
+        x = (y, 2);
+    }
+}
+
+cond_8: {
+    options = {
+        conditionals: true,
+        evaluate    : true,
+        booleans    : false
+    };
+    input: {
+        var a;
+        // compress these
+        a = condition ? true : false;
+        a = !condition ? true : false;
+        a = condition() ? true : false;
+
+        a = condition ? !0 : !1;
+        a = !condition ? !null : !2;
+        a = condition() ? !0 : !-3.5;
+
+        if (condition) {
+            a = true;
+        } else {
+            a = false;
+        }
+
+        if (condition) {
+            a = !0;
+        } else {
+            a = !1;
+        }
+
+        a = condition ? false : true;
+        a = !condition ? false : true;
+        a = condition() ? false : true;
+
+        a = condition ? !3 : !0;
+        a = !condition ? !2 : !0;
+        a = condition() ? !1 : !0;
+
+        if (condition) {
+            a = false;
+        } else {
+            a = true;
+        }
+
+        if (condition) {
+            a = !1;
+        } else {
+            a = !0;
+        }
+
+        // don't compress these
+        a = condition ? 1 : false;
+        a = !condition ? true : 0;
+        a = condition ? 1 : 0;
+    }
+    expect: {
+        var a;
+        a = !!condition;
+        a = !condition;
+        a = !!condition();
+
+        a = !!condition;
+        a = !condition;
+        a = !!condition();
+
+        a = !!condition;
+        a = !!condition;
+
+        a = !condition;
+        a = !!condition;
+        a = !condition();
+
+        a = !condition;
+        a = !!condition;
+        a = !condition();
+
+        a = !condition;
+        a = !condition;
+
+        a = !!condition && 1;
+        a = !condition || 0;
+        a = condition ? 1 : 0;
+    }
+}
+
+cond_8b: {
+    options = {
+        conditionals: true,
+        evaluate    : true,
+        booleans    : true
+    };
+    input: {
+        var a;
+        // compress these
+        a = condition ? true : false;
+        a = !condition ? true : false;
+        a = condition() ? true : false;
+
+        a = condition ? !0 : !1;
+        a = !condition ? !null : !2;
+        a = condition() ? !0 : !-3.5;
+
+        if (condition) {
+            a = true;
+        } else {
+            a = false;
+        }
+
+        if (condition) {
+            a = !0;
+        } else {
+            a = !1;
+        }
+
+        a = condition ? false : true;
+        a = !condition ? false : true;
+        a = condition() ? false : true;
+
+        a = condition ? !3 : !0;
+        a = !condition ? !2 : !0;
+        a = condition() ? !1 : !0;
+
+        if (condition) {
+            a = false;
+        } else {
+            a = true;
+        }
+
+        if (condition) {
+            a = !1;
+        } else {
+            a = !0;
+        }
+
+        a = condition ? 1 : false;
+        a = !condition ? true : 0;
+        a = condition ? 1 : 0;
+    }
+    expect: {
+        var a;
+        a = !!condition;
+        a = !condition;
+        a = !!condition();
+
+        a = !!condition;
+        a = !condition;
+        a = !!condition();
+
+        a = !!condition;
+        a = !!condition;
+
+        a = !condition;
+        a = !!condition;
+        a = !condition();
+
+        a = !condition;
+        a = !!condition;
+        a = !condition();
+
+        a = !condition;
+        a = !condition;
+
+        a = !!condition && 1;
+        a = !condition || 0;
+        a = condition ? 1 : 0;
+    }
+}
+
+cond_8c: {
+    options = {
+        conditionals: true,
+        evaluate    : false,
+        booleans    : false
+    };
+    input: {
+        var a;
+        // compress these
+        a = condition ? true : false;
+        a = !condition ? true : false;
+        a = condition() ? true : false;
+
+        a = condition ? !0 : !1;
+        a = !condition ? !null : !2;
+        a = condition() ? !0 : !-3.5;
+
+        if (condition) {
+            a = true;
+        } else {
+            a = false;
+        }
+
+        if (condition) {
+            a = !0;
+        } else {
+            a = !1;
+        }
+
+        a = condition ? false : true;
+        a = !condition ? false : true;
+        a = condition() ? false : true;
+
+        a = condition ? !3 : !0;
+        a = !condition ? !2 : !0;
+        a = condition() ? !1 : !0;
+
+        if (condition) {
+            a = false;
+        } else {
+            a = true;
+        }
+
+        if (condition) {
+            a = !1;
+        } else {
+            a = !0;
+        }
+
+        a = condition ? 1 : false;
+        a = !condition ? true : 0;
+        a = condition ? 1 : 0;
+    }
+    expect: {
+        var a;
+        a = !!condition;
+        a = !condition;
+        a = !!condition();
+
+        a = !!condition;
+        a = !condition;
+        a = !!condition() || !-3.5;
+
+        a = !!condition;
+        a = !!condition;
+
+        a = !condition;
+        a = !!condition;
+        a = !condition();
+
+        a = !condition;
+        a = !!condition;
+        a = !condition();
+
+        a = !condition;
+        a = !condition;
+
+        a = !!condition && 1;
+        a = !condition || 0;
+        a = condition ? 1 : 0;
+    }
+}
+
+ternary_boolean_consequent: {
+    options = {
+        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
+        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+    }
+    input: {
+        function f1() { return a == b ? true : x; }
+        function f2() { return a == b ? false : x; }
+        function f3() { return a < b ? !0 : x; }
+        function f4() { return a < b ? !1 : x; }
+        function f5() { return c ? !0 : x; }
+        function f6() { return c ? false : x; }
+        function f7() { return !c ? true : x; }
+        function f8() { return !c ? !1 : x; }
+    }
+    expect: {
+        function f1() { return a == b || x; }
+        function f2() { return a != b && x; }
+        function f3() { return a < b || x; }
+        function f4() { return !(a < b) && x; }
+        function f5() { return !!c || x; }
+        function f6() { return !c && x; }
+        function f7() { return !c || x; }
+        function f8() { return !!c && x; }
+    }
+}
+
+ternary_boolean_alternative: {
+    options = {
+        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
+        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+    }
+    input: {
+        function f1() { return a == b ? x : true; }
+        function f2() { return a == b ? x : false; }
+        function f3() { return a < b ? x : !0; }
+        function f4() { return a < b ? x : !1; }
+        function f5() { return c ? x : true; }
+        function f6() { return c ? x : !1; }
+        function f7() { return !c ? x : !0; }
+        function f8() { return !c ? x : false; }
+    }
+    expect: {
+        function f1() { return a != b || x; }
+        function f2() { return a == b && x; }
+        function f3() { return !(a < b) || x; }
+        function f4() { return a < b && x; }
+        function f5() { return !c || x; }
+        function f6() { return !!c && x; }
+        function f7() { return !!c || x; }
+        function f8() { return !c && x; }
+    }
+}
+
+trivial_boolean_ternary_expressions : {
+    options = {
+        conditionals: true,
+        evaluate    : true,
+        booleans    : true
+    };
+    input: {
+        f('foo' in m ? true  : false);
+        f('foo' in m ? false : true);
+
+        f(g       ? true : false);
+        f(foo()   ? true : false);
+        f("bar"   ? true : false);
+        f(5       ? true : false);
+        f(5.7     ? true : false);
+        f(x - y   ? true : false);
+
+        f(x == y  ? true : false);
+        f(x === y ?   !0 :    !1);
+        f(x < y   ?   !0 : false);
+        f(x <= y  ? true : false);
+        f(x > y   ? true :    !1);
+        f(x >= y  ?   !0 :    !1);
+
+        f(g       ? false : true);
+        f(foo()   ? false : true);
+        f("bar"   ? false : true);
+        f(5       ? false : true);
+        f(5.7     ? false : true);
+        f(x - y   ? false : true);
+
+        f(x == y  ?    !1 :   !0);
+        f(x === y ? false : true);
+
+        f(x < y   ? false : true);
+        f(x <= y  ? false :   !0);
+        f(x > y   ?    !1 : true);
+        f(x >= y  ?    !1 :   !0);
+    }
+    expect: {
+        f('foo' in m);
+        f(!('foo' in m));
+
+        f(!!g);
+        f(!!foo());
+        f(!0);
+        f(!0);
+        f(!0);
+        f(!!(x - y));
+
+        f(x == y);
+        f(x === y);
+        f(x < y);
+        f(x <= y);
+        f(x > y);
+        f(x >= y);
+
+        f(!g);
+        f(!foo());
+        f(!1);
+        f(!1);
+        f(!1);
+        f(!(x - y));
+
+        f(x != y);
+        f(x !== y);
+
+        f(!(x < y));
+        f(!(x <= y));
+        f(!(x > y));
+        f(!(x >= y));
+    }
+}
+
+issue_1154: {
+    options = {
+        conditionals: true,
+        evaluate    : true,
+        booleans    : true,
+        side_effects: true,
+    };
+    input: {
+        function f1(x) { return x ? -1 : -1; }
+        function f2(x) { return x ? +2 : +2; }
+        function f3(x) { return x ? ~3 : ~3; }
+        function f4(x) { return x ? !4 : !4; }
+        function f5(x) { return x ? void 5 : void 5; }
+        function f6(x) { return x ? typeof 6 : typeof 6; }
+
+        function g1() { return g() ? -1 : -1; }
+        function g2() { return g() ? +2 : +2; }
+        function g3() { return g() ? ~3 : ~3; }
+        function g4() { return g() ? !4 : !4; }
+        function g5() { return g() ? void 5 : void 5; }
+        function g6() { return g() ? typeof 6 : typeof 6; }
+    }
+    expect: {
+        function f1(x) { return -1; }
+        function f2(x) { return 2; }
+        function f3(x) { return -4; }
+        function f4(x) { return !1; }
+        function f5(x) { return; }
+        function f6(x) { return "number"; }
+
+        function g1() { return g(), -1; }
+        function g2() { return g(), 2; }
+        function g3() { return g(), -4; }
+        function g4() { return g(), !1; }
+        function g5() { return void g(); }
+        function g6() { return g(), "number"; }
+    }
+}
+
+no_evaluate: {
+    options = {
+        conditionals: true,
+        evaluate    : false,
+        side_effects: true,
+    }
+    input: {
+        function f(b) {
+            a = b ? !0 : !0;
+            a = b ? ~1 : ~1;
+            a = b ? -2 : -2;
+            a = b ? +3 : +3;
+        }
+    }
+    expect: {
+        function f(b) {
+            a = !0;
+            a = ~1;
+            a = -2;
+            a = +3;
+        }
+    }
+}
+
+equality_conditionals_false: {
+    options = {
+        conditionals: false,
+        sequences: true,
+    }
+    input: {
+        function f(a, b, c) {
+            console.log(
+                a == (b ? a : a),
+                a == (b ? a : c),
+                a != (b ? a : a),
+                a != (b ? a : c),
+                a === (b ? a : a),
+                a === (b ? a : c),
+                a !== (b ? a : a),
+                a !== (b ? a : c)
+            );
+        }
+        f(0, 0, 0);
+        f(0, true, 0);
+        f(1, 2, 3);
+        f(1, null, 3);
+        f(NaN);
+        f(NaN, "foo");
+    }
+    expect: {
+        function f(a, b, c) {
+            console.log(
+                a == (b ? a : a),
+                a == (b ? a : c),
+                a != (b ? a : a),
+                a != (b ? a : c),
+                a === (b ? a : a),
+                a === (b ? a : c),
+                a !== (b ? a : a),
+                a !== (b ? a : c)
+            );
+        }
+        f(0, 0, 0),
+        f(0, true, 0),
+        f(1, 2, 3),
+        f(1, null, 3),
+        f(NaN),
+        f(NaN, "foo");
+    }
+    expect_stdout: true
+}
+
+equality_conditionals_true: {
+    options = {
+        conditionals: true,
+        sequences: true,
+    }
+    input: {
+        function f(a, b, c) {
+            console.log(
+                a == (b ? a : a),
+                a == (b ? a : c),
+                a != (b ? a : a),
+                a != (b ? a : c),
+                a === (b ? a : a),
+                a === (b ? a : c),
+                a !== (b ? a : a),
+                a !== (b ? a : c)
+            );
+        }
+        f(0, 0, 0);
+        f(0, true, 0);
+        f(1, 2, 3);
+        f(1, null, 3);
+        f(NaN);
+        f(NaN, "foo");
+    }
+    expect: {
+        function f(a, b, c) {
+            console.log(
+                (b, a == a),
+                a == (b ? a : c),
+                (b, a != a),
+                a != (b ? a : c),
+                (b, a === a),
+                a === (b ? a : c),
+                (b, a !== a),
+                a !== (b ? a : c)
+            );
+        }
+        f(0, 0, 0),
+        f(0, true, 0),
+        f(1, 2, 3),
+        f(1, null, 3),
+        f(NaN),
+        f(NaN, "foo");
+    }
+    expect_stdout: true
+}
+
+issue_1645_1: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a = 100, b = 10;
+        (b = a) ? a++ + (b += a) ? b += a : b += a : b ^= a;
+        console.log(a, b);
+    }
+    expect: {
+        var a = 100, b = 10;
+        (b = a) ? (a++ + (b += a), b += a) : b ^= a;
+        console.log(a,b);
+    }
+    expect_stdout: true
+}
+
+issue_1645_2: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        var a = 0;
+        function f() {
+            return a++;
+        }
+        f() ? a += 2 : a += 4;
+        console.log(a);
+    }
+    expect: {
+        var a = 0;
+        function f(){
+            return a++;
+        }
+        f() ? a += 2 : a += 4;
+        console.log(a);
+    }
+    expect_stdout: true
+}
+
+condition_symbol_matches_consequent: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function foo(x, y) {
+            return x ? x : y;
+        }
+        function bar() {
+            return g ? g : h;
+        }
+        var g = 4;
+        var h = 5;
+        console.log(foo(3, null), foo(0, 7), foo(true, false), bar());
+    }
+    expect: {
+        function foo(x, y) {
+            return x || y;
+        }
+        function bar() {
+            return g || h;
+        }
+        var g = 4;
+        var h = 5;
+        console.log(foo(3, null), foo(0, 7), foo(true, false), bar());
+    }
+    expect_stdout: "3 7 true 4"
+}
+
+delete_conditional_1: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(delete (1 ? undefined : x));
+        console.log(delete (1 ? void 0 : x));
+        console.log(delete (1 ? Infinity : x));
+        console.log(delete (1 ? 1 / 0 : x));
+        console.log(delete (1 ? NaN : x));
+        console.log(delete (1 ? 0 / 0 : x));
+    }
+    expect: {
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+    }
+    expect_stdout: true
+}
+
+delete_conditional_2: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+        keep_infinity: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(delete (0 ? x : undefined));
+        console.log(delete (0 ? x : void 0));
+        console.log(delete (0 ? x : Infinity));
+        console.log(delete (0 ? x : 1 / 0));
+        console.log(delete (0 ? x : NaN));
+        console.log(delete (0 ? x : 0 / 0));
+    }
+    expect: {
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+    }
+    expect_stdout: true
+}

test/compress/const.js

@@ -0,0 +1,166 @@
+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
+}

test/compress/dead-code.js

@@ -64,7 +64,8 @@ dead_code_constant_boolean_should_warn_more: {
         loops        : true,
         booleans     : true,
         conditionals : true,
-        evaluate     : true
+        evaluate     : true,
+        side_effects : true,
     };
     input: {
         while (!((foo && bar) || (x + "0"))) {
@@ -72,7 +73,7 @@ dead_code_constant_boolean_should_warn_more: {
             var foo;
             function bar() {}
         }
-        for (var x = 10; x && (y || x) && (!typeof x); ++x) {
+        for (var x = 10, y; x && (y || x) && (!typeof x); ++x) {
             asdf();
             foo();
             var moo;
@@ -83,7 +84,175 @@ dead_code_constant_boolean_should_warn_more: {
         function bar() {}
         // nothing for the while
         // as for the for, it should keep:
-        var x = 10;
+        var x = 10, y;
         var moo;
     }
+    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,
+        dead_code: true,
+        evaluate: true,
+    }
+    input: {
+        var a = 1;
+        !function() {
+            try {
+                if (false) throw x;
+            } catch (a) {
+                var a = 2;
+                console.log("FAIL");
+            } finally {
+                a = 3;
+                console.log("PASS");
+            }
+        }();
+        try {
+            console.log(a);
+        } finally {
+        }
+    }
+    expect: {
+        var a = 1;
+        !function() {
+            var a;
+            a = 3;
+            console.log("PASS");
+        }();
+        try {
+            console.log(a);
+        } finally {
+        }
+    }
+    expect_stdout: [
+        "PASS",
+        "1",
+    ]
 }

test/compress/drop-console.js

@@ -0,0 +1,24 @@
+drop_console_1: {
+    options = {};
+    input: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+    expect: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+}
+
+drop_console_2: {
+    options = { drop_console: true };
+    input: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+    expect: {
+        // with regular compression these will be stripped out as well
+        void 0;
+        void 0;
+    }
+}

test/compress/evaluate.js

@@ -0,0 +1,991 @@
+and: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var a;
+        // compress these
+
+        a = true     && condition;
+        a = 1        && console.log("a");
+        a = 2 * 3    && 2 * condition;
+        a = 5 == 5   && condition + 3;
+        a = "string" && 4 - condition;
+        a = 5 + ""   && condition / 5;
+        a = -4.5     && 6 << condition;
+        a = 6        && 7;
+
+        a = false     && condition;
+        a = NaN       && console.log("b");
+        a = 0         && console.log("c");
+        a = undefined && 2 * condition;
+        a = null      && condition + 3;
+        a = 2 * 3 - 6 && 4 - condition;
+        a = 10 == 7   && condition / 5;
+        a = !"string" && 6 % condition;
+        a = 0         && 7;
+
+        // don't compress these
+
+        a = condition        && true;
+        a = console.log("a") && 2;
+        a = 4 - condition    && "string";
+        a = 6 << condition   && -4.5;
+
+        a = condition        && false;
+        a = console.log("b") && NaN;
+        a = console.log("c") && 0;
+        a = 2 * condition    && undefined;
+        a = condition + 3    && null;
+
+    }
+    expect: {
+        var a;
+
+        a = condition;
+        a = console.log("a");
+        a = 2 * condition;
+        a = condition + 3;
+        a = 4 - condition;
+        a = condition / 5;
+        a = 6 << condition;
+        a = 7;
+
+        a = false;
+        a = NaN;
+        a = 0;
+        a = void 0;
+        a = null;
+        a = 0;
+        a = false;
+        a = false;
+        a = 0;
+
+        a = condition        && true;
+        a = console.log("a") && 2;
+        a = 4 - condition    && "string";
+        a = 6 << condition   && -4.5;
+
+        a = condition        && false;
+        a = console.log("b") && NaN;
+        a = console.log("c") && 0;
+        a = 2 * condition    && void 0;
+        a = condition + 3    && null;
+    }
+}
+
+or: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var a;
+        // compress these
+
+        a = true     || condition;
+        a = 1        || console.log("a");
+        a = 2 * 3    || 2 * condition;
+        a = 5 == 5   || condition + 3;
+        a = "string" || 4 - condition;
+        a = 5 + ""   || condition / 5;
+        a = -4.5     || 6 << condition;
+        a = 6        || 7;
+
+        a = false     || condition;
+        a = 0         || console.log("b");
+        a = NaN       || console.log("c");
+        a = undefined || 2 * condition;
+        a = null      || condition + 3;
+        a = 2 * 3 - 6 || 4 - condition;
+        a = 10 == 7   || condition / 5;
+        a = !"string" || 6 % condition;
+        a = null      || 7;
+
+        a = console.log(undefined && condition || null);
+        a = console.log(undefined || condition && null);
+
+        // don't compress these
+
+        a = condition        || true;
+        a = console.log("a") || 2;
+        a = 4 - condition    || "string";
+        a = 6 << condition   || -4.5;
+
+        a = condition        || false;
+        a = console.log("b") || NaN;
+        a = console.log("c") || 0;
+        a = 2 * condition    || undefined;
+        a = condition + 3    || null;
+
+    }
+    expect: {
+        var a;
+
+        a = true;
+        a = 1;
+        a = 6;
+        a = true;
+        a = "string";
+        a = "5";
+        a = -4.5;
+        a = 6;
+
+        a = condition;
+        a = console.log("b");
+        a = console.log("c");
+        a = 2 * condition;
+        a = condition + 3;
+        a = 4 - condition;
+        a = condition / 5;
+        a = 6 % condition;
+        a = 7;
+
+        a = console.log(null);
+        a = console.log(condition && null);
+
+        a = condition        || true;
+        a = console.log("a") || 2;
+        a = 4 - condition    || "string";
+        a = 6 << condition   || -4.5;
+
+        a = condition        || false;
+        a = console.log("b") || NaN;
+        a = console.log("c") || 0;
+        a = 2 * condition    || void 0;
+        a = condition + 3    || null;
+    }
+}
+
+unary_prefix: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        a = !0 && b;
+        a = !0 || b;
+        a = ~1 && b;
+        a = ~1 || b;
+        a = -2 && b;
+        a = -2 || b;
+        a = +3 && b;
+        a = +3 || b;
+    }
+    expect: {
+        a = b;
+        a = !0;
+        a = b;
+        a = -2;
+        a = b;
+        a = -2;
+        a = b;
+        a = 3;
+    }
+}
+
+negative_zero: {
+    options = { evaluate: true }
+    input: {
+        console.log(
+            -"",
+            - -"",
+            1 / (-0),
+            1 / (-"")
+        );
+    }
+    expect: {
+        console.log(
+            -0,
+            0,
+            -1/0,
+            -1/0
+        );
+    }
+    expect_stdout: true
+}
+
+positive_zero: {
+    options = { evaluate: true }
+    input: {
+        console.log(
+            +"",
+            + -"",
+            1 / (+0),
+            1 / (+"")
+        );
+    }
+    expect: {
+        console.log(
+            0,
+            -0,
+            1/0,
+            1/0
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_constant: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            true.a,
+            false.a,
+            null.a,
+            undefined.a
+        );
+    }
+    expect: {
+        console.log(
+            true.a,
+            false.a,
+            null.a,
+            (void 0).a
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_object: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            ({a:1}) + 1,
+            ({a:1}).a + 1,
+            ({a:1}).b + 1,
+            ({a:1}).a.b + 1
+        );
+    }
+    expect: {
+        console.log(
+            ({a:1}) + 1,
+            2,
+            ({a:1}).b + 1,
+            1..b + 1
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_object_nested: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            ({a:{b:1}}) + 1,
+            ({a:{b:1}}).a + 1,
+            ({a:{b:1}}).b + 1,
+            ({a:{b:1}}).a.b + 1
+        );
+    }
+    expect: {
+        console.log(
+            ({a:{b:1}}) + 1,
+            ({a:{b:1}}).a + 1,
+            ({a:{b:1}}).b + 1,
+            2
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_object_complex: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            ({a:{b:1},b:1}) + 1,
+            ({a:{b:1},b:1}).a + 1,
+            ({a:{b:1},b:1}).b + 1,
+            ({a:{b:1},b:1}).a.b + 1
+        );
+    }
+    expect: {
+        console.log(
+            ({a:{b:1},b:1}) + 1,
+            ({a:{b:1},b:1}).a + 1,
+            2,
+            2
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_object_repeated: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            ({a:{b:1},a:1}) + 1,
+            ({a:{b:1},a:1}).a + 1,
+            ({a:{b:1},a:1}).b + 1,
+            ({a:{b:1},a:1}).a.b + 1
+        );
+    }
+    expect: {
+        console.log(
+            ({a:{b:1},a:1}) + 1,
+            2,
+            ({a:{b:1},a:1}).b + 1,
+            1..b + 1
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_object_accessor: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe: true,
+    }
+    input: {
+        function f() {
+            var a = {
+                get b() {},
+                set b() {}
+            };
+            return {a:a};
+        }
+    }
+    expect: {
+        function f() {
+            var a = {
+                get b() {},
+                set b() {}
+            };
+            return {a:a};
+        }
+    }
+}
+
+unsafe_function: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            ({a:{b:1},b:function(){}}) + 1,
+            ({a:{b:1},b:function(){}}).a + 1,
+            ({a:{b:1},b:function(){}}).b + 1,
+            ({a:{b:1},b:function(){}}).a.b + 1
+        );
+    }
+    expect: {
+        console.log(
+            ({a:{b:1},b:function(){}}) + 1,
+            ({a:{b:1},b:function(){}}).a + 1,
+            ({a:{b:1},b:function(){}}).b + 1,
+            ({a:{b:1},b:function(){}}).a.b + 1
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_integer_key: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            ({0:1}) + 1,
+            ({0:1})[0] + 1,
+            ({0:1})["0"] + 1,
+            ({0:1})[1] + 1,
+            ({0:1})[0][1] + 1,
+            ({0:1})[0]["1"] + 1
+        );
+    }
+    expect: {
+        console.log(
+            ({0:1}) + 1,
+            2,
+            2,
+            ({0:1})[1] + 1,
+            1[1] + 1,
+            1["1"] + 1
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_integer_key_complex: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            ({0:{1:1},1:1}) + 1,
+            ({0:{1:1},1:1})[0] + 1,
+            ({0:{1:1},1:1})["0"] + 1,
+            ({0:{1:1},1:1})[1] + 1,
+            ({0:{1:1},1:1})[0][1] + 1,
+            ({0:{1:1},1:1})[0]["1"] + 1
+        );
+    }
+    expect: {
+        console.log(
+            ({0:{1:1},1:1}) + 1,
+            "[object Object]1",
+            "[object Object]1",
+            2,
+            2,
+            2
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_float_key: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            ({2.72:1}) + 1,
+            ({2.72:1})[2.72] + 1,
+            ({2.72:1})["2.72"] + 1,
+            ({2.72:1})[3.14] + 1,
+            ({2.72:1})[2.72][3.14] + 1,
+            ({2.72:1})[2.72]["3.14"] + 1
+        );
+    }
+    expect: {
+        console.log(
+            ({2.72:1}) + 1,
+            2,
+            2,
+            ({2.72:1})[3.14] + 1,
+            1[3.14] + 1,
+            1["3.14"] + 1
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_float_key_complex: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            ({2.72:{3.14:1},3.14:1}) + 1,
+            ({2.72:{3.14:1},3.14:1})[2.72] + 1,
+            ({2.72:{3.14:1},3.14:1})["2.72"] + 1,
+            ({2.72:{3.14:1},3.14:1})[3.14] + 1,
+            ({2.72:{3.14:1},3.14:1})[2.72][3.14] + 1,
+            ({2.72:{3.14:1},3.14:1})[2.72]["3.14"] + 1
+        );
+    }
+    expect: {
+        console.log(
+            "[object Object]1",
+            "[object Object]1",
+            "[object Object]1",
+            2,
+            2,
+            2
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_array: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            [1, , 3][1],
+            [1, 2, 3, a] + 1,
+            [1, 2, 3, 4] + 1,
+            [1, 2, 3, a][0] + 1,
+            [1, 2, 3, 4][0] + 1,
+            [1, 2, 3, 4][6 - 5] + 1,
+            [1, , 3, 4][6 - 5] + 1,
+            [[1, 2], [3, 4]][0] + 1,
+            [[1, 2], [3, 4]][6 - 5][1] + 1,
+            [[1, 2], , [3, 4]][6 - 5][1] + 1
+        );
+    }
+    expect: {
+        console.log(
+            void 0,
+            [1, 2, 3, a] + 1,
+            "1,2,3,41",
+            [1, 2, 3, a][0] + 1,
+            2,
+            3,
+            NaN,
+            "1,21",
+            5,
+            (void 0)[1] + 1
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_string: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            "1234" + 1,
+            "1234"[0] + 1,
+            "1234"[6 - 5] + 1,
+            ("12" + "34")[0] + 1,
+            ("12" + "34")[6 - 5] + 1,
+            [1, 2, 3, 4].join("")[0] + 1
+        );
+    }
+    expect: {
+        console.log(
+            "12341",
+            "11",
+            "21",
+            "11",
+            "21",
+            "11"
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_array_bad_index: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            [1, 2, 3, 4].a + 1,
+            [1, 2, 3, 4]["a"] + 1,
+            [1, 2, 3, 4][3.14] + 1
+        );
+    }
+    expect: {
+        console.log(
+            [1, 2, 3, 4].a + 1,
+            [1, 2, 3, 4]["a"] + 1,
+            [1, 2, 3, 4][3.14] + 1
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_string_bad_index: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            "1234".a + 1,
+            "1234"["a"] + 1,
+            "1234"[3.14] + 1
+        );
+    }
+    expect: {
+        console.log(
+            "1234".a + 1,
+            "1234"["a"] + 1,
+            "1234"[3.14] + 1
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_prototype_function: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        var a = ({valueOf: 0}) < 1;
+        var b = ({toString: 0}) < 1;
+        var c = ({valueOf: 0}) + "";
+        var d = ({toString: 0}) + "";
+        var e = (({valueOf: 0}) + "")[2];
+        var f = (({toString: 0}) + "")[2];
+        var g = ({valueOf: 0}).valueOf();
+        var h = ({toString: 0}).toString();
+    }
+    expect: {
+        var a = ({valueOf: 0}) < 1;
+        var b = ({toString: 0}) < 1;
+        var c = ({valueOf: 0}) + "";
+        var d = ({toString: 0}) + "";
+        var e = (({valueOf: 0}) + "")[2];
+        var f = (({toString: 0}) + "")[2];
+        var g = ({valueOf: 0}).valueOf();
+        var h = "" + ({toString: 0});
+    }
+}
+
+call_args: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    }
+    input: {
+        const a = 1;
+        console.log(a);
+        +function(a) {
+            return a;
+        }(a);
+    }
+    expect: {
+        const a = 1;
+        console.log(1);
+        +(1, 1);
+    }
+    expect_stdout: true
+}
+
+call_args_drop_param: {
+    options = {
+        evaluate: true,
+        keep_fargs: false,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        const a = 1;
+        console.log(a);
+        +function(a) {
+            return a;
+        }(a, b);
+    }
+    expect: {
+        const a = 1;
+        console.log(1);
+        +(b, 1);
+    }
+    expect_stdout: true
+}
+
+in_boolean_context: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(
+            !42,
+            !"foo",
+            ![1, 2],
+            !/foo/,
+            !b(42),
+            !b("foo"),
+            !b([1, 2]),
+            !b(/foo/),
+            ![1, foo()],
+            ![1, foo(), 2]
+        );
+    }
+    expect: {
+        console.log(
+            !1,
+            !1,
+            !1,
+            !1,
+            !b(42),
+            !b("foo"),
+            !b([1, 2]),
+            !b(/foo/),
+            ![1, foo()],
+            (foo(), !1)
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_charAt: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            "1234" + 1,
+            "1234".charAt(0) + 1,
+            "1234".charAt(6 - 5) + 1,
+            ("12" + "34").charAt(0) + 1,
+            ("12" + "34").charAt(6 - 5) + 1,
+            [1, 2, 3, 4].join("").charAt(0) + 1
+        );
+    }
+    expect: {
+        console.log(
+            "12341",
+            "11",
+            "21",
+            "11",
+            "21",
+            "11"
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_charAt_bad_index: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            "1234".charAt() + 1,
+            "1234".charAt("a") + 1,
+            "1234".charAt(3.14) + 1
+        );
+    }
+    expect: {
+        console.log(
+            "11",
+            "11",
+            "41"
+        );
+    }
+    expect_stdout: true
+}
+
+unsafe_charAt_noop: {
+    options = {
+        evaluate  : true,
+        unsafe    : true
+    }
+    input: {
+        console.log(
+            s.charAt(0),
+            "string".charAt(x)
+        );
+    }
+    expect: {
+        console.log(
+            s.charAt(0),
+            "string".charAt(x)
+        );
+    }
+}
+
+issue_1649: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log(-1 + -1);
+    }
+    expect: {
+        console.log(-2);
+    }
+    expect_stdout: "-2";
+}
+
+issue_1760_1: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        !function(a) {
+            try {
+                throw 0;
+            } catch (NaN) {
+                a = +"foo";
+            }
+            console.log(a);
+        }();
+    }
+    expect: {
+        !function(a) {
+            try {
+                throw 0;
+            } catch (NaN) {
+                a = 0 / 0;
+            }
+            console.log(a);
+        }();
+    }
+    expect_stdout: "NaN"
+}
+
+issue_1760_2: {
+    options = {
+        evaluate: true,
+        keep_infinity: true,
+    }
+    input: {
+        !function(a) {
+            try {
+                throw 0;
+            } catch (Infinity) {
+                a = 123456789 / 0;
+            }
+            console.log(a);
+        }();
+    }
+    expect: {
+        !function(a) {
+            try {
+                throw 0;
+            } catch (Infinity) {
+                a = 1 / 0;
+            }
+            console.log(a);
+        }();
+    }
+    expect_stdout: "Infinity"
+}
+
+delete_expr_1: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        console.log(delete undefined);
+        console.log(delete void 0);
+        console.log(delete Infinity);
+        console.log(delete (1 / 0));
+        console.log(delete NaN);
+        console.log(delete (0 / 0));
+    }
+    expect: {
+        console.log(delete undefined);
+        console.log((void 0, !0));
+        console.log(delete Infinity);
+        console.log((1 / 0, !0));
+        console.log(delete NaN);
+        console.log((0 / 0, !0));
+    }
+    expect_stdout: true
+}
+
+delete_expr_2: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        keep_infinity: true,
+    }
+    input: {
+        console.log(delete undefined);
+        console.log(delete void 0);
+        console.log(delete Infinity);
+        console.log(delete (1 / 0));
+        console.log(delete NaN);
+        console.log(delete (0 / 0));
+    }
+    expect: {
+        console.log(delete undefined);
+        console.log((void 0, !0));
+        console.log(delete Infinity);
+        console.log((1 / 0, !0));
+        console.log(delete NaN);
+        console.log((0 / 0, !0));
+    }
+    expect_stdout: true
+}
+
+delete_binary_1: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(delete (true && undefined));
+        console.log(delete (true && void 0));
+        console.log(delete (true && Infinity));
+        console.log(delete (true && (1 / 0)));
+        console.log(delete (true && NaN));
+        console.log(delete (true && (0 / 0)));
+    }
+    expect: {
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+    }
+    expect_stdout: true
+}
+
+delete_binary_2: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        keep_infinity: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(delete (false || undefined));
+        console.log(delete (false || void 0));
+        console.log(delete (false || Infinity));
+        console.log(delete (false || (1 / 0)));
+        console.log(delete (false || NaN));
+        console.log(delete (false || (0 / 0)));
+    }
+    expect: {
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+    }
+    expect_stdout: true
+}
+
+Infinity_NaN_undefined_LHS: {
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        function f() {
+            Infinity = Infinity;
+            ++Infinity;
+            Infinity--;
+            NaN *= NaN;
+            ++NaN;
+            NaN--;
+            undefined |= undefined;
+            ++undefined;
+            undefined--;
+        }
+    }
+    expect_exact: [
+        "function f() {",
+        "    Infinity = 1 / 0;",
+        "    ++Infinity;",
+        "    Infinity--;",
+        "    NaN *= NaN;",
+        "    ++NaN;",
+        "    NaN--;",
+        "    undefined |= void 0;",
+        "    ++undefined;",
+        "    undefined--;",
+        "}",
+    ]
+}

test/compress/functions.js

@@ -0,0 +1,169 @@
+non_ascii_function_identifier_name: {
+    input: {
+        function fooλ(δλ) {}
+        function λ(δλ) {}
+        (function λ(δλ) {})()
+    }
+    expect_exact: "function fooλ(δλ){}function λ(δλ){}(function λ(δλ){})();"
+}
+
+iifes_returning_constants_keep_fargs_true: {
+    options = {
+        keep_fargs    : true,
+        side_effects  : true,
+        evaluate      : true,
+        unused        : true,
+        dead_code     : true,
+        conditionals  : true,
+        comparisons   : true,
+        booleans      : true,
+        if_return     : true,
+        join_vars     : true,
+        reduce_vars   : true,
+        cascade       : true,
+    }
+    input: {
+        (function(){ return -1.23; }());
+        console.log( function foo(){ return "okay"; }() );
+        console.log( function foo(x, y, z){ return 123; }() );
+        console.log( function(x, y, z){ return z; }() );
+        console.log( function(x, y, z){ if (x) return y; return z; }(1, 2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3, a(), b()) );
+    }
+    expect: {
+        console.log("okay");
+        console.log(123);
+        console.log(void 0);
+        console.log(2);
+        console.log(6);
+        console.log((a(), b(), 6));
+    }
+    expect_stdout: true
+}
+
+iifes_returning_constants_keep_fargs_false: {
+    options = {
+        keep_fargs    : false,
+        side_effects  : true,
+        evaluate      : true,
+        unused        : true,
+        dead_code     : true,
+        conditionals  : true,
+        comparisons   : true,
+        booleans      : true,
+        if_return     : true,
+        join_vars     : true,
+        reduce_vars   : true,
+        cascade       : true,
+    }
+    input: {
+        (function(){ return -1.23; }());
+        console.log( function foo(){ return "okay"; }() );
+        console.log( function foo(x, y, z){ return 123; }() );
+        console.log( function(x, y, z){ return z; }() );
+        console.log( function(x, y, z){ if (x) return y; return z; }(1, 2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3) );
+        console.log( function(x, y){ return x * y; }(2, 3, a(), b()) );
+    }
+    expect: {
+        console.log("okay");
+        console.log(123);
+        console.log(void 0);
+        console.log(2);
+        console.log(6);
+        console.log((a(), b(), 6));
+    }
+    expect_stdout: true
+}
+
+issue_485_crashing_1530: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+    }
+    input: {
+        (function(a) {
+            if (true) return;
+            var b = 42;
+        })(this);
+    }
+    expect: {
+        this, void 0;
+    }
+}
+
+issue_1841_1: {
+    options = {
+        keep_fargs: false,
+        pure_getters: "strict",
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var b = 10;
+        !function(arg) {
+            for (var key in "hi")
+                var n = arg.baz, n = [ b = 42 ];
+        }(--b);
+        console.log(b);
+    }
+    expect: {
+        var b = 10;
+        !function() {
+            for (var key in "hi")
+                b = 42;
+        }(--b);
+        console.log(b);
+    }
+    expect_exact: "42"
+}
+
+issue_1841_2: {
+    options = {
+        keep_fargs: false,
+        pure_getters: false,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        var b = 10;
+        !function(arg) {
+            for (var key in "hi")
+                var n = arg.baz, n = [ b = 42 ];
+        }(--b);
+        console.log(b);
+    }
+    expect: {
+        var b = 10;
+        !function(arg) {
+            for (var key in "hi")
+                arg.baz, b = 42;
+        }(--b);
+        console.log(b);
+    }
+    expect_exact: "42"
+}
+
+function_returning_constant_literal: {
+    options = {
+        reduce_vars: true,
+        unsafe: true,
+        toplevel: true,
+        evaluate: true,
+        cascade: true,
+        unused: true,
+    }
+    input: {
+        function greeter() {
+            return { message: 'Hello there' };
+        }
+        var greeting = greeter();
+        console.log(greeting.message);
+    }
+    expect: {
+        console.log("Hello there");
+    }
+    expect_stdout: "Hello there"
+}

test/compress/global_defs.js

@@ -0,0 +1,162 @@
+must_replace: {
+    options = {
+        global_defs: {
+            D: "foo bar",
+        }
+    }
+    input: {
+        console.log(D);
+    }
+    expect: {
+        console.log("foo bar");
+    }
+}
+
+keyword: {
+    options = {
+        global_defs: {
+            undefined: 0,
+            NaN: 1,
+            Infinity: 2,
+        },
+    }
+    input: {
+        console.log(undefined, NaN, Infinity);
+    }
+    expect: {
+        console.log(0, 1, 2);
+    }
+}
+
+object: {
+    options = {
+        evaluate: true,
+        global_defs: {
+            CONFIG: {
+                DEBUG: [ 0 ],
+                VALUE: 42,
+            },
+        },
+        unsafe: true,
+    }
+    input: {
+        function f(CONFIG) {
+            // CONFIG not global - do not replace
+            return CONFIG.VALUE;
+        }
+        function g() {
+            var CONFIG = { VALUE: 1 };
+            // CONFIG not global - do not replace
+            return CONFIG.VALUE;
+        }
+        function h() {
+            return CONFIG.VALUE;
+        }
+        if (CONFIG.DEBUG[0])
+            console.debug("foo");
+    }
+    expect: {
+        function f(CONFIG) {
+            return CONFIG.VALUE;
+        }
+        function g() {
+            var CONFIG = { VALUE: 1 };
+            return CONFIG.VALUE;
+        }
+        function h() {
+            return 42;
+        }
+        if (0)
+            console.debug("foo");
+    }
+}
+
+expanded: {
+    options = {
+        global_defs: {
+            "CONFIG.DEBUG": [ 0 ],
+            "CONFIG.VALUE": 42,
+        },
+    }
+    input: {
+        function f(CONFIG) {
+            // CONFIG not global - do not replace
+            return CONFIG.VALUE;
+        }
+        function g() {
+            var CONFIG = { VALUE: 1 };
+            // CONFIG not global - do not replace
+            return CONFIG.VALUE;
+        }
+        function h() {
+            return CONFIG.VALUE;
+        }
+        if (CONFIG.DEBUG[0])
+            console.debug("foo");
+    }
+    expect: {
+        function f(CONFIG) {
+            return CONFIG.VALUE;
+        }
+        function g() {
+            var CONFIG = { VALUE: 1 };
+            return CONFIG.VALUE;
+        }
+        function h() {
+            return 42;
+        }
+        if ([0][0])
+            console.debug("foo");
+    }
+}
+
+mixed: {
+    options = {
+        evaluate: true,
+        global_defs: {
+            "CONFIG.VALUE": 42,
+            "FOO.BAR": "moo",
+        },
+        properties: true,
+    }
+    input: {
+        const FOO = { BAR: 0 };
+        console.log(FOO.BAR);
+        console.log(++CONFIG.DEBUG);
+        console.log(++CONFIG.VALUE);
+        console.log(++CONFIG["VAL" + "UE"]);
+        console.log(++DEBUG[CONFIG.VALUE]);
+        CONFIG.VALUE.FOO = "bar";
+        console.log(CONFIG);
+    }
+    expect: {
+        const FOO = { BAR: 0 };
+        console.log("moo");
+        console.log(++CONFIG.DEBUG);
+        console.log(++CONFIG.VALUE);
+        console.log(++CONFIG.VALUE);
+        console.log(++DEBUG[42]);
+        CONFIG.VALUE.FOO = "bar";
+        console.log(CONFIG);
+    }
+    expect_warnings: [
+        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:126,22]',
+        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:127,22]',
+        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:129,8]',
+    ]
+}
+
+issue_1801: {
+    options = {
+        booleans: true,
+        global_defs: {
+            "CONFIG.FOO.BAR": true,
+        },
+    }
+    input: {
+        console.log(CONFIG.FOO.BAR);
+    }
+    expect: {
+        console.log(!0);
+    }
+}

test/compress/hoist_vars.js

@@ -0,0 +1,90 @@
+statements: {
+    options = {
+        hoist_funs: false,
+        hoist_vars: true,
+    }
+    input: {
+        function f() {
+            var a = 1;
+            var b = 2;
+            var c = 3;
+            function g() {}
+            return g(a, b, c);
+        }
+    }
+    expect: {
+        function f() {
+            var a = 1, b = 2, c = 3;
+            function g() {}
+            return g(a, b, c);
+        }
+    }
+}
+
+statements_funs: {
+    options = {
+        hoist_funs: true,
+        hoist_vars: true,
+    }
+    input: {
+        function f() {
+            var a = 1;
+            var b = 2;
+            var c = 3;
+            function g() {}
+            return g(a, b, c);
+        }
+    }
+    expect: {
+        function f() {
+            function g() {}
+            var a = 1, b = 2, c = 3;
+            return g(a, b, c);
+        }
+    }
+}
+
+sequences: {
+    options = {
+        hoist_funs: false,
+        hoist_vars: true,
+    }
+    input: {
+        function f() {
+            var a = 1, b = 2;
+            function g() {}
+            var c = 3;
+            return g(a, b, c);
+        }
+    }
+    expect: {
+        function f() {
+            var c, a = 1, b = 2;
+            function g() {}
+            c = 3;
+            return g(a, b, c);
+        }
+    }
+}
+
+sequences_funs: {
+    options = {
+        hoist_funs: true,
+        hoist_vars: true,
+    }
+    input: {
+        function f() {
+            var a = 1, b = 2;
+            function g() {}
+            var c = 3;
+            return g(a, b, c);
+        }
+    }
+    expect: {
+        function f() {
+            function g() {}
+            var a = 1, b = 2, c = 3;
+            return g(a, b, c);
+        }
+    }
+}

test/compress/html_comments.js

@@ -0,0 +1,55 @@
+html_comment_in_expression: {
+    input: {
+        function f(a, b, x, y) { return a < !--b && x-- > y; }
+    }
+    expect_exact: "function f(a,b,x,y){return a< !--b&&x-- >y}";
+}
+
+html_comment_in_less_than: {
+    input: {
+        function f(a, b) { return a < !--b; }
+    }
+    expect_exact: "function f(a,b){return a< !--b}";
+}
+
+html_comment_in_left_shift: {
+    input: {
+        function f(a, b) { return a << !--b; }
+    }
+    expect_exact: "function f(a,b){return a<< !--b}";
+}
+
+html_comment_in_right_shift: {
+    input: {
+        function f(a, b) { return a-- >> b; }
+    }
+    expect_exact: "function f(a,b){return a-- >>b}";
+}
+
+html_comment_in_zero_fill_right_shift: {
+    input: {
+        function f(a, b) { return a-- >>> b; }
+    }
+    expect_exact: "function f(a,b){return a-- >>>b}";
+}
+
+html_comment_in_greater_than: {
+    input: {
+        function f(a, b) { return a-- > b; }
+    }
+    expect_exact: "function f(a,b){return a-- >b}";
+}
+
+html_comment_in_greater_than_or_equal: {
+    input: {
+        function f(a, b) { return a-- >= b; }
+    }
+    expect_exact: "function f(a,b){return a-- >=b}";
+}
+
+html_comment_in_string_literal: {
+    input: {
+        function f() { return "<!--HTML-->comment in<!--string literal-->"; }
+    }
+    expect_exact: 'function f(){return"\\x3c!--HTML--\\x3ecomment in\\x3c!--string literal--\\x3e"}';
+}

test/compress/if_return.js

@@ -0,0 +1,304 @@
+if_return_1: {
+    options = {
+        if_return    : true,
+        sequences    : true,
+        conditionals : true,
+        comparisons  : true,
+        evaluate     : true,
+        booleans     : true,
+        unused       : true,
+        side_effects : true,
+        dead_code    : true,
+    }
+    input: {
+        function f(x) {
+            if (x) {
+                return true;
+            }
+        }
+    }
+    expect: {
+        function f(x){if(x)return!0}
+    }
+}
+
+if_return_2: {
+    options = {
+        if_return    : true,
+        sequences    : true,
+        conditionals : true,
+        comparisons  : true,
+        evaluate     : true,
+        booleans     : true,
+        unused       : true,
+        side_effects : true,
+        dead_code    : true,
+    }
+    input: {
+        function f(x, y) {
+            if (x)
+                return 3;
+            if (y)
+                return c();
+        }
+    }
+    expect: {
+        function f(x,y){return x?3:y?c():void 0}
+    }
+}
+
+if_return_3: {
+    options = {
+        if_return    : true,
+        sequences    : true,
+        conditionals : true,
+        comparisons  : true,
+        evaluate     : true,
+        booleans     : true,
+        unused       : true,
+        side_effects : true,
+        dead_code    : true,
+    }
+    input: {
+        function f(x) {
+            a();
+            if (x) {
+                b();
+                return false;
+            }
+        }
+    }
+    expect: {
+        function f(x){if(a(),x)return b(),!1}
+    }
+}
+
+if_return_4: {
+    options = {
+        if_return    : true,
+        sequences    : true,
+        conditionals : true,
+        comparisons  : true,
+        evaluate     : true,
+        booleans     : true,
+        unused       : true,
+        side_effects : true,
+        dead_code    : true,
+    }
+    input: {
+        function f(x, y) {
+            a();
+            if (x) return 3;
+            b();
+            if (y) return c();
+        }
+    }
+    expect: {
+        function f(x,y){return a(),x?3:(b(),y?c():void 0)}
+    }
+}
+
+if_return_5: {
+    options = {
+        if_return    : true,
+        sequences    : true,
+        conditionals : true,
+        comparisons  : true,
+        evaluate     : true,
+        booleans     : true,
+        unused       : true,
+        side_effects : true,
+        dead_code    : true,
+    }
+    input: {
+        function f() {
+            if (x)
+                return;
+            return 7;
+            if (y)
+                return j;
+        }
+    }
+    expect: {
+        function f(){if(!x)return 7}
+    }
+}
+
+if_return_6: {
+    options = {
+        if_return    : true,
+        sequences    : true,
+        conditionals : true,
+        comparisons  : true,
+        evaluate     : true,
+        booleans     : true,
+        unused       : true,
+        side_effects : true,
+        dead_code    : true,
+    }
+    input: {
+        function f(x) {
+          return x ? true : void 0;
+          return y;
+        }
+    }
+    expect: {
+        // suboptimal
+        function f(x){return!!x||void 0}
+    }
+}
+
+if_return_7: {
+    options = {
+        if_return    : true,
+        sequences    : true,
+        conditionals : true,
+        comparisons  : true,
+        evaluate     : true,
+        booleans     : true,
+        unused       : true,
+        side_effects : true,
+        dead_code    : true,
+    }
+    input: {
+        function f(x) {
+            if (x) {
+                return true;
+            }
+            foo();
+            bar();
+        }
+    }
+    expect: {
+        function f(x){if(x)return!0;foo(),bar()}
+    }
+}
+
+if_return_8: {
+    options = {
+        if_return:     true,
+        sequences:     true,
+        conditionals:  true,
+        side_effects : true,
+    }
+    input: {
+        function f(e) {
+            if (2 == e) return foo();
+            if (3 == e) return bar();
+            if (4 == e) return baz();
+            fail(e);
+        }
+
+        function g(e) {
+            if (a(e)) return foo();
+            if (b(e)) return bar();
+            if (c(e)) return baz();
+            fail(e);
+        }
+
+        function h(e) {
+            if (a(e)) return foo();
+            else if (b(e)) return bar();
+            else if (c(e)) return baz();
+            else fail(e);
+        }
+
+        function i(e) {
+            if (a(e)) return foo();
+            else if (b(e)) return bar();
+            else if (c(e)) return baz();
+            fail(e);
+        }
+    }
+    expect: {
+        function f(e){return 2==e?foo():3==e?bar():4==e?baz():void fail(e)}
+        function g(e){return a(e)?foo():b(e)?bar():c(e)?baz():void fail(e)}
+        function h(e){return a(e)?foo():b(e)?bar():c(e)?baz():void fail(e)}
+        function i(e){return a(e)?foo():b(e)?bar():c(e)?baz():void fail(e)}
+    }
+}
+
+issue_1089: {
+    options = {
+        if_return    : true,
+        sequences    : true,
+        conditionals : true,
+        comparisons  : true,
+        evaluate     : true,
+        booleans     : true,
+        unused       : true,
+        side_effects : true,
+        dead_code    : true,
+    }
+    input: {
+        function x() {
+            var f = document.getElementById("fname");
+            if (f.files[0].size > 12345) {
+                alert("alert");
+                f.focus();
+                return false;
+            }
+        }
+    }
+    expect: {
+        function x() {
+            var f = document.getElementById("fname");
+            if (f.files[0].size > 12345)
+                return alert("alert"), f.focus(), !1;
+        }
+    }
+}
+
+issue_1437: {
+    options = {
+        if_return    : true,
+        sequences    : true,
+        conditionals : false
+    }
+    input: {
+        function x() {
+            if (a())
+                return b();
+            if (c())
+                return d();
+            else
+                e();
+            f();
+        }
+    }
+    expect: {
+        function x() {
+            if (a())
+                return b();
+            if (c())
+                return d();
+            else
+                e()
+            f();
+        }
+    }
+}
+
+issue_1437_conditionals: {
+    options = {
+        conditionals : true,
+        if_return    : true,
+        sequences    : true
+    }
+    input: {
+        function x() {
+            if (a())
+                return b();
+            if (c())
+                return d();
+            else
+                e();
+            f();
+        }
+    }
+    expect: {
+        function x() {
+            return a() ? b() : c() ? d() : (e(), f(), void 0);
+        }
+    }
+}

test/compress/issue-1034.js

@@ -0,0 +1,118 @@
+non_hoisted_function_after_return: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true
+    }
+    input: {
+        function foo(x) {
+            if (x) {
+                return bar();
+                not_called1();
+            } else {
+                return baz();
+                not_called2();
+            }
+            function bar() { return 7; }
+            return not_reached;
+            function UnusedFunction() {}
+            function baz() { return 8; }
+        }
+    }
+    expect: {
+        function foo(x) {
+            return x ? bar() : baz();
+            function bar() { return 7 }
+            function baz() { return 8 }
+        }
+    }
+    expect_warnings: [
+        'WARN: Dropping unreachable code [test/compress/issue-1034.js:11,16]',
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:14,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:17,12]",
+        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:18,21]"
+    ]
+}
+
+non_hoisted_function_after_return_2a: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        collapse_vars: false, passes: 2, warnings: "verbose"
+    }
+    input: {
+        function foo(x) {
+            if (x) {
+                return bar(1);
+                var a = not_called(1);
+            } else {
+                return bar(2);
+                var b = not_called(2);
+            }
+            var c = bar(3);
+            function bar(x) { return 7 - x; }
+            function nope() {}
+            return b || c;
+        }
+    }
+    expect: {
+        function foo(x) {
+            return bar(x ? 1 : 2);
+            function bar(x) {
+                return 7 - x;
+            }
+        }
+    }
+    expect_warnings: [
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:48,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:48,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:51,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:51,16]",
+        "WARN: Dropping unused variable a [test/compress/issue-1034.js:48,20]",
+        "WARN: Dropping unused function nope [test/compress/issue-1034.js:55,21]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:53,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:53,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:56,12]",
+        "WARN: Dropping unused variable b [test/compress/issue-1034.js:51,20]",
+        "WARN: Dropping unused variable c [test/compress/issue-1034.js:53,16]",
+    ]
+}
+
+non_hoisted_function_after_return_2b: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        collapse_vars: false
+    }
+    input: {
+        function foo(x) {
+            if (x) {
+                return bar(1);
+            } else {
+                return bar(2);
+                var b;
+            }
+            var c = bar(3);
+            function bar(x) {
+                return 7 - x;
+            }
+            return b || c;
+        }
+    }
+    expect: {
+        function foo(x) {
+            return bar(x ? 1 : 2);
+            function bar(x) { return 7 - x; }
+        }
+    }
+    expect_warnings: [
+        // duplicate warnings no longer emitted
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:95,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:95,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:97,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:97,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:101,12]",
+    ]
+}

test/compress/issue-1041.js

@@ -0,0 +1,41 @@
+const_declaration: {
+    options = {
+        evaluate: true
+    };
+
+    input: {
+        const goog = goog || {};
+    }
+    expect: {
+        const goog = goog || {};
+    }
+}
+
+const_pragma: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    };
+
+    input: {
+        /** @const */ var goog = goog || {};
+    }
+    expect: {
+        var goog = goog || {};
+    }
+}
+
+// for completeness' sake
+not_const: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+    };
+
+    input: {
+        var goog = goog || {};
+    }
+    expect: {
+        var goog = goog || {};
+    }
+}

test/compress/issue-105.js

@@ -1,25 +0,0 @@
-typeof_eq_undefined: {
-    options = {
-        comparisons: true
-    };
-    input: { a = typeof b.c != "undefined" }
-    expect: { a = "undefined" != typeof b.c }
-}
-
-typeof_eq_undefined_unsafe: {
-    options = {
-        comparisons: true,
-        unsafe: true
-    };
-    input: { a = typeof b.c != "undefined" }
-    expect: { a = void 0 !== b.c }
-}
-
-typeof_eq_undefined_unsafe2: {
-    options = {
-        comparisons: true,
-        unsafe: true
-    };
-    input: { a = "undefined" != typeof b.c }
-    expect: { a = void 0 !== b.c }
-}

test/compress/issue-1052.js

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

test/compress/issue-1105.js

@@ -0,0 +1,305 @@
+with_in_global_scope: {
+    options = {
+        unused: true
+    }
+    input: {
+        var o = 42;
+        with(o) {
+            var foo = 'something'
+        }
+        doSomething(o);
+    }
+    expect: {
+        var o=42;
+        with(o)
+            var foo = "something";
+        doSomething(o);
+    }
+}
+with_in_function_scope: {
+    options = {
+        unused: true
+    }
+    input: {
+        function foo() {
+            var o = 42;
+            with(o) {
+                var foo = "something"
+            }
+            doSomething(o);
+        }
+    }
+    expect: {
+        function foo() {
+            var o=42;
+            with(o)
+                var foo = "something";
+            doSomething(o)
+        }
+    }
+}
+compress_with_with_in_other_scope: {
+    options = {
+        unused: true
+    }
+    input: {
+        function foo() {
+            var o = 42;
+            with(o) {
+                var foo = "something"
+            }
+            doSomething(o);
+        }
+        function bar() {
+            var unused = 42;
+            return something();
+        }
+    }
+    expect: {
+        function foo() {
+            var o = 42;
+            with(o)
+                var foo = "something";
+            doSomething(o)
+        }
+        function bar() {
+            return something()
+        }
+    }
+}
+with_using_existing_variable_outside_scope: {
+    options = {
+        unused: true
+    }
+    input: {
+        function f() {
+            var o = {};
+            var unused = {}; // Doesn't get removed because upper scope uses with
+            function foo() {
+                with(o) {
+                    var foo = "something"
+                }
+                doSomething(o);
+            }
+            foo()
+        }
+    }
+    expect: {
+        function f() {
+            var o = {};
+            var unused = {};
+            function foo() {
+                with(o)
+                    var foo = "something";
+                doSomething(o)
+            }
+            foo()
+        }
+    }
+}
+check_drop_unused_in_peer_function: {
+    options = {
+        unused: true
+    }
+    input: {
+        function outer() {
+            var o = {};
+            var unused = {};     // should be kept
+            function foo() {     // should be kept
+                function not_in_use() {
+                    var nested_unused = "foo"; // should be dropped
+                    return 24;
+                }
+                var unused = {}; // should be kept
+                with (o) {
+                    var foo = "something";
+                }
+                doSomething(o);
+            }
+            function bar() {
+                var unused = {}; // should be dropped
+                doSomethingElse();
+            }
+            foo();
+            bar();
+        }
+    }
+    expect: {
+        function outer() {
+            var o = {};
+            var unused = {};     // should be kept
+            function foo() {     // should be kept
+                function not_in_use() {
+                    return 24;
+                }
+                var unused = {}; // should be kept
+                with (o)
+                    var foo = "something";
+                doSomething(o);
+            }
+            function bar() {
+                doSomethingElse();
+            }
+            foo();
+            bar();
+        }
+    }
+}
+
+Infinity_not_in_with_scope: {
+    options = {
+        unused: true
+    }
+    input: {
+        var o = { Infinity: 'oInfinity' };
+        var vInfinity = "Infinity";
+        vInfinity = Infinity;
+    }
+    expect: {
+        var o = { Infinity: 'oInfinity' }
+        var vInfinity = "Infinity"
+        vInfinity = 1/0
+    }
+}
+
+Infinity_in_with_scope: {
+    options = {
+        unused: true
+    }
+    input: {
+        var o = { Infinity: 'oInfinity' };
+        var vInfinity = "Infinity";
+        with (o) { vInfinity = Infinity; }
+    }
+    expect: {
+        var o = { Infinity: 'oInfinity' }
+        var vInfinity = "Infinity"
+        with (o) vInfinity = Infinity
+    }
+}
+
+assorted_Infinity_NaN_undefined_in_with_scope: {
+    options = {
+        unused:        true,
+        evaluate:      true,
+        dead_code:     true,
+        conditionals:  true,
+        comparisons:   true,
+        booleans:      true,
+        hoist_funs:    true,
+        keep_fargs:    true,
+        if_return:     true,
+        join_vars:     true,
+        cascade:       true,
+        side_effects:  true,
+        sequences:     false,
+        keep_infinity: false,
+    }
+    input: {
+        var f = console.log;
+        var o = {
+            undefined : 3,
+            NaN       : 4,
+            Infinity  : 5,
+        };
+        if (o) {
+            f(undefined, void 0);
+            f(NaN, 0/0);
+            f(Infinity, 1/0);
+            f(-Infinity, -(1/0));
+            f(2 + 7 + undefined, 2 + 7 + void 0);
+        }
+        with (o) {
+            f(undefined, void 0);
+            f(NaN, 0/0);
+            f(Infinity, 1/0);
+            f(-Infinity, -(1/0));
+            f(2 + 7 + undefined, 2 + 7 + void 0);
+        }
+    }
+    expect: {
+        var f = console.log, o = {
+            undefined : 3,
+            NaN       : 4,
+            Infinity  : 5
+        };
+        if (o) {
+            f(void 0, void 0);
+            f(NaN, NaN);
+            f(1/0, 1/0);
+            f(-1/0, -1/0);
+            f(NaN, NaN);
+        }
+        with (o) {
+            f(undefined, void 0);
+            f(NaN, 0/0);
+            f(Infinity, 1/0);
+            f(-Infinity, -1/0);
+            f(9 + undefined, 9 + void 0);
+        }
+    }
+    expect_stdout: true
+}
+
+assorted_Infinity_NaN_undefined_in_with_scope_keep_infinity: {
+    options = {
+        unused:        true,
+        evaluate:      true,
+        dead_code:     true,
+        conditionals:  true,
+        comparisons:   true,
+        booleans:      true,
+        hoist_funs:    true,
+        keep_fargs:    true,
+        if_return:     true,
+        join_vars:     true,
+        cascade:       true,
+        side_effects:  true,
+        sequences:     false,
+        keep_infinity: true,
+    }
+    input: {
+        var f = console.log;
+        var o = {
+            undefined : 3,
+            NaN       : 4,
+            Infinity  : 5,
+        };
+        if (o) {
+            f(undefined, void 0);
+            f(NaN, 0/0);
+            f(Infinity, 1/0);
+            f(-Infinity, -(1/0));
+            f(2 + 7 + undefined, 2 + 7 + void 0);
+        }
+        with (o) {
+            f(undefined, void 0);
+            f(NaN, 0/0);
+            f(Infinity, 1/0);
+            f(-Infinity, -(1/0));
+            f(2 + 7 + undefined, 2 + 7 + void 0);
+        }
+    }
+    expect: {
+        var f = console.log, o = {
+            undefined : 3,
+            NaN       : 4,
+            Infinity  : 5
+        };
+        if (o) {
+            f(void 0, void 0);
+            f(NaN, NaN);
+            f(Infinity, 1/0);
+            f(-Infinity, -1/0);
+            f(NaN, NaN);
+        }
+        with (o) {
+            f(undefined, void 0);
+            f(NaN, 0/0);
+            f(Infinity, 1/0);
+            f(-Infinity, -1/0);
+            f(9 + undefined, 9 + void 0);
+        }
+    }
+    expect_stdout: true
+}

test/compress/issue-12.js

@@ -9,3 +9,50 @@ keep_name_of_setter: {
     input: { a = { set foo () {} } }
     expect: { a = { set foo () {} } }
 }
+
+setter_with_operator_keys: {
+    input: {
+        var tokenCodes  = {
+            get instanceof(){
+                return test0;
+            },
+            set instanceof(value){
+                test0 = value;
+            },
+            set typeof(value){
+                test1 = value;
+            },
+            get typeof(){
+                return test1;
+            },
+            set else(value){
+                test2 = value;
+            },
+            get else(){
+                return test2;
+            }
+        };
+    }
+    expect: {
+        var tokenCodes  = {
+            get instanceof(){
+                return test0;
+            },
+            set instanceof(value){
+                test0 = value;
+            },
+            set typeof(value){
+                test1 = value;
+            },
+            get typeof(){
+                return test1;
+            },
+            set else(value){
+                test2 = value;
+            },
+            get else(){
+                return test2;
+            }
+        };
+    }
+}

test/compress/issue-1202.js

@@ -0,0 +1,51 @@
+mangle_keep_fnames_false: {
+    options = {
+        keep_fnames : true,
+        keep_fargs  : true,
+    }
+    mangle = {
+        keep_fnames : false,
+    }
+    input: {
+        "use strict";
+        function total() {
+            return function n(a, b, c) {
+                return a + b + c;
+            };
+        }
+    }
+    expect: {
+        "use strict";
+        function total() {
+            return function t(n, r, u) {
+                return n + r + u;
+            };
+        }
+    }
+}
+
+mangle_keep_fnames_true: {
+    options = {
+        keep_fnames : true,
+        keep_fargs  : true,
+    }
+    mangle = {
+        keep_fnames : true,
+    }
+    input: {
+        "use strict";
+        function total() {
+            return function n(a, b, c) {
+                return a + b + c;
+            };
+        }
+    }
+    expect: {
+        "use strict";
+        function total() {
+            return function n(t, r, u) {
+                return t + r + u;
+            };
+        }
+    }
+}

test/compress/issue-126.js

@@ -0,0 +1,24 @@
+concatenate_rhs_strings: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+    }
+    input: {
+        foo(bar() + 123 + "Hello" + "World");
+        foo(bar() + (123 + "Hello") + "World");
+        foo((bar() + 123) + "Hello" + "World");
+        foo(bar() + 123 + "Hello" + "World" + ("Foo" + "Bar"));
+        foo("Foo" + "Bar" + bar() + 123 + "Hello" + "World" + ("Foo" + "Bar"));
+        foo("Hello" + bar() + 123 + "World");
+        foo(bar() + 'Foo' + (10 + parseInt('10')));
+    }
+    expect: {
+        foo(bar() + 123 + "HelloWorld");
+        foo(bar() + "123HelloWorld");
+        foo((bar() + 123) + "HelloWorld");
+        foo(bar() + 123 + "HelloWorldFooBar");
+        foo("FooBar" + bar() + "123HelloWorldFooBar");
+        foo("Hello" + bar() + "123World");
+        foo(bar() + 'Foo' + (10 + parseInt('10')));
+    }
+}

test/compress/issue-1261.js

@@ -0,0 +1,176 @@
+pure_function_calls: {
+    options = {
+        evaluate     : true,
+        conditionals : true,
+        comparisons  : true,
+        side_effects : true,
+        booleans     : true,
+        unused       : true,
+        if_return    : true,
+        join_vars    : true,
+        cascade      : true,
+        negate_iife  : true,
+    }
+    input: {
+        // pure top-level IIFE will be dropped
+        // @__PURE__ - comment
+        (function() {
+            console.log("iife0");
+        })();
+
+        // pure top-level IIFE assigned to unreferenced var will not be dropped
+        var iife1 = /*@__PURE__*/(function() {
+            console.log("iife1");
+            function iife1() {}
+            return iife1;
+        })();
+
+        (function(){
+            // pure IIFE in function scope assigned to unreferenced var will be dropped
+            var iife2 = /*#__PURE__*/(function() {
+                console.log("iife2");
+                function iife2() {}
+                return iife2;
+            })();
+        })();
+
+        // comment #__PURE__ comment
+        bar(), baz(), quux();
+        a.b(), /* @__PURE__ */ c.d.e(), f.g();
+    }
+    expect: {
+        var iife1 = function() {
+            console.log("iife1");
+            function iife1() {}
+            return iife1;
+        }();
+
+        baz(), quux();
+        a.b(), f.g();
+    }
+    expect_warnings: [
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:17,8]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:17,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:30,37]",
+        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:30,16]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:28,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:38,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:39,31]",
+    ]
+}
+
+pure_function_calls_toplevel: {
+    options = {
+        evaluate     : true,
+        conditionals : true,
+        comparisons  : true,
+        side_effects : true,
+        booleans     : true,
+        unused       : true,
+        if_return    : true,
+        join_vars    : true,
+        cascade      : true,
+        negate_iife  : true,
+        toplevel     : true,
+    }
+    input: {
+        // pure top-level IIFE will be dropped
+        // @__PURE__ - comment
+        (function() {
+            console.log("iife0");
+        })();
+
+        // pure top-level IIFE assigned to unreferenced var will be dropped
+        var iife1 = /*@__PURE__*/(function() {
+            console.log("iife1");
+            function iife1() {}
+            return iife1;
+        })();
+
+        (function(){
+            // pure IIFE in function scope assigned to unreferenced var will be dropped
+            var iife2 = /*#__PURE__*/(function() {
+                console.log("iife2");
+                function iife2() {}
+                return iife2;
+            })();
+        })();
+
+        // comment #__PURE__ comment
+        bar(), baz(), quux();
+        a.b(), /* @__PURE__ */ c.d.e(), f.g();
+    }
+    expect: {
+        baz(), quux();
+        a.b(), f.g();
+    }
+    expect_warnings: [
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:79,8]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:79,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:92,37]",
+        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:92,16]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:90,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:100,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:101,31]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:84,33]",
+        "WARN: Dropping unused variable iife1 [test/compress/issue-1261.js:84,12]",
+    ]
+}
+
+should_warn: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        evaluate: true,
+        side_effects: true,
+    }
+    input: {
+        /* @__PURE__ */(function(){x})(), void/* @__PURE__ */(function(){y})();
+        /* @__PURE__ */(function(){x})() || true ? foo() : bar();
+        true || /* @__PURE__ */(function(){y})() ? foo() : bar();
+        /* @__PURE__ */(function(){x})() && false ? foo() : bar();
+        false && /* @__PURE__ */(function(){y})() ? foo() : bar();
+        /* @__PURE__ */(function(){x})() + "foo" ? bar() : baz();
+        "foo" + /* @__PURE__ */(function(){y})() ? bar() : baz();
+        /* @__PURE__ */(function(){x})() ? foo() : foo();
+        [/* @__PURE__ */(function(){x})()] ? foo() : bar();
+        !{ foo: /* @__PURE__ */(function(){x})() } ? bar() : baz();
+    }
+    expect: {
+        foo();
+        foo();
+        bar();
+        bar();
+        bar();
+        bar();
+        foo();
+        foo();
+        baz();
+    }
+    expect_warnings: [
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:128,61]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:128,23]",
+        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:128,23]",
+        "WARN: Boolean || always true [test/compress/issue-1261.js:129,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:129,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:129,23]",
+        "WARN: Condition left of || always true [test/compress/issue-1261.js:130,8]",
+        "WARN: Condition always true [test/compress/issue-1261.js:130,8]",
+        "WARN: Boolean && always false [test/compress/issue-1261.js:131,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:131,23]",
+        "WARN: Condition always false [test/compress/issue-1261.js:131,23]",
+        "WARN: Condition left of && always false [test/compress/issue-1261.js:132,8]",
+        "WARN: Condition always false [test/compress/issue-1261.js:132,8]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:133,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:133,23]",
+        "WARN: Condition always true [test/compress/issue-1261.js:133,23]",
+        "WARN: + in boolean context always true [test/compress/issue-1261.js:134,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:134,31]",
+        "WARN: Condition always true [test/compress/issue-1261.js:134,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:135,23]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:136,24]",
+        "WARN: Condition always true [test/compress/issue-1261.js:136,8]",
+        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:137,31]",
+        "WARN: Condition always false [test/compress/issue-1261.js:137,8]",
+    ]
+}

test/compress/issue-1275.js

@@ -0,0 +1,50 @@
+string_plus_optimization: {
+    options = {
+        side_effects  : true,
+        evaluate      : true,
+        conditionals  : true,
+        comparisons   : true,
+        dead_code     : true,
+        booleans      : true,
+        unused        : true,
+        if_return     : true,
+        join_vars     : true,
+        cascade       : true,
+        hoist_funs    : true,
+    };
+    input: {
+        function foo(anything) {
+            function throwing_function() {
+                throw "nope";
+            }
+            try {
+                console.log('0' + throwing_function() ? "yes" : "no");
+            } catch (ex) {
+                console.log(ex);
+            }
+            console.log('0' + anything ? "yes" : "no");
+            console.log(anything + '0' ? "Yes" : "No");
+            console.log('' + anything);
+            console.log(anything + '');
+        }
+        foo();
+    }
+    expect: {
+        function foo(anything) {
+            function throwing_function() {
+                throw "nope";
+            }
+            try {
+                console.log((throwing_function(), "yes"));
+            } catch (ex) {
+                console.log(ex);
+            }
+            console.log("yes");
+            console.log("Yes");
+            console.log('' + anything);
+            console.log(anything + '');
+        }
+        foo();
+    }
+    expect_stdout: true
+}

test/compress/issue-1321.js

@@ -0,0 +1,57 @@
+issue_1321_no_debug: {
+    mangle_props = {
+        keep_quoted: true
+    }
+    input: {
+        var x = {};
+        x.foo = 1;
+        x["a"] = 2 * x.foo;
+        console.log(x.foo, x["a"]);
+    }
+    expect: {
+        var x = {};
+        x.b = 1;
+        x["a"] = 2 * x.b;
+        console.log(x.b, x["a"]);
+    }
+    expect_stdout: true
+}
+
+issue_1321_debug: {
+    mangle_props = {
+        keep_quoted: true,
+        debug: ""
+    }
+    input: {
+        var x = {};
+        x.foo = 1;
+        x["_$foo$_"] = 2 * x.foo;
+        console.log(x.foo, x["_$foo$_"]);
+    }
+    expect: {
+        var x = {};
+        x.a = 1;
+        x["_$foo$_"] = 2 * x.a;
+        console.log(x.a, x["_$foo$_"]);
+    }
+    expect_stdout: true
+}
+
+issue_1321_with_quoted: {
+    mangle_props = {
+        keep_quoted: false
+    }
+    input: {
+        var x = {};
+        x.foo = 1;
+        x["a"] = 2 * x.foo;
+        console.log(x.foo, x["a"]);
+    }
+    expect: {
+        var x = {};
+        x.a = 1;
+        x["b"] = 2 * x.a;
+        console.log(x.a, x["b"]);
+    }
+    expect_stdout: true
+}

test/compress/issue-1431.js

@@ -0,0 +1,151 @@
+level_zero: {
+    options = {
+        keep_fnames: true
+    }
+    mangle = {
+        keep_fnames: true
+    }
+    input: {
+        function f(x) {
+            function n(a) {
+                return a * a;
+            }
+            return function() {
+                return x;
+            };
+        }
+    }
+    expect: {
+        function f(r) {
+            function n(n) {
+                return n * n;
+            }
+            return function() {
+                return r;
+            };
+        }
+    }
+}
+
+level_one: {
+    options = {
+        keep_fnames: true
+    }
+    mangle = {
+        keep_fnames: true
+    }
+    input: {
+        function f(x) {
+            return function() {
+                function n(a) {
+                    return a * a;
+                }
+                return x(n);
+            };
+        }
+    }
+    expect: {
+        function f(r) {
+            return function() {
+                function n(n) {
+                    return n * n;
+                }
+                return r(n);
+            };
+        }
+    }
+}
+
+level_two: {
+    options = {
+        keep_fnames: true
+    }
+    mangle = {
+        keep_fnames: true
+    }
+    input: {
+        function f(x) {
+            return function() {
+                function r(a) {
+                    return a * a;
+                }
+                return function() {
+                    function n(a) {
+                        return a * a;
+                    }
+                    return x(n);
+                };
+            };
+        }
+    }
+    expect: {
+        function f(t) {
+            return function() {
+                function r(n) {
+                    return n * n;
+                }
+                return function() {
+                    function n(n) {
+                        return n * n;
+                    }
+                    return t(n);
+                };
+            };
+        }
+    }
+}
+
+level_three: {
+    options = {
+        keep_fnames: true
+    }
+    mangle = {
+        keep_fnames: true
+    }
+    input: {
+        function f(x) {
+            return function() {
+                function r(a) {
+                    return a * a;
+                }
+                return [
+                    function() {
+                        function t(a) {
+                            return a * a;
+                        }
+                        return t;
+                    },
+                    function() {
+                        function n(a) {
+                            return a * a;
+                        }
+                        return x(n);
+                    }
+                ];
+            };
+        }
+    }
+    expect: {
+        function f(t) {
+            return function() {
+                function r(n) {
+                    return n * n;
+                }
+                return [
+                    function() {
+                        function t(n) {
+                            return n * n;
+                        }
+                        return t;
+                    },
+                    function() {
+                        function n(n) {
+                            return n * n;
+                        }
+                        return t(n);
+                    }
+                ];
+            };
+        }
+    }
+}

test/compress/issue-1443.js

@@ -0,0 +1,61 @@
+// tests assume that variable `undefined` not redefined and has `void 0` as value
+
+unsafe_undefined: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        unsafe: true
+    }
+    mangle = {}
+    input: {
+        function f(undefined) {
+            return function() {
+                if (a)
+                    return b;
+                if (c)
+                    return d;
+            };
+        }
+    }
+    expect: {
+        function f(n) {
+            return function() {
+                return a ? b : c ? d : n;
+            };
+        }
+    }
+}
+
+keep_fnames: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        unsafe: true
+    }
+    mangle = {
+        keep_fnames: true
+    }
+    input: {
+        function f(undefined) {
+            return function() {
+                function n(a) {
+                    return a * a;
+                }
+                if (a)
+                    return b;
+                if (c)
+                    return d;
+            };
+        }
+    }
+    expect: {
+        function f(r) {
+            return function() {
+                function n(n) {
+                    return n * n;
+                }
+                return a ? b : c ? d : r;
+            };
+        }
+    }
+}

test/compress/issue-1446.js

@@ -0,0 +1,71 @@
+typeof_eq_undefined: {
+    options = {
+        comparisons: true
+    }
+    input: {
+        var a = typeof b != "undefined";
+        b = typeof a != "undefined";
+        var c = typeof d.e !== "undefined";
+        var f = "undefined" === typeof g;
+        g = "undefined" === typeof f;
+        var h = "undefined" == typeof i.j;
+    }
+    expect: {
+        var a = "undefined" != typeof b;
+        b = void 0 !== a;
+        var c = void 0 !== d.e;
+        var f = "undefined" == typeof g;
+        g = void 0 === f;
+        var h = void 0 === i.j;
+    }
+}
+
+typeof_eq_undefined_ie8: {
+    options = {
+        comparisons: true,
+        ie8: true,
+    }
+    input: {
+        var a = typeof b != "undefined";
+        b = typeof a != "undefined";
+        var c = typeof d.e !== "undefined";
+        var f = "undefined" === typeof g;
+        g = "undefined" === typeof f;
+        var h = "undefined" == typeof i.j;
+    }
+    expect: {
+        var a = "undefined" != typeof b;
+        b = void 0 !== a;
+        var c = "undefined" != typeof d.e;
+        var f = "undefined" == typeof g;
+        g = void 0 === f;
+        var h = "undefined" == typeof i.j;
+    }
+}
+
+undefined_redefined: {
+    options = {
+        comparisons: true
+    }
+    input: {
+        function f(undefined) {
+            var n = 1;
+            return typeof n == "undefined";
+        }
+    }
+    expect_exact: "function f(undefined){var n=1;return void 0===n}"
+}
+
+undefined_redefined_mangle: {
+    options = {
+        comparisons: true
+    }
+    mangle = {}
+    input: {
+        function f(undefined) {
+            var n = 1;
+            return typeof n == "undefined";
+        }
+    }
+    expect_exact: "function f(n){var r=1;return void 0===r}"
+}

test/compress/issue-1447.js

@@ -0,0 +1,46 @@
+else_with_empty_block: {
+    options = {}
+    input: {
+        if (x)
+            yes();
+        else {
+        }
+    }
+    expect_exact: "if(x)yes();"
+}
+
+else_with_empty_statement: {
+    options = {}
+    input: {
+        if (x)
+            yes();
+        else
+            ;
+    }
+    expect_exact: "if(x)yes();"
+}
+
+conditional_false_stray_else_in_loop: {
+    options = {
+        evaluate     : true,
+        comparisons  : true,
+        booleans     : true,
+        unused       : true,
+        loops        : true,
+        side_effects : true,
+        dead_code    : true,
+        hoist_vars   : true,
+        join_vars    : true,
+        if_return    : true,
+        cascade      : true,
+        conditionals : false,
+    }
+    input: {
+        for (var i = 1; i <= 4; ++i) {
+            if (i <= 2) continue;
+            console.log(i);
+        }
+    }
+    expect_exact: "for(var i=1;i<=4;++i)if(!(i<=2))console.log(i);"
+    expect_stdout: true
+}

test/compress/issue-1569.js

@@ -0,0 +1,19 @@
+inner_reference: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        !function f(a) {
+            return a && f(a - 1) + a;
+        }(42);
+        !function g(a) {
+            return a;
+        }(42);
+    }
+    expect: {
+        !function f(a) {
+            return a && f(a - 1) + a;
+        }(42);
+        !void 0;
+    }
+}

test/compress/issue-1588.js

@@ -0,0 +1,99 @@
+screw_ie8: {
+    options = {
+        ie8: false,
+    }
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        try { throw "foo"; } catch (x) { console.log(x); }
+    }
+    expect_exact: 'try{throw"foo"}catch(o){console.log(o)}'
+    expect_stdout: [
+        "foo"
+    ]
+}
+
+support_ie8: {
+    options = {
+        ie8: true,
+    }
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        try { throw "foo"; } catch (x) { console.log(x); }
+    }
+    expect_exact: 'try{throw"foo"}catch(x){console.log(x)}'
+    expect_stdout: "foo"
+}
+
+safe_undefined: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        unsafe: false,
+    }
+    mangle = {}
+    input: {
+        var a, c;
+        console.log(function(undefined) {
+            return function() {
+                if (a)
+                    return b;
+                if (c)
+                    return d;
+            };
+        }(1)());
+    }
+    expect: {
+        var a, c;
+        console.log(function(n) {
+            return function() {
+                return a ? b : c ? d : void 0;
+            };
+        }(1)());
+    }
+    expect_stdout: true
+}
+
+unsafe_undefined: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        unsafe: true,
+    }
+    mangle = {}
+    input: {
+        var a, c;
+        console.log(function(undefined) {
+            return function() {
+                if (a)
+                    return b;
+                if (c)
+                    return d;
+            };
+        }()());
+    }
+    expect: {
+        var a, c;
+        console.log(function(n) {
+            return function() {
+                return a ? b : c ? d : n;
+            };
+        }()());
+    }
+    expect_stdout: true
+}
+
+runtime_error: {
+    input: {
+        const a = 1;
+        console.log(a++);
+    }
+    expect: {
+        const a = 1;
+        console.log(a++);
+    }
+    expect_stdout: true
+}

test/compress/issue-1609.js

@@ -0,0 +1,52 @@
+chained_evaluation_1: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a = 1;
+            (function() {
+                var b = a, c;
+                c = f(b);
+                c.bar = b;
+            })();
+        })();
+    }
+    expect: {
+        (function() {
+            (function() {
+                f(1).bar = 1;
+            })();
+        })();
+    }
+}
+
+chained_evaluation_2: {
+    options = {
+        collapse_vars: true,
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a = "long piece of string";
+            (function() {
+                var b = a, c;
+                c = f(b);
+                c.bar = b;
+            })();
+        })();
+    }
+    expect: {
+        (function() {
+            (function() {
+                var b = "long piece of string";
+                f(b).bar = b;
+            })();
+        })();
+    }
+}

test/compress/issue-1639.js

@@ -0,0 +1,88 @@
+
+issue_1639_1: {
+    options = {
+        booleans: true,
+        cascade: true,
+        conditionals: true,
+        evaluate: true,
+        join_vars: true,
+        loops: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 100, b = 10;
+
+        var L1 = 5;
+        while (--L1 > 0) {
+            if ((--b), false) {
+                if (b) {
+                    var ignore = 0;
+                }
+            }
+        }
+
+        console.log(a, b);
+    }
+    expect: {
+        for (var a = 100, b = 10, L1 = 5; --L1 > 0;)
+            if (--b, !1) var ignore = 0;
+        console.log(a, b);
+    }
+    expect_stdout: true
+}
+
+issue_1639_2: {
+    options = {
+        booleans: true,
+        cascade: true,
+        conditionals: true,
+        evaluate: true,
+        join_vars: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 100, b = 10;
+
+        function f19() {
+            if (++a, false)
+                if (a)
+                    if (++a);
+        }
+        f19();
+
+        console.log(a, b);
+    }
+    expect: {
+        var a = 100, b = 10;
+        function f19() {
+            ++a, 1;
+        }
+        f19(),
+        console.log(a, b);
+    }
+    expect_stdout: true
+}
+
+issue_1639_3: {
+    options = {
+        booleans: true,
+        cascade: true,
+        conditionals: true,
+        evaluate: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 100, b = 10;
+        a++ && false && a ? 0 : 0;
+        console.log(a, b);
+    }
+    expect: {
+        var a = 100, b = 10;
+        a++,
+        console.log(a, b);
+    }
+    expect_stdout: true
+}

test/compress/issue-1656.js

@@ -0,0 +1,45 @@
+f7: {
+    options = {
+        booleans: true,
+        cascade: true,
+        collapse_vars: true,
+        comparisons: true,
+        conditionals: true,
+        dead_code: true,
+        drop_debugger: true,
+        evaluate: true,
+        hoist_funs: true,
+        if_return: true,
+        join_vars: true,
+        loops: true,
+        negate_iife: true,
+        passes: 3,
+        properties: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        toplevel: true,
+        unused: true,
+    }
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        var a = 100, b = 10;
+        function f22464() {
+            var brake146670 = 5;
+            while (((b = a) ? !a : ~a ? null : b += a) && --brake146670 > 0) {
+            }
+        }
+        f22464();
+        console.log(a, b);
+    }
+    expect_exact: [
+        "var b = 10;",
+        "",
+        "!function() {",
+        "    for (;b = 100, !1; ) ;",
+        "}(), console.log(100, b);",
+    ]
+    expect_stdout: true
+}

test/compress/issue-1673.js

@@ -0,0 +1,161 @@
+side_effects_catch: {
+    options = {
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {
+                try {
+                    throw 0;
+                } catch (e) {
+                    console.log("PASS");
+                }
+            }
+            g();
+        }
+        f();
+    }
+    expect: {
+        function f() {
+            (function() {
+                try {
+                    throw 0;
+                } catch (e) {
+                    console.log("PASS");
+                }
+            })();
+        }
+        f();
+    }
+    expect_stdout: "PASS"
+}
+
+side_effects_else: {
+    options = {
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f(x) {
+            function g() {
+                if (x);
+                else console.log("PASS");
+            }
+            g();
+        }
+        f(0);
+    }
+    expect: {
+        function f(x) {
+            (function() {
+                if (x);
+                else console.log("PASS");
+            })();
+        }
+        f(0);
+    }
+    expect_stdout: "PASS"
+}
+
+side_effects_finally: {
+    options = {
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {
+                try {
+                    x();
+                } catch (e) {
+                } finally {
+                    console.log("PASS");
+                }
+            }
+            g();
+        }
+        f();
+    }
+    expect: {
+        function f() {
+            (function() {
+                try {
+                    x();
+                } catch (e) {
+                } finally {
+                    console.log("PASS");
+                }
+            })();
+        }
+        f();
+    }
+    expect_stdout: "PASS"
+}
+
+side_effects_label: {
+    options = {
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f(x) {
+            function g() {
+                L: {
+                    console.log("PASS");
+                    break L;
+                }
+            }
+            g();
+        }
+        f(0);
+    }
+    expect: {
+        function f(x) {
+            (function() {
+                L: {
+                    console.log("PASS");
+                    break L;
+                }
+            })();
+        }
+        f(0);
+    }
+    expect_stdout: "PASS"
+}
+
+side_effects_switch: {
+    options = {
+        reduce_vars: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {
+                switch (0) {
+                  default:
+                  case console.log("PASS"):
+                }
+            }
+            g();
+        }
+        f();
+    }
+    expect: {
+        function f() {
+            (function() {
+                switch (0) {
+                  default:
+                  case console.log("PASS"):
+                }
+            })();
+        }
+        f();
+    }
+    expect_stdout: "PASS"
+}

test/compress/issue-1704.js

@@ -0,0 +1,347 @@
+mangle_catch: {
+    options = {
+        ie8: false,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: false,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="FAIL";try{throw 1}catch(o){a="PASS"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_ie8: {
+    options = {
+        ie8: true,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: false,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="FAIL";try{throw 1}catch(args){a="PASS"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_var: {
+    options = {
+        ie8: false,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: false,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            var a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="FAIL";try{throw 1}catch(o){var a="PASS"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_var_ie8: {
+    options = {
+        ie8: true,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: false,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            var a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="FAIL";try{throw 1}catch(args){var a="PASS"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_toplevel: {
+    options = {
+        ie8: false,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="FAIL";try{throw 1}catch(c){o="PASS"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_ie8_toplevel: {
+    options = {
+        ie8: true,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="FAIL";try{throw 1}catch(c){o="PASS"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_var_toplevel: {
+    options = {
+        ie8: false,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            var a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="FAIL";try{throw 1}catch(r){var o="PASS"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_var_ie8_toplevel: {
+    options = {
+        ie8: true,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw 1;
+        } catch (args) {
+            var a = "PASS";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="FAIL";try{throw 1}catch(r){var o="PASS"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_redef_1: {
+    options = {
+        ie8: false,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: false,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="PASS";try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_redef_1_ie8: {
+    options = {
+        ie8: true,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: false,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var a="PASS";try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_redef_1_toplevel: {
+    options = {
+        ie8: false,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="PASS";try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_redef_1_ie8_toplevel: {
+    options = {
+        ie8: true,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        var a = "PASS";
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'var o="PASS";try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
+    expect_stdout: "PASS"
+}
+
+mangle_catch_redef_2: {
+    options = {
+        ie8: false,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: false,
+    }
+    input: {
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
+    expect_stdout: "undefined"
+}
+
+mangle_catch_redef_2_ie8: {
+    options = {
+        ie8: true,
+        toplevel: false,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: false,
+    }
+    input: {
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
+    expect_stdout: "undefined"
+}
+
+mangle_catch_redef_2_toplevel: {
+    options = {
+        ie8: false,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: false,
+        toplevel: true,
+    }
+    input: {
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
+    expect_stdout: "undefined"
+}
+
+mangle_catch_redef_2_ie8_toplevel: {
+    options = {
+        ie8: true,
+        toplevel: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        try {
+            throw "FAIL1";
+        } catch (a) {
+            var a = "FAIL2";
+        }
+        console.log(a);
+    }
+    expect_exact: 'try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
+    expect_stdout: "undefined"
+}

test/compress/issue-1733.js

@@ -0,0 +1,97 @@
+function_iife_catch: {
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        function f(n) {
+            !function() {
+                try {
+                    throw 0;
+                } catch (n) {
+                    var a = 1;
+                    console.log(n, a);
+                }
+            }();
+        }
+        f();
+    }
+    expect_exact: "function f(o){!function(){try{throw 0}catch(c){var o=1;console.log(c,o)}}()}f();"
+    expect_stdout: "0 1"
+}
+
+function_iife_catch_ie8: {
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        function f(n) {
+            !function() {
+                try {
+                    throw 0;
+                } catch (n) {
+                    var a = 1;
+                    console.log(n, a);
+                }
+            }();
+        }
+        f();
+    }
+    expect_exact: "function f(o){!function(){try{throw 0}catch(o){var c=1;console.log(o,c)}}()}f();"
+    expect_stdout: "0 1"
+}
+
+function_catch_catch: {
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        var o = 0;
+        function f() {
+            try {
+                throw 1;
+            } catch (c) {
+                try {
+                    throw 2;
+                } catch (o) {
+                    var o = 3;
+                    console.log(o);
+                }
+            }
+            console.log(o);
+        }
+        f();
+    }
+    expect_exact: "var o=0;function f(){try{throw 1}catch(c){try{throw 2}catch(o){var o=3;console.log(o)}}console.log(o)}f();"
+    expect_stdout: [
+        "3",
+        "undefined",
+    ]
+}
+
+function_catch_catch_ie8: {
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        var o = 0;
+        function f() {
+            try {
+                throw 1;
+            } catch (c) {
+                try {
+                    throw 2;
+                } catch (o) {
+                    var o = 3;
+                    console.log(o);
+                }
+            }
+            console.log(o);
+        }
+        f();
+    }
+    expect_exact: "var o=0;function f(){try{throw 1}catch(c){try{throw 2}catch(o){var o=3;console.log(o)}}console.log(o)}f();"
+    expect_stdout: [
+        "3",
+        "undefined",
+    ]
+}

test/compress/issue-1750.js

@@ -0,0 +1,54 @@
+case_1: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        var a = 0, b = 1;
+        switch (true) {
+          case a, true:
+          default:
+            b = 2;
+          case true:
+        }
+        console.log(a, b);
+    }
+    expect: {
+        var a = 0, b = 1;
+        switch (true) {
+          case a, true:
+            b = 2;
+        }
+        console.log(a, b);
+    }
+    expect_stdout: "0 2"
+}
+
+case_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        var a = 0, b = 1;
+        switch (0) {
+          default:
+            b = 2;
+          case a:
+            a = 3;
+          case 0:
+        }
+        console.log(a, b);
+    }
+    expect: {
+        var a = 0, b = 1;
+        switch (0) {
+          case a:
+            a = 3;
+        }
+        console.log(a, b);
+    }
+    expect_stdout: "3 1"
+}

test/compress/issue-1770.js

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

test/compress/issue-1787.js

@@ -0,0 +1,15 @@
+unary_prefix: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var x = -(2 / 3);
+            return x;
+        }());
+    }
+    expect_exact: "console.log(-2/3);"
+    expect_stdout: true
+}

test/compress/issue-1833.js

@@ -0,0 +1,134 @@
+iife_for: {
+    options = {
+        negate_iife: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {
+                L: for (;;) break L;
+            }
+            g();
+        }
+        f();
+    }
+    expect: {
+        !function() {
+            !function() {
+                L: for (;;) break L;
+            }();
+        }();
+    }
+}
+
+iife_for_in: {
+    options = {
+        negate_iife: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {
+                L: for (var a in x) break L;
+            }
+            g();
+        }
+        f();
+    }
+    expect: {
+        !function() {
+            !function() {
+                L: for (var a in x) break L;
+            }();
+        }();
+    }
+}
+
+iife_do: {
+    options = {
+        negate_iife: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {
+                L: do {
+                    break L;
+                } while (1);
+            }
+            g();
+        }
+        f();
+    }
+    expect: {
+        !function() {
+            !function() {
+                L: do {
+                    break L;
+                } while (1);
+            }();
+        }();
+    }
+}
+
+iife_while: {
+    options = {
+        negate_iife: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            function g() {
+                L: while (1) break L;
+            }
+            g();
+        }
+        f();
+    }
+    expect: {
+        !function() {
+            !function() {
+                L: while (1) break L;
+            }();
+        }();
+    }
+}
+
+label_do: {
+    options = {
+        evaluate: true,
+        loops: true,
+    }
+    input: {
+        L: do {
+            continue L;
+        } while (0);
+    }
+    expect: {
+        L: do {
+            continue L;
+        } while (0);
+    }
+}
+
+label_while: {
+    options = {
+        evaluate: true,
+        dead_code: true,
+        loops: true,
+    }
+    input: {
+        function f() {
+            L: while (0) continue L;
+        }
+    }
+    expect_exact: "function f(){L:;}"
+}

test/compress/issue-208.js

@@ -0,0 +1,70 @@
+do_not_update_lhs: {
+    options = {
+        global_defs: { DEBUG: 0 }
+    }
+    input: {
+        DEBUG++;
+        DEBUG += 1;
+        DEBUG = 1;
+    }
+    expect: {
+        DEBUG++;
+        DEBUG += 1;
+        DEBUG = 1;
+    }
+}
+
+do_update_rhs: {
+    options = {
+        global_defs: { DEBUG: 0 }
+    }
+    input: {
+        MY_DEBUG = DEBUG;
+        MY_DEBUG += DEBUG;
+    }
+    expect: {
+        MY_DEBUG = 0;
+        MY_DEBUG += 0;
+    }
+}
+
+mixed: {
+    options = {
+        evaluate: true,
+        global_defs: {
+            DEBUG: 0,
+            ENV: 1,
+            FOO: 2,
+        }
+    }
+    input: {
+        const ENV = 3;
+        var FOO = 4;
+        f(ENV * 10);
+        --FOO;
+        DEBUG = 1;
+        DEBUG++;
+        DEBUG += 1;
+        f(DEBUG);
+        x = DEBUG;
+    }
+    expect: {
+        const ENV = 3;
+        var FOO = 4;
+        f(10);
+        --FOO;
+        DEBUG = 1;
+        DEBUG++;
+        DEBUG += 1;
+        f(0);
+        x = 0;
+    }
+    expect_warnings: [
+        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,14]',
+        'WARN: global_defs FOO redefined [test/compress/issue-208.js:42,12]',
+        'WARN: global_defs FOO redefined [test/compress/issue-208.js:44,10]',
+        'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:45,8]',
+        'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:46,8]',
+        'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:47,8]',
+    ]
+}

test/compress/issue-267.js

@@ -0,0 +1,11 @@
+issue_267: {
+    options = { comparisons: true };
+    input: {
+        x = a % b / b * c * 2;
+        x = a % b * 2
+    }
+    expect: {
+        x = a % b / b * c * 2;
+        x = a % b * 2;
+    }
+}

test/compress/issue-269.js

@@ -0,0 +1,66 @@
+issue_269_1: {
+	options = {unsafe: true};
+	input: {
+		f(
+			String(x),
+			Number(x),
+			Boolean(x),
+
+			String(),
+			Number(),
+			Boolean()
+		);
+	}
+	expect: {
+		f(
+			x + '', +x, !!x,
+			'', 0, false
+		);
+	}
+}
+
+issue_269_dangers: {
+	options = {unsafe: true};
+	input: {
+		f(
+			String(x, x),
+			Number(x, x),
+			Boolean(x, x)
+		);
+	}
+	expect: {
+		f(String(x, x), Number(x, x), Boolean(x, x));
+	}
+}
+
+issue_269_in_scope: {
+	options = {unsafe: true};
+	input: {
+		var String, Number, Boolean;
+		f(
+			String(x),
+			Number(x, x),
+			Boolean(x)
+		);
+	}
+	expect: {
+		var String, Number, Boolean;
+		f(String(x), Number(x, x), Boolean(x));
+	}
+}
+
+strings_concat: {
+	options = {unsafe: true};
+	input: {
+		f(
+			String(x + 'str'),
+			String('str' + x)
+		);
+	}
+	expect: {
+		f(
+			x + 'str',
+			'str' + x
+		);
+	}
+}

test/compress/issue-368.js

@@ -0,0 +1,55 @@
+collapse: {
+    options = {
+        cascade: true,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function f1() {
+            var a;
+            a = typeof b === 'function' ? b() : b;
+            return a !== undefined && c();
+        }
+        function f2(b) {
+            var a;
+            b = c();
+            a = typeof b === 'function' ? b() : b;
+            return 'stirng' == typeof a && d();
+        }
+        function f3(c) {
+            var a;
+            a = b(a / 2);
+            if (a < 0) {
+                a++;
+                ++c;
+                return c / 2;
+            }
+        }
+        function f4(c) {
+            var a;
+            a = b(a / 2);
+            if (a < 0) {
+                a++;
+                c++;
+                return c / 2;
+            }
+        }
+    }
+    expect: {
+        function f1() {
+            return void 0 !== ('function' === typeof b ? b() : b) && c();
+        }
+        function f2(b) {
+            return b = c(), 'stirng' == typeof ('function' === typeof b ? b() : b) && d();
+        }
+        function f3(c) {
+            var a;
+            if ((a = b(a / 2)) < 0) return a++, ++c / 2;
+        }
+        function f4(c) {
+            var a;
+            if ((a = b(a / 2)) < 0) return a++, ++c / 2;
+        }
+    }
+}

test/compress/issue-597.js

@@ -0,0 +1,157 @@
+NaN_and_Infinity_must_have_parens: {
+    options = {};
+    input: {
+        Infinity.toString();
+        NaN.toString();
+    }
+    expect: {
+        (1/0).toString();
+        NaN.toString();
+    }
+}
+
+NaN_and_Infinity_should_not_be_replaced_when_they_are_redefined: {
+    options = {};
+    input: {
+        var Infinity, NaN;
+        Infinity.toString();
+        NaN.toString();
+    }
+    expect: {
+        var Infinity, NaN;
+        Infinity.toString();
+        NaN.toString();
+    }
+}
+
+NaN_and_Infinity_must_have_parens_evaluate: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        (123456789 / 0).toString();
+        (+"foo").toString();
+    }
+    expect: {
+        (1/0).toString();
+        NaN.toString();
+    }
+}
+
+NaN_and_Infinity_should_not_be_replaced_when_they_are_redefined_evaluate: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var Infinity, NaN;
+        (123456789 / 0).toString();
+        (+"foo").toString();
+    }
+    expect: {
+        var Infinity, NaN;
+        (1/0).toString();
+        (0/0).toString();
+    }
+}
+
+beautify_off_1: {
+    options = {
+        evaluate: true,
+    }
+    beautify = {
+        beautify: false,
+    }
+    input: {
+        var NaN;
+        console.log(
+            null,
+            undefined,
+            Infinity,
+            NaN,
+            Infinity * undefined,
+            Infinity.toString(),
+            NaN.toString(),
+            (Infinity * undefined).toString()
+        );
+    }
+    expect_exact: "var NaN;console.log(null,void 0,1/0,NaN,0/0,(1/0).toString(),NaN.toString(),(0/0).toString());"
+    expect_stdout: true
+}
+
+beautify_off_2: {
+    options = {
+        evaluate: true,
+    }
+    beautify = {
+        beautify: false,
+    }
+    input: {
+        console.log(
+            null.toString(),
+            undefined.toString()
+        );
+    }
+    expect_exact: "console.log(null.toString(),(void 0).toString());"
+}
+
+beautify_on_1: {
+    options = {
+        evaluate: true,
+    }
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        var NaN;
+        console.log(
+            null,
+            undefined,
+            Infinity,
+            NaN,
+            Infinity * undefined,
+            Infinity.toString(),
+            NaN.toString(),
+            (Infinity * undefined).toString()
+        );
+    }
+    expect_exact: [
+        "var NaN;",
+        "",
+        "console.log(null, void 0, 1 / 0, NaN, 0 / 0, (1 / 0).toString(), NaN.toString(), (0 / 0).toString());",
+    ]
+    expect_stdout: true
+}
+
+beautify_on_2: {
+    options = {
+        evaluate: true,
+    }
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        console.log(
+            null.toString(),
+            undefined.toString()
+        );
+    }
+    expect_exact: "console.log(null.toString(), (void 0).toString());"
+}
+
+issue_1724: {
+    input: {
+        var a = 0;
+        ++a % Infinity | Infinity ? a++ : 0;
+        console.log(a);
+    }
+    expect_exact: "var a=0;++a%(1/0)|1/0?a++:0;console.log(a);"
+    expect_stdout: "2"
+}
+
+issue_1725: {
+    input: {
+        ([].length === 0) % Infinity ? console.log("PASS") : console.log("FAIL");
+    }
+    expect_exact: '(0===[].length)%(1/0)?console.log("PASS"):console.log("FAIL");'
+    expect_stdout: "PASS"
+}

test/compress/issue-611.js

@@ -0,0 +1,21 @@
+issue_611: {
+  options = {
+    sequences: true,
+    side_effects: true
+  };
+  input: {
+    define(function() {
+      function fn() {}
+      if (fn()) {
+        fn();
+        return void 0;
+      }
+    });
+  }
+  expect: {
+    define(function() {
+      function fn(){}
+      if (fn()) return void fn();
+    });
+  }
+}

test/compress/issue-637.js

@@ -0,0 +1,22 @@
+wrongly_optimized: {
+    options = {
+        conditionals: true,
+        booleans: true,
+        evaluate: true
+    };
+    input: {
+        function func() {
+            foo();
+        }
+        if (func() || true) {
+            bar();
+        }
+    }
+    expect: {
+        function func() {
+            foo();
+        }
+        // TODO: optimize to `func(), bar()`
+        (func(), 0) || bar();
+    }
+}

test/compress/issue-640.js

@@ -0,0 +1,320 @@
+cond_5: {
+    options = {
+        conditionals: true,
+        expression: true,
+    }
+    input: {
+        if (some_condition()) {
+            if (some_other_condition()) {
+                do_something();
+            } else {
+                alternate();
+            }
+        } else {
+            alternate();
+        }
+
+        if (some_condition()) {
+            if (some_other_condition()) {
+                do_something();
+            }
+        }
+    }
+    expect: {
+        some_condition() && some_other_condition() ? do_something() : alternate();
+        if (some_condition() && some_other_condition()) do_something();
+    }
+}
+
+dead_code_const_annotation_regex: {
+    options = {
+        booleans     : true,
+        conditionals : true,
+        dead_code    : true,
+        evaluate     : true,
+        expression   : true,
+        loops        : 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;
+        if (CONST_FOO_ANN) console.log('reachable');
+    }
+    expect_stdout: true
+}
+
+drop_console_2: {
+    options = {
+        drop_console: true,
+        expression: true,
+    }
+    input: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+    expect: {
+        // with regular compression these will be stripped out as well
+        void 0;
+        void 0;
+    }
+}
+
+drop_value: {
+    options = {
+        expression: true,
+        side_effects: true,
+    }
+    input: {
+        (1, [2, foo()], 3, {a:1, b:bar()});
+    }
+    expect: {
+        foo(), {a:1, b:bar()};
+    }
+}
+
+wrongly_optimized: {
+    options = {
+        conditionals: true,
+        booleans: true,
+        evaluate: true,
+        expression: true,
+    }
+    input: {
+        function func() {
+            foo();
+        }
+        if (func() || true) {
+            bar();
+        }
+    }
+    expect: {
+        function func() {
+            foo();
+        }
+        // TODO: optimize to `func(), bar()`
+        if (func(), !0) bar();
+    }
+}
+
+negate_iife_1: {
+    options = {
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function(){ stuff() })();
+    }
+    expect: {
+        (function(){ stuff() })();
+    }
+}
+
+negate_iife_3: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_3_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: false,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+}
+
+negate_iife_4: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function(){ return t }() ? console.log(false) : console.log(true), function(){
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_5: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: true,
+        sequences: true,
+    }
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function(){ return t }() ? bar(false) : foo(true), function(){
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_5_off: {
+    options = {
+        conditionals: true,
+        expression: true,
+        negate_iife: false,
+        sequences: true,
+    };
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function(){ return t }() ? bar(false) : foo(true), function(){
+            console.log("something");
+        }();
+    }
+}
+
+issue_1254_negate_iife_true: {
+    options = {
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: '(function(){return function(){console.log("test")}})()();'
+    expect_stdout: true
+}
+
+issue_1254_negate_iife_nested: {
+    options = {
+        expression: true,
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()()()()();
+    }
+    expect_exact: '(function(){return function(){console.log("test")}})()()()()();'
+    expect_stdout: true
+}
+
+conditional: {
+    options = {
+        expression: true,
+        pure_funcs: [ "pure" ],
+        side_effects: true,
+    }
+    input: {
+        pure(1 | a() ? 2 & b() : 7 ^ c());
+        pure(1 | a() ? 2 & b() : 5);
+        pure(1 | a() ? 4 : 7 ^ c());
+        pure(1 | a() ? 4 : 5);
+        pure(3 ? 2 & b() : 7 ^ c());
+        pure(3 ? 2 & b() : 5);
+        pure(3 ? 4 : 7 ^ c());
+        pure(3 ? 4 : 5);
+    }
+    expect: {
+        1 | a() ? b() : c();
+        1 | a() && b();
+        1 | a() || c();
+        a();
+        3 ? b() : c();
+        3 && b();
+        3 || c();
+        pure(3 ? 4 : 5);
+    }
+}
+
+limit_1: {
+    options = {
+        expression: true,
+        sequences: 3,
+    }
+    input: {
+        a;
+        b;
+        c;
+        d;
+        e;
+        f;
+        g;
+        h;
+        i;
+        j;
+        k;
+    }
+    expect: {
+        // Turned into a single return statement
+        // so it can no longer be split into lines
+        a,b,c,d,e,f,g,h,i,j,k;
+    }
+}
+
+iife: {
+    options = {
+        expression: true,
+        sequences: true,
+    }
+    input: {
+        x = 42;
+        (function a() {})();
+        !function b() {}();
+        ~function c() {}();
+        +function d() {}();
+        -function e() {}();
+        void function f() {}();
+        typeof function g() {}();
+    }
+    expect: {
+        x = 42, function a() {}(), function b() {}(), function c() {}(),
+        function d() {}(), function e() {}(), function f() {}(), typeof function g() {}();
+    }
+}

test/compress/issue-747.js

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

test/compress/issue-751.js

@@ -0,0 +1,29 @@
+negate_booleans_1: {
+    options = {
+        comparisons: true
+    };
+    input: {
+        var a = !a || !b || !c || !d || !e || !f;
+    }
+    expect: {
+        var a = !(a && b && c && d && e && f);
+    }
+}
+
+negate_booleans_2: {
+    options = {
+        comparisons: true
+    };
+    input: {
+        var match = !x &&       // should not touch this one
+            (!z || c) &&
+            (!k || d) &&
+            the_stuff();
+    }
+    expect: {
+        var match = !x &&
+            (!z || c) &&
+            (!k || d) &&
+            the_stuff();
+    }
+}

test/compress/issue-782.js

@@ -0,0 +1,27 @@
+remove_redundant_sequence_items: {
+    options = { side_effects: true };
+    input: {
+        (0, 1, eval)();
+        (0, 1, logThis)();
+        (0, 1, _decorators.logThis)();
+    }
+    expect: {
+        (0, eval)();
+        logThis();
+        (0, _decorators.logThis)();
+    }
+}
+
+dont_remove_this_binding_sequence: {
+    options = { side_effects: true };
+    input: {
+        (0, eval)();
+        (0, logThis)();
+        (0, _decorators.logThis)();
+    }
+    expect: {
+        (0, eval)();
+        logThis();
+        (0, _decorators.logThis)();
+    }
+}

test/compress/issue-892.js

@@ -0,0 +1,33 @@
+dont_mangle_arguments: {
+    mangle = {
+    };
+    options = {
+        sequences     : true,
+        properties    : true,
+        dead_code     : true,
+        drop_debugger : true,
+        conditionals  : true,
+        comparisons   : true,
+        evaluate      : true,
+        booleans      : true,
+        loops         : true,
+        unused        : true,
+        hoist_funs    : true,
+        keep_fargs    : true,
+        keep_fnames   : false,
+        hoist_vars    : true,
+        if_return     : true,
+        join_vars     : true,
+        cascade       : true,
+        side_effects  : true,
+        negate_iife   : false
+    };
+    input: {
+        (function(){
+            var arguments = arguments, not_arguments = 9;
+            console.log(not_arguments, arguments);
+        })(5,6,7);
+    }
+    expect_exact: "(function(){var arguments=arguments,o=9;console.log(o,arguments)})(5,6,7);"
+    expect_stdout: true
+}

test/compress/issue-913.js

@@ -0,0 +1,20 @@
+keep_var_for_in: {
+    options = {
+        hoist_vars: true,
+        unused: true
+    };
+    input: {
+        (function(obj){
+            var foo = 5;
+            for (var i in obj)
+                return foo;
+        })();
+    }
+    expect: {
+        (function(obj){
+            var i, foo = 5;
+            for (i in obj)
+                return foo;
+        })();
+    }
+}

test/compress/issue-973.js

@@ -0,0 +1,97 @@
+this_binding_conditionals: {
+    options = {
+        conditionals: true,
+        evaluate    : true
+    };
+    input: {
+        (1 && a)();
+        (0 || a)();
+        (0 || 1 && a)();
+        (1 ? a : 0)();
+
+        (1 && a.b)();
+        (0 || a.b)();
+        (0 || 1 && a.b)();
+        (1 ? a.b : 0)();
+
+        (1 && a[b])();
+        (0 || a[b])();
+        (0 || 1 && a[b])();
+        (1 ? a[b] : 0)();
+
+        (1 && eval)();
+        (0 || eval)();
+        (0 || 1 && eval)();
+        (1 ? eval : 0)();
+    }
+    expect: {
+        a();
+        a();
+        a();
+        a();
+
+        (0, a.b)();
+        (0, a.b)();
+        (0, a.b)();
+        (0, a.b)();
+
+        (0, a[b])();
+        (0, a[b])();
+        (0, a[b])();
+        (0, a[b])();
+
+        (0, eval)();
+        (0, eval)();
+        (0, eval)();
+        (0, eval)();
+    }
+}
+
+this_binding_collapse_vars: {
+    options = {
+        collapse_vars: true,
+        toplevel: true,
+    };
+    input: {
+        var c = a; c();
+        var d = a.b; d();
+        var e = eval; e();
+    }
+    expect: {
+        a();
+        (0, a.b)();
+        (0, eval)();
+    }
+}
+
+this_binding_side_effects: {
+    options = {
+        side_effects : true
+    };
+    input: {
+        (function (foo) {
+            (0, foo)();
+            (0, foo.bar)();
+            (0, eval)('console.log(foo);');
+        }());
+        (function (foo) {
+            var eval = console;
+            (0, foo)();
+            (0, foo.bar)();
+            (0, eval)('console.log(foo);');
+        }());
+    }
+    expect: {
+        (function (foo) {
+            foo();
+            (0, foo.bar)();
+            (0, eval)('console.log(foo);');
+        }());
+        (function (foo) {
+            var eval = console;
+            foo();
+            (0, foo.bar)();
+            (0, eval)('console.log(foo);');
+        }());
+    }
+}

test/compress/issue-976.js

@@ -0,0 +1,89 @@
+eval_collapse_vars: {
+    options = {
+        collapse_vars:true, sequences:false, properties:true, dead_code:true, conditionals:true,
+        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+    };
+    input: {
+        function f1() {
+            var e = 7;
+            var s = "abcdef";
+            var i = 2;
+            var eval = console.log.bind(console);
+            var x = s.charAt(i++);
+            var y = s.charAt(i++);
+            var z = s.charAt(i++);
+            eval(x, y, z, e);
+        }
+        function p1() { var a = foo(), b = bar(), eval = baz(); return a + b + eval; }
+        function p2() { var a = foo(), b = bar(), eval = baz; return a + b + eval(); }
+        (function f2(eval) {
+            var a = 2;
+            console.log(a - 5);
+            eval("console.log(a);");
+        })(eval);
+    }
+    expect: {
+        function f1() {
+            var e = 7,
+                s = "abcdef",
+                i = 2,
+                eval = console.log.bind(console),
+                x = s.charAt(i++),
+                y = s.charAt(i++),
+                z = s.charAt(i++);
+            eval(x, y, z, e);
+        }
+        function p1() { return foo() + bar() + baz(); }
+        function p2() { var a = foo(), b = bar(), eval = baz; return a + b + eval(); }
+        (function f2(eval) {
+            var a = 2;
+            console.log(a - 5);
+            eval("console.log(a);");
+        })(eval);
+    }
+    expect_stdout: true
+}
+
+eval_unused: {
+    options = { unused: true, keep_fargs: false };
+    input: {
+        function f1(a, eval, c, d, e) {
+            return a('c') + eval;
+        }
+        function f2(a, b, c, d, e) {
+            return a + eval('c');
+        }
+        function f3(a, eval, c, d, e) {
+            return a + eval('c');
+        }
+    }
+    expect: {
+        function f1(a, eval) {
+            return a('c') + eval;
+        }
+        function f2(a, b, c, d, e) {
+            return a + eval('c');
+        }
+        function f3(a, eval, c, d, e) {
+            return a + eval('c');
+        }
+    }
+}
+
+eval_mangle: {
+    mangle = {
+    };
+    input: {
+        function f1(a, eval, c, d, e) {
+            return a('c') + eval;
+        }
+        function f2(a, b, c, d, e) {
+            return a + eval('c');
+        }
+        function f3(a, eval, c, d, e) {
+            return a + eval('c');
+        }
+    }
+    expect_exact: 'function f1(n,c,e,a,f){return n("c")+c}function f2(a,b,c,d,e){return a+eval("c")}function f3(a,eval,c,d,e){return a+eval("c")}'
+}

test/compress/issue-979.js

@@ -0,0 +1,89 @@
+issue979_reported: {
+    options = {
+        sequences:true, properties:true, dead_code:true, conditionals:true,
+        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+    }
+    input: {
+        function f1() {
+            if (a == 1 || b == 2) {
+                foo();
+            }
+        }
+        function f2() {
+            if (!(a == 1 || b == 2)) {
+            }
+            else {
+                foo();
+            }
+        }
+    }
+    expect: {
+        function f1() {
+            1!=a&&2!=b||foo();
+        }
+        function f2() {
+            1!=a&&2!=b||foo();
+        }
+    }
+}
+
+issue979_test_negated_is_best: {
+    options = {
+        sequences:true, properties:true, dead_code:true, conditionals:true,
+        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
+    }
+    input: {
+        function f3() {
+            if (a == 1 | b == 2) {
+                foo();
+            }
+        }
+        function f4() {
+            if (!(a == 1 | b == 2)) {
+            }
+            else {
+                foo();
+            }
+        }
+        function f5() {
+            if (a == 1 && b == 2) {
+                foo();
+            }
+        }
+        function f6() {
+            if (!(a == 1 && b == 2)) {
+            }
+            else {
+                foo();
+            }
+        }
+        function f7() {
+            if (a == 1 || b == 2) {
+                foo();
+            }
+            else {
+                return bar();
+            }
+        }
+    }
+    expect: {
+        function f3() {
+            1==a|2==b&&foo();
+        }
+        function f4() {
+            1==a|2==b&&foo();
+        }
+        function f5() {
+            1==a&&2==b&&foo();
+        }
+        function f6() {
+            1!=a||2!=b||foo();
+        }
+        function f7() {
+            if(1!=a&&2!=b)return bar();foo()
+        }
+    }
+}
+

test/compress/labels.js

@@ -9,6 +9,7 @@ labels_1: {
     expect: {
         foo || console.log("bar");
     }
+    expect_stdout: true
 }
 
 labels_2: {
@@ -40,6 +41,7 @@ labels_3: {
         for (var i = 0; i < 5; ++i)
             i < 3 || console.log(i);
     }
+    expect_stdout: true
 }
 
 labels_4: {
@@ -54,6 +56,7 @@ labels_4: {
         for (var i = 0; i < 5; ++i)
             i < 3 || console.log(i);
     }
+    expect_stdout: true
 }
 
 labels_5: {

test/compress/loops.js

@@ -121,3 +121,362 @@ drop_if_else_break_4: {
         for (; bar() && (x(), y(), foo());) baz(), z(), k();
     }
 }
+
+parse_do_while_with_semicolon: {
+    options = { loops: false };
+    input: {
+        do {
+            x();
+        } while (false);y()
+    }
+    expect: {
+        do x(); while (false);y();
+    }
+}
+
+parse_do_while_without_semicolon: {
+    options = { loops: false };
+    input: {
+        do {
+            x();
+        } while (false)y()
+    }
+    expect: {
+        do x(); while (false);y();
+    }
+}
+
+
+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,
+        dead_code: true,
+        evaluate: true,
+    };
+    input: {
+        while (true) {
+            a();
+        }
+        while (false) {
+            b();
+        }
+        do {
+            c();
+        } while (true);
+        do {
+            d();
+        } while (false);
+    }
+    expect: {
+        for(;;)
+            a();
+        for(;;)
+            c();
+        d();
+    }
+}
+
+issue_1532: {
+    options = {
+        evaluate: true,
+        loops: true,
+    }
+    input: {
+        function f(x, y) {
+            do {
+                if (x) break;
+                foo();
+            } while (false);
+        }
+    }
+    expect: {
+        function f(x, y) {
+            do {
+                if (x) break;
+                foo();
+            } while (false);
+        }
+    }
+}
+
+issue_186: {
+    beautify = {
+        beautify: false,
+        ie8: false,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x=3;if(foo())do{do{alert(x)}while(--x)}while(x);else bar();'
+}
+
+issue_186_ie8: {
+    beautify = {
+        beautify: false,
+        ie8: true,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x=3;if(foo()){do{do{alert(x)}while(--x)}while(x)}else bar();'
+}
+
+issue_186_beautify: {
+    beautify = {
+        beautify: true,
+        ie8: false,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: [
+        'var x = 3;',
+        '',
+        'if (foo()) do {',
+        '    do {',
+        '        alert(x);',
+        '    } while (--x);',
+        '} while (x); else bar();',
+    ]
+}
+
+issue_186_beautify_ie8: {
+    beautify = {
+        beautify: true,
+        ie8: true,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: [
+        'var x = 3;',
+        '',
+        'if (foo()) {',
+        '    do {',
+        '        do {',
+        '            alert(x);',
+        '        } while (--x);',
+        '    } while (x);',
+        '} else bar();',
+    ]
+}
+
+issue_186_bracketize: {
+    beautify = {
+        beautify: false,
+        bracketize: true,
+        ie8: false,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x=3;if(foo()){do{do{alert(x)}while(--x)}while(x)}else{bar()}'
+}
+
+issue_186_bracketize_ie8: {
+    beautify = {
+        beautify: false,
+        bracketize: true,
+        ie8: true,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: 'var x=3;if(foo()){do{do{alert(x)}while(--x)}while(x)}else{bar()}'
+}
+
+issue_186_beautify_bracketize: {
+    beautify = {
+        beautify: true,
+        bracketize: true,
+        ie8: false,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: [
+        'var x = 3;',
+        '',
+        'if (foo()) {',
+        '    do {',
+        '        do {',
+        '            alert(x);',
+        '        } while (--x);',
+        '    } while (x);',
+        '} else {',
+        '    bar();',
+        '}',
+    ]
+}
+
+issue_186_beautify_bracketize_ie8: {
+    beautify = {
+        beautify: true,
+        bracketize: true,
+        ie8: true,
+    }
+    input: {
+        var x = 3;
+        if (foo())
+            do
+                do
+                    alert(x);
+                while (--x);
+            while (x);
+        else
+            bar();
+    }
+    expect_exact: [
+        'var x = 3;',
+        '',
+        'if (foo()) {',
+        '    do {',
+        '        do {',
+        '            alert(x);',
+        '        } while (--x);',
+        '    } while (x);',
+        '} else {',
+        '    bar();',
+        '}',
+    ]
+}
+
+issue_1648: {
+    options = {
+        join_vars: true,
+        loops: true,
+        passes: 2,
+        sequences: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            x();
+            var b = 1;
+            while (1);
+        }
+    }
+    expect_exact: "function f(){for(x();1;);}"
+}
+
+do_switch: {
+    options = {
+        evaluate: true,
+        loops: true,
+    }
+    input: {
+        do {
+            switch (a) {
+              case b:
+                continue;
+            }
+        } while (false);
+    }
+    expect: {
+        do {
+            switch (a) {
+              case b:
+                continue;
+            }
+        } while (false);
+    }
+}

test/compress/max_line_len.js

@@ -0,0 +1,39 @@
+too_short: {
+    beautify = {
+        max_line_len: 10,
+    }
+    input: {
+        function f(a) {
+            return { c: 42, d: a(), e: "foo"};
+        }
+    }
+    expect_exact: [
+        'function f(a){',
+        'return{',
+        'c:42,',
+        'd:a(),',
+        'e:"foo"}}',
+    ]
+    expect_warnings: [
+        "WARN: Output exceeds 10 characters"
+    ]
+}
+
+just_enough: {
+    beautify = {
+        max_line_len: 14,
+    }
+    input: {
+        function f(a) {
+            return { c: 42, d: a(), e: "foo"};
+        }
+    }
+    expect_exact: [
+        'function f(a){',
+        'return{c:42,',
+        'd:a(),e:"foo"}',
+        '}',
+    ]
+    expect_warnings: [
+    ]
+}

test/compress/negate-iife.js

@@ -0,0 +1,414 @@
+negate_iife_1: {
+    options = {
+        negate_iife: true
+    };
+    input: {
+        (function(){ stuff() })();
+    }
+    expect: {
+        !function(){ stuff() }();
+    }
+}
+
+negate_iife_1_off: {
+    options = {
+        negate_iife: false,
+    };
+    input: {
+        (function(){ stuff() })();
+    }
+    expect_exact: '(function(){stuff()})();'
+}
+
+negate_iife_2: {
+    options = {
+        negate_iife: true
+    };
+    input: {
+        (function(){ return {} })().x = 10;
+    }
+    expect_exact: "({}).x=10;"
+}
+
+negate_iife_2_side_effects: {
+    options = {
+        negate_iife: true,
+        side_effects: true,
+    }
+    input: {
+        (function(){ return {} })().x = 10;
+    }
+    expect_exact: "({}).x=10;"
+}
+
+negate_iife_3: {
+    options = {
+        negate_iife: true,
+        conditionals: true
+    };
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        !function(){ return t }() ? console.log(false) : console.log(true);
+    }
+}
+
+negate_iife_3_evaluate: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        negate_iife: true,
+    }
+    input: {
+        (function(){ return true })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        console.log(true);
+    }
+    expect_stdout: true
+}
+
+negate_iife_3_side_effects: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        side_effects: true,
+    }
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        !function(){ return t }() ? console.log(false) : console.log(true);
+    }
+}
+
+negate_iife_3_off: {
+    options = {
+        negate_iife: false,
+        conditionals: true,
+    };
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        !function(){ return t }() ? console.log(false) : console.log(true);
+    }
+}
+
+negate_iife_3_off_evaluate: {
+    options = {
+        conditionals: true,
+        evaluate: true,
+        negate_iife: false,
+    }
+    input: {
+        (function(){ return true })() ? console.log(true) : console.log(false);
+    }
+    expect: {
+        console.log(true);
+    }
+    expect_stdout: true
+}
+
+negate_iife_4: {
+    options = {
+        negate_iife: true,
+        conditionals: true,
+        sequences: true
+    };
+    input: {
+        (function(){ return t })() ? console.log(true) : console.log(false);
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function(){ return t }() ? console.log(false) : console.log(true), function(){
+            console.log("something");
+        }();
+    }
+}
+
+sequence_off: {
+    options = {
+        negate_iife: false,
+        conditionals: true,
+        sequences: true,
+        passes: 2,
+    };
+    input: {
+        function f() {
+            (function(){ return t })() ? console.log(true) : console.log(false);
+            (function(){
+                console.log("something");
+            })();
+        }
+        function g() {
+            (function(){
+                console.log("something");
+            })();
+            (function(){ return t })() ? console.log(true) : console.log(false);
+        }
+    }
+    expect: {
+        function f() {
+            !function(){ return t }() ? console.log(false) : console.log(true), function(){
+                console.log("something");
+            }();
+        }
+        function g() {
+            (function(){
+                console.log("something");
+            })(), function(){ return t }() ? console.log(true) : console.log(false);
+        }
+    }
+}
+
+negate_iife_5: {
+    options = {
+        negate_iife: true,
+        sequences: true,
+        conditionals: true,
+    };
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function(){ return t }() ? bar(false) : foo(true), function(){
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_5_off: {
+    options = {
+        negate_iife: false,
+        sequences: true,
+        conditionals: true,
+    };
+    input: {
+        if ((function(){ return t })()) {
+            foo(true);
+        } else {
+            bar(false);
+        }
+        (function(){
+            console.log("something");
+        })();
+    }
+    expect: {
+        !function(){ return t }() ? bar(false) : foo(true), function(){
+            console.log("something");
+        }();
+    }
+}
+
+negate_iife_nested: {
+    options = {
+        negate_iife: true,
+        sequences: true,
+        conditionals: true,
+    };
+    input: {
+        function Foo(f) {
+            this.f = f;
+        }
+        new Foo(function() {
+            (function(x) {
+                (function(y) {
+                    console.log(y);
+                })(x);
+            })(7);
+        }).f();
+    }
+    expect: {
+        function Foo(f) {
+            this.f = f;
+        }
+        new Foo(function() {
+            !function(x) {
+                !function(y) {
+                    console.log(y);
+                }(x);
+            }(7);
+        }).f();
+    }
+    expect_stdout: true
+}
+
+negate_iife_nested_off: {
+    options = {
+        negate_iife: false,
+        sequences: true,
+        conditionals: true,
+    };
+    input: {
+        function Foo(f) {
+            this.f = f;
+        }
+        new Foo(function() {
+            (function(x) {
+                (function(y) {
+                    console.log(y);
+                })(x);
+            })(7);
+        }).f();
+    }
+    expect: {
+        function Foo(f) {
+            this.f = f;
+        }
+        new Foo(function() {
+            (function(x) {
+                (function(y) {
+                    console.log(y);
+                })(x);
+            })(7);
+        }).f();
+    }
+    expect_stdout: true
+}
+
+negate_iife_issue_1073: {
+    options = {
+        negate_iife: true,
+        sequences: true,
+        conditionals: true,
+    };
+    input: {
+        new (function(a) {
+            return function Foo() {
+                this.x = a;
+                console.log(this);
+            };
+        }(7))();
+    }
+    expect: {
+        new (function(a) {
+            return function Foo() {
+                this.x = a,
+                console.log(this);
+            };
+        }(7))();
+    }
+    expect_stdout: true
+}
+
+issue_1254_negate_iife_false: {
+    options = {
+        negate_iife: false,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: '(function(){return function(){console.log("test")}})()();'
+    expect_stdout: true
+}
+
+issue_1254_negate_iife_true: {
+    options = {
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: '!function(){return function(){console.log("test")}}()();'
+    expect_stdout: true
+}
+
+issue_1254_negate_iife_nested: {
+    options = {
+        negate_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()()()()();
+    }
+    expect_exact: '!function(){return function(){console.log("test")}}()()()()();'
+    expect_stdout: true
+}
+
+issue_1288: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        side_effects: false,
+    };
+    input: {
+        if (w) ;
+        else {
+            (function f() {})();
+        }
+        if (!x) {
+            (function() {
+                x = {};
+            })();
+        }
+        if (y)
+            (function() {})();
+        else
+            (function(z) {
+                return z;
+            })(0);
+    }
+    expect: {
+        w || !function f() {}();
+        x || !function() {
+            x = {};
+        }();
+        y ? !function() {}() : !function(z) {
+            return z;
+        }(0);
+    }
+}
+
+issue_1288_side_effects: {
+    options = {
+        conditionals: true,
+        negate_iife: true,
+        side_effects: true,
+    }
+    input: {
+        if (w) ;
+        else {
+            (function f() {})();
+        }
+        if (!x) {
+            (function() {
+                x = {};
+            })();
+        }
+        if (y)
+            (function() {})();
+        else
+            (function(z) {
+                return z;
+            })(0);
+    }
+    expect: {
+        w;
+        x || function() {
+            x = {};
+        }();
+        y;
+    }
+}

test/compress/new.js

@@ -0,0 +1,84 @@
+new_statement: {
+    input: {
+        new x(1);
+        new x(1)(2);
+        new x(1)(2)(3);
+        new new x(1);
+        new new x(1)(2);
+        new (new x(1))(2);
+        (new new x(1))(2);
+    }
+    expect_exact: "new x(1);new x(1)(2);new x(1)(2)(3);new new x(1);new new x(1)(2);new new x(1)(2);(new new x(1))(2);"
+}
+
+new_statements_2: {
+    input: {
+        new x;
+        new new x;
+        new new new x;
+        new true;
+        new (0);
+        new (!0);
+        new (bar = function(foo) {this.foo=foo;})(123);
+        new (bar = function(foo) {this.foo=foo;})();
+    }
+    expect_exact: "new x;new(new x);new(new(new x));new true;new 0;new(!0);new(bar=function(foo){this.foo=foo})(123);new(bar=function(foo){this.foo=foo});"
+}
+
+new_statements_3: {
+    input: {
+        new (function(foo){this.foo=foo;})(1);
+        new (function(foo){this.foo=foo;})();
+        new (function test(foo){this.foo=foo;})(1);
+        new (function test(foo){this.foo=foo;})();
+    }
+    expect_exact: "new function(foo){this.foo=foo}(1);new function(foo){this.foo=foo};new function test(foo){this.foo=foo}(1);new function test(foo){this.foo=foo};"
+}
+
+new_with_rewritten_true_value: {
+    options = { booleans: true }
+    input: {
+        new true;
+    }
+    expect_exact: "new(!0);"
+}
+
+new_with_many_parameters: {
+    input: {
+        new foo.bar("baz");
+        new x(/123/, 456);
+    }
+    expect_exact: 'new foo.bar("baz");new x(/123/,456);'
+}
+
+new_constructor_with_unary_arguments: {
+    input: {
+        new x();
+        new x(-1);
+        new x(-1, -2);
+        new x(void 1, +2, -3, ~4, !5, --a, ++b, c--, d++, typeof e, delete f);
+        new (-1);     // should parse despite being invalid at runtime.
+        new (-1)();   // should parse despite being invalid at runtime.
+        new (-1)(-2); // should parse despite being invalid at runtime.
+    }
+    expect_exact: "new x;new x(-1);new x(-1,-2);new x(void 1,+2,-3,~4,!5,--a,++b,c--,d++,typeof e,delete f);new(-1);new(-1);new(-1)(-2);"
+}
+
+call_with_unary_arguments: {
+    input: {
+        x();
+        x(-1);
+        x(-1, -2);
+        x(void 1, +2, -3, ~4, !5, --a, ++b, c--, d++, typeof e, delete f);
+        (-1)();   // should parse despite being invalid at runtime.
+        (-1)(-2); // should parse despite being invalid at runtime.
+    }
+    expect_exact: "x();x(-1);x(-1,-2);x(void 1,+2,-3,~4,!5,--a,++b,c--,d++,typeof e,delete f);(-1)();(-1)(-2);"
+}
+
+new_with_unary_prefix: {
+    input: {
+        var bar = (+new Date()).toString(32);
+    }
+    expect_exact: 'var bar=(+new Date).toString(32);';
+}

test/compress/numbers.js

@@ -0,0 +1,204 @@
+hex_numbers_in_parentheses_for_prototype_functions: {
+    input: {
+        (-2);
+        (-2).toFixed(0);
+
+        (2);
+        (2).toFixed(0);
+
+        (0.2);
+        (0.2).toFixed(0);
+
+        (0.00000002);
+        (0.00000002).toFixed(0);
+
+        (1000000000000000128);
+        (1000000000000000128).toFixed(0);
+    }
+    expect_exact: "-2;(-2).toFixed(0);2;2..toFixed(0);.2;.2.toFixed(0);2e-8;2e-8.toFixed(0);0xde0b6b3a7640080;(0xde0b6b3a7640080).toFixed(0);"
+}
+
+comparisons: {
+    options = {
+        comparisons: true,
+    }
+    input: {
+        console.log(
+            ~x === 42,
+            x % n === 42
+        );
+    }
+    expect: {
+        console.log(
+            42 == ~x,
+            x % n == 42
+        );
+    }
+}
+
+evaluate_1: {
+    options = {
+        evaluate: true,
+        unsafe_math: false,
+    }
+    input: {
+        console.log(
+            x + 1 + 2,
+            x * 1 * 2,
+            +x + 1 + 2,
+            1 + x + 2 + 3,
+            1 | x | 2 | 3,
+            1 + x-- + 2 + 3,
+            1 + (x*y + 2) + 3,
+            1 + (2 + x + 3),
+            1 + (2 + ~x + 3),
+            -y + (2 + ~x + 3),
+            1 & (2 & x & 3),
+            1 + (2 + (x |= 0) + 3)
+        );
+    }
+    expect: {
+        console.log(
+            x + 1 + 2,
+            1 * x * 2,
+            +x + 1 + 2,
+            1 + x + 2 + 3,
+            3 | x,
+            1 + x-- + 2 + 3,
+            x*y + 2 + 1 + 3,
+            1 + (2 + x + 3),
+            2 + ~x + 3 + 1,
+            -y + (2 + ~x + 3),
+            0 & x,
+            2 + (x |= 0) + 3 + 1
+        );
+    }
+}
+
+evaluate_2: {
+    options = {
+        evaluate: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(
+            x + 1 + 2,
+            x * 1 * 2,
+            +x + 1 + 2,
+            1 + x + 2 + 3,
+            1 | x | 2 | 3,
+            1 + x-- + 2 + 3,
+            1 + (x*y + 2) + 3,
+            1 + (2 + x + 3),
+            1 & (2 & x & 3),
+            1 + (2 + (x |= 0) + 3)
+        );
+    }
+    expect: {
+        console.log(
+            x + 1 + 2,
+            2 * x,
+            3 + +x,
+            1 + x + 2 + 3,
+            3 | x,
+            6 + x--,
+            6 + x*y,
+            1 + (2 + x + 3),
+            0 & x,
+            6 + (x |= 0)
+        );
+    }
+}
+
+evaluate_3: {
+    options = {
+        evaluate: true,
+        unsafe: true,
+        unsafe_math: true,
+    }
+    input: {
+        console.log(1 + Number(x) + 2);
+    }
+    expect: {
+        console.log(3 + +x);
+    }
+}
+
+evaluate_4: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        console.log(
+            1+ +a,
+            +a+1,
+            1+-a,
+            -a+1,
+            +a+ +b,
+            +a+-b,
+            -a+ +b,
+            -a+-b
+        );
+    }
+    expect: {
+        console.log(
+            +a+1,
+            +a+1,
+            1-a,
+            1-a,
+            +a+ +b,
+            +a-b,
+            -a+ +b,
+            -a-b
+        );
+    }
+}
+
+issue_1710: {
+    options = {
+        evaluate: true,
+    }
+    input: {
+        var x = {};
+        console.log((x += 1) + -x);
+    }
+    expect: {
+        var x = {};
+        console.log((x += 1) + -x);
+    }
+    expect_stdout: true
+}
+
+unary_binary_parenthesis: {
+    input: {
+        var v = [ 0, 1, NaN, Infinity, null, undefined, true, false, "", "foo", /foo/ ];
+        v.forEach(function(x) {
+            v.forEach(function(y) {
+                console.log(
+                    +(x*y),
+                    +(x/y),
+                    +(x%y),
+                    -(x*y),
+                    -(x/y),
+                    -(x%y)
+                );
+            });
+        });
+    }
+    expect: {
+        var v = [ 0, 1, NaN, 1/0, null, void 0, true, false, "", "foo", /foo/ ];
+        v.forEach(function(x) {
+            v.forEach(function(y) {
+                console.log(
+                    +x*y,
+                    +x/y,
+                    +x%y,
+                    -x*y,
+                    -x/y,
+                    -x%y
+                );
+            });
+        });
+    }
+    expect_stdout: true
+}

test/compress/properties.js

@@ -12,7 +12,8 @@ keep_properties: {
 
 dot_properties: {
     options = {
-        properties: true
+        properties: true,
+        ie8: true,
     };
     input: {
         a["foo"] = "bar";
@@ -26,7 +27,7 @@ dot_properties: {
         a.foo = "bar";
         a["if"] = "if";
         a["*"] = "asterisk";
-        a.\u0EB3 = "unicode";
+        a["\u0EB3"] = "unicode";
         a[""] = "whitespace";
         a["1_1"] = "foo";
     }
@@ -35,7 +36,7 @@ dot_properties: {
 dot_properties_es5: {
     options = {
         properties: true,
-        screw_ie8: true
+        ie8: false,
     };
     input: {
         a["foo"] = "bar";
@@ -48,7 +49,509 @@ dot_properties_es5: {
         a.foo = "bar";
         a.if = "if";
         a["*"] = "asterisk";
-        a.\u0EB3 = "unicode";
+        a["\u0EB3"] = "unicode";
         a[""] = "whitespace";
     }
 }
+
+sub_properties: {
+    options = {
+        evaluate: true,
+        properties: true
+    };
+    input: {
+        a[0] = 0;
+        a["0"] = 1;
+        a[3.14] = 2;
+        a["3" + ".14"] = 3;
+        a["i" + "f"] = 4;
+        a["foo" + " bar"] = 5;
+        a[0 / 0] = 6;
+        a[null] = 7;
+        a[undefined] = 8;
+    }
+    expect: {
+        a[0] = 0;
+        a[0] = 1;
+        a[3.14] = 2;
+        a[3.14] = 3;
+        a.if = 4;
+        a["foo bar"] = 5;
+        a[NaN] = 6;
+        a[null] = 7;
+        a[void 0] = 8;
+    }
+}
+
+evaluate_array_length: {
+    options = {
+        properties: true,
+        unsafe: true,
+        evaluate: true
+    };
+    input: {
+        a = [1, 2, 3].length;
+        a = [1, 2, 3].join()["len" + "gth"];
+        a = [1, 2, b].length;
+        a = [1, 2, 3].join(b).length;
+    }
+    expect: {
+        a = 3;
+        a = 5;
+        a = [1, 2, b].length;
+        a = [1, 2, 3].join(b).length;
+    }
+}
+
+evaluate_string_length: {
+    options = {
+        properties: true,
+        unsafe: true,
+        evaluate: true
+    };
+    input: {
+        a = "foo".length;
+        a = ("foo" + "bar")["len" + "gth"];
+        a = b.length;
+        a = ("foo" + b).length;
+    }
+    expect: {
+        a = 3;
+        a = 6;
+        a = b.length;
+        a = ("foo" + b).length;
+    }
+}
+
+mangle_properties: {
+    mangle_props = {
+        keep_quoted: false
+    };
+    input: {
+        a["foo"] = "bar";
+        a.color = "red";
+        x = {"bar": 10};
+        a.run(x.bar, a.foo);
+        a['run']({color: "blue", foo: "baz"});
+    }
+    expect: {
+        a["a"] = "bar";
+        a.b = "red";
+        x = {c: 10};
+        a.d(x.c, a.a);
+        a['d']({b: "blue", a: "baz"});
+    }
+}
+
+mangle_unquoted_properties: {
+    options = {
+        properties: false
+    }
+    mangle_props = {
+        keep_quoted: true
+    }
+    beautify = {
+        beautify: false,
+        quote_style: 3,
+        keep_quoted_props: true,
+    }
+    input: {
+        a.top = 1;
+        function f1() {
+            a["foo"] = "bar";
+            a.color = "red";
+            a.stuff = 2;
+            x = {"bar": 10, size: 7};
+            a.size = 9;
+        }
+        function f2() {
+            a.foo = "bar";
+            a['color'] = "red";
+            x = {bar: 10, size: 7};
+            a.size = 9;
+            a.stuff = 3;
+        }
+    }
+    expect: {
+        a.a = 1;
+        function f1() {
+            a["foo"] = "bar";
+            a.color = "red";
+            a.b = 2;
+            x = {"bar": 10, c: 7};
+            a.c = 9;
+        }
+        function f2() {
+            a.foo = "bar";
+            a['color'] = "red";
+            x = {bar: 10, c: 7};
+            a.c = 9;
+            a.b = 3;
+        }
+    }
+}
+
+mangle_debug: {
+    mangle_props = {
+        debug: ""
+    };
+    input: {
+        a.foo = "bar";
+        x = { baz: "ban" };
+    }
+    expect: {
+        a._$foo$_ = "bar";
+        x = { _$baz$_: "ban" };
+    }
+}
+
+mangle_debug_true: {
+    mangle_props = {
+        debug: true
+    };
+    input: {
+        a.foo = "bar";
+        x = { baz: "ban" };
+    }
+    expect: {
+        a._$foo$_ = "bar";
+        x = { _$baz$_: "ban" };
+    }
+}
+
+mangle_debug_suffix: {
+    mangle_props = {
+        debug: "XYZ"
+    };
+    input: {
+        a.foo = "bar";
+        x = { baz: "ban" };
+    }
+    expect: {
+        a._$foo$XYZ_ = "bar";
+        x = { _$baz$XYZ_: "ban" };
+    }
+}
+
+mangle_debug_suffix_keep_quoted: {
+    options = {
+        properties: false
+    }
+    mangle_props = {
+        keep_quoted: true,
+        debug: "XYZ",
+        reserved: []
+    }
+    beautify = {
+        beautify: false,
+        quote_style: 3,
+        keep_quoted_props: true,
+    }
+    input: {
+        a.top = 1;
+        function f1() {
+            a["foo"] = "bar";
+            a.color = "red";
+            a.stuff = 2;
+            x = {"bar": 10, size: 7};
+            a.size = 9;
+        }
+        function f2() {
+            a.foo = "bar";
+            a['color'] = "red";
+            x = {bar: 10, size: 7};
+            a.size = 9;
+            a.stuff = 3;
+        }
+    }
+    expect: {
+        a._$top$XYZ_ = 1;
+        function f1() {
+            a["foo"] = "bar";
+            a.color = "red";
+            a._$stuff$XYZ_ = 2;
+            x = {"bar": 10, _$size$XYZ_: 7};
+            a._$size$XYZ_ = 9;
+        }
+        function f2() {
+            a.foo = "bar";
+            a['color'] = "red";
+            x = {bar: 10, _$size$XYZ_: 7};
+            a._$size$XYZ_ = 9;
+            a._$stuff$XYZ_ = 3;
+        }
+    }
+}
+
+first_256_chars_as_properties: {
+    beautify = {
+        ascii_only: true,
+    }
+    input: {
+        // Note: some of these unicode character keys are not visible on github.com
+        var o = {
+            "\0":0,"
":1,"":2,"":3,"":4,"":5,"":6,"":7,"\b":8,
+            "\t":9,"\n":10,"\v":11,"\f":12,"\r":13,"":14,"":15,"":16,"":17,
+            "":18,"":19,"":20,"":21,"":22,"":23,"":24,"":25,"":26,
+            "":27,"":28,"":29,"":30,"":31," ":32,"!":33,'"':34,"#":35,
+            $:36,"%":37,"&":38,"'":39,"(":40,")":41,"*":42,"+":43,",":44,
+            "-":45,".":46,"/":47,"0":48,"1":49,"2":50,"3":51,"4":52,"5":53,"6":54,"7":55,
+            "8":56,"9":57,":":58,";":59,"<":60,"=":61,">":62,"?":63,"@":64,A:65,
+            B:66,C:67,D:68,E:69,F:70,G:71,H:72,I:73,J:74,K:75,L:76,M:77,N:78,
+            O:79,P:80,Q:81,R:82,S:83,T:84,U:85,V:86,W:87,X:88,Y:89,Z:90,"[":91,
+            "\\":92,"]":93,"^":94,_:95,"`":96,a:97,b:98,c:99,d:100,e:101,
+            f:102,g:103,h:104,i:105,j:106,k:107,l:108,m:109,n:110,o:111,p:112,
+            q:113,r:114,s:115,t:116,u:117,v:118,w:119,x:120,y:121,z:122,"{":123,
+            "|":124,"}":125,"~":126,"":127,"€":128,"":129,"‚":130,"ƒ":131,
+            "„":132,"…":133,"†":134,"‡":135,"ˆ":136,"‰":137,"Š":138,"‹":139,
+            "Œ":140,"":141,"Ž":142,"":143,"":144,"‘":145,"’":146,"“":147,
+            "”":148,"•":149,"–":150,"—":151,"˜":152,"™":153,"š":154,"›":155,
+            "œ":156,"":157,"ž":158,"Ÿ":159," ":160,"¡":161,"¢":162,"£":163,
+            "¤":164,"¥":165,"¦":166,"§":167,"¨":168,"©":169,"ª":170,"«":171,
+            "¬":172,"­":173,"®":174,"¯":175,"°":176,"±":177,"²":178,"³":179,
+            "´":180,"µ":181,"¶":182,"·":183,"¸":184,"¹":185,"º":186,"»":187,
+            "¼":188,"½":189,"¾":190,"¿":191,"À":192,"Á":193,"Â":194,"Ã":195,
+            "Ä":196,"Å":197,"Æ":198,"Ç":199,"È":200,"É":201,"Ê":202,"Ë":203,
+            "Ì":204,"Í":205,"Î":206,"Ï":207,"Ð":208,"Ñ":209,"Ò":210,"Ó":211,
+            "Ô":212,"Õ":213,"Ö":214,"×":215,"Ø":216,"Ù":217,"Ú":218,"Û":219,
+            "Ü":220,"Ý":221,"Þ":222,"ß":223,"à":224,"á":225,"â":226,"ã":227,
+            "ä":228,"å":229,"æ":230,"ç":231,"è":232,"é":233,"ê":234,"ë":235,
+            "ì":236,"í":237,"î":238,"ï":239,"ð":240,"ñ":241,"ò":242,"ó":243,
+            "ô":244,"õ":245,"ö":246,"÷":247,"ø":248,"ù":249,"ú":250,"û":251,
+            "ü":252,"ý":253,"þ":254,"ÿ":255
+        };
+    }
+    expect: {
+        var o = {
+            "\0":0,"\x01":1,"\x02":2,"\x03":3,"\x04":4,"\x05":5,"\x06":6,
+            "\x07":7,"\b":8,"\t":9,"\n":10,"\v":11,"\f":12,"\r":13,"\x0e":14,
+            "\x0f":15,"\x10":16,"\x11":17,"\x12":18,"\x13":19,"\x14":20,"\x15":21,
+            "\x16":22,"\x17":23,"\x18":24,"\x19":25,"\x1a":26,"\x1b":27,"\x1c":28,
+            "\x1d":29,"\x1e":30,"\x1f":31," ":32,"!":33,'"':34,"#":35,$:36,
+            "%":37,"&":38,"'":39,"(":40,")":41,"*":42,"+":43,",":44,"-":45,
+            ".":46,"/":47,0:48,1:49,2:50,3:51,4:52,5:53,6:54,7:55,8:56,9:57,
+            ":":58,";":59,"<":60,"=":61,">":62,"?":63,"@":64,A:65,B:66,C:67,
+            D:68,E:69,F:70,G:71,H:72,I:73,J:74,K:75,L:76,M:77,N:78,O:79,P:80,
+            Q:81,R:82,S:83,T:84,U:85,V:86,W:87,X:88,Y:89,Z:90,"[":91,"\\":92,
+            "]":93,"^":94,_:95,"`":96,a:97,b:98,c:99,d:100,e:101,f:102,g:103,
+            h:104,i:105,j:106,k:107,l:108,m:109,n:110,o:111,p:112,q:113,r:114,
+            s:115,t:116,u:117,v:118,w:119,x:120,y:121,z:122,"{":123,"|":124,
+            "}":125,"~":126,"\x7f":127,"\x80":128,"\x81":129,"\x82":130,"\x83":131,
+            "\x84":132,"\x85":133,"\x86":134,"\x87":135,"\x88":136,"\x89":137,
+            "\x8a":138,"\x8b":139,"\x8c":140,"\x8d":141,"\x8e":142,"\x8f":143,
+            "\x90":144,"\x91":145,"\x92":146,"\x93":147,"\x94":148,"\x95":149,
+            "\x96":150,"\x97":151,"\x98":152,"\x99":153,"\x9a":154,"\x9b":155,
+            "\x9c":156,"\x9d":157,"\x9e":158,"\x9f":159,"\xa0":160,"\xa1":161,
+            "\xa2":162,"\xa3":163,"\xa4":164,"\xa5":165,"\xa6":166,"\xa7":167,
+            "\xa8":168,"\xa9":169,"\xaa":170,"\xab":171,"\xac":172,"\xad":173,
+            "\xae":174,"\xaf":175,"\xb0":176,"\xb1":177,"\xb2":178,"\xb3":179,
+            "\xb4":180,"\xb5":181,"\xb6":182,"\xb7":183,"\xb8":184,"\xb9":185,
+            "\xba":186,"\xbb":187,"\xbc":188,"\xbd":189,"\xbe":190,"\xbf":191,
+            "\xc0":192,"\xc1":193,"\xc2":194,"\xc3":195,"\xc4":196,"\xc5":197,
+            "\xc6":198,"\xc7":199,"\xc8":200,"\xc9":201,"\xca":202,"\xcb":203,
+            "\xcc":204,"\xcd":205,"\xce":206,"\xcf":207,"\xd0":208,"\xd1":209,
+            "\xd2":210,"\xd3":211,"\xd4":212,"\xd5":213,"\xd6":214,"\xd7":215,
+            "\xd8":216,"\xd9":217,"\xda":218,"\xdb":219,"\xdc":220,"\xdd":221,
+            "\xde":222,"\xdf":223,"\xe0":224,"\xe1":225,"\xe2":226,"\xe3":227,
+            "\xe4":228,"\xe5":229,"\xe6":230,"\xe7":231,"\xe8":232,"\xe9":233,
+            "\xea":234,"\xeb":235,"\xec":236,"\xed":237,"\xee":238,"\xef":239,
+            "\xf0":240,"\xf1":241,"\xf2":242,"\xf3":243,"\xf4":244,"\xf5":245,
+            "\xf6":246,"\xf7":247,"\xf8":248,"\xf9":249,"\xfa":250,"\xfb":251,
+            "\xfc":252,"\xfd":253,"\xfe":254,"\xff":255
+        };
+    }
+}
+
+first_256_unicode_chars_as_properties: {
+    input: {
+        var o = {
+            "\u0000":   0, "\u0001":   1, "\u0002":   2, "\u0003":   3, "\u0004":   4, "\u0005":   5,
+            "\u0006":   6, "\u0007":   7, "\u0008":   8, "\u0009":   9, "\u000A":  10, "\u000B":  11,
+            "\u000C":  12, "\u000D":  13, "\u000E":  14, "\u000F":  15, "\u0010":  16, "\u0011":  17,
+            "\u0012":  18, "\u0013":  19, "\u0014":  20, "\u0015":  21, "\u0016":  22, "\u0017":  23,
+            "\u0018":  24, "\u0019":  25, "\u001A":  26, "\u001B":  27, "\u001C":  28, "\u001D":  29,
+            "\u001E":  30, "\u001F":  31, "\u0020":  32, "\u0021":  33, "\u0022":  34, "\u0023":  35,
+            "\u0024":  36, "\u0025":  37, "\u0026":  38, "\u0027":  39, "\u0028":  40, "\u0029":  41,
+            "\u002A":  42, "\u002B":  43, "\u002C":  44, "\u002D":  45, "\u002E":  46, "\u002F":  47,
+            "\u0030":  48, "\u0031":  49, "\u0032":  50, "\u0033":  51, "\u0034":  52, "\u0035":  53,
+            "\u0036":  54, "\u0037":  55, "\u0038":  56, "\u0039":  57, "\u003A":  58, "\u003B":  59,
+            "\u003C":  60, "\u003D":  61, "\u003E":  62, "\u003F":  63, "\u0040":  64, "\u0041":  65,
+            "\u0042":  66, "\u0043":  67, "\u0044":  68, "\u0045":  69, "\u0046":  70, "\u0047":  71,
+            "\u0048":  72, "\u0049":  73, "\u004A":  74, "\u004B":  75, "\u004C":  76, "\u004D":  77,
+            "\u004E":  78, "\u004F":  79, "\u0050":  80, "\u0051":  81, "\u0052":  82, "\u0053":  83,
+            "\u0054":  84, "\u0055":  85, "\u0056":  86, "\u0057":  87, "\u0058":  88, "\u0059":  89,
+            "\u005A":  90, "\u005B":  91, "\u005C":  92, "\u005D":  93, "\u005E":  94, "\u005F":  95,
+            "\u0060":  96, "\u0061":  97, "\u0062":  98, "\u0063":  99, "\u0064": 100, "\u0065": 101,
+            "\u0066": 102, "\u0067": 103, "\u0068": 104, "\u0069": 105, "\u006A": 106, "\u006B": 107,
+            "\u006C": 108, "\u006D": 109, "\u006E": 110, "\u006F": 111, "\u0070": 112, "\u0071": 113,
+            "\u0072": 114, "\u0073": 115, "\u0074": 116, "\u0075": 117, "\u0076": 118, "\u0077": 119,
+            "\u0078": 120, "\u0079": 121, "\u007A": 122, "\u007B": 123, "\u007C": 124, "\u007D": 125,
+            "\u007E": 126, "\u007F": 127, "\u0080": 128, "\u0081": 129, "\u0082": 130, "\u0083": 131,
+            "\u0084": 132, "\u0085": 133, "\u0086": 134, "\u0087": 135, "\u0088": 136, "\u0089": 137,
+            "\u008A": 138, "\u008B": 139, "\u008C": 140, "\u008D": 141, "\u008E": 142, "\u008F": 143,
+            "\u0090": 144, "\u0091": 145, "\u0092": 146, "\u0093": 147, "\u0094": 148, "\u0095": 149,
+            "\u0096": 150, "\u0097": 151, "\u0098": 152, "\u0099": 153, "\u009A": 154, "\u009B": 155,
+            "\u009C": 156, "\u009D": 157, "\u009E": 158, "\u009F": 159, "\u00A0": 160, "\u00A1": 161,
+            "\u00A2": 162, "\u00A3": 163, "\u00A4": 164, "\u00A5": 165, "\u00A6": 166, "\u00A7": 167,
+            "\u00A8": 168, "\u00A9": 169, "\u00AA": 170, "\u00AB": 171, "\u00AC": 172, "\u00AD": 173,
+            "\u00AE": 174, "\u00AF": 175, "\u00B0": 176, "\u00B1": 177, "\u00B2": 178, "\u00B3": 179,
+            "\u00B4": 180, "\u00B5": 181, "\u00B6": 182, "\u00B7": 183, "\u00B8": 184, "\u00B9": 185,
+            "\u00BA": 186, "\u00BB": 187, "\u00BC": 188, "\u00BD": 189, "\u00BE": 190, "\u00BF": 191,
+            "\u00C0": 192, "\u00C1": 193, "\u00C2": 194, "\u00C3": 195, "\u00C4": 196, "\u00C5": 197,
+            "\u00C6": 198, "\u00C7": 199, "\u00C8": 200, "\u00C9": 201, "\u00CA": 202, "\u00CB": 203,
+            "\u00CC": 204, "\u00CD": 205, "\u00CE": 206, "\u00CF": 207, "\u00D0": 208, "\u00D1": 209,
+            "\u00D2": 210, "\u00D3": 211, "\u00D4": 212, "\u00D5": 213, "\u00D6": 214, "\u00D7": 215,
+            "\u00D8": 216, "\u00D9": 217, "\u00DA": 218, "\u00DB": 219, "\u00DC": 220, "\u00DD": 221,
+            "\u00DE": 222, "\u00DF": 223, "\u00E0": 224, "\u00E1": 225, "\u00E2": 226, "\u00E3": 227,
+            "\u00E4": 228, "\u00E5": 229, "\u00E6": 230, "\u00E7": 231, "\u00E8": 232, "\u00E9": 233,
+            "\u00EA": 234, "\u00EB": 235, "\u00EC": 236, "\u00ED": 237, "\u00EE": 238, "\u00EF": 239,
+            "\u00F0": 240, "\u00F1": 241, "\u00F2": 242, "\u00F3": 243, "\u00F4": 244, "\u00F5": 245,
+            "\u00F6": 246, "\u00F7": 247, "\u00F8": 248, "\u00F9": 249, "\u00FA": 250, "\u00FB": 251,
+            "\u00FC": 252, "\u00FD": 253, "\u00FE": 254, "\u00FF": 255
+        };
+    }
+    expect: {
+        var o = {
+            "\0":0,"\x01":1,"\x02":2,"\x03":3,"\x04":4,"\x05":5,"\x06":6,
+            "\x07":7,"\b":8,"\t":9,"\n":10,"\v":11,"\f":12,"\r":13,"\x0e":14,
+            "\x0f":15,"\x10":16,"\x11":17,"\x12":18,"\x13":19,"\x14":20,"\x15":21,
+            "\x16":22,"\x17":23,"\x18":24,"\x19":25,"\x1a":26,"\x1b":27,"\x1c":28,
+            "\x1d":29,"\x1e":30,"\x1f":31," ":32,"!":33,'"':34,"#":35,$:36,
+            "%":37,"&":38,"'":39,"(":40,")":41,"*":42,"+":43,",":44,"-":45,
+            ".":46,"/":47,0:48,1:49,2:50,3:51,4:52,5:53,6:54,7:55,8:56,9:57,
+            ":":58,";":59,"<":60,"=":61,">":62,"?":63,"@":64,A:65,B:66,C:67,
+            D:68,E:69,F:70,G:71,H:72,I:73,J:74,K:75,L:76,M:77,N:78,O:79,P:80,
+            Q:81,R:82,S:83,T:84,U:85,V:86,W:87,X:88,Y:89,Z:90,"[":91,"\\":92,
+            "]":93,"^":94,_:95,"`":96,a:97,b:98,c:99,d:100,e:101,f:102,g:103,
+            h:104,i:105,j:106,k:107,l:108,m:109,n:110,o:111,p:112,q:113,r:114,
+            s:115,t:116,u:117,v:118,w:119,x:120,y:121,z:122,"{":123,"|":124,
+            "}":125,"~":126,"\x7f":127,"\x80":128,"\x81":129,"\x82":130,"\x83":131,
+            "\x84":132,"\x85":133,"\x86":134,"\x87":135,"\x88":136,"\x89":137,
+            "\x8a":138,"\x8b":139,"\x8c":140,"\x8d":141,"\x8e":142,"\x8f":143,
+            "\x90":144,"\x91":145,"\x92":146,"\x93":147,"\x94":148,"\x95":149,
+            "\x96":150,"\x97":151,"\x98":152,"\x99":153,"\x9a":154,"\x9b":155,
+            "\x9c":156,"\x9d":157,"\x9e":158,"\x9f":159,"\xa0":160,"\xa1":161,
+            "\xa2":162,"\xa3":163,"\xa4":164,"\xa5":165,"\xa6":166,"\xa7":167,
+            "\xa8":168,"\xa9":169,"\xaa":170,"\xab":171,"\xac":172,"\xad":173,
+            "\xae":174,"\xaf":175,"\xb0":176,"\xb1":177,"\xb2":178,"\xb3":179,
+            "\xb4":180,"\xb5":181,"\xb6":182,"\xb7":183,"\xb8":184,"\xb9":185,
+            "\xba":186,"\xbb":187,"\xbc":188,"\xbd":189,"\xbe":190,"\xbf":191,
+            "\xc0":192,"\xc1":193,"\xc2":194,"\xc3":195,"\xc4":196,"\xc5":197,
+            "\xc6":198,"\xc7":199,"\xc8":200,"\xc9":201,"\xca":202,"\xcb":203,
+            "\xcc":204,"\xcd":205,"\xce":206,"\xcf":207,"\xd0":208,"\xd1":209,
+            "\xd2":210,"\xd3":211,"\xd4":212,"\xd5":213,"\xd6":214,"\xd7":215,
+            "\xd8":216,"\xd9":217,"\xda":218,"\xdb":219,"\xdc":220,"\xdd":221,
+            "\xde":222,"\xdf":223,"\xe0":224,"\xe1":225,"\xe2":226,"\xe3":227,
+            "\xe4":228,"\xe5":229,"\xe6":230,"\xe7":231,"\xe8":232,"\xe9":233,
+            "\xea":234,"\xeb":235,"\xec":236,"\xed":237,"\xee":238,"\xef":239,
+            "\xf0":240,"\xf1":241,"\xf2":242,"\xf3":243,"\xf4":244,"\xf5":245,
+            "\xf6":246,"\xf7":247,"\xf8":248,"\xf9":249,"\xfa":250,"\xfb":251,
+            "\xfc":252,"\xfd":253,"\xfe":254,"\xff":255
+        };
+    }
+}
+
+first_256_hex_chars_as_properties: {
+    input: {
+        var o = {
+            "\x00":   0, "\x01":   1, "\x02":   2, "\x03":   3, "\x04":   4, "\x05":   5,
+            "\x06":   6, "\x07":   7, "\x08":   8, "\x09":   9, "\x0A":  10, "\x0B":  11,
+            "\x0C":  12, "\x0D":  13, "\x0E":  14, "\x0F":  15, "\x10":  16, "\x11":  17,
+            "\x12":  18, "\x13":  19, "\x14":  20, "\x15":  21, "\x16":  22, "\x17":  23,
+            "\x18":  24, "\x19":  25, "\x1A":  26, "\x1B":  27, "\x1C":  28, "\x1D":  29,
+            "\x1E":  30, "\x1F":  31, "\x20":  32, "\x21":  33, "\x22":  34, "\x23":  35,
+            "\x24":  36, "\x25":  37, "\x26":  38, "\x27":  39, "\x28":  40, "\x29":  41,
+            "\x2A":  42, "\x2B":  43, "\x2C":  44, "\x2D":  45, "\x2E":  46, "\x2F":  47,
+            "\x30":  48, "\x31":  49, "\x32":  50, "\x33":  51, "\x34":  52, "\x35":  53,
+            "\x36":  54, "\x37":  55, "\x38":  56, "\x39":  57, "\x3A":  58, "\x3B":  59,
+            "\x3C":  60, "\x3D":  61, "\x3E":  62, "\x3F":  63, "\x40":  64, "\x41":  65,
+            "\x42":  66, "\x43":  67, "\x44":  68, "\x45":  69, "\x46":  70, "\x47":  71,
+            "\x48":  72, "\x49":  73, "\x4A":  74, "\x4B":  75, "\x4C":  76, "\x4D":  77,
+            "\x4E":  78, "\x4F":  79, "\x50":  80, "\x51":  81, "\x52":  82, "\x53":  83,
+            "\x54":  84, "\x55":  85, "\x56":  86, "\x57":  87, "\x58":  88, "\x59":  89,
+            "\x5A":  90, "\x5B":  91, "\x5C":  92, "\x5D":  93, "\x5E":  94, "\x5F":  95,
+            "\x60":  96, "\x61":  97, "\x62":  98, "\x63":  99, "\x64": 100, "\x65": 101,
+            "\x66": 102, "\x67": 103, "\x68": 104, "\x69": 105, "\x6A": 106, "\x6B": 107,
+            "\x6C": 108, "\x6D": 109, "\x6E": 110, "\x6F": 111, "\x70": 112, "\x71": 113,
+            "\x72": 114, "\x73": 115, "\x74": 116, "\x75": 117, "\x76": 118, "\x77": 119,
+            "\x78": 120, "\x79": 121, "\x7A": 122, "\x7B": 123, "\x7C": 124, "\x7D": 125,
+            "\x7E": 126, "\x7F": 127, "\x80": 128, "\x81": 129, "\x82": 130, "\x83": 131,
+            "\x84": 132, "\x85": 133, "\x86": 134, "\x87": 135, "\x88": 136, "\x89": 137,
+            "\x8A": 138, "\x8B": 139, "\x8C": 140, "\x8D": 141, "\x8E": 142, "\x8F": 143,
+            "\x90": 144, "\x91": 145, "\x92": 146, "\x93": 147, "\x94": 148, "\x95": 149,
+            "\x96": 150, "\x97": 151, "\x98": 152, "\x99": 153, "\x9A": 154, "\x9B": 155,
+            "\x9C": 156, "\x9D": 157, "\x9E": 158, "\x9F": 159, "\xA0": 160, "\xA1": 161,
+            "\xA2": 162, "\xA3": 163, "\xA4": 164, "\xA5": 165, "\xA6": 166, "\xA7": 167,
+            "\xA8": 168, "\xA9": 169, "\xAA": 170, "\xAB": 171, "\xAC": 172, "\xAD": 173,
+            "\xAE": 174, "\xAF": 175, "\xB0": 176, "\xB1": 177, "\xB2": 178, "\xB3": 179,
+            "\xB4": 180, "\xB5": 181, "\xB6": 182, "\xB7": 183, "\xB8": 184, "\xB9": 185,
+            "\xBA": 186, "\xBB": 187, "\xBC": 188, "\xBD": 189, "\xBE": 190, "\xBF": 191,
+            "\xC0": 192, "\xC1": 193, "\xC2": 194, "\xC3": 195, "\xC4": 196, "\xC5": 197,
+            "\xC6": 198, "\xC7": 199, "\xC8": 200, "\xC9": 201, "\xCA": 202, "\xCB": 203,
+            "\xCC": 204, "\xCD": 205, "\xCE": 206, "\xCF": 207, "\xD0": 208, "\xD1": 209,
+            "\xD2": 210, "\xD3": 211, "\xD4": 212, "\xD5": 213, "\xD6": 214, "\xD7": 215,
+            "\xD8": 216, "\xD9": 217, "\xDA": 218, "\xDB": 219, "\xDC": 220, "\xDD": 221,
+            "\xDE": 222, "\xDF": 223, "\xE0": 224, "\xE1": 225, "\xE2": 226, "\xE3": 227,
+            "\xE4": 228, "\xE5": 229, "\xE6": 230, "\xE7": 231, "\xE8": 232, "\xE9": 233,
+            "\xEA": 234, "\xEB": 235, "\xEC": 236, "\xED": 237, "\xEE": 238, "\xEF": 239,
+            "\xF0": 240, "\xF1": 241, "\xF2": 242, "\xF3": 243, "\xF4": 244, "\xF5": 245,
+            "\xF6": 246, "\xF7": 247, "\xF8": 248, "\xF9": 249, "\xFA": 250, "\xFB": 251,
+            "\xFC": 252, "\xFD": 253, "\xFE": 254, "\xFF": 255
+        };
+    }
+    expect: {
+        var o = {
+            "\0":0,"\x01":1,"\x02":2,"\x03":3,"\x04":4,"\x05":5,"\x06":6,
+            "\x07":7,"\b":8,"\t":9,"\n":10,"\v":11,"\f":12,"\r":13,"\x0e":14,
+            "\x0f":15,"\x10":16,"\x11":17,"\x12":18,"\x13":19,"\x14":20,"\x15":21,
+            "\x16":22,"\x17":23,"\x18":24,"\x19":25,"\x1a":26,"\x1b":27,"\x1c":28,
+            "\x1d":29,"\x1e":30,"\x1f":31," ":32,"!":33,'"':34,"#":35,$:36,
+            "%":37,"&":38,"'":39,"(":40,")":41,"*":42,"+":43,",":44,"-":45,
+            ".":46,"/":47,0:48,1:49,2:50,3:51,4:52,5:53,6:54,7:55,8:56,9:57,
+            ":":58,";":59,"<":60,"=":61,">":62,"?":63,"@":64,A:65,B:66,C:67,
+            D:68,E:69,F:70,G:71,H:72,I:73,J:74,K:75,L:76,M:77,N:78,O:79,P:80,
+            Q:81,R:82,S:83,T:84,U:85,V:86,W:87,X:88,Y:89,Z:90,"[":91,"\\":92,
+            "]":93,"^":94,_:95,"`":96,a:97,b:98,c:99,d:100,e:101,f:102,g:103,
+            h:104,i:105,j:106,k:107,l:108,m:109,n:110,o:111,p:112,q:113,r:114,
+            s:115,t:116,u:117,v:118,w:119,x:120,y:121,z:122,"{":123,"|":124,
+            "}":125,"~":126,"\x7f":127,"\x80":128,"\x81":129,"\x82":130,"\x83":131,
+            "\x84":132,"\x85":133,"\x86":134,"\x87":135,"\x88":136,"\x89":137,
+            "\x8a":138,"\x8b":139,"\x8c":140,"\x8d":141,"\x8e":142,"\x8f":143,
+            "\x90":144,"\x91":145,"\x92":146,"\x93":147,"\x94":148,"\x95":149,
+            "\x96":150,"\x97":151,"\x98":152,"\x99":153,"\x9a":154,"\x9b":155,
+            "\x9c":156,"\x9d":157,"\x9e":158,"\x9f":159,"\xa0":160,"\xa1":161,
+            "\xa2":162,"\xa3":163,"\xa4":164,"\xa5":165,"\xa6":166,"\xa7":167,
+            "\xa8":168,"\xa9":169,"\xaa":170,"\xab":171,"\xac":172,"\xad":173,
+            "\xae":174,"\xaf":175,"\xb0":176,"\xb1":177,"\xb2":178,"\xb3":179,
+            "\xb4":180,"\xb5":181,"\xb6":182,"\xb7":183,"\xb8":184,"\xb9":185,
+            "\xba":186,"\xbb":187,"\xbc":188,"\xbd":189,"\xbe":190,"\xbf":191,
+            "\xc0":192,"\xc1":193,"\xc2":194,"\xc3":195,"\xc4":196,"\xc5":197,
+            "\xc6":198,"\xc7":199,"\xc8":200,"\xc9":201,"\xca":202,"\xcb":203,
+            "\xcc":204,"\xcd":205,"\xce":206,"\xcf":207,"\xd0":208,"\xd1":209,
+            "\xd2":210,"\xd3":211,"\xd4":212,"\xd5":213,"\xd6":214,"\xd7":215,
+            "\xd8":216,"\xd9":217,"\xda":218,"\xdb":219,"\xdc":220,"\xdd":221,
+            "\xde":222,"\xdf":223,"\xe0":224,"\xe1":225,"\xe2":226,"\xe3":227,
+            "\xe4":228,"\xe5":229,"\xe6":230,"\xe7":231,"\xe8":232,"\xe9":233,
+            "\xea":234,"\xeb":235,"\xec":236,"\xed":237,"\xee":238,"\xef":239,
+            "\xf0":240,"\xf1":241,"\xf2":242,"\xf3":243,"\xf4":244,"\xf5":245,
+            "\xf6":246,"\xf7":247,"\xf8":248,"\xf9":249,"\xfa":250,"\xfb":251,
+            "\xfc":252,"\xfd":253,"\xfe":254,"\xff":255
+        };
+    }
+}
+
+native_prototype: {
+    options = {
+        unsafe_proto: true,
+    }
+    input: {
+        Array.prototype.splice.apply(a, [1, 2, b, c]);
+        Object.prototype.hasOwnProperty.call(d, "foo");
+        String.prototype.indexOf.call(e, "bar");
+    }
+    expect: {
+        [].splice.apply(a, [1, 2, b, c]);
+        ({}).hasOwnProperty.call(d, "foo");
+        "".indexOf.call(e, "bar");
+    }
+}

test/compress/pure_funcs.js

@@ -0,0 +1,295 @@
+array: {
+    options = {
+        pure_funcs: [ "Math.floor" ],
+        side_effects: true,
+    }
+    input: {
+        var a;
+        function f(b) {
+            Math.floor(a / b);
+            Math.floor(c / b);
+        }
+    }
+    expect: {
+        var a;
+        function f(b) {
+            c;
+        }
+    }
+}
+
+func: {
+    options = {
+        pure_funcs: function(node) {
+            return !~node.args[0].print_to_string().indexOf("a");
+        },
+        side_effects: true,
+    }
+    input: {
+        function f(a, b) {
+            Math.floor(a / b);
+            Math.floor(c / b);
+        }
+    }
+    expect: {
+        function f(a, b) {
+            Math.floor(c / b);
+        }
+    }
+}
+
+side_effects: {
+    options = {
+        pure_funcs: [ "console.log" ],
+        side_effects: true,
+    }
+    input: {
+        function f(a, b) {
+            console.log(a());
+            console.log(b);
+        }
+    }
+    expect: {
+        function f(a, b) {
+            a();
+        }
+    }
+}
+
+unused: {
+    options = {
+        pure_funcs: [ "pure" ],
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function foo() {
+            var u = pure(1);
+            var x = pure(2);
+            var y = pure(x);
+            var z = pure(pure(side_effects()));
+            return pure(3);
+        }
+    }
+    expect: {
+        function foo() {
+            side_effects();
+            return pure(3);
+        }
+    }
+}
+
+babel: {
+    options = {
+        pure_funcs: [ "_classCallCheck" ],
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        function _classCallCheck(instance, Constructor) {
+            if (!(instance instanceof Constructor))
+                throw new TypeError("Cannot call a class as a function");
+        }
+        var Foo = function Foo() {
+            _classCallCheck(this, Foo);
+        };
+    }
+    expect: {
+        function _classCallCheck(instance, Constructor) {
+            if (!(instance instanceof Constructor))
+                throw new TypeError("Cannot call a class as a function");
+        }
+        var Foo = function() {
+        };
+    }
+}
+
+conditional: {
+    options = {
+        pure_funcs: [ "pure" ],
+        side_effects: true,
+    }
+    input: {
+        pure(1 | a() ? 2 & b() : 7 ^ c());
+        pure(1 | a() ? 2 & b() : 5);
+        pure(1 | a() ? 4 : 7 ^ c());
+        pure(1 | a() ? 4 : 5);
+        pure(3 ? 2 & b() : 7 ^ c());
+        pure(3 ? 2 & b() : 5);
+        pure(3 ? 4 : 7 ^ c());
+        pure(3 ? 4 : 5);
+    }
+    expect: {
+        1 | a() ? b() : c();
+        1 | a() && b();
+        1 | a() || c();
+        a();
+        3 ? b() : c();
+        3 && b();
+        3 || c();
+    }
+}
+
+relational: {
+    options = {
+        pure_funcs: [ "foo" ],
+        side_effects :true,
+    }
+    input: {
+        foo() in foo();
+        foo() instanceof bar();
+        foo() < "bar";
+        bar() > foo();
+        bar() != bar();
+        bar() !== "bar";
+        "bar" == foo();
+        "bar" === bar();
+        "bar" >= "bar";
+    }
+    expect: {
+        bar();
+        bar();
+        bar(), bar();
+        bar();
+        bar();
+    }
+}
+
+arithmetic: {
+    options = {
+        pure_funcs: [ "foo" ],
+        side_effects :true,
+    }
+    input: {
+        foo() + foo();
+        foo() - bar();
+        foo() * "bar";
+        bar() / foo();
+        bar() & bar();
+        bar() | "bar";
+        "bar" >> foo();
+        "bar" << bar();
+        "bar" >>> "bar";
+    }
+    expect: {
+        bar();
+        bar();
+        bar(), bar();
+        bar();
+        bar();
+    }
+}
+
+boolean_and: {
+    options = {
+        pure_funcs: [ "foo" ],
+        side_effects :true,
+    }
+    input: {
+        foo() && foo();
+        foo() && bar();
+        foo() && "bar";
+        bar() && foo();
+        bar() && bar();
+        bar() && "bar";
+        "bar" && foo();
+        "bar" && bar();
+        "bar" && "bar";
+    }
+    expect: {
+        foo() && bar();
+        bar();
+        bar() && bar();
+        bar();
+        "bar" && bar();
+    }
+}
+
+boolean_or: {
+    options = {
+        pure_funcs: [ "foo" ],
+        side_effects :true,
+    }
+    input: {
+        foo() || foo();
+        foo() || bar();
+        foo() || "bar";
+        bar() || foo();
+        bar() || bar();
+        bar() || "bar";
+        "bar" || foo();
+        "bar" || bar();
+        "bar" || "bar";
+    }
+    expect: {
+        foo() || bar();
+        bar();
+        bar() || bar();
+        bar();
+        "bar" || bar();
+    }
+}
+
+assign: {
+    options = {
+        pure_funcs: [ "foo" ],
+        side_effects :true,
+    }
+    input: {
+        var a;
+        function f(b) {
+            a = foo();
+            b *= 4 + foo();
+            c >>= 0 | foo();
+        }
+    }
+    expect: {
+        var a;
+        function f(b) {
+            a = foo();
+            b *= 4 + foo();
+            c >>= 0 | foo();
+        }
+    }
+}
+
+unary: {
+    options = {
+        pure_funcs: [ "foo" ],
+        side_effects :true,
+    }
+    input: {
+        typeof foo();
+        typeof bar();
+        typeof "bar";
+        void foo();
+        void bar();
+        void "bar";
+        delete a[foo()];
+        delete a[bar()];
+        delete a["bar"];
+        a[foo()]++;
+        a[bar()]++;
+        a["bar"]++;
+        --a[foo()];
+        --a[bar()];
+        --a["bar"];
+        ~foo();
+        ~bar();
+        ~"bar";
+    }
+    expect: {
+        bar();
+        bar();
+        delete a[foo()];
+        delete a[bar()];
+        delete a["bar"];
+        a[foo()]++;
+        a[bar()]++;
+        a["bar"]++;
+        --a[foo()];
+        --a[bar()];
+        --a["bar"];
+        bar();
+    }
+}

test/compress/pure_getters.js

@@ -0,0 +1,121 @@
+strict: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: false,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b = null, c = {};
+        a.prop;
+        b.prop;
+        c.prop;
+        d.prop;
+        null.prop;
+        (void 0).prop;
+        undefined.prop;
+    }
+    expect: {
+        var a, b = null, c = {};
+        a.prop;
+        b.prop;
+        c.prop;
+        d.prop;
+        null.prop;
+        (void 0).prop;
+        (void 0).prop;
+    }
+}
+
+strict_reduce_vars: {
+    options = {
+        pure_getters: "strict",
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b = null, c = {};
+        a.prop;
+        b.prop;
+        c.prop;
+        d.prop;
+        null.prop;
+        (void 0).prop;
+        undefined.prop;
+    }
+    expect: {
+        var a, b = null, c = {};
+        a.prop;
+        b.prop;
+        d.prop;
+        null.prop;
+        (void 0).prop;
+        (void 0).prop;
+    }
+}
+
+unsafe: {
+    options = {
+        pure_getters: true,
+        reduce_vars: false,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b = null, c = {};
+        a.prop;
+        b.prop;
+        c.prop;
+        d.prop;
+        null.prop;
+        (void 0).prop;
+        undefined.prop;
+    }
+    expect: {
+        var a, b = null, c = {};
+        d;
+        null.prop;
+        (void 0).prop;
+        (void 0).prop;
+    }
+}
+
+unsafe_reduce_vars: {
+    options = {
+        pure_getters: true,
+        reduce_vars: true,
+        side_effects: true,
+        toplevel: true,
+    }
+    input: {
+        var a, b = null, c = {};
+        a.prop;
+        b.prop;
+        c.prop;
+        d.prop;
+        null.prop;
+        (void 0).prop;
+        undefined.prop;
+    }
+    expect: {
+        var a, b = null, c = {};
+        d;
+        null.prop;
+        (void 0).prop;
+        (void 0).prop;
+    }
+}
+
+chained: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        a.b.c;
+    }
+    expect: {
+        a.b.c;
+    }
+}

test/compress/return_undefined.js

@@ -0,0 +1,124 @@
+return_undefined: {
+    options = {
+        sequences     : false,
+        if_return     : true,
+        evaluate      : true,
+        dead_code     : true,
+        conditionals  : true,
+        comparisons   : true,
+        booleans      : true,
+        unused        : true,
+        side_effects  : true,
+        properties    : true,
+        drop_debugger : true,
+        loops         : true,
+        hoist_funs    : true,
+        keep_fargs    : true,
+        keep_fnames   : false,
+        hoist_vars    : true,
+        join_vars     : true,
+        cascade       : true,
+        negate_iife   : true
+    };
+    input: {
+        function f0() {
+        }
+        function f1() {
+            return undefined;
+        }
+        function f2() {
+            return void 0;
+        }
+        function f3() {
+            return void 123;
+        }
+        function f4() {
+            return;
+        }
+        function f5(a, b) {
+            console.log(a, b);
+            baz(a);
+            return;
+        }
+        function f6(a, b) {
+            console.log(a, b);
+            if (a) {
+                foo(b);
+                baz(a);
+                return a + b;
+            }
+            return undefined;
+        }
+        function f7(a, b) {
+            console.log(a, b);
+            if (a) {
+                foo(b);
+                baz(a);
+                return void 0;
+            }
+            return a + b;
+        }
+        function f8(a, b) {
+            foo(a);
+            bar(b);
+            return void 0;
+        }
+        function f9(a, b) {
+            foo(a);
+            bar(b);
+            return undefined;
+        }
+        function f10() {
+            return false;
+        }
+        function f11() {
+            return null;
+        }
+        function f12() {
+            return 0;
+        }
+    }
+    expect: {
+        function f0() {}
+        function f1() {}
+        function f2() {}
+        function f3() {}
+        function f4() {}
+        function f5(a, b) {
+            console.log(a, b);
+            baz(a);
+        }
+        function f6(a, b) {
+            console.log(a, b);
+            if (a) {
+                foo(b);
+                baz(a);
+                return a + b;
+            }
+        }
+        function f7(a, b) {
+            console.log(a, b);
+            if (!a)
+                return a + b;
+            foo(b);
+            baz(a);
+        }
+        function f8(a, b) {
+            foo(a);
+            bar(b);
+        }
+        function f9(a, b) {
+            foo(a);
+            bar(b);
+        }
+        function f10() {
+            return !1;
+        }
+        function f11() {
+            return null;
+        }
+        function f12() {
+            return 0;
+        }
+    }
+}

test/compress/screw-ie8.js

@@ -0,0 +1,257 @@
+do_screw: {
+    options = {
+        ie8: false,
+    }
+    beautify = {
+        ie8: false,
+        ascii_only: true,
+    }
+    input: {
+        f("\v");
+    }
+    expect_exact: 'f("\\v");'
+}
+
+dont_screw: {
+    options = {
+        ie8: true,
+    }
+    beautify = {
+        ie8: true,
+        ascii_only: true,
+    }
+    input: {
+        f("\v");
+    }
+    expect_exact: 'f("\\x0B");'
+}
+
+do_screw_constants: {
+    options = {
+        ie8: false,
+    }
+    input: {
+        f(undefined, Infinity);
+    }
+    expect_exact: "f(void 0,1/0);"
+}
+
+dont_screw_constants: {
+    options = {
+        ie8: true,
+    }
+    input: {
+        f(undefined, Infinity);
+    }
+    expect_exact: "f(undefined,Infinity);"
+}
+
+do_screw_try_catch: {
+    options = {
+        ie8: false,
+    }
+    mangle = {
+        ie8: false,
+    }
+    beautify = {
+        ie8: false,
+    }
+    input: {
+        good = function(e){
+            return function(error){
+                try{
+                    e()
+                } catch(e) {
+                    error(e)
+                }
+            }
+        };
+    }
+    expect: {
+        good = function(n){
+            return function(t){
+                try{
+                    n()
+                } catch(n) {
+                    t(n)
+                }
+            }
+        };
+    }
+}
+
+dont_screw_try_catch: {
+    options = {
+        ie8: true,
+    }
+    mangle = {
+        ie8: true,
+    }
+    beautify = {
+        ie8: true,
+    }
+    input: {
+        bad = function(e){
+            return function(error){
+                try{
+                    e()
+                } catch(e) {
+                    error(e)
+                }
+            }
+        };
+    }
+    expect: {
+        bad = function(n){
+            return function(t){
+                try{
+                    n()
+                } catch(n) {
+                    t(n)
+                }
+            }
+        };
+    }
+}
+
+do_screw_try_catch_undefined: {
+    options = {
+        ie8: false,
+    }
+    mangle = {
+        ie8: false,
+    }
+    beautify = {
+        ie8: false,
+    }
+    input: {
+        function a(b){
+            try {
+                throw 'Stuff';
+            } catch (undefined) {
+                console.log('caught: ' + undefined);
+            }
+            console.log('undefined is ' + undefined);
+            return b === undefined;
+        };
+    }
+    expect: {
+        function a(o){
+            try{
+                throw "Stuff"
+            } catch (o) {
+                console.log("caught: "+o)
+            }
+            console.log("undefined is " + void 0);
+            return void 0===o
+        }
+    }
+    expect_stdout: true
+}
+
+dont_screw_try_catch_undefined: {
+    options = {
+        ie8: true,
+    }
+    mangle = {
+        ie8: true,
+    }
+    beautify = {
+        ie8: true,
+    }
+    input: {
+        function a(b){
+            try {
+                throw 'Stuff';
+            } catch (undefined) {
+                console.log('caught: ' + undefined);
+            }
+            console.log('undefined is ' + undefined);
+            return b === undefined;
+        };
+    }
+    expect: {
+        function a(n){
+            try{
+                throw "Stuff"
+            } catch (undefined) {
+                console.log("caught: " + undefined)
+            }
+            console.log("undefined is " + undefined);
+            return n === undefined
+        }
+    }
+    expect_stdout: true
+}
+
+reduce_vars: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        ie8: true,
+        unused: true,
+    }
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        function f() {
+            var a;
+            try {
+                x();
+            } catch (a) {
+                y();
+            }
+            alert(a);
+        }
+    }
+    expect: {
+        function f() {
+            var t;
+            try {
+                x();
+            } catch (t) {
+                y();
+            }
+            alert(t);
+        }
+    }
+}
+
+issue_1586_1: {
+    options = {
+        ie8: true,
+    }
+    mangle = {
+        ie8: true,
+    }
+    input: {
+        function f() {
+            try {
+                x();
+            } catch (err) {
+                console.log(err.message);
+            }
+        }
+    }
+    expect_exact: "function f(){try{x()}catch(c){console.log(c.message)}}"
+}
+
+issue_1586_2: {
+    options = {
+        ie8: false,
+    }
+    mangle = {
+        ie8: false,
+    }
+    input: {
+        function f() {
+            try {
+                x();
+            } catch (err) {
+                console.log(err.message);
+            }
+        }
+    }
+    expect_exact: "function f(){try{x()}catch(c){console.log(c.message)}}"
+}

test/compress/sequences.js

@@ -86,14 +86,17 @@ make_sequences_4: {
         switch (x = 5, y) {}
         with (x = 5, obj);
     }
+    expect_stdout: true
 }
 
 lift_sequences_1: {
     options = { sequences: true };
     input: {
+        var foo, x, y, bar;
         foo = !(x(), y(), bar());
     }
     expect: {
+        var foo, x, y, bar;
         x(), y(), foo = !bar();
     }
 }
@@ -101,19 +104,28 @@ lift_sequences_1: {
 lift_sequences_2: {
     options = { sequences: true, evaluate: true };
     input: {
-        q = 1 + (foo(), bar(), 5) + 7 * (5 / (3 - (a(), (QW=ER), c(), 2))) - (x(), y(), 5);
+        var foo = 1, bar;
+        foo.x = (foo = {}, 10);
+        bar = (bar = {}, 10);
+        console.log(foo, bar);
     }
     expect: {
-        foo(), bar(), a(), QW = ER, c(), x(), y(), q = 36
+        var foo = 1, bar;
+        foo.x = (foo = {}, 10),
+        bar = {}, bar = 10,
+        console.log(foo, bar);
     }
+    expect_stdout: true
 }
 
 lift_sequences_3: {
     options = { sequences: true, conditionals: true };
     input: {
+        var x, foo, bar, baz;
         x = (foo(), bar(), baz()) ? 10 : 20;
     }
     expect: {
+        var x, foo, bar, baz;
         foo(), bar(), x = baz() ? 10 : 20;
     }
 }
@@ -121,13 +133,32 @@ lift_sequences_3: {
 lift_sequences_4: {
     options = { side_effects: true };
     input: {
+        var x, foo, bar, baz;
         x = (foo, bar, baz);
     }
     expect: {
+        var x, foo, bar, baz;
         x = baz;
     }
 }
 
+lift_sequences_5: {
+    options = {
+        sequences: true,
+    }
+    input: {
+        var a = 2, b;
+        a *= (b, a = 4, 3);
+        console.log(a);
+    }
+    expect: {
+        var a = 2, b;
+        b, a *= (a = 4, 3),
+        console.log(a);
+    }
+    expect_stdout: "6"
+}
+
 for_sequences: {
     options = { sequences: true };
     input: {
@@ -159,3 +190,523 @@ for_sequences: {
         for (y = 5; false;);
     }
 }
+
+limit_1: {
+    options = {
+        sequences: 3,
+    };
+    input: {
+        a;
+        b;
+        c;
+        d;
+        e;
+        f;
+        g;
+        h;
+        i;
+        j;
+        k;
+    }
+    expect: {
+        a, b, c;
+        d, e, f;
+        g, h, i;
+        j, k;
+    }
+}
+
+limit_2: {
+    options = {
+        sequences: 3,
+    };
+    input: {
+        a, b;
+        c, d;
+        e, f;
+        g, h;
+        i, j;
+        k;
+    }
+    expect: {
+        a, b, c, d;
+        e, f, g, h;
+        i, j, k;
+    }
+}
+
+negate_iife_for: {
+    options = {
+        sequences: true,
+        negate_iife: true,
+    };
+    input: {
+        (function() {})();
+        for (i = 0; i < 5; i++) console.log(i);
+
+        (function() {})();
+        for (; i < 5; i++) console.log(i);
+    }
+    expect: {
+        for (!function() {}(), i = 0; i < 5; i++) console.log(i);
+        for (function() {}(); i < 5; i++) console.log(i);
+    }
+    expect_stdout: true
+}
+
+iife: {
+    options = {
+        sequences: true,
+    };
+    input: {
+        x = 42;
+        (function a() {})();
+        !function b() {}();
+        ~function c() {}();
+        +function d() {}();
+        -function e() {}();
+        void function f() {}();
+        typeof function g() {}();
+    }
+    expect: {
+        x = 42, function a() {}(), function b() {}(), function c() {}(),
+        function d() {}(), function e() {}(), function f() {}(), function g() {}();
+    }
+}
+
+unsafe_undefined: {
+    options = {
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+        side_effects: true,
+        unsafe: true,
+    }
+    input: {
+        function f(undefined) {
+            if (a)
+                return b;
+            if (c)
+                return d;
+        }
+        function g(undefined) {
+            if (a)
+                return b;
+            if (c)
+                return d;
+            e();
+        }
+    }
+    expect: {
+        function f(undefined) {
+            return a ? b : c ? d : undefined;
+        }
+        function g(undefined) {
+            return a ? b : c ? d : void e();
+        }
+    }
+}
+
+issue_1685: {
+    options = {
+        cascade: true,
+        side_effects: true,
+    }
+    input: {
+        var a = 100, b = 10;
+        function f() {
+            var a = (a--, delete a && --b);
+        }
+        f();
+        console.log(a, b);
+    }
+    expect: {
+        var a = 100, b = 10;
+        function f() {
+            var a = (a--, delete a && --b);
+        }
+        f();
+        console.log(a, b);
+    }
+    expect_stdout: true
+}
+
+func_def_1: {
+    options = {
+        cascade: true,
+        side_effects: true,
+    }
+    input: {
+        function f() {
+            return f = 0, !!f;
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            return !!(f = 0);
+        }
+        console.log(f());
+    }
+    expect_stdout: "false"
+}
+
+func_def_2: {
+    options = {
+        cascade: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function f() {
+            return f = 0, !!f;
+        }());
+    }
+    expect: {
+        console.log(function f() {
+            return f = 0, !!f;
+        }());
+    }
+    expect_stdout: "true"
+}
+
+func_def_3: {
+    options = {
+        cascade: true,
+        side_effects: true,
+    }
+    input: {
+        function f() {
+            function g() {}
+            return g = 0, !!g;
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            function g() {}
+            return !!(g = 0);
+        }
+        console.log(f());
+    }
+    expect_stdout: "false"
+}
+
+func_def_4: {
+    options = {
+        cascade: true,
+        side_effects: true,
+    }
+    input: {
+        function f() {
+            function g() {
+                return g = 0, !!g;
+            }
+            return g();
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            function g() {
+                return !!(g = 0);
+            }
+            return g();
+        }
+        console.log(f());
+    }
+    expect_stdout: "false"
+}
+
+func_def_5: {
+    options = {
+        cascade: true,
+        side_effects: true,
+    }
+    input: {
+        function f() {
+            return function g(){
+                return g = 0, !!g;
+            }();
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            return function g(){
+                return g = 0, !!g;
+            }();
+        }
+        console.log(f());
+    }
+    expect_stdout: "true"
+}
+
+issue_1758: {
+    options = {
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(function(c) {
+            var undefined = 42;
+            return function() {
+                c--;
+                c--, c.toString();
+                return;
+            }();
+        }());
+    }
+    expect: {
+        console.log(function(c) {
+            var undefined = 42;
+            return function() {
+                return c--, c--, void c.toString();
+            }();
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+delete_seq_1: {
+    options = {
+        booleans: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(delete (1, undefined));
+        console.log(delete (1, void 0));
+        console.log(delete (1, Infinity));
+        console.log(delete (1, 1 / 0));
+        console.log(delete (1, NaN));
+        console.log(delete (1, 0 / 0));
+    }
+    expect: {
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+    }
+    expect_stdout: true
+}
+
+delete_seq_2: {
+    options = {
+        booleans: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(delete (1, 2, undefined));
+        console.log(delete (1, 2, void 0));
+        console.log(delete (1, 2, Infinity));
+        console.log(delete (1, 2, 1 / 0));
+        console.log(delete (1, 2, NaN));
+        console.log(delete (1, 2, 0 / 0));
+    }
+    expect: {
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+    }
+    expect_stdout: true
+}
+
+delete_seq_3: {
+    options = {
+        booleans: true,
+        keep_infinity: true,
+        side_effects: true,
+    }
+    input: {
+        console.log(delete (1, 2, undefined));
+        console.log(delete (1, 2, void 0));
+        console.log(delete (1, 2, Infinity));
+        console.log(delete (1, 2, 1 / 0));
+        console.log(delete (1, 2, NaN));
+        console.log(delete (1, 2, 0 / 0));
+    }
+    expect: {
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+        console.log(!0);
+    }
+    expect_stdout: true
+}
+
+delete_seq_4: {
+    options = {
+        booleans: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function f() {}
+        console.log(delete (f(), undefined));
+        console.log(delete (f(), void 0));
+        console.log(delete (f(), Infinity));
+        console.log(delete (f(), 1 / 0));
+        console.log(delete (f(), NaN));
+        console.log(delete (f(), 0 / 0));
+    }
+    expect: {
+        function f() {}
+        console.log((f(), !0)),
+        console.log((f(), !0)),
+        console.log((f(), !0)),
+        console.log((f(), !0)),
+        console.log((f(), !0)),
+        console.log((f(), !0));
+    }
+    expect_stdout: true
+}
+
+delete_seq_5: {
+    options = {
+        booleans: true,
+        keep_infinity: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function f() {}
+        console.log(delete (f(), undefined));
+        console.log(delete (f(), void 0));
+        console.log(delete (f(), Infinity));
+        console.log(delete (f(), 1 / 0));
+        console.log(delete (f(), NaN));
+        console.log(delete (f(), 0 / 0));
+    }
+    expect: {
+        function f() {}
+        console.log((f(), !0)),
+        console.log((f(), !0)),
+        console.log((f(), !0)),
+        console.log((f(), !0)),
+        console.log((f(), !0)),
+        console.log((f(), !0));
+    }
+    expect_stdout: true
+}
+
+delete_seq_6: {
+    options = {
+        booleans: true,
+        side_effects: true,
+    }
+    input: {
+        var a;
+        console.log(delete (1, a));
+    }
+    expect: {
+        var a;
+        console.log(!0);
+    }
+    expect_stdout: true
+}
+
+side_effects: {
+    options = {
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        0, a(), 1, b(), 2, c(), 3;
+    }
+    expect: {
+        a(), b(), c();
+    }
+}
+
+side_effects_cascade_1: {
+    options = {
+        cascade: true,
+        conditionals: true,
+        sequences: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a, b) {
+            a -= 42;
+            if (a < 0) a = 0;
+            b.a = a;
+        }
+    }
+    expect: {
+        function f(a, b) {
+            (a -= 42) < 0 && (a = 0), b.a = a;
+        }
+    }
+}
+
+side_effects_cascade_2: {
+    options = {
+        cascade: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a, b) {
+            b = a,
+            !a + (b += a) || (b += a),
+            b = a,
+            b;
+        }
+    }
+    expect: {
+        function f(a, b) {
+            b = a,
+            !a + (b += a) || (b += a),
+            b = a;
+        }
+    }
+}
+
+side_effects_cascade_3: {
+    options = {
+        cascade: true,
+        conditionals: true,
+        side_effects: true,
+    }
+    input: {
+        function f(a, b) {
+            "foo" ^ (b += a),
+            b ? false : (b = a) ? -1 : (b -= a) - (b ^= a),
+            a-- || !a,
+            a;
+        }
+    }
+    expect: {
+        function f(a, b) {
+            !(b += a) && ((b = a) || (b -= a, b ^= a)),
+            --a;
+        }
+    }
+}
+
+issue_27: {
+    options = {
+        cascade: true,
+        passes: 2,
+        sequences: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        (function(jQuery) {
+            var $;
+            $ = jQuery;
+            $("body").addClass("foo");
+        })(jQuery);
+    }
+    expect: {
+        (function(jQuery) {
+            jQuery("body").addClass("foo");
+        })(jQuery);
+    }
+}

test/compress/string-literal.js

@@ -0,0 +1,10 @@
+octal_escape_sequence: {
+    input: {
+        var boundaries = "\0\7\00\07\70\77\000\077\300\377";
+        var border_check = "\400\700\0000\3000";
+    }
+    expect: {
+        var boundaries = "\x00\x07\x00\x07\x38\x3f\x00\x3f\xc0\xff";
+        var border_check = "\x20\x30\x38\x30\x00\x30\xc0\x30";
+    }
+}

test/compress/switch.js

@@ -1,5 +1,10 @@
 constant_switch_1: {
-    options = { dead_code: true, evaluate: true };
+    options = {
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+        switches: true,
+    }
     input: {
         switch (1+1) {
           case 1: foo(); break;
@@ -13,7 +18,12 @@ constant_switch_1: {
 }
 
 constant_switch_2: {
-    options = { dead_code: true, evaluate: true };
+    options = {
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+        switches: true,
+    }
     input: {
         switch (1) {
           case 1: foo();
@@ -28,7 +38,12 @@ constant_switch_2: {
 }
 
 constant_switch_3: {
-    options = { dead_code: true, evaluate: true };
+    options = {
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+        switches: true,
+    }
     input: {
         switch (10) {
           case 1: foo();
@@ -44,7 +59,12 @@ constant_switch_3: {
 }
 
 constant_switch_4: {
-    options = { dead_code: true, evaluate: true };
+    options = {
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+        switches: true,
+    }
     input: {
         switch (2) {
           case 1:
@@ -65,7 +85,12 @@ constant_switch_4: {
 }
 
 constant_switch_5: {
-    options = { dead_code: true, evaluate: true };
+    options = {
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+        switches: true,
+    }
     input: {
         switch (1) {
           case 1:
@@ -94,7 +119,12 @@ constant_switch_5: {
 }
 
 constant_switch_6: {
-    options = { dead_code: true, evaluate: true };
+    options = {
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+        switches: true,
+    }
     input: {
         OUT: {
             foo();
@@ -123,7 +153,12 @@ constant_switch_6: {
 }
 
 constant_switch_7: {
-    options = { dead_code: true, evaluate: true };
+    options = {
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+        switches: true,
+    }
     input: {
         OUT: {
             foo();
@@ -161,7 +196,12 @@ constant_switch_7: {
 }
 
 constant_switch_8: {
-    options = { dead_code: true, evaluate: true };
+    options = {
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+        switches: true,
+    }
     input: {
         OUT: switch (1) {
           case 1:
@@ -185,7 +225,12 @@ constant_switch_8: {
 }
 
 constant_switch_9: {
-    options = { dead_code: true, evaluate: true };
+    options = {
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+        switches: true,
+    }
     input: {
         OUT: switch (1) {
           case 1:
@@ -210,7 +255,10 @@ constant_switch_9: {
 }
 
 drop_default_1: {
-    options = { dead_code: true };
+    options = {
+        dead_code: true,
+        switches: true,
+    }
     input: {
         switch (foo) {
           case 'bar': baz();
@@ -225,7 +273,10 @@ drop_default_1: {
 }
 
 drop_default_2: {
-    options = { dead_code: true };
+    options = {
+        dead_code: true,
+        switches: true,
+    }
     input: {
         switch (foo) {
           case 'bar': baz(); break;
@@ -241,7 +292,10 @@ drop_default_2: {
 }
 
 keep_default: {
-    options = { dead_code: true };
+    options = {
+        dead_code: true,
+        switches: true,
+    }
     input: {
         switch (foo) {
           case 'bar': baz();
@@ -258,3 +312,507 @@ keep_default: {
         }
     }
 }
+
+issue_1663: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+        switches: true,
+    }
+    input: {
+        var a = 100, b = 10;
+        function f() {
+            switch (1) {
+              case 1:
+                b = a++;
+                return ++b;
+              default:
+                var b;
+            }
+        }
+        f();
+        console.log(a, b);
+    }
+    expect: {
+        var a = 100, b = 10;
+        function f() {
+            var b;
+            b = a++;
+            return ++b;
+        }
+        f();
+        console.log(a, b);
+    }
+    expect_stdout: true
+}
+
+drop_case: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (foo) {
+          case 'bar': baz(); break;
+          case 'moo':
+            break;
+        }
+    }
+    expect: {
+        switch (foo) {
+          case 'bar': baz();
+        }
+    }
+}
+
+keep_case: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (foo) {
+          case 'bar': baz(); break;
+          case moo:
+            break;
+        }
+    }
+    expect: {
+        switch (foo) {
+          case 'bar': baz(); break;
+          case moo:
+        }
+    }
+}
+
+issue_376: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        switch (true) {
+          case boolCondition:
+            console.log(1);
+            break;
+          case false:
+            console.log(2);
+            break;
+        }
+    }
+    expect: {
+        switch (true) {
+          case boolCondition:
+            console.log(1);
+        }
+    }
+}
+
+issue_441_1: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (foo) {
+          case bar:
+            qux();
+            break;
+          case baz:
+            qux();
+            break;
+          default:
+            qux();
+            break;
+        }
+    }
+    expect: {
+        switch (foo) {
+          case bar:
+          case baz:
+          default:
+            qux();
+        }
+    }
+}
+
+issue_441_2: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (foo) {
+          case bar:
+            // TODO: Fold into the case below
+            qux();
+            break;
+          case fall:
+          case baz:
+            qux();
+            break;
+          default:
+            qux();
+            break;
+        }
+    }
+    expect: {
+        switch (foo) {
+          case bar:
+            qux();
+            break;
+          case fall:
+          case baz:
+          default:
+            qux();
+        }
+    }
+}
+
+issue_1674: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        side_effects: true,
+        switches: true,
+    }
+    input: {
+        switch (0) {
+          default:
+            console.log("FAIL");
+            break;
+          case 0:
+            console.log("PASS");
+            break;
+        }
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_1679: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        var a = 100, b = 10;
+        function f() {
+            switch (--b) {
+              default:
+              case !function x() {}:
+                break;
+              case b--:
+                switch (0) {
+                  default:
+                  case a--:
+                }
+                break;
+              case (a++):
+                break;
+            }
+        }
+        f();
+        console.log(a, b);
+    }
+    expect: {
+        var a = 100, b = 10;
+        function f() {
+            switch (--b) {
+              default:
+              case !function x() {}:
+                break;
+              case b--:
+                switch (0) {
+                  default:
+                  case a--:
+                }
+                break;
+              case (a++):
+            }
+        }
+        f();
+        console.log(a, b);
+    }
+    expect_stdout: true
+}
+
+issue_1680_1: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        switches: true,
+    }
+    input: {
+        function f(x) {
+            console.log(x);
+            return x + 1;
+        }
+        switch (2) {
+          case f(0):
+          case f(1):
+            f(2);
+          case 2:
+          case f(3):
+          case f(4):
+            f(5);
+        }
+    }
+    expect: {
+        function f(x) {
+            console.log(x);
+            return x + 1;
+        }
+        switch (2) {
+          case f(0):
+          case f(1):
+            f(2);
+          case 2:
+            f(5);
+        }
+    }
+    expect_stdout: [
+        "0",
+        "1",
+        "2",
+        "5",
+    ]
+}
+
+issue_1680_2: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var a = 100, b = 10;
+        switch (b) {
+          case a--:
+            break;
+          case b:
+            var c;
+            break;
+          case a:
+            break;
+          case a--:
+            break;
+        }
+        console.log(a, b);
+    }
+    expect: {
+        var a = 100, b = 10;
+        switch (b) {
+          case a--:
+            break;
+          case b:
+            var c;
+            break;
+          case a:
+          case a--:
+        }
+        console.log(a, b);
+    }
+    expect_stdout: true
+}
+
+issue_1690_1: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (console.log("PASS")) {}
+    }
+    expect: {
+        console.log("PASS");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_1690_2: {
+    options = {
+        dead_code: false,
+        switches: true,
+    }
+    input: {
+        switch (console.log("PASS")) {}
+    }
+    expect: {
+        switch (console.log("PASS")) {}
+    }
+    expect_stdout: "PASS"
+}
+
+if_switch_typeof: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        side_effects: true,
+        switches: true,
+    }
+    input: {
+        if (a) switch(typeof b) {}
+    }
+    expect: {
+        a;
+    }
+}
+
+issue_1698: {
+    options = {
+        side_effects: true,
+        switches: true,
+    }
+    input: {
+        var a = 1;
+        !function() {
+            switch (a++) {}
+        }();
+        console.log(a);
+    }
+    expect: {
+        var a = 1;
+        !function() {
+            switch (a++) {}
+        }();
+        console.log(a);
+    }
+    expect_stdout: "2"
+}
+
+issue_1705_1: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var a = 0;
+        switch (a) {
+          default:
+            console.log("FAIL");
+          case 0:
+            break;
+        }
+    }
+    expect: {
+        var a = 0;
+        switch (a) {
+          default:
+            console.log("FAIL");
+          case 0:
+        }
+    }
+    expect_stdout: true
+}
+
+issue_1705_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        reduce_vars: true,
+        sequences: true,
+        side_effects: true,
+        switches: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = 0;
+        switch (a) {
+          default:
+            console.log("FAIL");
+          case 0:
+            break;
+        }
+    }
+    expect: {
+    }
+    expect_stdout: true
+}
+
+issue_1705_3: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        switch (a) {
+          case 0:
+            break;
+          default:
+            break;
+        }
+    }
+    expect: {
+        a;
+    }
+    expect_stdout: true
+}
+
+beautify: {
+    beautify = {
+        beautify: true,
+    }
+    input: {
+        switch (a) {
+          case 0:
+          case 1:
+            break;
+          case 2:
+          default:
+        }
+        switch (b) {
+          case 3:
+            foo();
+            bar();
+          default:
+            break;
+        }
+    }
+    expect_exact: [
+        "switch (a) {",
+        "  case 0:",
+        "  case 1:",
+        "    break;",
+        "",
+        "  case 2:",
+        "  default:",
+        "}",
+        "",
+        "switch (b) {",
+        "  case 3:",
+        "    foo();",
+        "    bar();",
+        "",
+        "  default:",
+        "    break;",
+        "}",
+    ]
+}
+
+issue_1758: {
+    options = {
+        dead_code: true,
+        switches: true,
+    }
+    input: {
+        var a = 1, b = 2;
+        switch (a--) {
+          default:
+            b++;
+        }
+        console.log(a, b);
+    }
+    expect: {
+        var a = 1, b = 2;
+        a--;
+        b++;
+        console.log(a, b);
+    }
+    expect_stdout: "0 3"
+}

test/compress/transform.js

@@ -0,0 +1,130 @@
+booleans_evaluate: {
+    options = {
+        booleans: true,
+        evaluate: true,
+    }
+    input: {
+        console.log(typeof void 0 != "undefined");
+        console.log(1 == 1, 1 === 1)
+        console.log(1 != 1, 1 !== 1)
+    }
+    expect: {
+        console.log(!1);
+        console.log(!0, !0);
+        console.log(!1, !1);
+    }
+    expect_stdout: true
+}
+
+booleans_global_defs: {
+    options = {
+        booleans: true,
+        evaluate: true,
+        global_defs: {
+            A: true,
+        },
+    }
+    input: {
+        console.log(A == 1);
+    }
+    expect: {
+        console.log(!0);
+    }
+}
+
+condition_evaluate: {
+    options = {
+        booleans: true,
+        dead_code: false,
+        evaluate: true,
+        loops: false,
+    }
+    input: {
+        while (1 === 2);
+        for (; 1 == true;);
+        if (void 0 == null);
+    }
+    expect: {
+        while (!1);
+        for (; !0;);
+        if (!0);
+    }
+}
+
+if_else_empty: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        if ({} ? a : b); else {}
+    }
+    expect: {
+        !{} ? b : a;
+    }
+}
+
+label_if_break: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+    }
+    input: {
+        L: if (true) {
+            a;
+            break L;
+        }
+    }
+    expect: {
+        a;
+    }
+}
+
+while_if_break: {
+    options = {
+        conditionals: true,
+        loops: true,
+        sequences: true,
+    }
+    input: {
+        while (a) {
+            if (b) if(c) d;
+            if (e) break;
+        }
+    }
+    expect: {
+        for(; a && (b && c && d, !e););
+    }
+}
+
+if_return: {
+    options = {
+        booleans: true,
+        conditionals: true,
+        if_return: true,
+        sequences: true,
+    }
+    input: {
+        function f(w, x, y, z) {
+            if (x) return;
+            if (w) {
+                if (y) return;
+            } else if (z) return;
+            if (x == y) return true;
+
+            if (x) w();
+            if (y) z();
+            return true;
+        }
+    }
+    expect: {
+        function f(w, x, y, z) {
+            if (!x) {
+                if (w) {
+                    if (y) return;
+                } else if (z) return;
+                return x == y || (x && w(), y && z(), !0);
+            }
+        }
+    }
+}

test/compress/typeof.js

@@ -23,3 +23,40 @@ typeof_evaluation: {
         h='undefined';
     }
 }
+
+typeof_in_boolean_context: {
+    options = {
+        booleans     : true,
+        evaluate     : true,
+        conditionals : true,
+        side_effects : true,
+    };
+    input: {
+        function f1(x) { return typeof x ? "yes" : "no"; }
+        function f2() { return typeof g()? "Yes" : "No"; }
+        typeof 0 ? foo() : bar();
+        !typeof console.log(1);
+        var a = !typeof console.log(2);
+        if (typeof (1 + foo()));
+    }
+    expect: {
+        function f1(x) { return "yes"; }
+        function f2() { return g(), "Yes"; }
+        foo();
+        console.log(1);
+        var a = !(console.log(2), !0);
+        foo();
+    }
+}
+
+issue_1668: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        if (typeof bar);
+    }
+    expect: {
+        if (!0);
+    }
+}

test/compress/unicode.js

@@ -0,0 +1,17 @@
+unicode_parse_variables: {
+    options = {};
+    input: {
+        var a = {};
+        a.你好 = 456;
+
+        var ↂωↂ = 123;
+        var l০ = 3; // 2nd char is a unicode digit
+    }
+    expect: {
+        var a = {};
+        a.你好 = 456;
+
+        var ↂωↂ = 123;
+        var l০ = 3;
+    }
+}

test/compress/wrap_iife.js

@@ -0,0 +1,48 @@
+wrap_iife: {
+    options = {
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        (function() {
+            return function() {
+                console.log('test')
+            };
+        })()();
+    }
+    expect_exact: '(function(){return function(){console.log("test")}})()();'
+}
+
+wrap_iife_in_expression: {
+    options = {
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        foo = (function () {
+            return bar();
+        })();
+    }
+    expect_exact: 'foo=(function(){return bar()})();'
+}
+
+wrap_iife_in_return_call: {
+    options = {
+        negate_iife: false,
+    }
+    beautify = {
+        wrap_iife: true,
+    }
+    input: {
+        (function() {
+            return (function() {
+                console.log('test')
+            })();
+        })()();
+    }
+    expect_exact: '(function(){return(function(){console.log("test")})()})()();'
+}