v2.3.4

Add --expr, an option to parse a single expression (suitable for JSON)
Only compress code in new Function if all arguments are strings.
2013-05-15 13:27:40 +03:00 · 2013-05-15 13:27:23 +03:00 · 2013-05-14 18:36:31 +03:00 · 2013-05-14 11:33:28 +03:00 · 2013-05-14 10:47:06 +03:00 · 2013-05-14 10:42:34 +03:00
25 changed files with 1728 additions and 458 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 tmp/
+node_modules/
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,7 @@
+language: node_js
+node_js:
+    - "0.4"
+    - "0.6"
+    - "0.8"
+    - "0.10"
+    - "0.11"
--- a/29
+++ b/29
@@ -0,0 +1,29 @@
+UglifyJS is released under the BSD license:
+
+Copyright 2012-2013 (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.
--- a/README.md
+++ b/README.md
@@ -1,5 +1,6 @@
 UglifyJS 2
 ==========
+[![Build Status](https://travis-ci.org/mishoo/UglifyJS2.png)](https://travis-ci.org/mishoo/UglifyJS2)

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

@@ -12,9 +13,16 @@ Chrome and probably Safari).
 Install
 -------

-From NPM:
+First make sure you have installed the latest version of [node.js](http://nodejs.org/)
+(You may need to restart your computer after this step).

-    npm install uglify-js2
+From NPM for use as a command line app:
+
+    npm install uglify-js -g
+
+From NPM for programmatic use:
+
+    npm install uglify-js

 From Git:

@@ -25,7 +33,7 @@ From Git:
 Usage
 -----

-    uglifyjs2 [input files] [options]
+    uglifyjs [input files] [options]

 UglifyJS2 can take multiple input files.  It's recommended that you pass the
 input files first, then pass the options.  UglifyJS will parse input files
@@ -42,8 +50,14 @@ The available options are:
                                                                          [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.
@@ -67,7 +81,7 @@ The available options are:
                       cascading statements into sequences.               [string]
    --stats            Display operations run time on STDERR.            [boolean]
    --acorn            Use Acorn for parsing.                            [boolean]
-    --spidermonkey     Assume input fles are SpiderMonkey AST format (as JSON).
+    --spidermonkey     Assume input files are SpiderMonkey AST format (as JSON).
                                                                         [boolean]
    --self             Build itself (UglifyJS2) as a library (implies
                       --wrap=UglifyJS --export-all)                     [boolean]
@@ -78,7 +92,9 @@ The available options are:
                                                                          [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]

 Specify `--output` (`-o`) to declare the output file.  Otherwise the output
 goes to STDOUT.
@@ -98,12 +114,12 @@ map.

 For example:

-    uglifyjs2 /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
+    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

 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
@@ -129,18 +145,25 @@ input files from the command line.

 ## Mangler options

-To enable the mangler you need to pass `--mangle` (`-m`).  Optionally you
-can pass `-m sort` (we'll possibly have other flags in the future) in order
-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.
+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
+  (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
 comma-separated list of names.  For example:

-    uglifyjs2 ... -m -r '$,require,exports'
+    uglifyjs ... -m -r '$,require,exports'

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

@@ -151,15 +174,12 @@ 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`).

-The defaults should be tuned for maximum compression on most code.  Here are
-the available options (all are `true` by default, except `hoist_vars`):
-
 - `sequences` -- join consecutive simple statements using the comma operator
 - `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` -- apply "unsafe" transformations (discussion below)
+- `dead_code` -- remove unreachable code
+- `drop_debugger` -- remove `debugger;` statements
+- `unsafe` (default: false) -- apply "unsafe" transformations (discussion below)
 - `conditionals` -- apply optimizations for `if`-s and conditional
  expressions
 - `comparisons` -- apply certain optimizations to binary nodes, for example:
@@ -171,26 +191,43 @@ the available options (all are `true` by default, except `hoist_vars`):
 - `loops` -- optimizations for `do`, `while` and `for` loops when we can
  statically determine the condition
 - `unused` -- drop unreferenced functions and variables
- `hoist-funs` -- hoist function declarations
- `hoist-vars` -- 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
+- `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()`
 - `warnings` -- display warnings when dropping unreachable code or unused
  declarations etc.

+### The `unsafe` option
+
+It enables some transformations that *might* break code logic in certain
+contrived cases, but should be fine for most code.  You might want to try it
+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 Object()` → `{}`
+- `String(exp)` or `exp.toString()` → `"" + exp`
+- `new Object/RegExp/Function/Error/Array (...)` → we discard the `new`
+- `typeof foo == "undefined"` → `foo === void 0`
+- `void 0` → `"undefined"` (if there is a variable named "undefined" in
+  scope; we do it because the variable name will be mangled, typically
+  reduced to a single character).
+
 ### Conditional compilation

 You can use the `--define` (`-d`) switch in order to declare global
 variables that UglifyJS will assume to be constants (unless defined in
 scope).  For example if you pass `--define DEBUG=false` then, coupled with
 dead code removal UglifyJS will discard the following from the output:
-
-    if (DEBUG) {
-        console.log("debug stuff");
-    }
+```javascript
+if (DEBUG) {
+	console.log("debug stuff");
+}
+```

 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
@@ -199,20 +236,22 @@ warning, you can pass `warnings=false` to turn off *all* warnings.
 Another way of doing that is to declare your globals as constants in a
 separate file and include it into the build.  For example you can have a
 `build/defines.js` file with the following:
-
-    const DEBUG = false;
-    const PRODUCTION = true;
-    // etc.
+```javascript
+const DEBUG = false;
+const PRODUCTION = true;
+// etc.
+```

 and build your code like this:

-    uglifyjs2 build/defines.js js/foo.js js/bar.js... -c
+    uglifyjs build/defines.js js/foo.js js/bar.js... -c

 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.

+<a name="codegen-options"></a>
 ## Beautifier options

 The code generator tries to output shortest code possible by default.  In
@@ -260,14 +299,15 @@ keep only comments that match this regexp.  For example `--comments

 Note, however, that there might be situations where comments are lost.  For
 example:
-
-    function f() {
-      /** @preserve Foo Bar */
-      function g() {
-        // this function is never called
-      }
-      return something();
-    }
+```javascript
+function f() {
+	/** @preserve Foo Bar */
+	function g() {
+	  // this function is never called
+	}
+	return something();
+}
+```

 Even though it has "@preserve", the comment will be lost because the inner
 function `g` (which is the AST node to which the comment is attached to) is
@@ -288,7 +328,7 @@ 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 | uglifyjs2 --spidermonkey -m -c
+    acorn file.js | uglifyjs --spidermonkey -m -c

 The `--spidermonkey` option tells UglifyJS that all input files are not
 JavaScript, but JS code described in SpiderMonkey AST in JSON.  Therefore we
@@ -309,8 +349,9 @@ API Reference

 Assuming installation via NPM, you can load UglifyJS in your application
 like this:
-
-    var UglifyJS = require("uglify-js2");
+```javascript
+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)
@@ -321,44 +362,49 @@ parse, (2) compress, (3) mangle, (4) generate output code.
 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`.
 Example:
-
-    // see "fromString" below if you need to pass code instead of file name
-    var result = UglifyJS.minify("/path/to/file.js");
-    console.log(result.code); // minified output
+```javascript
+var result = UglifyJS.minify("/path/to/file.js");
+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:
-
-    var result = UglifyJS.minify([ "file1.js", "file2.js", "file3.js" ]);
-    console.log(result.code);
+```javascript
+var result = UglifyJS.minify([ "file1.js", "file2.js", "file3.js" ]);
+console.log(result.code);
+```

 To generate a source map:
-
-    var result = UglifyJS.minify([ "file1.js", "file2.js", "file3.js" ], {
-        outSourceMap: "out.js.map"
-    });
-    console.log(result.code); // minified output
-    console.log(result.map);
+```javascript
+var result = UglifyJS.minify([ "file1.js", "file2.js", "file3.js" ], {
+	outSourceMap: "out.js.map"
+});
+console.log(result.code); // minified output
+console.log(result.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]).

 You can also specify sourceRoot property to be included in source map:
-
-    var result = UglifyJS.minify([ "file1.js", "file2.js", "file3.js" ], {
-        outSourceMap: "out.js.map",
-        sourceRoot: "http://example.com/src"
-    });
-
+```javascript
+var result = UglifyJS.minify([ "file1.js", "file2.js", "file3.js" ], {
+	outSourceMap: "out.js.map",
+	sourceRoot: "http://example.com/src"
+});
+```

 If you're compressing compiled JavaScript and have a source map for it, you
 can use the `inSourceMap` argument:
-
-    var result = UglifyJS.minify("compiled.js", {
-        inSourceMap: "compiled.js.map",
-        outSourceMap: "minified.js.map"
-    });
-    // same as before, it returns `code` and `map`
+```javascript
+var result = UglifyJS.minify("compiled.js", {
+	inSourceMap: "compiled.js.map",
+	outSourceMap: "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).
@@ -366,9 +412,19 @@ no sense otherwise).
 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` — pass `false` to skip mangling names.
+
+- `output` (default `null`) — pass an object if you wish to specify
+  additional [output options][codegen].  The defaults are optimized
+  for best compression.
+
+- `compress` (default `{}`) — pass `false` to skip compressing entirely.
+  Pass an object to specify custom [compressor options][compressor].
+
 We could add more options to `UglifyJS.minify` — if you need additional
 functionality please suggest!

@@ -378,8 +434,9 @@ Following there's more detailed API info, in case the `minify` function is
 too simple for your needs.

 #### The parser
-
-    var toplevel_ast = UglifyJS.parse(code, options);
+```javascript
+var toplevel_ast = UglifyJS.parse(code, options);
+```

 `options` is optional and if present it must be an object.  The following
 properties are available:
@@ -393,15 +450,16 @@ properties are available:
 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:
-
-    var toplevel = null;
-    files.forEach(function(file){
-        var code = fs.readFileSync(file);
-        toplevel = UglifyJS.parse(code, {
-            filename: file,
-            toplevel: toplevel
-        });
-    });
+```javascript
+var toplevel = null;
+files.forEach(function(file){
+	var code = fs.readFileSync(file);
+	toplevel = UglifyJS.parse(code, {
+		filename: file,
+		toplevel: toplevel
+	});
+});
+```

 After this, we have in `toplevel` a big AST containing all our files, with
 each token having proper information about where it came from.
@@ -415,15 +473,17 @@ 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:
-
-    toplevel.figure_out_scope()
+```javascript
+toplevel.figure_out_scope()
+```

 #### Compression

 Like this:
-
-    var compressor = UglifyJS.Compressor(options);
-    var compressed_ast = toplevel.transform(compressor);
+```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
@@ -439,23 +499,26 @@ 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:
-
-    compressed_ast.figure_out_scope();
-    compressed_ast.compute_char_frequency();
-    compressed_ast.mangle_names();
+```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:
-
-    var stream = UglifyJS.OutputStream(options);
-    compressed_ast.print(stream);
-    var code = stream.toString(); // this is your minified code
+```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:
-
-    var code = compressed_ast.print_to_string(options);
+```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
@@ -493,16 +556,17 @@ 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 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
+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:

@@ -516,3 +580,5 @@ The `source_map_options` (optional) can contain the following properties:
  [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
--- a/bin/uglifyjs2
+++ b/bin/uglifyjs2
@@ -7,6 +7,7 @@ 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\
@@ -19,7 +20,10 @@ 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).")
@@ -30,6 +34,7 @@ For example -p 3 will drop 3 directories from file names and ensure they are rel
 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\". \
@@ -42,13 +47,14 @@ 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 fles are SpiderMonkey AST format (as JSON).")
+    .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")
@@ -58,15 +64,22 @@ You need to pass an argument to this option to specify the name that your module
    .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")
@@ -74,6 +87,7 @@ You need to pass an argument to this option to specify the name that your module
    .boolean("acorn")
    .boolean("spidermonkey")
    .boolean("lint")
+    .boolean("V")

    .wrap(80)

@@ -82,6 +96,12 @@ You need to pass an argument to this option to specify the name that your module

 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));
@@ -101,12 +121,17 @@ var COMPRESS = getOptions("c", true);
 var MANGLE = getOptions("m", true);
 var BEAUTIFY = getOptions("b", true);

-if (COMPRESS && ARGS.d) {
-    COMPRESS.global_defs = getOptions("d");
+if (ARGS.d) {
+    if (COMPRESS) COMPRESS.global_defs = getOptions("d");
 }

-if (MANGLE && ARGS.r) {
-    MANGLE.except = ARGS.r.replace(/^\s+|\s+$/g).split(/\s*,+\s*/);
+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 = {
@@ -195,100 +220,117 @@ try {
    }
 }

-files.forEach(function(file) {
-    var code = read_whole_file(file);
-    if (ARGS.p != null) {
-        file = file.replace(/^\/+/, "").split(/\/+/).slice(ARGS.p).join("/");
+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);
    }
-    time_it("parse", function(){
-        if (ARGS.spidermonkey) {
-            var program = JSON.parse(code);
-            if (!TOPLEVEL) TOPLEVEL = program;
-            else TOPLEVEL.body = TOPLEVEL.body.concat(program.body);
+
+    if (ARGS.enclose) {
+        var arg_parameter_list = ARGS.enclose;
+
+        if (!(arg_parameter_list instanceof Array)) {
+            arg_parameter_list = [arg_parameter_list];
        }
-        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
-            });
-        };
+
+        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);
    });
-});
-
-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);
-}
-
-var SCOPE_IS_NEEDED = COMPRESS || MANGLE || ARGS.lint;
-
-if (SCOPE_IS_NEEDED) {
-    time_it("scope", function(){
-        TOPLEVEL.figure_out_scope();
-        if (ARGS.lint) {
-            TOPLEVEL.scope_warnings();
-        }
+    time_it("generate", function(){
+        TOPLEVEL.print(output);
    });
-}

-if (COMPRESS) {
-    time_it("squeeze", function(){
-        TOPLEVEL = TOPLEVEL.transform(compressor);
-    });
-}
+    output = output.get();

-if (SCOPE_IS_NEEDED) {
-    time_it("scope", function(){
-        TOPLEVEL.figure_out_scope();
-        if (MANGLE) {
-            TOPLEVEL.compute_char_frequency();
-        }
-    });
-}
+    if (SOURCE_MAP) {
+        fs.writeFileSync(ARGS.source_map, SOURCE_MAP, "utf8");
+        output += "\n/*\n//@ sourceMappingURL=" + (ARGS.source_map_url || ARGS.source_map) + "\n*/";
+    }

-if (MANGLE) time_it("mangle", function(){
-    TOPLEVEL.mangle_names(MANGLE);
-});
-time_it("generate", function(){
-    TOPLEVEL.print(output);
-});
+    if (OUTPUT_FILE) {
+        fs.writeFileSync(OUTPUT_FILE, output, "utf8");
+    } else {
+        sys.print(output);
+        sys.error("\n");
+    }

-output = output.get();
-
-if (SOURCE_MAP) {
-    fs.writeFileSync(ARGS.source_map, SOURCE_MAP, "utf8");
-    output += "\n//@ sourceMappingURL=" + ARGS.source_map;
-}
-
-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)
+    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)
+            }));
+        }
    }
-}
+});

 /* -----[ functions ]----- */

@@ -333,17 +375,18 @@ function getOptions(x, constants) {
    return ret;
 }

-function read_whole_file(filename) {
+function read_whole_file(filename, cb) {
    if (filename == "-") {
-        // XXX: this sucks.  How does one read the whole STDIN
-        // synchronously?
-        filename = "/dev/stdin";
-    }
-    try {
-        return fs.readFileSync(filename, "utf8");
-    } catch(ex) {
-        sys.error("ERROR: can't read file: " + filename);
-        process.exit(1);
+        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();
+    } else {
+        fs.readFile(filename, "utf-8", cb);
    }
 }

--- a/lib/ast.js
+++ b/lib/ast.js
@@ -285,11 +285,32 @@ 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(",") + ")";
+        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();
-            var to_export = [];
            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))
@@ -345,6 +366,10 @@ var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments", {
    }
 }, AST_Scope);

+var AST_Accessor = DEFNODE("Accessor", null, {
+    $documentation: "A setter/getter function"
+}, AST_Lambda);
+
 var AST_Function = DEFNODE("Function", null, {
    $documentation: "A function expression"
 }, AST_Lambda);
@@ -758,6 +783,10 @@ var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
    $documentation: "Base class for all symbols",
 });

+var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
+    $documentation: "The name of a property accessor (setter/getter function)"
+}, AST_Symbol);
+
 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
    $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
    $propdoc: {
@@ -802,7 +831,7 @@ var AST_SymbolRef = DEFNODE("SymbolRef", null, {

 var AST_LabelRef = DEFNODE("LabelRef", null, {
    $documentation: "Reference to a label symbol",
-}, AST_SymbolRef);
+}, AST_Symbol);

 var AST_This = DEFNODE("This", null, {
    $documentation: "The `this` symbol",
@@ -855,6 +884,11 @@ var AST_Undefined = DEFNODE("Undefined", null, {
    value: (function(){}())
 }, AST_Atom);

+var AST_Hole = DEFNODE("Hole", null, {
+    $documentation: "A hole in an array",
+    value: (function(){}())
+}, AST_Atom);
+
 var AST_Infinity = DEFNODE("Infinity", null, {
    $documentation: "The `Infinity` value",
    value: 1/0
--- a/lib/compress.js
+++ b/lib/compress.js
@@ -52,7 +52,8 @@ function Compressor(options, false_by_default) {
        properties    : !false_by_default,
        dead_code     : !false_by_default,
        drop_debugger : !false_by_default,
-        unsafe        : !false_by_default,
+        unsafe        : false,
+        unsafe_comps  : false,
        conditionals  : !false_by_default,
        comparisons   : !false_by_default,
        evaluate      : !false_by_default,
@@ -65,6 +66,7 @@ function Compressor(options, false_by_default) {
        join_vars     : !false_by_default,
        cascade       : !false_by_default,
        side_effects  : !false_by_default,
+        screw_ie8     : false,

        warnings      : true,
        global_defs   : {}
@@ -155,7 +157,7 @@ merge(Compressor.prototype, {
                value: val
            }).optimize(compressor);
          case "boolean":
-            return make_node(val ? AST_True : AST_False, orig);
+            return make_node(val ? AST_True : AST_False, orig).optimize(compressor);
          case "undefined":
            return make_node(AST_Undefined, orig).optimize(compressor);
          default:
@@ -427,12 +429,23 @@ merge(Compressor.prototype, {
            var ret = [], prev = null;
            statements.forEach(function(stat){
                if (prev) {
-                    if (stat instanceof AST_For && stat.init && !(stat.init instanceof AST_Definitions)) {
-                        stat.init = cons_seq(stat.init);
-                    }
-                    else if (stat instanceof AST_For && !stat.init) {
-                        stat.init = prev.body;
-                        ret.pop();
+                    if (stat instanceof AST_For) {
+                        var opera = {};
+                        try {
+                            prev.body.walk(new TreeWalker(function(node){
+                                if (node instanceof AST_Binary && node.operator == "in")
+                                    throw opera;
+                            }));
+                            if (stat.init && !(stat.init instanceof AST_Definitions)) {
+                                stat.init = cons_seq(stat.init);
+                            }
+                            else if (!stat.init) {
+                                stat.init = prev.body;
+                                ret.pop();
+                            }
+                        } catch(ex) {
+                            if (ex !== opera) throw ex;
+                        }
                    }
                    else if (stat instanceof AST_If) {
                        stat.condition = cons_seq(stat.condition);
@@ -542,12 +555,24 @@ merge(Compressor.prototype, {
        def(AST_UnaryPrefix, function(){
            return this.operator == "typeof";
        });
-        def(AST_Binary, function(){
+        def(AST_Binary, function(compressor){
            return this.operator == "+" &&
-                (this.left.is_string() || this.right.is_string());
+                (this.left.is_string(compressor) || this.right.is_string(compressor));
        });
-        def(AST_Assign, function(){
-            return this.operator == "=" && this.right.is_string();
+        def(AST_Assign, function(compressor){
+            return (this.operator == "=" || this.operator == "+=") && this.right.is_string(compressor);
+        });
+        def(AST_Seq, function(compressor){
+            return this.cdr.is_string(compressor);
+        });
+        def(AST_Conditional, function(compressor){
+            return this.consequent.is_string(compressor) && this.alternative.is_string(compressor);
+        });
+        def(AST_Call, function(compressor){
+            return compressor.option("unsafe")
+                && this.expression instanceof AST_SymbolRef
+                && this.expression.name == "String"
+                && this.expression.undeclared();
        });
    })(function(node, func){
        node.DEFMETHOD("is_string", func);
@@ -601,10 +626,24 @@ merge(Compressor.prototype, {
            var e = this.expression;
            switch (this.operator) {
              case "!": return !ev(e);
-              case "typeof": return typeof ev(e);
+              case "typeof":
+                // Function would be evaluated to an array and so typeof would
+                // incorrectly return 'object'. Hence making is a special case.
+                if (e instanceof AST_Function) return typeof function(){};
+
+                e = ev(e);
+
+                // typeof <RegExp> returns "object" or "function" on different platforms
+                // so cannot evaluate reliably
+                if (e instanceof RegExp) throw def;
+
+                return typeof e;
              case "void": return void ev(e);
              case "~": return ~ev(e);
-              case "-": return -ev(e);
+              case "-":
+                e = ev(e);
+                if (e === 0) throw def;
+                return -e;
              case "+": return +ev(e);
            }
            throw def;
@@ -645,12 +684,7 @@ merge(Compressor.prototype, {
        });
        def(AST_SymbolRef, function(){
            var d = this.definition();
-            if (d && d.constant) {
-                var orig = d.orig[0];
-                if (orig) orig = orig.init[0];
-                orig = orig && orig.value;
-                if (orig) return ev(orig);
-            }
+            if (d && d.constant && d.init) return ev(d.init);
            throw def;
        });
    })(function(node, func){
@@ -692,7 +726,7 @@ merge(Compressor.prototype, {
        });
        def(AST_Binary, function(compressor){
            var self = this.clone(), op = this.operator;
-            if (compressor.option("comparisons") && compressor.option("unsafe")) {
+            if (compressor.option("unsafe_comps")) {
                switch (op) {
                  case "<=" : self.operator = ">"  ; return self;
                  case "<"  : self.operator = ">=" ; return self;
@@ -802,10 +836,12 @@ merge(Compressor.prototype, {
    (function(def){
        def(AST_Statement, function(){ return null });
        def(AST_Jump, function(){ return this });
-        def(AST_BlockStatement, function(){
+        function block_aborts(){
            var n = this.body.length;
            return n > 0 && aborts(this.body[n - 1]);
-        });
+        };
+        def(AST_BlockStatement, block_aborts);
+        def(AST_SwitchBranch, block_aborts);
        def(AST_If, function(){
            return this.alternative && aborts(this.body) && aborts(this.alternative);
        });
@@ -857,23 +893,28 @@ merge(Compressor.prototype, {
            && !self.uses_eval
           ) {
            var in_use = [];
+            var initializations = new Dictionary();
            // pass 1: find out which symbols are directly used in
            // this scope (not in nested scopes).
            var scope = this;
            var tw = new TreeWalker(function(node, descend){
                if (node !== self) {
                    if (node instanceof AST_Defun) {
+                        initializations.add(node.name.name, node);
                        return true; // don't go in nested scopes
                    }
                    if (node instanceof AST_Definitions && scope === self) {
                        node.definitions.forEach(function(def){
-                            if (def.value && def.value.has_side_effects()) {
-                                def.value.walk(tw);
+                            if (def.value) {
+                                initializations.add(def.name.name, def.value);
+                                if (def.value.has_side_effects()) {
+                                    def.value.walk(tw);
+                                }
                            }
                        });
                        return true;
                    }
-                    if (node instanceof AST_SymbolRef && !(node instanceof AST_LabelRef)) {
+                    if (node instanceof AST_SymbolRef) {
                        push_uniq(in_use, node.definition());
                        return true;
                    }
@@ -893,22 +934,20 @@ merge(Compressor.prototype, {
            for (var i = 0; i < in_use.length; ++i) {
                in_use[i].orig.forEach(function(decl){
                    // undeclared globals will be instanceof AST_SymbolRef
-                    if (decl instanceof AST_SymbolDeclaration) {
-                        decl.init.forEach(function(init){
-                            var tw = new TreeWalker(function(node){
-                                if (node instanceof AST_SymbolRef
-                                    && !(node instanceof AST_LabelRef)) {
-                                    push_uniq(in_use, node.definition());
-                                }
-                            });
-                            init.walk(tw);
+                    var init = initializations.get(decl.name);
+                    if (init) init.forEach(function(init){
+                        var tw = new TreeWalker(function(node){
+                            if (node instanceof AST_SymbolRef) {
+                                push_uniq(in_use, node.definition());
+                            }
                        });
-                    }
+                        init.walk(tw);
+                    });
                });
            }
            // pass 3: we should drop declarations not in_use
            var tt = new TreeTransformer(
-                function before(node, descend) {
+                function before(node, descend, in_list) {
                    if (node instanceof AST_Lambda) {
                        for (var a = node.argnames, i = a.length; --i >= 0;) {
                            var sym = a[i];
@@ -999,6 +1038,19 @@ merge(Compressor.prototype, {
                        }
                        return node;
                    }
+                    if (node instanceof AST_For && node.init instanceof AST_BlockStatement) {
+                        descend(node, this);
+                        // certain combination of unused name + side effect leads to:
+                        //    https://github.com/mishoo/UglifyJS2/issues/44
+                        // that's an invalid AST.
+                        // We fix it at this stage by moving the `var` outside the `for`.
+                        var body = node.init.body.slice(0, -1);
+                        node.init = node.init.body.slice(-1)[0].body;
+                        body.push(node);
+                        return in_list ? MAP.splice(body) : make_node(AST_BlockStatement, node, {
+                            body: body
+                        });
+                    }
                    if (node instanceof AST_Scope && node !== self)
                        return node;
                }
@@ -1014,7 +1066,7 @@ merge(Compressor.prototype, {
        if (hoist_funs || hoist_vars) {
            var dirs = [];
            var hoisted = [];
-            var vars = {}, vars_found = 0, var_decl = 0;
+            var vars = new Dictionary(), vars_found = 0, var_decl = 0;
            // let's count var_decl first, we seem to waste a lot of
            // space if we hoist `var` when there's only one.
            self.walk(new TreeWalker(function(node){
@@ -1039,7 +1091,7 @@ merge(Compressor.prototype, {
                        }
                        if (node instanceof AST_Var && hoist_vars) {
                            node.definitions.forEach(function(def){
-                                vars[def.name.name] = def;
+                                vars.set(def.name.name, def);
                                ++vars_found;
                            });
                            var seq = node.to_assignments();
@@ -1062,13 +1114,71 @@ merge(Compressor.prototype, {
                }
            );
            self = self.transform(tt);
-            if (vars_found > 0) hoisted.unshift(make_node(AST_Var, self, {
-                definitions: Object.keys(vars).map(function(name){
-                    var def = vars[name].clone();
-                    def.value = null;
-                    return def;
-                })
-            }));
+            if (vars_found > 0) {
+                // collect only vars which don't show up in self's arguments list
+                var defs = [];
+                vars.each(function(def, name){
+                    if (self instanceof AST_Lambda
+                        && find_if(function(x){ return x.name == def.name.name },
+                                   self.argnames)) {
+                        vars.del(name);
+                    } else {
+                        def = def.clone();
+                        def.value = null;
+                        defs.push(def);
+                        vars.set(name, def);
+                    }
+                });
+                if (defs.length > 0) {
+                    // try to merge in assignments
+                    for (var i = 0; i < self.body.length;) {
+                        if (self.body[i] instanceof AST_SimpleStatement) {
+                            var expr = self.body[i].body, sym, assign;
+                            if (expr instanceof AST_Assign
+                                && expr.operator == "="
+                                && (sym = expr.left) instanceof AST_Symbol
+                                && vars.has(sym.name))
+                            {
+                                var def = vars.get(sym.name);
+                                if (def.value) break;
+                                def.value = expr.right;
+                                remove(defs, def);
+                                defs.push(def);
+                                self.body.splice(i, 1);
+                                continue;
+                            }
+                            if (expr instanceof AST_Seq
+                                && (assign = expr.car) instanceof AST_Assign
+                                && assign.operator == "="
+                                && (sym = assign.left) instanceof AST_Symbol
+                                && vars.has(sym.name))
+                            {
+                                var def = vars.get(sym.name);
+                                if (def.value) break;
+                                def.value = assign.right;
+                                remove(defs, def);
+                                defs.push(def);
+                                self.body[i].body = expr.cdr;
+                                continue;
+                            }
+                        }
+                        if (self.body[i] instanceof AST_EmptyStatement) {
+                            self.body.splice(i, 1);
+                            continue;
+                        }
+                        if (self.body[i] instanceof AST_BlockStatement) {
+                            var tmp = [ i, 1 ].concat(self.body[i].body);
+                            self.body.splice.apply(self.body, tmp);
+                            continue;
+                        }
+                        break;
+                    }
+                    defs = make_node(AST_Var, self, {
+                        definitions: defs
+                    });
+                    hoisted.push(defs);
+                };
+            }
            self.body = dirs.concat(hoisted, self.body);
        }
        return self;
@@ -1099,13 +1209,66 @@ merge(Compressor.prototype, {
                    extract_declarations_from_unreachable_code(compressor, self.body, a);
                    return make_node(AST_BlockStatement, self, { body: a });
                }
-            } else {
-                return self.body;
            }
        }
        return self;
    });

+    function if_break_in_loop(self, compressor) {
+        function drop_it(rest) {
+            rest = as_statement_array(rest);
+            if (self.body instanceof AST_BlockStatement) {
+                self.body = self.body.clone();
+                self.body.body = rest.concat(self.body.body.slice(1));
+                self.body = self.body.transform(compressor);
+            } else {
+                self.body = make_node(AST_BlockStatement, self.body, {
+                    body: rest
+                }).transform(compressor);
+            }
+            if_break_in_loop(self, compressor);
+        }
+        var first = self.body instanceof AST_BlockStatement ? self.body.body[0] : self.body;
+        if (first instanceof AST_If) {
+            if (first.body instanceof AST_Break
+                && compressor.loopcontrol_target(first.body.label) === self) {
+                if (self.condition) {
+                    self.condition = make_node(AST_Binary, self.condition, {
+                        left: self.condition,
+                        operator: "&&",
+                        right: first.condition.negate(compressor),
+                    });
+                } else {
+                    self.condition = first.condition.negate(compressor);
+                }
+                drop_it(first.alternative);
+            }
+            else if (first.alternative instanceof AST_Break
+                     && compressor.loopcontrol_target(first.alternative.label) === self) {
+                if (self.condition) {
+                    self.condition = make_node(AST_Binary, self.condition, {
+                        left: self.condition,
+                        operator: "&&",
+                        right: first.condition,
+                    });
+                } else {
+                    self.condition = first.condition;
+                }
+                drop_it(first.body);
+            }
+        }
+    };
+
+    OPT(AST_While, function(self, compressor) {
+        if (!compressor.option("loops")) return self;
+        self = AST_DWLoop.prototype.optimize.call(self, compressor);
+        if (self instanceof AST_While) {
+            if_break_in_loop(self, compressor);
+            self = make_node(AST_For, self, self).transform(compressor);
+        }
+        return self;
+    });
+
    OPT(AST_For, function(self, compressor){
        var cond = self.condition;
        if (cond) {
@@ -1130,6 +1293,7 @@ merge(Compressor.prototype, {
                }
            }
        }
+        if_break_in_loop(self, compressor);
        return self;
    });

@@ -1262,11 +1426,91 @@ merge(Compressor.prototype, {
                body: self.expression
            }).transform(compressor);
        }
-        var last_branch = self.body[self.body.length - 1];
-        if (last_branch) {
-            var stat = last_branch.body[last_branch.body.length - 1]; // last statement
-            if (stat instanceof AST_Break && loop_body(compressor.loopcontrol_target(stat.label)) === self)
-                last_branch.body.pop();
+        for(;;) {
+            var last_branch = self.body[self.body.length - 1];
+            if (last_branch) {
+                var stat = last_branch.body[last_branch.body.length - 1]; // last statement
+                if (stat instanceof AST_Break && loop_body(compressor.loopcontrol_target(stat.label)) === self)
+                    last_branch.body.pop();
+                if (last_branch instanceof AST_Default && last_branch.body.length == 0) {
+                    self.body.pop();
+                    continue;
+                }
+            }
+            break;
+        }
+        var exp = self.expression.evaluate(compressor);
+        out: if (exp.length == 2) try {
+            // constant expression
+            self.expression = exp[0];
+            if (!compressor.option("dead_code")) break out;
+            var value = exp[1];
+            var in_if = false;
+            var in_block = false;
+            var started = false;
+            var stopped = false;
+            var ruined = false;
+            var tt = new TreeTransformer(function(node, descend, in_list){
+                if (node instanceof AST_Lambda || node instanceof AST_SimpleStatement) {
+                    // no need to descend these node types
+                    return node;
+                }
+                else if (node instanceof AST_Switch && node === self) {
+                    node = node.clone();
+                    descend(node, this);
+                    return ruined ? node : make_node(AST_BlockStatement, node, {
+                        body: node.body.reduce(function(a, branch){
+                            return a.concat(branch.body);
+                        }, [])
+                    }).transform(compressor);
+                }
+                else if (node instanceof AST_If || node instanceof AST_Try) {
+                    var save = in_if;
+                    in_if = !in_block;
+                    descend(node, this);
+                    in_if = save;
+                    return node;
+                }
+                else if (node instanceof AST_StatementWithBody || node instanceof AST_Switch) {
+                    var save = in_block;
+                    in_block = true;
+                    descend(node, this);
+                    in_block = save;
+                    return node;
+                }
+                else if (node instanceof AST_Break && this.loopcontrol_target(node.label) === self) {
+                    if (in_if) {
+                        ruined = true;
+                        return node;
+                    }
+                    if (in_block) return node;
+                    stopped = true;
+                    return in_list ? MAP.skip : make_node(AST_EmptyStatement, node);
+                }
+                else if (node instanceof AST_SwitchBranch && this.parent() === self) {
+                    if (stopped) return MAP.skip;
+                    if (node instanceof AST_Case) {
+                        var exp = node.expression.evaluate(compressor);
+                        if (exp.length < 2) {
+                            // got a case with non-constant expression, baling out
+                            throw self;
+                        }
+                        if (exp[1] === value || started) {
+                            started = true;
+                            if (aborts(node)) stopped = true;
+                            descend(node, this);
+                            return node;
+                        }
+                        return MAP.skip;
+                    }
+                    descend(node, this);
+                    return node;
+                }
+            });
+            tt.stack = compressor.stack.slice(); // so that's able to see parent nodes
+            self = self.transform(tt);
+        } catch(ex) {
+            if (ex !== self) throw ex;
        }
        return self;
    });
@@ -1337,18 +1581,60 @@ merge(Compressor.prototype, {
                    }
                    break;
                  case "String":
+                    if (self.args.length == 0) return make_node(AST_String, self, {
+                        value: ""
+                    });
                    return make_node(AST_Binary, self, {
                        left: self.args[0],
                        operator: "+",
                        right: make_node(AST_String, self, { value: "" })
                    });
+                  case "Function":
+                    if (all(self.args, function(x){ return x instanceof AST_String })) {
+                        // quite a corner-case, but we can handle it:
+                        //   https://github.com/mishoo/UglifyJS2/issues/203
+                        // if the code argument is a constant, then we can minify it.
+                        try {
+                            var code = "(function(" + self.args.slice(0, -1).map(function(arg){
+                                return arg.value;
+                            }).join(",") + "){" + self.args[self.args.length - 1].value + "})()";
+                            var ast = parse(code);
+                            ast.figure_out_scope();
+                            var comp = new Compressor(compressor.options);
+                            ast = ast.transform(comp);
+                            ast.figure_out_scope();
+                            ast.mangle_names();
+                            var fun = ast.body[0].body.expression;
+                            var args = fun.argnames.map(function(arg, i){
+                                return make_node(AST_String, self.args[i], {
+                                    value: arg.print_to_string()
+                                });
+                            });
+                            var code = OutputStream();
+                            AST_BlockStatement.prototype._codegen.call(fun, fun, code);
+                            code = code.toString().replace(/^\{|\}$/g, "");
+                            args.push(make_node(AST_String, self.args[self.args.length - 1], {
+                                value: code
+                            }));
+                            self.args = args;
+                            return self;
+                        } catch(ex) {
+                            if (ex instanceof JS_Parse_Error) {
+                                compressor.warn("Error parsing code passed to new Function [{file}:{line},{col}]", self.args[self.args.length - 1].start);
+                                compressor.warn(ex.toString());
+                            } else {
+                                console.log(ex);
+                            }
+                        }
+                    }
+                    break;
                }
            }
            else if (exp instanceof AST_Dot && exp.property == "toString" && self.args.length == 0) {
                return make_node(AST_Binary, self, {
-                    left: exp.expression,
+                    left: make_node(AST_String, self, { value: "" }),
                    operator: "+",
-                    right: make_node(AST_String, self, { value: "" })
+                    right: exp.expression
                }).transform(compressor);
            }
        }
@@ -1372,7 +1658,7 @@ merge(Compressor.prototype, {
                  case "Function":
                  case "Error":
                  case "Array":
-                    return make_node(AST_Call, self, self);
+                    return make_node(AST_Call, self, self).transform(compressor);
                }
            }
        }
@@ -1382,8 +1668,19 @@ merge(Compressor.prototype, {
    OPT(AST_Seq, function(self, compressor){
        if (!compressor.option("side_effects"))
            return self;
-        if (!self.car.has_side_effects())
-            return self.cdr;
+        if (!self.car.has_side_effects()) {
+            // we shouldn't compress (1,eval)(something) to
+            // eval(something) because that changes the meaning of
+            // eval (becomes lexical instead of global).
+            var p;
+            if (!(self.cdr instanceof AST_SymbolRef
+                  && self.cdr.name == "eval"
+                  && self.cdr.undeclared()
+                  && (p = compressor.parent()) instanceof AST_Call
+                  && p.expression === self)) {
+                return self.cdr;
+            }
+        }
        if (compressor.option("cascade")) {
            if (self.car instanceof AST_Assign
                && !self.car.left.has_side_effects()
@@ -1434,9 +1731,9 @@ merge(Compressor.prototype, {
                compressor.warn("Boolean expression always true [{file}:{line},{col}]", self.start);
                return make_node(AST_True, self);
            }
-        }
-        if (e instanceof AST_Binary) {
-            self = best_of(self, e.negate(compressor));
+            if (e instanceof AST_Binary && self.operator == "!") {
+                self = best_of(self, e.negate(compressor));
+            }
        }
        return self.evaluate(compressor)[0];
    });
@@ -1465,37 +1762,46 @@ merge(Compressor.prototype, {
        return this;
    });

+    var commutativeOperators = makePredicate("== === != !== * & | ^");
+
    OPT(AST_Binary, function(self, compressor){
+        function reverse(op, force) {
+            if (force || !(self.left.has_side_effects() || self.right.has_side_effects())) {
+                if (op) self.operator = op;
+                var tmp = self.left;
+                self.left = self.right;
+                self.right = tmp;
+            }
+        };
+        if (commutativeOperators(self.operator)) {
+            if (self.right instanceof AST_Constant
+                && !(self.left instanceof AST_Constant)) {
+                // if right is a constant, whatever side effects the
+                // left side might have could not influence the
+                // result.  hence, force switch.
+                reverse(null, true);
+            }
+        }
        self = self.lift_sequences(compressor);
        if (compressor.option("comparisons")) switch (self.operator) {
          case "===":
          case "!==":
-            if ((self.left.is_string() && self.right.is_string()) ||
+            if ((self.left.is_string(compressor) && self.right.is_string(compressor)) ||
                (self.left.is_boolean() && self.right.is_boolean())) {
                self.operator = self.operator.substr(0, 2);
            }
            // XXX: intentionally falling down to the next case
          case "==":
          case "!=":
-            if (self.left instanceof AST_UnaryPrefix
-                && self.left.operator == "typeof"
-                && self.right instanceof AST_String
-                && self.right.value == "undefined") {
-                if (!(self.left.expression instanceof AST_SymbolRef)
-                    || !self.left.expression.undeclared()) {
-                    self.left = self.left.expression;
-                    self.right = make_node(AST_Undefined, self.right).optimize(compressor);
-                    if (self.operator.length == 2) self.operator += "=";
-                }
-            }
-            else if (self.left instanceof AST_String
-                     && self.left.value == "undefined"
-                     && self.right instanceof AST_UnaryPrefix
-                     && self.right.operator == "typeof") {
+            if (self.left instanceof AST_String
+                && self.left.value == "undefined"
+                && self.right instanceof AST_UnaryPrefix
+                && self.right.operator == "typeof"
+                && compressor.option("unsafe")) {
                if (!(self.right.expression instanceof AST_SymbolRef)
                    || !self.right.expression.undeclared()) {
-                    self.left = self.right.expression;
-                    self.right = make_node(AST_Undefined, self.left).optimize(compressor);
+                    self.right = self.right.expression;
+                    self.left = make_node(AST_Undefined, self.left).optimize(compressor);
                    if (self.operator.length == 2) self.operator += "=";
                }
            }
@@ -1554,17 +1860,16 @@ merge(Compressor.prototype, {
                });
                self = best_of(self, negated);
            }
-            var reverse = function(op) {
-                self.operator = op;
-                var tmp = self.left;
-                self.left = self.right;
-                self.right = tmp;
-            };
            switch (self.operator) {
              case "<": reverse(">"); break;
              case "<=": reverse(">="); break;
            }
        }
+        if (self.operator == "+" && self.right instanceof AST_String
+            && self.right.getValue() === "" && self.left instanceof AST_Binary
+            && self.left.operator == "+" && self.left.is_string(compressor)) {
+            return self.left;
+        }
        return self;
    });

@@ -1699,7 +2004,8 @@ merge(Compressor.prototype, {
        var prop = self.property;
        if (prop instanceof AST_String && compressor.option("properties")) {
            prop = prop.getValue();
-            if (is_identifier(prop)) {
+            if ((compressor.option("screw_ie8") && RESERVED_WORDS(prop))
+                || (!(RESERVED_WORDS(prop)) && is_identifier_string(prop))) {
                return make_node(AST_Dot, self, {
                    expression : self.expression,
                    property   : prop
--- a/lib/mozilla-ast.js
+++ b/lib/mozilla-ast.js
@@ -148,12 +148,14 @@
    };

    function From_Moz_Unary(M) {
-        return new (M.prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({
+        var prefix = "prefix" in M ? M.prefix
+            : M.type == "UnaryExpression" ? true : false;
+        return new (prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({
            start      : my_start_token(M),
            end        : my_end_token(M),
            operator   : M.operator,
            expression : from_moz(M.argument)
-        })
+        });
    };

    var ME_TO_MOZ = {};
--- a/lib/output.js
+++ b/lib/output.js
@@ -59,7 +59,8 @@ function OutputStream(options) {
        source_map    : null,
        bracketize    : false,
        semicolons    : true,
-        comments      : false
+        comments      : false,
+        preserve_line : false
    }, true);

    var indentation = 0;
@@ -68,11 +69,16 @@ function OutputStream(options) {
    var current_pos = 0;
    var OUTPUT = "";

-    function to_ascii(str) {
+    function to_ascii(str, identifier) {
        return str.replace(/[\u0080-\uffff]/g, function(ch) {
            var code = ch.charCodeAt(0).toString(16);
-            while (code.length < 4) code = "0" + code;
-            return "\\u" + code;
+            if (code.length <= 2 && !identifier) {
+                while (code.length < 2) code = "0" + code;
+                return "\\x" + code;
+            } else {
+                while (code.length < 4) code = "0" + code;
+                return "\\u" + code;
+            }
        });
    };

@@ -108,7 +114,7 @@ function OutputStream(options) {
    function make_name(name) {
        name = name.toString();
        if (options.ascii_only)
-            name = to_ascii(name);
+            name = to_ascii(name, true);
        return name;
    };

@@ -137,7 +143,7 @@ function OutputStream(options) {
        str = String(str);
        var ch = str.charAt(0);
        if (might_need_semicolon) {
-            if (";}".indexOf(ch) < 0 && !/[;]$/.test(last)) {
+            if ((!ch || ";}".indexOf(ch) < 0) && !/[;]$/.test(last)) {
                if (options.semicolons || requireSemicolonChars(ch)) {
                    OUTPUT += ";";
                    current_col++;
@@ -154,6 +160,18 @@ function OutputStream(options) {
            might_need_semicolon = false;
            maybe_newline();
        }
+
+        if (!options.beautify && options.preserve_line && stack[stack.length - 1]) {
+            var target_line = stack[stack.length - 1].start.line;
+            while (current_line < target_line) {
+                OUTPUT += "\n";
+                current_pos++;
+                current_line++;
+                current_col = 0;
+                might_need_space = false;
+            }
+        }
+
        if (might_need_space) {
            var prev = last_char();
            if ((is_identifier_char(prev)
@@ -327,23 +345,28 @@ function OutputStream(options) {
    /* -----[ utils ]----- */

    function DEFPRINT(nodetype, generator) {
-        nodetype.DEFMETHOD("print", function(stream){
-            var self = this;
-            stream.push_node(self);
-            if (self.needs_parens(stream)) {
-                stream.with_parens(function(){
-                    self.add_comments(stream);
-                    self.add_source_map(stream);
-                    generator(self, stream);
-                });
-            } else {
+        nodetype.DEFMETHOD("_codegen", generator);
+    };
+
+    AST_Node.DEFMETHOD("print", function(stream, force_parens){
+        var self = this, generator = self._codegen;
+        stream.push_node(self);
+        var needs_parens = self.needs_parens(stream);
+        var fc = self instanceof AST_Function && !stream.option("beautify");
+        if (force_parens || (needs_parens && !fc)) {
+            stream.with_parens(function(){
                self.add_comments(stream);
                self.add_source_map(stream);
                generator(self, stream);
-            }
-            stream.pop_node();
-        });
-    };
+            });
+        } else {
+            self.add_comments(stream);
+            if (needs_parens && fc) stream.print("!");
+            self.add_source_map(stream);
+            generator(self, stream);
+        }
+        stream.pop_node();
+    });

    AST_Node.DEFMETHOD("print_to_string", function(options){
        var s = OutputStream(options);
@@ -360,6 +383,16 @@ function OutputStream(options) {
            if (start && !start._comments_dumped) {
                start._comments_dumped = true;
                var comments = start.comments_before;
+
+                // XXX: ugly fix for https://github.com/mishoo/UglifyJS2/issues/112
+                //      if this node is `return` or `throw`, we cannot allow comments before
+                //      the returned or thrown value.
+                if (self instanceof AST_Exit &&
+                    self.value && self.value.start.comments_before.length > 0) {
+                    comments = (comments || []).concat(self.value.start.comments_before);
+                    self.value.start.comments_before = [];
+                }
+
                if (c.test) {
                    comments = comments.filter(function(comment){
                        return c.test(comment.value);
@@ -410,6 +443,11 @@ function OutputStream(options) {
        return first_in_statement(output);
    });

+    PARENS(AST_Unary, function(output){
+        var p = output.parent();
+        return p instanceof AST_PropAccess && p.expression === this;
+    });
+
    PARENS(AST_Seq, function(output){
        var p = output.parent();
        return p instanceof AST_Call             // (foo, bar)() or foo(1, (2, 3), 4)
@@ -449,24 +487,50 @@ function OutputStream(options) {
                return true;
            }
        }
-        // for (var i = (foo in bar);;); ← perhaps useless, but valid syntax
-        if (this.operator == "in") {
-            // the “NoIn” stuff :-\
-            // UglifyJS 1.3.3 misses this one.
-            if ((p instanceof AST_For || p instanceof AST_ForIn) && p.init === this)
+    });
+
+    PARENS(AST_PropAccess, function(output){
+        var p = output.parent();
+        if (p instanceof AST_New && p.expression === this) {
+            // i.e. new (foo.bar().baz)
+            //
+            // if there's one call into this subtree, then we need
+            // parens around it too, otherwise the call will be
+            // interpreted as passing the arguments to the upper New
+            // expression.
+            try {
+                this.walk(new TreeWalker(function(node){
+                    if (node instanceof AST_Call) throw p;
+                }));
+            } catch(ex) {
+                if (ex !== p) throw ex;
                return true;
-            if (p instanceof AST_VarDef) {
-                var v = output.parent(1), p2 = output.parent(2);
-                if ((p2 instanceof AST_For || p2 instanceof AST_ForIn) && p2.init === v)
-                    return true;
            }
        }
    });

+    PARENS(AST_Call, function(output){
+        var p = output.parent();
+        return p instanceof AST_New && p.expression === this;
+    });
+
    PARENS(AST_New, function(output){
        var p = output.parent();
-        // (new Date).getTime();
-        if (p instanceof AST_Dot && no_constructor_parens(this, output))
+        if (no_constructor_parens(this, output)
+            && (p instanceof AST_PropAccess // (new Date).getTime(), (new Date)["getTime"]()
+                || p instanceof AST_Call && p.expression === this)) // (new foo)(bar)
+            return true;
+    });
+
+    PARENS(AST_Number, function(output){
+        var p = output.parent();
+        if (this.getValue() < 0 && p instanceof AST_PropAccess && p.expression === this)
+            return true;
+    });
+
+    PARENS(AST_NaN, function(output){
+        var p = output.parent();
+        if (p instanceof AST_PropAccess && p.expression === this)
            return true;
    });

@@ -529,6 +593,7 @@ function OutputStream(options) {
    });
    DEFPRINT(AST_Toplevel, function(self, output){
        display_body(self.body, true, output);
+        output.print("");
    });
    DEFPRINT(AST_LabeledStatement, function(self, output){
        self.label.print(output);
@@ -577,7 +642,11 @@ function OutputStream(options) {
        output.space();
        output.with_parens(function(){
            if (self.init) {
-                self.init.print(output);
+                if (self.init instanceof AST_Definitions) {
+                    self.init.print(output);
+                } else {
+                    parenthesize_for_noin(self.init, output, true);
+                }
                output.print(";");
                output.space();
            } else {
@@ -689,7 +758,7 @@ function OutputStream(options) {
        // to the inner IF).  This function checks for this case and
        // adds the block brackets if needed.
        if (!self.body)
-            return output.semicolon();
+            return output.force_semicolon();
        if (self.body instanceof AST_Do
            && output.option("ie_proof")) {
            // https://github.com/mishoo/UglifyJS/issues/#issue/57 IE
@@ -713,7 +782,7 @@ function OutputStream(options) {
            }
            else break;
        }
-        self.body.print(output);
+        force_statement(self.body, output);
    };
    DEFPRINT(AST_If, function(self, output){
        output.print("if");
@@ -821,13 +890,32 @@ function OutputStream(options) {
    DEFPRINT(AST_Const, function(self, output){
        self._do_print(output, "const");
    });
+
+    function parenthesize_for_noin(node, output, noin) {
+        if (!noin) node.print(output);
+        else try {
+            // need to take some precautions here:
+            //    https://github.com/mishoo/UglifyJS2/issues/60
+            node.walk(new TreeWalker(function(node){
+                if (node instanceof AST_Binary && node.operator == "in")
+                    throw output;
+            }));
+            node.print(output);
+        } catch(ex) {
+            if (ex !== output) throw ex;
+            node.print(output, true);
+        }
+    };
+
    DEFPRINT(AST_VarDef, function(self, output){
        self.name.print(output);
        if (self.value) {
            output.space();
            output.print("=");
            output.space();
-            self.value.print(output);
+            var p = output.parent(1);
+            var noin = p instanceof AST_For || p instanceof AST_ForIn;
+            parenthesize_for_noin(self.value, output, noin);
        }
    });

@@ -846,7 +934,7 @@ function OutputStream(options) {
    DEFPRINT(AST_New, function(self, output){
        output.print("new");
        output.space();
-        AST_Call.prototype.print.call(self, output);
+        AST_Call.prototype._codegen(self, output);
    });

    AST_Seq.DEFMETHOD("_do_print", function(output){
@@ -874,7 +962,7 @@ function OutputStream(options) {
    DEFPRINT(AST_Dot, function(self, output){
        var expr = self.expression;
        expr.print(output);
-        if (expr instanceof AST_Number) {
+        if (expr instanceof AST_Number && expr.getValue() >= 0) {
            if (!/[xa-f.]/i.test(output.last())) {
                output.print(".");
            }
@@ -926,8 +1014,7 @@ function OutputStream(options) {
            if (len > 0) output.space();
            a.forEach(function(exp, i){
                if (i) output.comma();
-                if (!(exp instanceof AST_Undefined))
-                    exp.print(output);
+                exp.print(output);
            });
            if (len > 0) output.space();
        });
@@ -949,7 +1036,7 @@ function OutputStream(options) {
    DEFPRINT(AST_ObjectKeyVal, function(self, output){
        var key = self.key;
        if (output.option("quote_keys")) {
-            output.print_string(key);
+            output.print_string(key + "");
        } else if ((typeof key == "number"
                    || !output.option("beautify")
                    && +key + "" == key)
@@ -978,6 +1065,7 @@ function OutputStream(options) {
    DEFPRINT(AST_Undefined, function(self, output){
        output.print("void 0");
    });
+    DEFPRINT(AST_Hole, noop);
    DEFPRINT(AST_Infinity, function(self, output){
        output.print("1/0");
    });
@@ -1001,6 +1089,9 @@ function OutputStream(options) {
        if (output.option("ascii_only"))
            str = output.to_ascii(str);
        output.print(str);
+        var p = output.parent();
+        if (p instanceof AST_Binary && /^in/.test(p.operator) && p.left === self)
+            output.print(" ");
    });

    function force_statement(stat, output) {
--- a/lib/parse.js
+++ b/lib/parse.js
@@ -149,7 +149,7 @@ function is_unicode_connector_punctuation(ch) {
 };

 function is_identifier(name) {
-    return /^[a-z_$][a-z0-9_$]*$/i.test(name) && !RESERVED_WORDS(name);
+    return !RESERVED_WORDS(name) && /^[a-z_$][a-z0-9_$]*$/i.test(name);
 };

 function is_identifier_start(code) {
@@ -167,6 +167,17 @@ function is_identifier_char(ch) {
    ;
 };

+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;
+};
+
 function parse_js_number(num) {
    if (RE_HEX_NUMBER.test(num)) {
        return parseInt(num.substr(2), 16);
@@ -190,12 +201,6 @@ JS_Parse_Error.prototype.toString = function() {
 };

 function js_error(message, filename, line, col, pos) {
-    AST_Node.warn("ERROR: {message} [{file}:{line},{col}]", {
-        message: message,
-        file: filename,
-        line: line,
-        col: col
-    });
    throw new JS_Parse_Error(message, line, col, pos);
 };

@@ -583,9 +588,10 @@ 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
+        strict     : false,
+        filename   : null,
+        toplevel   : null,
+        expression : false
    });

    var S = {
@@ -881,9 +887,14 @@ function parse($TEXT, options) {
    };

    var function_ = function(in_statement, ctor) {
-        var name = is("name") ? as_symbol(in_statement
-                                          ? AST_SymbolDefun
-                                          : AST_SymbolLambda) : null;
+        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);
        if (in_statement && !name)
            unexpected();
        expect("(");
@@ -1126,7 +1137,7 @@ function parse($TEXT, options) {
            if (first) first = false; else expect(",");
            if (allow_trailing_comma && is("punc", closing)) break;
            if (is("punc", ",") && allow_empty) {
-                a.push(new AST_Undefined({ start: S.token, end: S.token }));
+                a.push(new AST_Hole({ start: S.token, end: S.token }));
            } else {
                a.push(expression(false));
            }
@@ -1158,7 +1169,7 @@ function parse($TEXT, options) {
                    a.push(new AST_ObjectGetter({
                        start : start,
                        key   : name,
-                        value : function_(false, AST_Lambda),
+                        value : function_(false, AST_Accessor),
                        end   : prev()
                    }));
                    continue;
@@ -1167,7 +1178,7 @@ function parse($TEXT, options) {
                    a.push(new AST_ObjectSetter({
                        start : start,
                        key   : name,
-                        value : function_(false, AST_Lambda),
+                        value : function_(false, AST_Accessor),
                        end   : prev()
                    }));
                    continue;
@@ -1331,15 +1342,8 @@ function parse($TEXT, options) {

    function is_assignable(expr) {
        if (!options.strict) return true;
-        switch (expr[0]+"") {
-          case "dot":
-          case "sub":
-          case "new":
-          case "call":
-            return true;
-          case "name":
-            return expr[1] != "this";
-        }
+        if (expr instanceof AST_This) return false;
+        return (expr instanceof AST_PropAccess || expr instanceof AST_Symbol);
    };

    var maybe_assign = function(no_in) {
@@ -1353,7 +1357,7 @@ function parse($TEXT, options) {
                    left     : left,
                    operator : val,
                    right    : maybe_assign(no_in),
-                    end      : peek()
+                    end      : prev()
                });
            }
            croak("Invalid assignment");
@@ -1383,6 +1387,10 @@ function parse($TEXT, options) {
        return ret;
    };

+    if (options.expression) {
+        return expression(true);
+    }
+
    return (function(){
        var start = S.token;
        var body = [];
--- a/lib/scope.js
+++ b/lib/scope.js
@@ -43,7 +43,7 @@

 "use strict";

-function SymbolDef(scope, orig) {
+function SymbolDef(scope, index, orig) {
    this.name = orig.name;
    this.orig = [ orig ];
    this.scope = scope;
@@ -52,15 +52,22 @@ function SymbolDef(scope, orig) {
    this.mangled_name = null;
    this.undeclared = false;
    this.constant = false;
+    this.index = index;
 };

 SymbolDef.prototype = {
-    unmangleable: function() {
-        return this.global || this.undeclared || this.scope.uses_eval || this.scope.uses_with;
+    unmangleable: function(options) {
+        return (this.global && !(options && options.toplevel))
+            || this.undeclared
+            || (!(options && options.eval) && (this.scope.uses_eval || this.scope.uses_with));
    },
-    mangle: function() {
-        if (!this.mangled_name && !this.unmangleable())
-            this.mangled_name = this.scope.next_mangled();
+    mangle: function(options) {
+        if (!this.mangled_name && !this.unmangleable(options)) {
+            var s = this.scope;
+            if (this.orig[0] instanceof AST_SymbolLambda && !options.screw_ie8)
+                s = s.parent_scope;
+            this.mangled_name = s.next_mangled(options);
+        }
    }
 };

@@ -75,14 +82,20 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
    // pass 1: setup scope chaining and handle definitions
    var self = this;
    var scope = self.parent_scope = null;
-    var labels = Object.create(null);
+    var labels = new Dictionary();
+    var nesting = 0;
    var tw = new TreeWalker(function(node, descend){
        if (node instanceof AST_Scope) {
-            node.init_scope_vars();
+            node.init_scope_vars(nesting);
            var save_scope = node.parent_scope = scope;
+            var save_labels = labels;
+            ++nesting;
            scope = node;
+            labels = new Dictionary();
            descend();
+            labels = save_labels;
            scope = save_scope;
+            --nesting;
            return true;        // don't descend again in TreeWalker
        }
        if (node instanceof AST_Directive) {
@@ -97,16 +110,13 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
        }
        if (node instanceof AST_LabeledStatement) {
            var l = node.label;
-            if (labels[l.name])
+            if (labels.has(l.name))
                throw new Error(string_template("Label {name} defined twice", l));
-            labels[l.name] = l;
+            labels.set(l.name, l);
            descend();
-            delete labels[l.name];
+            labels.del(l.name);
            return true;        // no descend again
        }
-        if (node instanceof AST_SymbolDeclaration) {
-            node.init_scope_vars();
-        }
        if (node instanceof AST_Symbol) {
            node.scope = scope;
        }
@@ -116,7 +126,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
        }
        if (node instanceof AST_SymbolLambda) {
            scope.def_function(node);
-            node.init.push(tw.parent());
        }
        else if (node instanceof AST_SymbolDefun) {
            // Careful here, the scope where this should be defined is
@@ -125,14 +134,12 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
            // instanceof AST_Scope) but we get to the symbol a bit
            // later.
            (node.scope = scope.parent_scope).def_function(node);
-            node.init.push(tw.parent());
        }
        else if (node instanceof AST_SymbolVar
                 || node instanceof AST_SymbolConst) {
            var def = scope.def_variable(node);
            def.constant = node instanceof AST_SymbolConst;
-            def = tw.parent();
-            if (def.value) node.init.push(def);
+            def.init = tw.parent().value;
        }
        else if (node instanceof AST_SymbolCatch) {
            // XXX: this is wrong according to ECMA-262 (12.4).  the
@@ -144,7 +151,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
            scope.def_variable(node);
        }
        if (node instanceof AST_LabelRef) {
-            var sym = labels[node.name];
+            var sym = labels.get(node.name);
            if (!sym) throw new Error(string_template("Undefined label {name} [{line},{col}]", {
                name: node.name,
                line: node.start.line,
@@ -157,7 +164,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){

    // pass 2: find back references and eval
    var func = null;
-    var globals = self.globals = Object.create(null);
+    var globals = self.globals = new Dictionary();
    var tw = new TreeWalker(function(node, descend){
        if (node instanceof AST_Lambda) {
            var prev_func = func;
@@ -175,12 +182,12 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
            var sym = node.scope.find_variable(name);
            if (!sym) {
                var g;
-                if (globals[name]) {
-                    g = globals[name];
+                if (globals.has(name)) {
+                    g = globals.get(name);
                } else {
-                    g = new SymbolDef(self, node);
+                    g = new SymbolDef(self, globals.size(), node);
                    g.undeclared = true;
-                    globals[name] = g;
+                    globals.set(name, g);
                }
                node.thedef = g;
                if (name == "eval" && tw.parent() instanceof AST_Call) {
@@ -200,15 +207,16 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
    self.walk(tw);
 });

-AST_Scope.DEFMETHOD("init_scope_vars", function(){
+AST_Scope.DEFMETHOD("init_scope_vars", function(nesting){
    this.directives = [];     // contains the directives defined in this scope, i.e. "use strict"
-    this.variables = Object.create(null); // map name to AST_SymbolVar (variables defined in this scope; includes functions)
-    this.functions = Object.create(null); // map name to AST_SymbolDefun (functions defined in this 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 = 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_Scope.DEFMETHOD("strict", function(){
@@ -216,7 +224,7 @@ AST_Scope.DEFMETHOD("strict", function(){
 });

 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
-    AST_Scope.prototype.init_scope_vars.call(this);
+    AST_Scope.prototype.init_scope_vars.apply(this, arguments);
    this.uses_arguments = false;
 });

@@ -229,10 +237,7 @@ AST_SymbolRef.DEFMETHOD("reference", function() {
        if (s === def.scope) break;
        s = s.parent_scope;
    }
-});
-
-AST_SymbolDeclaration.DEFMETHOD("init_scope_vars", function(){
-    this.init = [];
+    this.frame = this.scope.nesting - def.scope.nesting;
 });

 AST_Label.DEFMETHOD("init_scope_vars", function(){
@@ -245,7 +250,7 @@ AST_LabelRef.DEFMETHOD("reference", function(){

 AST_Scope.DEFMETHOD("find_variable", function(name){
    if (name instanceof AST_Symbol) name = name.name;
-    return this.variables[name]
+    return this.variables.get(name)
        || (this.parent_scope && this.parent_scope.find_variable(name));
 });

@@ -255,33 +260,33 @@ AST_Scope.DEFMETHOD("has_directive", function(value){
 });

 AST_Scope.DEFMETHOD("def_function", function(symbol){
-    this.functions[symbol.name] = this.def_variable(symbol);
+    this.functions.set(symbol.name, this.def_variable(symbol));
 });

 AST_Scope.DEFMETHOD("def_variable", function(symbol){
    var def;
-    if (!this.variables[symbol.name]) {
-        def = new SymbolDef(this, symbol);
-        this.variables[symbol.name] = def;
+    if (!this.variables.has(symbol.name)) {
+        def = new SymbolDef(this, this.variables.size(), symbol);
+        this.variables.set(symbol.name, def);
        def.global = !this.parent_scope;
    } else {
-        def = this.variables[symbol.name];
+        def = this.variables.get(symbol.name);
        def.orig.push(symbol);
    }
    return symbol.thedef = def;
 });

-AST_Scope.DEFMETHOD("next_mangled", function(){
-    var ext = this.enclosed, n = ext.length;
+AST_Scope.DEFMETHOD("next_mangled", function(options){
+    var ext = this.enclosed;
    out: while (true) {
        var m = base54(++this.cname);
        if (!is_identifier(m)) continue; // skip over "do"
        // 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.
-        for (var i = n; --i >= 0;) {
+        for (var i = ext.length; --i >= 0;) {
            var sym = ext[i];
-            var name = sym.mangled_name || (sym.unmangleable() && sym.name);
+            var name = sym.mangled_name || (sym.unmangleable(options) && sym.name);
            if (m == name) continue out;
        }
        return m;
@@ -293,8 +298,13 @@ AST_Scope.DEFMETHOD("references", function(sym){
    return this.enclosed.indexOf(sym) < 0 ? null : sym;
 });

-AST_Symbol.DEFMETHOD("unmangleable", function(){
-    return this.definition().unmangleable();
+AST_Symbol.DEFMETHOD("unmangleable", function(options){
+    return this.definition().unmangleable(options);
+});
+
+// property accessors are not mangleable
+AST_SymbolAccessor.DEFMETHOD("unmangleable", function(){
+    return true;
 });

 // labels are always mangleable
@@ -327,10 +337,18 @@ AST_Symbol.DEFMETHOD("global", function(){
    return this.definition().global;
 });

-AST_Toplevel.DEFMETHOD("mangle_names", function(options){
-    options = defaults(options, {
-        except : []
+AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
+    return defaults(options, {
+        except   : [],
+        eval     : false,
+        sort     : false,
+        toplevel : false,
+        screw_ie8 : false
    });
+});
+
+AST_Toplevel.DEFMETHOD("mangle_names", function(options){
+    options = this._default_mangler_options(options);
    // 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
@@ -346,17 +364,16 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
            return true;        // don't descend again in TreeWalker
        }
        if (node instanceof AST_Scope) {
-            var p = tw.parent();
-            var is_setget = p instanceof AST_ObjectSetter || p instanceof AST_ObjectGetter;
-            var a = node.variables;
-            for (var i in a) {
-                var symbol = a[i];
-                if (!(is_setget && symbol instanceof AST_SymbolLambda)) {
-                    if (options.except.indexOf(symbol.name) < 0) {
-                        to_mangle.push(symbol);
-                    }
+            var p = tw.parent(), a = [];
+            node.variables.each(function(symbol){
+                if (options.except.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;
        }
        if (node instanceof AST_Label) {
@@ -370,7 +387,8 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
    to_mangle.forEach(function(def){ def.mangle(options) });
 });

-AST_Toplevel.DEFMETHOD("compute_char_frequency", function(){
+AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
+    options = this._default_mangler_options(options);
    var tw = new TreeWalker(function(node){
        if (node instanceof AST_Constant)
            base54.consider(node.print_to_string());
@@ -428,7 +446,7 @@ AST_Toplevel.DEFMETHOD("compute_char_frequency", function(){
            base54.consider("catch");
        else if (node instanceof AST_Finally)
            base54.consider("finally");
-        else if (node instanceof AST_Symbol && node.unmangleable())
+        else if (node instanceof AST_Symbol && node.unmangleable(options))
            base54.consider(node.name);
        else if (node instanceof AST_Unary || node instanceof AST_Binary)
            base54.consider(node.operator);
--- a/lib/transform.js
+++ b/lib/transform.js
@@ -44,7 +44,6 @@
 "use strict";

 // Tree transformer helpers.
-// XXX: eventually I should refactor the compressor to use this infrastructure.

 function TreeTransformer(before, after) {
    TreeWalker.call(this);
@@ -65,7 +64,7 @@ TreeTransformer.prototype = new TreeWalker;
                    x = this;
                    descend(x, tw);
                } else {
-                    tw.stack[tw.stack - 1] = x = this.clone();
+                    tw.stack[tw.stack.length - 1] = x = this.clone();
                    descend(x, tw);
                    y = tw.after(x, in_list);
                    if (y !== undefined) x = y;
--- a/lib/utils.js
+++ b/lib/utils.js
@@ -244,3 +244,52 @@ function makePredicate(words) {
    }
    return new Function("str", f);
 };
+
+function all(array, predicate) {
+    for (var i = array.length; --i >= 0;)
+        if (!predicate(array[i]))
+            return false;
+    return true;
+};
+
+function Dictionary() {
+    this._values = Object.create(null);
+    this._size = 0;
+};
+Dictionary.prototype = {
+    set: function(key, val) {
+        if (!this.has(key)) ++this._size;
+        this._values["$" + key] = val;
+        return this;
+    },
+    add: function(key, val) {
+        if (this.has(key)) {
+            this.get(key).push(val);
+        } else {
+            this.set(key, [ val ]);
+        }
+        return this;
+    },
+    get: function(key) { return this._values["$" + key] },
+    del: function(key) {
+        if (this.has(key)) {
+            --this._size;
+            delete this._values["$" + key];
+        }
+        return this;
+    },
+    has: function(key) { return ("$" + key) in this._values },
+    each: function(f) {
+        for (var i in this._values)
+            f(this._values[i], i.substr(1));
+    },
+    size: function() {
+        return this._size;
+    },
+    map: function(f) {
+        var ret = [];
+        for (var i in this._values)
+            ret.push(f(this._values[i], i.substr(1)));
+        return ret;
+    }
+};
--- a/package.json
+++ b/package.json
@@ -1,9 +1,9 @@
 {
-    "name": "uglify-js2",
+    "name": "uglify-js",
    "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
    "homepage": "http://lisperator.net/uglifyjs",
    "main": "tools/node.js",
-    "version": "2.1.3",
+    "version": "2.3.4",
    "engines": { "node" : ">=0.4.0" },
    "maintainers": [{
        "name": "Mihai Bazon",
@@ -15,11 +15,12 @@
        "url": "https://github.com/mishoo/UglifyJS2.git"
    }],
    "dependencies": {
-        "source-map" : "*",
-        "optimist"   : "*"
+        "async"      : "~0.2.6",
+        "source-map" : "~0.1.7",
+        "optimist"   : "~0.3.5"
    },
    "bin": {
-        "uglifyjs2" : "bin/uglifyjs2"
+        "uglifyjs" : "bin/uglifyjs"
    },
    "scripts": {"test": "node test/run-tests.js"}
 }
--- a/test/compress/arrays.js
+++ b/test/compress/arrays.js
@@ -0,0 +1,12 @@
+holes_and_undefined: {
+    input: {
+        x = [1, 2, undefined];
+        y = [1, , 2, ];
+        z = [1, undefined, 3];
+    }
+    expect: {
+        x=[1,2,void 0];
+        y=[1,,2];
+        z=[1,void 0,3];
+    }
+}
--- a/test/compress/issue-105.js
+++ b/test/compress/issue-105.js
@@ -0,0 +1,25 @@
+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 }
+}
--- a/test/compress/issue-143.js
+++ b/test/compress/issue-143.js
@@ -0,0 +1,48 @@
+/**
+ * There was an incorrect sort behaviour documented in issue #143:
+ * (x = f(…)) <= x → x >= (x = f(…))
+ *
+ * For example, let the equation be:
+ * (a = parseInt('100')) <= a
+ *
+ * If a was an integer and has the value of 99,
+ * (a = parseInt('100')) <= a → 100 <= 100 → true
+ *
+ * When transformed incorrectly:
+ * a >= (a = parseInt('100')) → 99 >= 100 → false
+ */
+
+tranformation_sort_order_equal: {
+    options = {
+        comparisons: true,
+    };
+
+    input: { (a = parseInt('100')) == a }
+    expect: { (a = parseInt('100')) == a }
+}
+
+tranformation_sort_order_unequal: {
+    options = {
+        comparisons: true,
+    };
+
+    input: { (a = parseInt('100')) != a }
+    expect: { (a = parseInt('100')) != a }
+}
+
+tranformation_sort_order_lesser_or_equal: {
+    options = {
+        comparisons: true,
+    };
+
+    input: { (a = parseInt('100')) <= a }
+    expect: { (a = parseInt('100')) <= a }
+}
+tranformation_sort_order_greater_or_equal: {
+    options = {
+        comparisons: true,
+    };
+
+    input: { (a = parseInt('100')) >= a }
+    expect: { (a = parseInt('100')) >= a }
+}
--- a/test/compress/issue-44.js
+++ b/test/compress/issue-44.js
@@ -0,0 +1,31 @@
+issue_44_valid_ast_1: {
+    options = { unused: true };
+    input: {
+        function a(b) {
+            for (var i = 0, e = b.qoo(); ; i++) {}
+        }
+    }
+    expect: {
+        function a(b) {
+            var i = 0;
+            for (b.qoo(); ; i++);
+        }
+    }
+}
+
+issue_44_valid_ast_2: {
+    options = { unused: true };
+    input: {
+        function a(b) {
+            if (foo) for (var i = 0, e = b.qoo(); ; i++) {}
+        }
+    }
+    expect: {
+        function a(b) {
+            if (foo) {
+                var i = 0;
+                for (b.qoo(); ; i++);
+            }
+        }
+    }
+}
--- a/test/compress/issue-59.js
+++ b/test/compress/issue-59.js
@@ -0,0 +1,30 @@
+keep_continue: {
+    options = {
+        dead_code: true,
+        evaluate: true
+    };
+    input: {
+        while (a) {
+            if (b) {
+                switch (true) {
+                  case c():
+                    d();
+                }
+                continue;
+            }
+            f();
+        }
+    }
+    expect: {
+        while (a) {
+            if (b) {
+                switch (true) {
+                  case c():
+                    d();
+                }
+                continue;
+            }
+            f();
+        }
+    }
+}
--- a/test/compress/loops.js
+++ b/test/compress/loops.js
@@ -0,0 +1,123 @@
+while_becomes_for: {
+    options = { loops: true };
+    input: {
+        while (foo()) bar();
+    }
+    expect: {
+        for (; foo(); ) bar();
+    }
+}
+
+drop_if_break_1: {
+    options = { loops: true };
+    input: {
+        for (;;)
+            if (foo()) break;
+    }
+    expect: {
+        for (; !foo(););
+    }
+}
+
+drop_if_break_2: {
+    options = { loops: true };
+    input: {
+        for (;bar();)
+            if (foo()) break;
+    }
+    expect: {
+        for (; bar() && !foo(););
+    }
+}
+
+drop_if_break_3: {
+    options = { loops: true };
+    input: {
+        for (;bar();) {
+            if (foo()) break;
+            stuff1();
+            stuff2();
+        }
+    }
+    expect: {
+        for (; bar() && !foo();) {
+            stuff1();
+            stuff2();
+        }
+    }
+}
+
+drop_if_break_4: {
+    options = { loops: true, sequences: true };
+    input: {
+        for (;bar();) {
+            x();
+            y();
+            if (foo()) break;
+            z();
+            k();
+        }
+    }
+    expect: {
+        for (; bar() && (x(), y(), !foo());) z(), k();
+    }
+}
+
+drop_if_else_break_1: {
+    options = { loops: true };
+    input: {
+        for (;;) if (foo()) bar(); else break;
+    }
+    expect: {
+        for (; foo(); ) bar();
+    }
+}
+
+drop_if_else_break_2: {
+    options = { loops: true };
+    input: {
+        for (;bar();) {
+            if (foo()) baz();
+            else break;
+        }
+    }
+    expect: {
+        for (; bar() && foo();) baz();
+    }
+}
+
+drop_if_else_break_3: {
+    options = { loops: true };
+    input: {
+        for (;bar();) {
+            if (foo()) baz();
+            else break;
+            stuff1();
+            stuff2();
+        }
+    }
+    expect: {
+        for (; bar() && foo();) {
+            baz();
+            stuff1();
+            stuff2();
+        }
+    }
+}
+
+drop_if_else_break_4: {
+    options = { loops: true, sequences: true };
+    input: {
+        for (;bar();) {
+            x();
+            y();
+            if (foo()) baz();
+            else break;
+            z();
+            k();
+        }
+    }
+    expect: {
+        for (; bar() && (x(), y(), foo());) baz(), z(), k();
+    }
+}
--- a/test/compress/properties.js
+++ b/test/compress/properties.js
@@ -17,9 +17,38 @@ dot_properties: {
    input: {
        a["foo"] = "bar";
        a["if"] = "if";
+        a["*"] = "asterisk";
+        a["\u0EB3"] = "unicode";
+        a[""] = "whitespace";
+        a["1_1"] = "foo";
    }
    expect: {
        a.foo = "bar";
        a["if"] = "if";
+        a["*"] = "asterisk";
+        a.\u0EB3 = "unicode";
+        a[""] = "whitespace";
+        a["1_1"] = "foo";
+    }
+}
+
+dot_properties_es5: {
+    options = {
+        properties: true,
+        screw_ie8: true
+    };
+    input: {
+        a["foo"] = "bar";
+        a["if"] = "if";
+        a["*"] = "asterisk";
+        a["\u0EB3"] = "unicode";
+        a[""] = "whitespace";
+    }
+    expect: {
+        a.foo = "bar";
+        a.if = "if";
+        a["*"] = "asterisk";
+        a.\u0EB3 = "unicode";
+        a[""] = "whitespace";
    }
 }
--- a/test/compress/sequences.js
+++ b/test/compress/sequences.js
@@ -127,3 +127,35 @@ lift_sequences_4: {
        x = baz;
    }
 }
+
+for_sequences: {
+    options = { sequences: true };
+    input: {
+        // 1
+        foo();
+        bar();
+        for (; false;);
+        // 2
+        foo();
+        bar();
+        for (x = 5; false;);
+        // 3
+        x = (foo in bar);
+        for (; false;);
+        // 4
+        x = (foo in bar);
+        for (y = 5; false;);
+    }
+    expect: {
+        // 1
+        for (foo(), bar(); false;);
+        // 2
+        for (foo(), bar(), x = 5; false;);
+        // 3
+        x = (foo in bar);
+        for (; false;);
+        // 4
+        x = (foo in bar);
+        for (y = 5; false;);
+    }
+}
--- a/test/compress/switch.js
+++ b/test/compress/switch.js
@@ -0,0 +1,260 @@
+constant_switch_1: {
+    options = { dead_code: true, evaluate: true };
+    input: {
+        switch (1+1) {
+          case 1: foo(); break;
+          case 1+1: bar(); break;
+          case 1+1+1: baz(); break;
+        }
+    }
+    expect: {
+        bar();
+    }
+}
+
+constant_switch_2: {
+    options = { dead_code: true, evaluate: true };
+    input: {
+        switch (1) {
+          case 1: foo();
+          case 1+1: bar(); break;
+          case 1+1+1: baz();
+        }
+    }
+    expect: {
+        foo();
+        bar();
+    }
+}
+
+constant_switch_3: {
+    options = { dead_code: true, evaluate: true };
+    input: {
+        switch (10) {
+          case 1: foo();
+          case 1+1: bar(); break;
+          case 1+1+1: baz();
+          default:
+            def();
+        }
+    }
+    expect: {
+        def();
+    }
+}
+
+constant_switch_4: {
+    options = { dead_code: true, evaluate: true };
+    input: {
+        switch (2) {
+          case 1:
+            x();
+            if (foo) break;
+            y();
+            break;
+          case 1+1:
+            bar();
+          default:
+            def();
+        }
+    }
+    expect: {
+        bar();
+        def();
+    }
+}
+
+constant_switch_5: {
+    options = { dead_code: true, evaluate: true };
+    input: {
+        switch (1) {
+          case 1:
+            x();
+            if (foo) break;
+            y();
+            break;
+          case 1+1:
+            bar();
+          default:
+            def();
+        }
+    }
+    expect: {
+        // the break inside the if ruins our job
+        // we can still get rid of irrelevant cases.
+        switch (1) {
+          case 1:
+            x();
+            if (foo) break;
+            y();
+        }
+        // XXX: we could optimize this better by inventing an outer
+        // labeled block, but that's kinda tricky.
+    }
+}
+
+constant_switch_6: {
+    options = { dead_code: true, evaluate: true };
+    input: {
+        OUT: {
+            foo();
+            switch (1) {
+              case 1:
+                x();
+                if (foo) break OUT;
+                y();
+              case 1+1:
+                bar();
+                break;
+              default:
+                def();
+            }
+        }
+    }
+    expect: {
+        OUT: {
+            foo();
+            x();
+            if (foo) break OUT;
+            y();
+            bar();
+        }
+    }
+}
+
+constant_switch_7: {
+    options = { dead_code: true, evaluate: true };
+    input: {
+        OUT: {
+            foo();
+            switch (1) {
+              case 1:
+                x();
+                if (foo) break OUT;
+                for (var x = 0; x < 10; x++) {
+                    if (x > 5) break; // this break refers to the for, not to the switch; thus it
+                                      // shouldn't ruin our optimization
+                    console.log(x);
+                }
+                y();
+              case 1+1:
+                bar();
+                break;
+              default:
+                def();
+            }
+        }
+    }
+    expect: {
+        OUT: {
+            foo();
+            x();
+            if (foo) break OUT;
+            for (var x = 0; x < 10; x++) {
+                if (x > 5) break;
+                console.log(x);
+            }
+            y();
+            bar();
+        }
+    }
+}
+
+constant_switch_8: {
+    options = { dead_code: true, evaluate: true };
+    input: {
+        OUT: switch (1) {
+          case 1:
+            x();
+            for (;;) break OUT;
+            y();
+            break;
+          case 1+1:
+            bar();
+          default:
+            def();
+        }
+    }
+    expect: {
+        OUT: {
+            x();
+            for (;;) break OUT;
+            y();
+        }
+    }
+}
+
+constant_switch_9: {
+    options = { dead_code: true, evaluate: true };
+    input: {
+        OUT: switch (1) {
+          case 1:
+            x();
+            for (;;) if (foo) break OUT;
+            y();
+          case 1+1:
+            bar();
+          default:
+            def();
+        }
+    }
+    expect: {
+        OUT: {
+            x();
+            for (;;) if (foo) break OUT;
+            y();
+            bar();
+            def();
+        }
+    }
+}
+
+drop_default_1: {
+    options = { dead_code: true };
+    input: {
+        switch (foo) {
+          case 'bar': baz();
+          default:
+        }
+    }
+    expect: {
+        switch (foo) {
+          case 'bar': baz();
+        }
+    }
+}
+
+drop_default_2: {
+    options = { dead_code: true };
+    input: {
+        switch (foo) {
+          case 'bar': baz(); break;
+          default:
+            break;
+        }
+    }
+    expect: {
+        switch (foo) {
+          case 'bar': baz();
+        }
+    }
+}
+
+keep_default: {
+    options = { dead_code: true };
+    input: {
+        switch (foo) {
+          case 'bar': baz();
+          default:
+            something();
+            break;
+        }
+    }
+    expect: {
+        switch (foo) {
+          case 'bar': baz();
+          default:
+            something();
+        }
+    }
+}
--- a/test/compress/typeof.js
+++ b/test/compress/typeof.js
@@ -0,0 +1,25 @@
+typeof_evaluation: {
+    options = {
+        evaluate: true
+    };
+    input: {
+        a = typeof 1;
+        b = typeof 'test';
+        c = typeof [];
+        d = typeof {};
+        e = typeof /./;
+        f = typeof false;
+        g = typeof function(){};
+        h = typeof undefined;
+    }
+    expect: {
+        a='number';
+        b='string';
+        c=typeof[];
+        d=typeof{};
+        e=typeof/./;
+        f='boolean';
+        g='function';
+        h='undefined';
+    }
+}
--- a/tools/node.js
+++ b/tools/node.js
@@ -1,16 +1,5 @@
 var path = require("path");
 var fs = require("fs");
-
-// Avoid NodeJS warning.
-//
-// There's a --no-deprecation command line argument supported by
-// NodeJS, but that's tricky to use, so I'd like to set it from the
-// program itself.  Turns out you need to set `process.noDeprecation`,
-// but by the time you can set that the `path` module is already
-// loaded and `path.existsSync` is already changed to display that
-// warning, therefore here's the poor solution:
-path.existsSync = fs.existsSync;
-
 var vm = require("vm");
 var sys = require("util");

@@ -67,6 +56,9 @@ exports.minify = function(files, options) {
        inSourceMap  : null,
        fromString   : false,
        warnings     : false,
+        mangle       : {},
+        output       : null,
+        compress     : {}
    });
    if (typeof files == "string")
        files = [ files ];
@@ -84,33 +76,42 @@ exports.minify = function(files, options) {
    });

    // 2. compress
-    toplevel.figure_out_scope();
-    var sq = UglifyJS.Compressor({
-        warnings: options.warnings,
-    });
-    toplevel = toplevel.transform(sq);
+    if (options.compress) {
+        var compress = { warnings: options.warnings };
+        UglifyJS.merge(compress, options.compress);
+        toplevel.figure_out_scope();
+        var sq = UglifyJS.Compressor(compress);
+        toplevel = toplevel.transform(sq);
+    }

    // 3. mangle
-    toplevel.figure_out_scope();
-    toplevel.compute_char_frequency();
-    toplevel.mangle_names();
+    if (options.mangle) {
+        toplevel.figure_out_scope();
+        toplevel.compute_char_frequency();
+        toplevel.mangle_names(options.mangle);
+    }

    // 4. output
-    var map = null;
-    var inMap = null;
-    if (options.inSourceMap) {
+    var inMap = options.inSourceMap;
+    var output = {};
+    if (typeof options.inSourceMap == "string") {
        inMap = fs.readFileSync(options.inSourceMap, "utf8");
    }
-    if (options.outSourceMap) map = UglifyJS.SourceMap({
-        file: options.outSourceMap,
-        orig: inMap,
-        root: options.sourceRoot
-    });
-    var stream = UglifyJS.OutputStream({ source_map: map });
+    if (options.outSourceMap) {
+        output.source_map = UglifyJS.SourceMap({
+            file: options.outSourceMap,
+            orig: inMap,
+            root: options.sourceRoot
+        });
+    }
+    if (options.output) {
+        UglifyJS.merge(output, options.output);
+    }
+    var stream = UglifyJS.OutputStream(output);
    toplevel.print(stream);
    return {
        code : stream + "",
-        map  : map + ""
+        map  : output.source_map + ""
    };
 };
Author	SHA1	Message	Date
Mihai Bazon	2b40a5ac62	v2.3.4	2013-05-15 13:27:40 +03:00
Mihai Bazon	ca3388cf5a	Add `--expr`, an option to parse a single expression (suitable for JSON)	2013-05-15 13:27:23 +03:00
Mihai Bazon	caa8896a8a	Only compress code in `new Function` if all arguments are strings.	2013-05-14 18:36:31 +03:00
Mihai Bazon	d13aa3954d	v2.3.3	2013-05-14 11:33:28 +03:00
Mihai Bazon	f64539fb76	Compress code passed to `new Function` if it's a constant. Only for `--unsafe`. Close #203	2013-05-14 10:47:06 +03:00
Mihai Bazon	d56ebd7d7b	Fix a["1_1"] Close #204	2013-05-14 10:42:34 +03:00
Mihai Bazon	3edfe7d0ee	Merge pull request #202 from nschonni/add-travis-ci Add CI build for supported Node versions	2013-05-10 02:56:24 -07:00
Mihai Bazon	7f77edadb3	v2.3.2	2013-05-09 08:58:55 +03:00
Mihai Bazon	a9511dfbe5	Use the negation hack rather than parens for a toplevel function expression call (only in !beautify mode)	2013-05-09 08:58:47 +03:00
Mihai Bazon	064e7aa1bb	Fix is_assignable (not likely to be noticed, it's only used in `strict` parse mode)	2013-05-09 08:44:24 +03:00
Nick Schonning	46814f88d9	Add Travis build badge to README	2013-05-08 23:48:12 -04:00
Nick Schonning	4a19802d0c	Add CI build for supported Node versions	2013-05-08 23:42:06 -04:00
Trey Griffith	1e9f98aa51	add a test for zero-length string in is_identifier_string, which is used in property compression. Also added a test exercising the change.	2013-05-08 22:43:20 +03:00
Mihai Bazon	11e24d53a1	Fix property names Close #199	2013-05-08 22:37:48 +03:00
Mihai Bazon	0f509f8336	v2.3.1	2013-05-08 16:45:36 +03:00
Mihai Bazon	a6ed2c84ac	Better fix for equality of typeof ... against "undefined"	2013-05-08 16:22:48 +03:00
Justin Lau	a1958aad56	Fixed typeof undefined optimization and updated related test case to accomodates the sort behaviour changes made in commit mishoo/UglifyJS2@aebafad41e. Signed-off-by: Justin Lau <justin@tclau.com>	2013-05-08 16:22:48 +03:00
Justin Lau	672699613e	Added test cases for #104 . Signed-off-by: Justin Lau <justin@tclau.com>	2013-05-08 16:22:48 +03:00
Mihai Bazon	645d5bdbc5	Merge pull request #195 from kjbekkelund/typo Fix typo in bin and readme	2013-05-08 05:51:52 -07:00
Justin Lau	9af2bbffde	Fixed dot properties not optimizing unicode identifiers. Signed-off-by: Justin Lau <justin@tclau.com>	2013-05-07 14:20:19 +03:00
Justin Lau	fcd544cc10	Added test scenario with unicode in properties name. Signed-off-by: Justin Lau <justin@tclau.com>	2013-05-06 01:26:33 +08:00
Justin Lau	1e3bc0caa0	Fixed dot property issue with invlid identifier names. Signed-off-by: Justin Lau <justin@tclau.com>	2013-05-05 22:27:43 +08:00
Justin Lau	8227e8795b	Added scenario in test case where properties shouldn't be accessed with dotted syntax even with screw_ie8 option. Signed-off-by: Justin Lau <justin@tclau.com>	2013-05-05 22:08:13 +08:00
Kim Joar Bekkelund	790b3bcdc6	Fix typo in bin and readme	2013-05-02 11:15:33 +02:00
Mihai Bazon	d6e6458f68	Merge pull request #194 from ulikoehler/master Add README syntax highlighting	2013-05-01 07:04:01 -07:00
Uli Köhler	a54b6703c0	Add README syntax highlighting	2013-05-01 15:56:20 +02:00
Mihai Bazon	8e6266136d	Take two. v2.3.0	2013-05-01 13:15:34 +03:00
Mihai Bazon	5c22a1bdf5	v2.3	2013-05-01 13:14:07 +03:00
Mihai Bazon	9794ebf88c	Workaround for missing `prefix` in UnaryExpression generated by Esprima See #193	2013-04-29 15:03:52 +03:00
Mihai Bazon	68394eed93	Make compress/mangle disabled by default, as before `5af144522a`	2013-04-21 11:35:50 +03:00
Mihai Bazon	753b4b6cc8	Merge pull request #191 from michaelficarra/use-es5-member-access-with-screw-ie use dotted member access when --screw-ie8 option given	2013-04-21 01:30:02 -07:00
Mihai Bazon	a9c1b9f138	Merge pull request #190 from michaelficarra/patch-1 unbalanced parentheses in readme	2013-04-21 01:28:45 -07:00
Michael Ficarra	5af144522a	fixes #189 : use dotted member access when --screw-ie8 option given	2013-04-20 15:11:05 -05:00
Michael Ficarra	483e0cadfb	unbalanced parentheses in readme	2013-04-20 14:05:52 -05:00
Roman Bataev	4b818056cf	Fix typeof evaluation for regex and function	2013-04-03 22:34:38 -04:00
Roman Bataev	b956e5f1d9	Add tests for typeof evaluation	2013-04-03 22:34:19 -04:00
Vladimir Zhuravlev	37d7cb8565	Quote objects with numeric keys	2013-03-31 19:52:28 +03:00
Mihai Bazon	2b8e206fec	fix package.json	2013-03-31 13:38:02 +03:00
Mihai Bazon	a869b854fa	Don't use \xYY for identifiers Fix #173	2013-03-31 13:36:22 +03:00
Andreas Lind Petersen	81f5efe39a	Output, to_ascii: Escape non-ascii chars with \xnn instead of \unnnn whenever possible.	2013-03-31 13:36:22 +03:00
Andreas Lind Petersen	69dde0462b	uglifyjs binary: Make read_whole_file async and don't attempt to read STDIN synchronously.	2013-03-31 13:36:22 +03:00
Mihai Bazon	7628bcac01	Merge pull request #163 from mzgol/screw-oldie renamed --screw-ie to --screw-oldie, documented it in README.md, indicat...	2013-03-25 09:05:44 -07:00
Michał Gołębiowski	75f0bbe6e8	renamed --screw-ie to --screw-ie8, documented it in README.md, indicated it doesn't break IE9+	2013-03-25 17:03:21 +01:00
Jake Harding	478bf4dbdd	Add support for enclose option. Closes #139 .	2013-03-24 11:11:23 +02:00
Mihai Bazon	e0f67baf2d	Don't print the warning on parse error, just throw a JS_Parse_Error. Fix #159	2013-03-24 00:57:35 +02:00
Mihai Bazon	b14d3df3d2	Keep legit code working even when --screw-ie is not passed. Previously: Without `--screw-ie`, UglifyJS would always leak names of function expressions into the containing scope, as if they were function declarations. That was to emulate IE<9 behavior. Code relying on this IE bug would continue to work properly after mangling, although it would only work in IE (since other engines don't share the bug). Sometimes this broke legitimage code (see #153 and #155). With `--screw-ie` the names would not be leaked into the current scope, working properly in legit cases; but still it broke legit code when running in IE<9 (see #24). Currently: Regardless of the `--screw-ie` setting, the names will not be leaked. Code relying on the IE bug will not work properly after mangling. <evil laughter here> Without `--screw-ie`: a hack has been added to the mangler to avoid using the same name for a function expression and some other variable in the same scope. This keeps legit code working, at the (negligible, indeed) cost of one more identifier. With `--screw-ie` you allow the mangler to name function expressions with the same identifier as another variable in scope. After mangling code might break in IE<9. Oh man, the commit message is longer than the patch. Fix #153, #155	2013-03-22 18:04:46 +02:00
Mihai Bazon	24e58ee70c	Merge pull request #125 from devongovett/master Allow inSourceMap option to be a generated JSON source map	2013-03-13 01:36:55 -07:00
Mihai Bazon	9b1a40dfc3	Support mangling toplevel names Close #127	2013-03-13 09:44:06 +02:00
Mihai Bazon	e4b078cff7	Disable `unsafe` by default Close #147	2013-03-11 00:04:31 +02:00
Mihai Bazon	3bd7ca9961	Merge pull request #146 from mbostock/read-all-stdin Read the entire STDIN.	2013-03-05 22:17:09 -08:00
Mike Bostock	f83aca65b7	Read the entire STDIN. The problem with reading synchronously from /dev/stdin is that you can get a spurious EOF when the input buffer is empty, even if more content is coming. Now STDIN is read from a loop, and only stops polling when all input has been read. This fixes #70 #85 and other errors related to parsing large files on STDIN.	2013-03-05 20:35:49 -08:00
Mihai Bazon	aebafad41e	Fix reordering comparisons Close #143	2013-03-04 10:06:01 +02:00
Mihai Bazon	26746ce316	Add `--screw-ie` option For now the implication is that UglifyJS will not leak a function expression's name in the surrounding scope (IE < 9 does that). (ref. mishoo/UglifyJS#485)	2013-03-02 14:28:34 +02:00
Mihai Bazon	dac6efb43d	Drop last `default:` if it's the last branch and empty Close #141	2013-03-01 13:12:03 +02:00
Mihai Bazon	8880f4824c	Compress boolean constants after evaluation Close #137	2013-03-01 10:26:06 +02:00
Mihai Bazon	cb0c576bdd	Add license Close #131	2013-02-22 13:58:16 +02:00
Mihai Bazon	3a591c43fe	Fix compressing `do {...} while (false)` It's not safe to transform it to {...} because the body might contain `break`. The solution could be more elaborate (detect if body contains `break`) but I don't think it's worth the trouble. Close #129	2013-02-19 18:12:19 +02:00
Mihai Bazon	db66eca958	v2.2.5	2013-02-14 12:51:13 +02:00
Devon Govett	f2767452e6	Allow inSourceMap to be a generated JSON source map instead of just a file name	2013-02-10 10:06:13 -08:00
Mihai Bazon	916faf0a48	Force space after literal regexp when used in "instanceof" or "in" Close #118	2013-02-06 11:57:59 +02:00
Mihai Bazon	f36e4e9a78	Give up evaluating (unary-prefix '-' 0) Close #117 ------ JS, WHY YOU SUCK SO BADLY? ;-(	2013-02-06 11:51:09 +02:00
Mihai Bazon	fdf8b5eb71	Fix parens for NaN Close #116	2013-02-06 11:38:29 +02:00
Mihai Bazon	de7ec7f1b7	Fix parens for negative numbers Close #115	2013-02-06 11:36:04 +02:00
Mihai Bazon	3c8a0bdff4	Fix parens for AST_New Close #114	2013-02-06 11:28:49 +02:00
Mihai Bazon	9e8ba27dcd	Fix handling of constants Close #113	2013-02-06 11:15:31 +02:00
Mihai Bazon	719a8fd102	Ugly hack to print comments before return/throw statements Close #112	2013-02-05 19:11:39 +02:00
Mihai Bazon	3a22e917de	Merge pull request #111 from mattrobenolt/safer-sourcemap Wraps sourceMappingURL in a multiline comment. Fixes #108	2013-02-03 23:44:31 -08:00
Matt Robenolt	a9af2c9e62	Wraps sourceMappingURL in a multiline comment. Fixes #108	2013-02-03 16:01:01 -08:00
Mihai Bazon	31e99cebe7	v2.2.4	2013-02-01 13:32:15 +02:00
Mihai Bazon	a5b209470c	Fix end token for Assign nodes	2013-02-01 13:32:15 +02:00
Mihai Bazon	e9a571b2a1	Merge pull request #94 from paulmillr/patch-1 Add better fromstring docs.	2013-01-31 23:50:59 -08:00
Mihai Bazon	8bf83f42ea	Merge pull request #106 from gibson042/105 Fix #105: property comparison to undefined is not always safe	2013-01-24 05:51:33 -08:00
Richard Gibson	522566ea80	Fix #105 : property comparison to undefined is not always safe	2013-01-23 23:52:04 -05:00
Mihai Bazon	297af47c89	Add --source-map-url option Fix #100 Fix #47	2013-01-20 12:32:07 +02:00
Mihai Bazon	faa354f5ca	[AST_Hole] the print function can be a no-op.	2013-01-17 11:36:10 +02:00
David Glasser	1529ab965a	Fix output for arrays containing undefined values. `1b6bcca7` was a first attempt at this. That commit made Uglify stop replacing holes with undefined, but instead it started replacing undefined with holes. This is slightly problematic, because there is a difference between a hole and an undefined value. More problematically, it changed [1,undefined] to [1,] which generally doesn't even parse as a hole (just as a trailing comma), so it didn't even preserve the length of the array! Instead, parse holes as their own special AST node which prints invisibly.	2013-01-17 11:36:10 +02:00
Mihai Bazon	605f330e69	Merge pull request #98 from ForbesLindesay/patch-1 Update installation instructions	2013-01-17 01:08:59 -08:00
Mihai Bazon	f0909bdc8f	Handle String() with no arguments. Fix #91	2013-01-17 11:01:38 +02:00
Forbes Lindesay	c13e7e621d	Update installation instructions re #4	2013-01-17 00:13:42 +00:00
Paul Miller	ad071f8017	Add better fromstring docs.	2013-01-13 18:45:43 +02:00
Mihai Bazon	c058d8b9cd	Merge pull request #90 from jakearchibald/patch-1 Compressor options use underscores rather than hyphens	2013-01-08 14:21:25 -08:00
Jake Archibald	1d8871a092	Compressor options use underscores rather than hyphens	2013-01-08 12:33:58 -08:00
Mihai Bazon	16953c2064	v2.2.3	2013-01-04 22:50:53 +02:00
Mihai Bazon	6b14f7c224	Fix handling of labels in nested scopes	2013-01-04 14:17:33 +02:00
Mihai Bazon	130c623be7	Support `output`, `mangle` and `compress` options to `UglifyJS.minify`. Close #57 Close #86 Close #33	2013-01-04 11:25:13 +02:00
Mihai Bazon	47c9895d59	Merge pull request #87 from BenoitZugmeyer/master Add a --version option	2013-01-03 02:28:35 -08:00
Benoît Zugmeyer	ba403331c5	Set --version as a boolean #87	2013-01-03 11:22:37 +01:00
Benoît Zugmeyer	e82e89d1b0	--version option	2013-01-03 11:07:53 +01:00
Mihai Bazon	83a4ebfedc	Implement `-m sort=true` close #83	2013-01-02 12:39:00 +02:00
Mihai Bazon	9916d0e547	Accept string or number as name of an accessor. [not sure I'm happy about this fix] Reference mishoo/UglifyJS#478	2012-12-22 01:24:04 +02:00
Mihai Bazon	31c4a37e37	Optimize new Array(1, 2, 3) → [1, 2, 3] Close #74	2012-12-21 21:04:35 +02:00
Mihai Bazon	08219f0cee	Fix output when semicolons is off. (need to force a semicolon for the empty body of an `if`) Close #72	2012-12-21 11:57:08 +02:00
Mihai Bazon	c4993e1e5c	Small cleanup	2012-12-12 11:51:55 +02:00
Mihai Bazon	6064bea3db	v2.2.2	2012-12-06 14:25:18 +02:00
Mihai Bazon	98978fc827	Add proper parens in "NoIn" expressions. fix #60.	2012-12-06 12:27:57 +02:00
Mihai Bazon	16430acc1f	small improvement on merging assignments into hoisted vars	2012-12-05 13:14:49 +02:00
Mihai Bazon	320c110b33	When hoisting variables, try to merge in assignments that follow.	2012-12-05 12:30:25 +02:00
Mihai Bazon	dbe33bbfc5	Revert "Fixed reading from STDIN." It breaks usage like this: echo '...code...' \| uglifyjs This reverts commit `e48802ad29`.	2012-11-30 11:33:50 +02:00
Mihai Bazon	b5c3253b49	Add test for issue #59	2012-11-30 11:26:37 +02:00
Mihai Bazon	5cc90db7d0	Don't messup compressor stack while optimizing Switch Fix #59	2012-11-30 11:16:09 +02:00
Mihai Bazon	f427e5efc7	Merge pull request #58 from roxeteer/master Fixed reading from STDIN	2012-11-29 01:23:07 -08:00
Visa Kopu	e48802ad29	Fixed reading from STDIN.	2012-11-29 10:51:15 +02:00
Mihai Bazon	13c4dfcabd	fix #55	2012-11-24 10:02:08 +02:00
Mihai Bazon	1abde9c8b0	v2.2.1	2012-11-23 10:25:44 +02:00
Mihai Bazon	4f555e2232	fix for https://github.com/mishoo/UglifyJS/issues/474	2012-11-23 10:20:00 +02:00
Mihai Bazon	642ba2e92c	rename the npm package to "uglify-js" and cli tool to "uglifyjs"	2012-11-21 13:27:03 +02:00
Mihai Bazon	089ac908b7	fix #51	2012-11-18 17:37:45 +02:00
Mihai Bazon	0d3fd2ef30	retain (1,eval) as is when it's the expression of an AST_Call otherwise we change the meaning of eval from global to lexical.	2012-11-17 12:05:31 +02:00
Richard van Velzen	e98119496a	Add support for somewhat preserving line numbers. Usage: uglifyjs2 -b "beautify=0,preserve_line=1" /path/to/js ref #46	2012-11-14 15:30:18 +02:00
Mihai Bazon	bdfcbf496b	better solution for the last test in constant switch folding	2012-11-14 12:21:43 +02:00
Mihai Bazon	dba8da4800	optimize constant switch blocks ref. mishoo/UglifyJS#441	2012-11-14 12:06:07 +02:00
Mihai Bazon	60c0f40250	Merge branch 'optimize_concat' of https://github.com/rvanvelzen/UglifyJS2 into rvanvelzen-optimize_concat	2012-11-13 14:38:55 +02:00
Mihai Bazon	e02771a5f2	don't change order in binary expressions if both operands have side effects	2012-11-13 14:32:07 +02:00
Richard van Velzen	f96f796f71	Add simple optimization for empty-string concats. ref. #43	2012-11-12 15:41:03 +01:00
Mihai Bazon	a9fa178f86	v2.1.11	2012-11-12 13:24:52 +02:00
Mihai Bazon	53355bdb24	fix invalid AST produced by dropping unused variable close #44	2012-11-12 13:23:57 +02:00
Mihai Bazon	f05c99d89f	Merge pull request #41 from Skalman/toString-patch Convert x.toString() to ""+x instead of x+""	2012-11-12 00:47:56 -08:00
Dan Wolff	b49230ab8d	convert x.toString() to ""+x instead of x+"" In some places this can save one byte in whitespace, e.g. after return. Example: function f(arg) { // return""+arg - no space between return and "" return arg.toString(); }	2012-11-11 15:53:34 +02:00
Mihai Bazon	78856a3dab	declare dependency versions close #40	2012-11-09 16:43:49 +02:00
Mihai Bazon	1e5e13ed81	AST_LabelRef no longer inherits from AST_SymbolRef	2012-11-08 15:39:14 +02:00
Mihai Bazon	64270b9778	v2.1.10	2012-11-08 12:33:27 +02:00
Mihai Bazon	e312c5c2a7	fix API breakage close #36, #38	2012-11-08 12:31:28 +02:00
Mihai Bazon	1a5fd3e052	optimization for if/break as first statement in a loop body for(...; x; ...) if (y) break; → for(...; x&&!y; ...); similarly for `while` and some combinations (i.e. the `break` appears in the `else` clause, etc.)	2012-11-08 11:43:14 +02:00
Mihai Bazon	5a7e54cf72	ignore node_modules/	2012-11-07 15:27:12 +02:00
Mihai Bazon	39f8a62703	v2.1.9	2012-11-07 13:31:58 +02:00
Mihai Bazon	46be3f2bf1	fix another small regression we do need parens here: `new (foo.bar().baz)`, but not here: `new foo.bar.baz`	2012-11-07 13:31:43 +02:00
Mihai Bazon	258b46f4dc	v2.1.8	2012-11-07 13:03:11 +02:00
Mihai Bazon	80da21dab4	fix regression from `5346fb94` (shouldn't parenthesize i++ in x[i++])	2012-11-07 13:02:51 +02:00
Mihai Bazon	bb0e4d7126	v2.1.7	2012-11-07 12:45:23 +02:00
Mihai Bazon	5276a4a873	add AST_Accessor and AST_SymbolAccessor node types AST_Accessor will represent the function for a setter or getter. Since they are not mangleable, and they should not introduce a name in scope, we have a new node for their name (AST_SymbolAccessor) which doesn't inherit from AST_SymbolDeclaration. fix #37	2012-11-07 12:43:27 +02:00
Mihai Bazon	a1ae0c8609	parenthesize property access when it's the expression in New refs #35	2012-11-07 12:26:33 +02:00
Mihai Bazon	a90c1aeafe	further fix for parens around New (refs #35 )	2012-11-07 11:49:06 +02:00
Mihai Bazon	ff388a8d2d	parenthesize a Call expression when its parent is New fix #35	2012-11-07 11:36:15 +02:00
Mihai Bazon	5346fb94bb	add proper parens around unary expressions fix #34	2012-11-07 11:23:50 +02:00
Mihai Bazon	a4f6d46118	add option to mangle names even if eval/with is in use (for more fair comparison to Closure compiler)	2012-11-06 18:19:51 +02:00
Mihai Bazon	7f5f4d60b7	discard the hack that worked around the deprecation warning (since the source-map module no longer uses require.js) refs #9	2012-11-05 22:23:51 +02:00
Mihai Bazon	ffccb233e5	convert `while` into `for`	2012-11-05 16:01:20 +02:00
Mihai Bazon	fba0c1aafe	minor	2012-11-05 16:01:09 +02:00
Mihai Bazon	774f2ded94	minor optimization for `==` or `!=` against a constant, prefer to display the constant first. should help a bit after gzip, i.e.: typeof foo=="undefined" ^^^^^^ ^^^^^^^^^^^^^ vs: "undefined"==typeof foo ^^^^^^^^^^^^^^^^^^^ (longer sequence that could repeat) idea stolen from closure.	2012-11-05 13:13:06 +02:00
Mihai Bazon	85af942d64	print final semicolon close #28	2012-11-05 13:09:39 +02:00
Mihai Bazon	8413787efc	use a Dictionary object instead of plain object for hashes to mitigate the `__proto__` issue related to #30	2012-11-02 10:58:45 +02:00
Mihai Bazon	dde57452aa	v2.1.6	2012-11-01 16:55:10 +02:00
Mihai Bazon	cf409800be	it's safe to negate expression in !EXP only in boolean context #kendo	2012-11-01 15:49:05 +02:00
Mihai Bazon	18270dd9f3	added unsafe_comps for negating `<=` with `>` since it has the potential to break code, let's keep it disabled by default	2012-11-01 15:14:56 +02:00
Mihai Bazon	d4c25c571b	fix compressing UnaryPrefix only try negating the expression if the operator is `!` #kendo	2012-11-01 13:35:08 +02:00
Mihai Bazon	5248b79506	v2.1.5	2012-10-30 14:51:05 +02:00
Mihai Bazon	abe0ebbf02	don't move expressions containing the binary `in` operator into the `for` initializer (opera can't parse it) close #25	2012-10-30 14:50:47 +02:00
Mihai Bazon	0852f5595e	v2.1.4	2012-10-25 18:52:49 +03:00
Mihai Bazon	cb3cafa14d	cripple scope to make IE happy :-( close #24	2012-10-25 18:52:35 +03:00
Mihai Bazon	202fb93799	test for fs.existsSync	2012-10-25 10:58:48 +03:00