Take two. v2.3.0

See #193

LICENSE

@@ -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.

README.md

@@ -12,9 +12,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 +32,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 +49,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.
@@ -78,7 +91,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 +113,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 +144,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 +173,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,16 +190,32 @@ 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
@@ -206,13 +241,14 @@ separate file and include it into the build.  For example you can have a
 
 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
@@ -288,7 +324,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
@@ -310,7 +346,7 @@ API Reference
 Assuming installation via NPM, you can load UglifyJS in your application
 like this:
 
-    var UglifyJS = require("uglify-js2");
+    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)
@@ -322,9 +358,10 @@ 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
+    // 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:
 
@@ -366,9 +403,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!
 
@@ -516,3 +563,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

bin/uglifyjs

@@ -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,9 @@ 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("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 +33,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\". \
@@ -49,6 +53,7 @@ You need to pass an argument to this option to specify the name that your module
     .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 +63,20 @@ 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("screw-ie8")
     .boolean("export-all")
     .boolean("self")
     .boolean("v")
@@ -74,6 +84,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 +93,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 +118,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 +217,116 @@ 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
+                });
+            };
+        });
+        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(MANGLE);
-        }
-    });
-}
+    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 +371,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);
     }
 }
 

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))
@@ -863,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

lib/compress.js

@@ -52,7 +52,7 @@ 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,
@@ -66,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   : {}
@@ -156,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:
@@ -554,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);
@@ -613,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;
@@ -657,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){
@@ -814,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);
         });
@@ -869,18 +893,23 @@ 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;
@@ -905,16 +934,15 @@ 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) {
-                                    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
@@ -1086,13 +1114,71 @@ merge(Compressor.prototype, {
                 }
             );
             self = self.transform(tt);
-            if (vars_found > 0) hoisted.unshift(make_node(AST_Var, self, {
-                definitions: vars.map(function(def){
-                    def = def.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;
@@ -1123,8 +1209,6 @@ 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;
@@ -1342,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;
     });
@@ -1417,6 +1581,9 @@ 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: "+",
@@ -1452,7 +1619,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);
                 }
             }
         }
@@ -1462,8 +1629,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()
@@ -1549,10 +1727,12 @@ merge(Compressor.prototype, {
 
     OPT(AST_Binary, function(self, compressor){
         function reverse(op) {
-            if (op) self.operator = op;
-            var tmp = self.left;
-            self.left = self.right;
-            self.right = tmp;
+            if (!(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
@@ -1564,7 +1744,7 @@ merge(Compressor.prototype, {
         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);
             }
@@ -1574,7 +1754,8 @@ merge(Compressor.prototype, {
             if (self.left instanceof AST_String
                 && self.left.value == "undefined"
                 && self.right instanceof AST_UnaryPrefix
-                && self.right.operator == "typeof") {
+                && self.right.operator == "typeof"
+                && compressor.option("unsafe")) {
                 if (!(self.right.expression instanceof AST_SymbolRef)
                     || !self.right.expression.undeclared()) {
                     self.left = self.right.expression;
@@ -1642,6 +1823,11 @@ merge(Compressor.prototype, {
               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;
     });
 
@@ -1776,7 +1962,7 @@ merge(Compressor.prototype, {
         var prop = self.property;
         if (prop instanceof AST_String && compressor.option("properties")) {
             prop = prop.getValue();
-            if (is_identifier(prop)) {
+            if (is_identifier(prop) || compressor.option("screw_ie8")) {
                 return make_node(AST_Dot, self, {
                     expression : self.expression,
                     property   : prop

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 = {};

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;
     };
 
@@ -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,25 @@ 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);
+        if (force_parens || self.needs_parens(stream)) {
+            stream.with_parens(function(){
                 self.add_comments(stream);
                 self.add_source_map(stream);
                 generator(self, stream);
-            }
-            stream.pop_node();
-        });
-    };
+            });
+        } else {
+            self.add_comments(stream);
+            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 +380,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);
@@ -454,18 +484,6 @@ 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)
-                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_PropAccess, function(output){
@@ -496,11 +514,23 @@ function OutputStream(options) {
     PARENS(AST_New, function(output){
         var p = output.parent();
         if (no_constructor_parens(this, output)
-            && (p instanceof AST_Dot // (new Date).getTime()
+            && (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;
+    });
+
     function assign_and_conditional_paren_rules(output) {
         var p = output.parent();
         // !(a = false) → true
@@ -609,7 +639,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 {
@@ -721,7 +755,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
@@ -745,7 +779,7 @@ function OutputStream(options) {
             }
             else break;
         }
-        self.body.print(output);
+        force_statement(self.body, output);
     };
     DEFPRINT(AST_If, function(self, output){
         output.print("if");
@@ -853,13 +887,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);
         }
     });
 
@@ -878,7 +931,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){
@@ -906,7 +959,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(".");
             }
@@ -958,8 +1011,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();
         });
@@ -981,7 +1033,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)
@@ -1010,6 +1062,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");
     });
@@ -1033,6 +1086,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) {

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) {
@@ -190,12 +190,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);
 };
 
@@ -881,11 +875,14 @@ function parse($TEXT, options) {
     };
 
     var function_ = function(in_statement, ctor) {
-        var name = is("name") ? as_symbol(in_statement
-                                          ? AST_SymbolDefun
-                                          : ctor === AST_Accessor
-                                          ? AST_SymbolAccessor
-                                          : 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("(");
@@ -1128,7 +1125,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));
             }
@@ -1355,7 +1352,7 @@ function parse($TEXT, options) {
                     left     : left,
                     operator : val,
                     right    : maybe_assign(no_in),
-                    end      : peek()
+                    end      : prev()
                 });
             }
             croak("Invalid assignment");

lib/scope.js

@@ -57,13 +57,17 @@ function SymbolDef(scope, index, orig) {
 
 SymbolDef.prototype = {
     unmangleable: function(options) {
-        return this.global
+        return (this.global && !(options && options.toplevel))
             || this.undeclared
             || (!(options && options.eval) && (this.scope.uses_eval || this.scope.uses_with));
     },
     mangle: function(options) {
-        if (!this.mangled_name && !this.unmangleable(options))
-            this.mangled_name = this.scope.next_mangled(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);
+        }
     }
 };
 
@@ -84,9 +88,12 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
         if (node instanceof AST_Scope) {
             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
@@ -110,9 +117,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
             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;
         }
@@ -121,15 +125,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(){
             node.init_scope_vars();
         }
         if (node instanceof AST_SymbolLambda) {
-            //scope.def_function(node);
-            //
-            // https://github.com/mishoo/UglifyJS2/issues/24 — MSIE
-            // leaks function expression names into the containing
-            // scope.  Don't like this fix but seems we can't do any
-            // better.  IE: please die. Please!
-            (node.scope = scope.parent_scope).def_function(node);
-
-            node.init.push(tw.parent());
+            scope.def_function(node);
         }
         else if (node instanceof AST_SymbolDefun) {
             // Careful here, the scope where this should be defined is
@@ -138,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
@@ -246,10 +240,6 @@ AST_SymbolRef.DEFMETHOD("reference", function() {
     this.frame = this.scope.nesting - def.scope.nesting;
 });
 
-AST_SymbolDeclaration.DEFMETHOD("init_scope_vars", function(){
-    this.init = [];
-});
-
 AST_Label.DEFMETHOD("init_scope_vars", function(){
     this.references = [];
 });
@@ -287,14 +277,14 @@ AST_Scope.DEFMETHOD("def_variable", function(symbol){
 });
 
 AST_Scope.DEFMETHOD("next_mangled", function(options){
-    var ext = this.enclosed, n = ext.length;
+    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(options) && sym.name);
             if (m == name) continue out;
@@ -349,8 +339,11 @@ AST_Symbol.DEFMETHOD("global", function(){
 
 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
     return defaults(options, {
-        except : [],
-        eval   : false,
+        except   : [],
+        eval     : false,
+        sort     : false,
+        toplevel : false,
+        screw_ie8 : false
     });
 });
 
@@ -371,12 +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 p = tw.parent(), a = [];
             node.variables.each(function(symbol){
                 if (options.except.indexOf(symbol.name) < 0) {
-                    to_mangle.push(symbol);
+                    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) {

lib/transform.js

@@ -65,7 +65,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;

lib/utils.js

@@ -255,6 +255,14 @@ Dictionary.prototype = {
         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)) {

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.11",
+    "version": "2.3.0",
     "engines": { "node" : ">=0.4.0" },
     "maintainers": [{
         "name": "Mihai Bazon",
@@ -15,11 +15,12 @@
         "url": "https://github.com/mishoo/UglifyJS2.git"
     }],
     "dependencies": {
+        "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"}
 }

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];
+    }
+}

test/compress/issue-105.js

@@ -0,0 +1,17 @@
+typeof_eq_undefined: {
+    options = {
+        comparisons: true,
+        unsafe: false
+    };
+    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 = b.c !== void 0 }
+}

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

test/compress/properties.js

@@ -23,3 +23,18 @@ dot_properties: {
         a["if"] = "if";
     }
 }
+
+dot_properties_es5: {
+    options = {
+        properties: true,
+        screw_ie8: true
+    };
+    input: {
+        a["foo"] = "bar";
+        a["if"] = "if";
+    }
+    expect: {
+        a.foo = "bar";
+        a.if = "if";
+    }
+}

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

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';
+    }
+}

tools/node.js

@@ -56,6 +56,9 @@ exports.minify = function(files, options) {
         inSourceMap  : null,
         fromString   : false,
         warnings     : false,
+        mangle       : {},
+        output       : null,
+        compress     : {}
     });
     if (typeof files == "string")
         files = [ files ];
@@ -73,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 + ""
     };
 };