v2.4.17

Clean up unit test breakage
In 992b6b9fcc unit test broke (which I missed). This was due to undeclared variables not being side-effects free. However, since they're really not side-effect free, just declare them in the test cases.
2015-03-11 00:03:12 +02:00 · 2015-02-11 21:27:21 +01:00 · 2015-02-11 21:08:41 +01:00 · 2015-02-11 18:29:15 +01:00 · 2015-01-31 13:24:44 +01:00 · 2015-01-27 22:26:27 +02:00
26 changed files with 1601 additions and 343 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,6 @@
 language: node_js
+before_install: "npm install -g npm"
 node_js:
-    - "0.4"
-    - "0.6"
    - "0.8"
    - "0.10"
    - "0.11"
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 UglifyJS 2
 ==========
-[![Build Status](https://travis-ci.org/mishoo/UglifyJS2.png)](https://travis-ci.org/mishoo/UglifyJS2)
+[![Build Status](https://travis-ci.org/mishoo/UglifyJS2.svg)](https://travis-ci.org/mishoo/UglifyJS2)

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

@@ -44,6 +44,11 @@ variable/function declared in another file will be matched properly.
 If you want to read from STDIN instead, pass a single dash instead of input
 files.

+If you wish to pass your options before the input files, separate the two with
+a double dash to prevent input files being used as option arguments:
+
+    uglifyjs --compress --mangle -- input.js
+
 The available options are:

 ```
@@ -54,6 +59,10 @@ The available options are:
  --source-map-url   The path to the source map to be added in //#
                     sourceMappingURL.  Defaults to the value passed with
                     --source-map.                                      [string]
+  --source-map-include-sources
+                     Pass this flag if you want to include the content of
+                     source files in the source map as sourcesContent
+                     property.                                         [boolean]
  --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
@@ -169,7 +178,7 @@ To enable the mangler you need to pass `--mangle` (`-m`).  The following
 - `toplevel` — mangle names declared in the toplevel scope (disabled by
  default).

- `eval` — mangle names visible in scopes where `eval` or `when` are used
+- `eval` — mangle names visible in scopes where `eval` or `with` are used
  (disabled by default).

 When mangling is enabled but you want to prevent certain names from being
@@ -252,6 +261,10 @@ to set `true`; it's effectively a shortcut for `foo=true`).
 - `drop_console` -- default `false`.  Pass `true` to discard calls to
  `console.*` functions.

+- `keep_fargs` -- default `false`.  Pass `true` to prevent the
+  compressor from discarding unused function arguments.  You need this
+  for code which relies on `Function.length`.
+
 ### The `unsafe` option

 It enables some transformations that *might* break code logic in certain
@@ -339,6 +352,13 @@ can pass additional arguments that control the code output:
  it will be prepended to the output literally.  The source map will
  adjust for this text.  Can be used to insert a comment containing
  licensing information, for example.
+- `quote_style` (default `0`) -- preferred quote style for strings (affects
+  quoted property names and directives as well):
+  - `0` -- prefers double quotes, switches to single quotes when there are
+    more double quotes in the string itself.
+  - `1` -- always use single quotes
+  - `2` -- always use double quotes
+  - `3` -- always use the original quotes

 ### Keeping copyright notices or other comments

@@ -396,6 +416,38 @@ Acorn is really fast (e.g. 250ms instead of 380ms on some 650K code), but
 converting the SpiderMonkey tree that Acorn produces takes another 150ms so
 in total it's a bit more than just using UglifyJS's own parser.

+### Using UglifyJS to transform SpiderMonkey AST
+
+Now you can use UglifyJS as any other intermediate tool for transforming
+JavaScript ASTs in SpiderMonkey format.
+
+Example:
+
+```javascript
+function uglify(ast, options, mangle) {
+  // Conversion from SpiderMonkey AST to internal format
+  var uAST = UglifyJS.AST_Node.from_mozilla_ast(ast);
+
+  // Compression
+  uAST.figure_out_scope();
+  uAST = uAST.transform(UglifyJS.Compressor(options));
+
+  // Mangling (optional)
+  if (mangle) {
+    uAST.figure_out_scope();
+    uAST.compute_char_frequency();
+    uAST.mangle_names();
+  }
+
+  // Back-conversion to SpiderMonkey AST
+  return uAST.to_mozilla_ast();
+}
+```
+
+Check out
+[original blog post](http://rreverser.com/using-mozilla-ast-with-uglifyjs/)
+for details.
+
 API Reference
 -------------

@@ -505,7 +557,7 @@ something like this:
 ```javascript
 var toplevel = null;
 files.forEach(function(file){
-	var code = fs.readFileSync(file);
+	var code = fs.readFileSync(file, "utf8");
 	toplevel = UglifyJS.parse(code, {
 		filename: file,
 		toplevel: toplevel
@@ -572,7 +624,7 @@ or, for a shortcut you can do:
 var code = compressed_ast.print_to_string(options);
 ```

-As usual, `options` is optional.  The output stream accepts a lot of otions,
+As usual, `options` is optional.  The output stream accepts a lot of options,
 most of them documented above in section “Beautifier options”.  The two
 which we care about here are `source_map` and `comments`.

--- a/bin/uglifyjs
+++ b/bin/uglifyjs
@@ -5,12 +5,12 @@

 var UglifyJS = require("../tools/node");
 var sys = require("util");
-var optimist = require("optimist");
+var yargs = require("yargs");
 var fs = require("fs");
 var path = require("path");
 var async = require("async");
 var acorn;
-var ARGS = optimist
+var ARGS = yargs
    .usage("$0 input1.js [input2.js ...] [options]\n\
 Use a single dash to read input from the standard input.\
 \n\n\
@@ -22,6 +22,7 @@ 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("source-map-include-sources", "Pass this flag if you want to include the content of source files in the source map as sourcesContent property.")
    .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)")
@@ -63,6 +64,9 @@ You need to pass an argument to this option to specify the name that your module
    .describe("v", "Verbose")
    .describe("V", "Print version number and exit.")
    .describe("noerr", "Don't throw an error for unknown options in -c, -b or -m.")
+    .describe("bare-returns", "Allow return outside of functions.  Useful when minifying CommonJS modules.")
+    .describe("keep-fnames", "Do not mangle/drop function names.  Useful for code relying on Function.prototype.name.")
+    .describe("quotes", "Quote style (0 - auto, 1 - single, 2 - double, 3 - original)")

    .alias("p", "prefix")
    .alias("o", "output")
@@ -74,6 +78,7 @@ You need to pass an argument to this option to specify the name that your module
    .alias("r", "reserved")
    .alias("V", "version")
    .alias("e", "enclose")
+    .alias("q", "quotes")

    .string("source-map")
    .string("source-map-root")
@@ -88,6 +93,7 @@ You need to pass an argument to this option to specify the name that your module
    .string("p")

    .boolean("expr")
+    .boolean("source-map-include-sources")
    .boolean("screw-ie8")
    .boolean("export-all")
    .boolean("self")
@@ -98,6 +104,8 @@ You need to pass an argument to this option to specify the name that your module
    .boolean("lint")
    .boolean("V")
    .boolean("noerr")
+    .boolean("bare-returns")
+    .boolean("keep-fnames")

    .wrap(80)

@@ -125,7 +133,7 @@ if (ARGS.ast_help) {
 }

 if (ARGS.h || ARGS.help) {
-    sys.puts(optimist.help());
+    sys.puts(yargs.help());
    process.exit(0);
 }

@@ -145,9 +153,14 @@ if (ARGS.r) {
    if (MANGLE) MANGLE.except = ARGS.r.replace(/^\s+|\s+$/g).split(/\s*,+\s*/);
 }

+if (ARGS.quotes === true) {
+    ARGS.quotes = 3;
+}
+
 var OUTPUT_OPTIONS = {
-    beautify: BEAUTIFY ? true : false,
-    preamble: ARGS.preamble || null,
+    beautify    : BEAUTIFY ? true : false,
+    preamble    : ARGS.preamble || null,
+    quote_style : ARGS.quotes != null ? ARGS.quotes : 0
 };

 if (ARGS.screw_ie8) {
@@ -156,12 +169,22 @@ if (ARGS.screw_ie8) {
    OUTPUT_OPTIONS.screw_ie8 = true;
 }

+if (ARGS.keep_fnames) {
+    if (COMPRESS) COMPRESS.keep_fnames = true;
+    if (MANGLE) MANGLE.keep_fnames = true;
+}
+
 if (BEAUTIFY)
    UglifyJS.merge(OUTPUT_OPTIONS, BEAUTIFY);

 if (ARGS.comments) {
-    if (/^\//.test(ARGS.comments)) {
-        OUTPUT_OPTIONS.comments = new Function("return(" + ARGS.comments + ")")();
+    if (/^\/.*\/[a-zA-Z]*$/.test(ARGS.comments)) {
+        var regex_pos = ARGS.comments.lastIndexOf("/");
+        try {
+            OUTPUT_OPTIONS.comments = new RegExp(ARGS.comments.substr(1, regex_pos - 1), ARGS.comments.substr(regex_pos + 1));
+        } catch (e) {
+            sys.error("ERROR: Invalid --comments: " + e.message);
+        }
    } else if (ARGS.comments == "all") {
        OUTPUT_OPTIONS.comments = true;
    } else {
@@ -218,6 +241,7 @@ var STATS = {};
 var OUTPUT_FILE = ARGS.o;
 var TOPLEVEL = null;
 var P_RELATIVE = ARGS.p && ARGS.p == "relative";
+var SOURCES_CONTENT = {};

 var SOURCE_MAP = ARGS.source_map ? UglifyJS.SourceMap({
    file: P_RELATIVE ? path.relative(path.dirname(ARGS.source_map), OUTPUT_FILE) : OUTPUT_FILE,
@@ -247,7 +271,7 @@ async.eachLimit(files, 1, function (file, cb) {
        }
        if (ARGS.p != null) {
            if (P_RELATIVE) {
-                file = path.relative(path.dirname(ARGS.source_map), file);
+                file = path.relative(path.dirname(ARGS.source_map), file).replace(/\\/g, '/');
            } else {
                var p = parseInt(ARGS.p, 10);
                if (!isNaN(p)) {
@@ -255,6 +279,7 @@ async.eachLimit(files, 1, function (file, cb) {
                }
            }
        }
+        SOURCES_CONTENT[file] = code;
        time_it("parse", function(){
            if (ARGS.spidermonkey) {
                var program = JSON.parse(code);
@@ -271,9 +296,10 @@ async.eachLimit(files, 1, function (file, cb) {
            else {
                try {
                    TOPLEVEL = UglifyJS.parse(code, {
-                        filename   : file,
-                        toplevel   : TOPLEVEL,
-                        expression : ARGS.expr,
+                        filename     : file,
+                        toplevel     : TOPLEVEL,
+                        expression   : ARGS.expr,
+                        bare_returns : ARGS.bare_returns,
                    });
                } catch(ex) {
                    if (ex instanceof UglifyJS.JS_Parse_Error) {
@@ -337,6 +363,15 @@ async.eachLimit(files, 1, function (file, cb) {
    if (MANGLE) time_it("mangle", function(){
        TOPLEVEL.mangle_names(MANGLE);
    });
+
+    if (ARGS.source_map_include_sources) {
+        for (var file in SOURCES_CONTENT) {
+            if (SOURCES_CONTENT.hasOwnProperty(file)) {
+                SOURCE_MAP.get().setSourceContent(file, SOURCES_CONTENT[file]);
+            }
+        }
+    }
+
    time_it("generate", function(){
        TOPLEVEL.print(output);
    });
@@ -357,7 +392,6 @@ async.eachLimit(files, 1, function (file, cb) {
        fs.writeFileSync(OUTPUT_FILE, output, "utf8");
    } else {
        sys.print(output);
-        sys.error("\n");
    }

    if (ARGS.stats) {
--- a/lib/ast.js
+++ b/lib/ast.js
@@ -84,7 +84,7 @@ function DEFNODE(type, props, methods, base) {
    return ctor;
 };

-var AST_Token = DEFNODE("Token", "type value line col pos endpos nlb comments_before file", {
+var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before file", {
 }, null);

 var AST_Node = DEFNODE("Node", "start end", {
@@ -120,11 +120,12 @@ var AST_Debugger = DEFNODE("Debugger", null, {
    $documentation: "Represents a debugger statement",
 }, AST_Statement);

-var AST_Directive = DEFNODE("Directive", "value scope", {
+var AST_Directive = DEFNODE("Directive", "value scope quote", {
    $documentation: "Represents a directive, like \"use strict\";",
    $propdoc: {
        value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
-        scope: "[AST_Scope/S] The scope that this directive affects"
+        scope: "[AST_Scope/S] The scope that this directive affects",
+        quote: "[string] the original quote character"
    },
 }, AST_Statement);

@@ -205,21 +206,27 @@ var AST_DWLoop = DEFNODE("DWLoop", "condition", {
    $documentation: "Base class for do/while statements",
    $propdoc: {
        condition: "[AST_Node] the loop condition.  Should not be instanceof AST_Statement"
-    },
+    }
+}, AST_IterationStatement);
+
+var AST_Do = DEFNODE("Do", null, {
+    $documentation: "A `do` statement",
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.body._walk(visitor);
+            this.condition._walk(visitor);
+        });
+    }
+}, AST_DWLoop);
+
+var AST_While = DEFNODE("While", null, {
+    $documentation: "A `while` statement",
    _walk: function(visitor) {
        return visitor._visit(this, function(){
            this.condition._walk(visitor);
            this.body._walk(visitor);
        });
    }
-}, AST_IterationStatement);
-
-var AST_Do = DEFNODE("Do", null, {
-    $documentation: "A `do` statement",
-}, AST_DWLoop);
-
-var AST_While = DEFNODE("While", null, {
-    $documentation: "A `while` statement",
 }, AST_DWLoop);

 var AST_For = DEFNODE("For", "init condition step", {
@@ -295,10 +302,10 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
        var parameters = [];

        arg_parameter_pairs.forEach(function(pair) {
-            var split = pair.split(":");
+            var splitAt = pair.lastIndexOf(":");

-            args.push(split[0]);
-            parameters.push(split[1]);
+            args.push(pair.substr(0, splitAt));
+            parameters.push(pair.substr(splitAt + 1));
        });

        var wrapped_tl = "(function(" + parameters.join(",") + "){ '$ORIG'; })(" + args.join(",") + ")";
@@ -760,8 +767,11 @@ var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
    }
 });

-var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", null, {
+var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", {
    $documentation: "A key: value object property",
+    $propdoc: {
+        quote: "[string] the original quote character"
+    }
 }, AST_ObjectProperty);

 var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
@@ -846,10 +856,11 @@ var AST_Constant = DEFNODE("Constant", null, {
    }
 });

-var AST_String = DEFNODE("String", "value", {
+var AST_String = DEFNODE("String", "value quote", {
    $documentation: "A string literal",
    $propdoc: {
-        value: "[string] the contents of this string"
+        value: "[string] the contents of this string",
+        quote: "[string] the original quote character"
    }
 }, AST_Constant);

--- a/lib/compress.js
+++ b/lib/compress.js
@@ -61,6 +61,8 @@ function Compressor(options, false_by_default) {
        loops         : !false_by_default,
        unused        : !false_by_default,
        hoist_funs    : !false_by_default,
+        keep_fargs    : false,
+        keep_fnames   : false,
        hoist_vars    : false,
        if_return     : !false_by_default,
        join_vars     : !false_by_default,
@@ -71,6 +73,7 @@ function Compressor(options, false_by_default) {
        negate_iife   : !false_by_default,
        screw_ie8     : false,
        drop_console  : false,
+        angular       : false,

        warnings      : true,
        global_defs   : {}
@@ -160,10 +163,10 @@ merge(Compressor.prototype, {
            return make_node(AST_Undefined, orig).optimize(compressor);
          default:
            if (val === null) {
-                return make_node(AST_Null, orig).optimize(compressor);
+                return make_node(AST_Null, orig, { value: null }).optimize(compressor);
            }
            if (val instanceof RegExp) {
-                return make_node(AST_RegExp, orig).optimize(compressor);
+                return make_node(AST_RegExp, orig, { value: val }).optimize(compressor);
            }
            throw new Error(string_template("Can't handle constant of type: {type}", {
                type: typeof val
@@ -198,6 +201,9 @@ merge(Compressor.prototype, {
        var CHANGED;
        do {
            CHANGED = false;
+            if (compressor.option("angular")) {
+                statements = process_for_angular(statements);
+            }
            statements = eliminate_spurious_blocks(statements);
            if (compressor.option("dead_code")) {
                statements = eliminate_dead_code(statements, compressor);
@@ -219,6 +225,80 @@ merge(Compressor.prototype, {

        return statements;

+        function process_for_angular(statements) {
+            function has_inject(comment) {
+                return /@ngInject/.test(comment.value);
+            }
+            function make_arguments_names_list(func) {
+                return func.argnames.map(function(sym){
+                    return make_node(AST_String, sym, { value: sym.name });
+                });
+            }
+            function make_array(orig, elements) {
+                return make_node(AST_Array, orig, { elements: elements });
+            }
+            function make_injector(func, name) {
+                return make_node(AST_SimpleStatement, func, {
+                    body: make_node(AST_Assign, func, {
+                        operator: "=",
+                        left: make_node(AST_Dot, name, {
+                            expression: make_node(AST_SymbolRef, name, name),
+                            property: "$inject"
+                        }),
+                        right: make_array(func, make_arguments_names_list(func))
+                    })
+                });
+            }
+            function check_expression(body) {
+                if (body && body.args) {
+                    // if this is a function call check all of arguments passed
+                    body.args.forEach(function(argument, index, array) {
+                        var comments = argument.start.comments_before;
+                        // if the argument is function preceded by @ngInject
+                        if (argument instanceof AST_Lambda && comments.length && has_inject(comments[0])) {
+                            // replace the function with an array of names of its parameters and function at the end
+                            array[index] = make_array(argument, make_arguments_names_list(argument).concat(argument));
+                        }
+                    });
+                    // if this is chained call check previous one recursively
+                    if (body.expression && body.expression.expression) {
+                        check_expression(body.expression.expression);
+                    }
+                }
+            }
+            return statements.reduce(function(a, stat){
+                a.push(stat);
+
+                if (stat.body && stat.body.args) {
+                    check_expression(stat.body);
+                } else {
+                    var token = stat.start;
+                    var comments = token.comments_before;
+                    if (comments && comments.length > 0) {
+                        var last = comments.pop();
+                        if (has_inject(last)) {
+                            // case 1: defun
+                            if (stat instanceof AST_Defun) {
+                                a.push(make_injector(stat, stat.name));
+                            }
+                            else if (stat instanceof AST_Definitions) {
+                                stat.definitions.forEach(function(def) {
+                                    if (def.value && def.value instanceof AST_Lambda) {
+                                        a.push(make_injector(def.value, def.name));
+                                    }
+                                });
+                            }
+                            else {
+                                compressor.warn("Unknown statement marked with @ngInject [{file}:{line},{col}]", token);
+                            }
+                        }
+                    }
+                }
+
+                return a;
+            }, []);
+        }
+
        function eliminate_spurious_blocks(statements) {
            var seen_dirs = [];
            return statements.reduce(function(a, stat){
@@ -328,7 +408,7 @@ merge(Compressor.prototype, {
                        stat = stat.clone();
                        stat.condition = stat.condition.negate(compressor);
                        stat.body = make_node(AST_BlockStatement, stat, {
-                            body: ret
+                            body: as_statement_array(stat.alternative).concat(ret)
                        });
                        stat.alternative = make_node(AST_BlockStatement, stat, {
                            body: body
@@ -726,6 +806,14 @@ merge(Compressor.prototype, {
            if (d && d.constant && d.init) return ev(d.init, compressor);
            throw def;
        });
+        def(AST_Dot, function(compressor){
+            if (compressor.option("unsafe") && this.property == "length") {
+                var str = ev(this.expression, compressor);
+                if (typeof str == "string")
+                    return str.length;
+            }
+            throw def;
+        });
    })(function(node, func){
        node.DEFMETHOD("_eval", func);
    });
@@ -840,7 +928,9 @@ merge(Compressor.prototype, {
                || this.operator == "--"
                || this.expression.has_side_effects(compressor);
        });
-        def(AST_SymbolRef, function(compressor){ return false });
+        def(AST_SymbolRef, function(compressor){
+            return this.global() && this.undeclared();
+        });
        def(AST_Object, function(compressor){
            for (var i = this.properties.length; --i >= 0;)
                if (this.properties[i].has_side_effects(compressor))
@@ -890,7 +980,7 @@ merge(Compressor.prototype, {
        def(AST_BlockStatement, block_aborts);
        def(AST_SwitchBranch, block_aborts);
        def(AST_If, function(){
-            return this.alternative && aborts(this.body) && aborts(this.alternative);
+            return this.alternative && aborts(this.body) && aborts(this.alternative) && this;
        });
    })(function(node, func){
        node.DEFMETHOD("aborts", func);
@@ -996,18 +1086,20 @@ merge(Compressor.prototype, {
            var tt = new TreeTransformer(
                function before(node, descend, in_list) {
                    if (node instanceof AST_Lambda && !(node instanceof AST_Accessor)) {
-                        for (var a = node.argnames, i = a.length; --i >= 0;) {
-                            var sym = a[i];
-                            if (sym.unreferenced()) {
-                                a.pop();
-                                compressor.warn("Dropping unused function argument {name} [{file}:{line},{col}]", {
-                                    name : sym.name,
-                                    file : sym.start.file,
-                                    line : sym.start.line,
-                                    col  : sym.start.col
-                                });
+                        if (!compressor.option("keep_fargs")) {
+                            for (var a = node.argnames, i = a.length; --i >= 0;) {
+                                var sym = a[i];
+                                if (sym.unreferenced()) {
+                                    a.pop();
+                                    compressor.warn("Dropping unused function argument {name} [{file}:{line},{col}]", {
+                                        name : sym.name,
+                                        file : sym.start.file,
+                                        line : sym.start.line,
+                                        col  : sym.start.col
+                                    });
+                                }
+                                else break;
                            }
-                            else break;
                        }
                    }
                    if (node instanceof AST_Defun && node !== self) {
@@ -1605,7 +1697,7 @@ merge(Compressor.prototype, {

    OPT(AST_Function, function(self, compressor){
        self = AST_Lambda.prototype.optimize.call(self, compressor);
-        if (compressor.option("unused")) {
+        if (compressor.option("unused") && !compressor.option("keep_fnames")) {
            if (self.name && self.name.unreferenced()) {
                self.name = null;
            }
@@ -1661,6 +1753,11 @@ merge(Compressor.prototype, {
                    }).transform(compressor);
                    break;
                  case "Function":
+                    // new Function() => function(){}
+                    if (self.args.length == 0) return make_node(AST_Function, self, {
+                        argnames: [],
+                        body: []
+                    });
                    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
@@ -1686,6 +1783,7 @@ merge(Compressor.prototype, {
                            } catch(ex) {
                                if (ex !== ast) throw ex;
                            };
+                            if (!fun) return self;
                            var args = fun.argnames.map(function(arg, i){
                                return make_node(AST_String, self.args[i], {
                                    value: arg.print_to_string()
@@ -1775,11 +1873,16 @@ merge(Compressor.prototype, {
            }
        }
        if (compressor.option("drop_console")) {
-            if (self.expression instanceof AST_PropAccess &&
-                self.expression.expression instanceof AST_SymbolRef &&
-                self.expression.expression.name == "console" &&
-                self.expression.expression.undeclared()) {
-                return make_node(AST_Undefined, self).transform(compressor);
+            if (self.expression instanceof AST_PropAccess) {
+                var name = self.expression.expression;
+                while (name.expression) {
+                    name = name.expression;
+                }
+                if (name instanceof AST_SymbolRef
+                    && name.name == "console"
+                    && name.undeclared()) {
+                    return make_node(AST_Undefined, self).transform(compressor);
+                }
            }
        }
        return self.evaluate(compressor)[0];
@@ -1836,6 +1939,18 @@ merge(Compressor.prototype, {
                return self.car;
            }
        }
+        if (self.cdr instanceof AST_UnaryPrefix
+            && self.cdr.operator == "void"
+            && !self.cdr.expression.has_side_effects(compressor)) {
+            self.cdr.expression = self.car;
+            return self.cdr;
+        }
+        if (self.cdr instanceof AST_Undefined) {
+            return make_node(AST_UnaryPrefix, self, {
+                operator   : "void",
+                expression : self.car
+            });
+        }
        return self;
    });

@@ -1995,6 +2110,12 @@ merge(Compressor.prototype, {
            var rr = self.right.evaluate(compressor);
            if ((ll.length > 1 && !ll[1]) || (rr.length > 1 && !rr[1])) {
                compressor.warn("Boolean && always false [{file}:{line},{col}]", self.start);
+                if (self.left.has_side_effects(compressor)) {
+                    return make_node(AST_Seq, self, {
+                        car: self.left,
+                        cdr: make_node(AST_False)
+                    }).optimize(compressor);
+                }
                return make_node(AST_False, self);
            }
            if (ll.length > 1 && ll[1]) {
@@ -2009,6 +2130,12 @@ merge(Compressor.prototype, {
            var rr = self.right.evaluate(compressor);
            if ((ll.length > 1 && ll[1]) || (rr.length > 1 && rr[1])) {
                compressor.warn("Boolean || always true [{file}:{line},{col}]", self.start);
+                if (self.left.has_side_effects(compressor)) {
+                    return make_node(AST_Seq, self, {
+                        car: self.left,
+                        cdr: make_node(AST_True)
+                    }).optimize(compressor);
+                }
                return make_node(AST_True, self);
            }
            if (ll.length > 1 && !ll[1]) {
@@ -2129,14 +2256,30 @@ merge(Compressor.prototype, {
              case "undefined":
                return make_node(AST_Undefined, self);
              case "NaN":
-                return make_node(AST_NaN, self);
+                return make_node(AST_NaN, self).transform(compressor);
              case "Infinity":
-                return make_node(AST_Infinity, self);
+                return make_node(AST_Infinity, self).transform(compressor);
            }
        }
        return self;
    });

+    OPT(AST_Infinity, function (self, compressor) {
+        return make_node(AST_Binary, self, {
+            operator : '/',
+            left     : make_node(AST_Number, null, {value: 1}),
+            right    : make_node(AST_Number, null, {value: 0})
+        });
+    });
+
+    OPT(AST_NaN, function (self, compressor) {
+        return make_node(AST_Binary, self, {
+            operator : '/',
+            left     : make_node(AST_Number, null, {value: 0}),
+            right    : make_node(AST_Number, null, {value: 0})
+        });
+    });
+
    OPT(AST_Undefined, function(self, compressor){
        if (compressor.option("unsafe")) {
            var scope = compressor.find_parent(AST_Scope);
@@ -2207,7 +2350,7 @@ merge(Compressor.prototype, {
             * ==>
             * exp = foo ? something : something_else;
             */
-            self = make_node(AST_Assign, self, {
+            return make_node(AST_Assign, self, {
                operator: consequent.operator,
                left: consequent.left,
                right: make_node(AST_Conditional, self, {
@@ -2217,6 +2360,63 @@ merge(Compressor.prototype, {
                })
            });
        }
+        if (consequent instanceof AST_Call
+            && alternative.TYPE === consequent.TYPE
+            && consequent.args.length == alternative.args.length
+            && consequent.expression.equivalent_to(alternative.expression)) {
+            if (consequent.args.length == 0) {
+                return make_node(AST_Seq, self, {
+                    car: self.condition,
+                    cdr: consequent
+                });
+            }
+            if (consequent.args.length == 1) {
+                consequent.args[0] = make_node(AST_Conditional, self, {
+                    condition: self.condition,
+                    consequent: consequent.args[0],
+                    alternative: alternative.args[0]
+                });
+                return consequent;
+            }
+        }
+        // x?y?z:a:a --> x&&y?z:a
+        if (consequent instanceof AST_Conditional
+            && consequent.alternative.equivalent_to(alternative)) {
+            return make_node(AST_Conditional, self, {
+                condition: make_node(AST_Binary, self, {
+                    left: self.condition,
+                    operator: "&&",
+                    right: consequent.condition
+                }),
+                consequent: consequent.consequent,
+                alternative: alternative
+            });
+        }
+        // x=y?1:1 --> x=1
+        if (consequent instanceof AST_Constant
+            && alternative instanceof AST_Constant
+            && consequent.equivalent_to(alternative)) {
+            if (self.condition.has_side_effects(compressor)) {
+                return AST_Seq.from_array([self.condition, make_node_from_constant(compressor, consequent.value, self)]);
+            } else {
+                return make_node_from_constant(compressor, consequent.value, self);
+
+            }
+        }
+        // x=y?true:false --> x=!!y
+        if (consequent instanceof AST_True
+            && alternative instanceof AST_False) {
+            self.condition = self.condition.negate(compressor);
+            return make_node(AST_UnaryPrefix, self.condition, {
+                operator: "!",
+                expression: self.condition
+            });
+        }
+        // x=y?false:true --> x=!y
+        if (consequent instanceof AST_False
+            && alternative instanceof AST_True) {
+            return self.condition.negate(compressor)
+        }
        return self;
    });

@@ -2254,12 +2454,31 @@ merge(Compressor.prototype, {
                return make_node(AST_Dot, self, {
                    expression : self.expression,
                    property   : prop
+                }).optimize(compressor);
+            }
+            var v = parseFloat(prop);
+            if (!isNaN(v) && v.toString() == prop) {
+                self.property = make_node(AST_Number, self.property, {
+                    value: v
                });
            }
        }
        return self;
    });

+    OPT(AST_Dot, function(self, compressor){
+        var prop = self.property;
+        if (RESERVED_WORDS(prop) && !compressor.option("screw_ie8")) {
+            return make_node(AST_Sub, self, {
+                expression : self.expression,
+                property   : make_node(AST_String, self, {
+                    value: prop
+                })
+            }).optimize(compressor);
+        }
+        return self.evaluate(compressor)[0];
+    });
+
    function literals_in_boolean_context(self, compressor) {
        if (compressor.option("booleans") && compressor.in_boolean_context()) {
            return make_node(AST_True, self);
--- a/lib/mozilla-ast.js
+++ b/lib/mozilla-ast.js
@@ -46,53 +46,68 @@
 (function(){

    var MOZ_TO_ME = {
-        TryStatement : function(M) {
+        ExpressionStatement: function(M) {
+            var expr = M.expression;
+            if (expr.type === "Literal" && typeof expr.value === "string") {
+                return new AST_Directive({
+                    start: my_start_token(M),
+                    end: my_end_token(M),
+                    value: expr.value
+                });
+            }
+            return new AST_SimpleStatement({
+                start: my_start_token(M),
+                end: my_end_token(M),
+                body: from_moz(expr)
+            });
+        },
+        TryStatement: function(M) {
+            var handlers = M.handlers || [M.handler];
+            if (handlers.length > 1 || M.guardedHandlers && M.guardedHandlers.length) {
+                throw new Error("Multiple catch clauses are not supported.");
+            }
            return new AST_Try({
                start    : my_start_token(M),
                end      : my_end_token(M),
                body     : from_moz(M.block).body,
-                bcatch   : from_moz(M.handlers[0]),
+                bcatch   : from_moz(handlers[0]),
                bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null
            });
        },
-        CatchClause : function(M) {
-            return new AST_Catch({
-                start   : my_start_token(M),
-                end     : my_end_token(M),
-                argname : from_moz(M.param),
-                body    : from_moz(M.body).body
-            });
+        Property: function(M) {
+            var key = M.key;
+            var name = key.type == "Identifier" ? key.name : key.value;
+            var args = {
+                start    : my_start_token(key),
+                end      : my_end_token(M.value),
+                key      : name,
+                value    : from_moz(M.value)
+            };
+            switch (M.kind) {
+              case "init":
+                return new AST_ObjectKeyVal(args);
+              case "set":
+                args.value.name = from_moz(key);
+                return new AST_ObjectSetter(args);
+              case "get":
+                args.value.name = from_moz(key);
+                return new AST_ObjectGetter(args);
+            }
        },
-        ObjectExpression : function(M) {
+        ObjectExpression: function(M) {
            return new AST_Object({
                start      : my_start_token(M),
                end        : my_end_token(M),
                properties : M.properties.map(function(prop){
-                    var key = prop.key;
-                    var name = key.type == "Identifier" ? key.name : key.value;
-                    var args = {
-                        start    : my_start_token(key),
-                        end      : my_end_token(prop.value),
-                        key      : name,
-                        value    : from_moz(prop.value)
-                    };
-                    switch (prop.kind) {
-                      case "init":
-                        return new AST_ObjectKeyVal(args);
-                      case "set":
-                        args.value.name = from_moz(key);
-                        return new AST_ObjectSetter(args);
-                      case "get":
-                        args.value.name = from_moz(key);
-                        return new AST_ObjectGetter(args);
-                    }
+                    prop.type = "Property";
+                    return from_moz(prop)
                })
            });
        },
-        SequenceExpression : function(M) {
+        SequenceExpression: function(M) {
            return AST_Seq.from_array(M.expressions.map(from_moz));
        },
-        MemberExpression : function(M) {
+        MemberExpression: function(M) {
            return new (M.computed ? AST_Sub : AST_Dot)({
                start      : my_start_token(M),
                end        : my_end_token(M),
@@ -100,7 +115,7 @@
                expression : from_moz(M.object)
            });
        },
-        SwitchCase : function(M) {
+        SwitchCase: function(M) {
            return new (M.test ? AST_Case : AST_Default)({
                start      : my_start_token(M),
                end        : my_end_token(M),
@@ -108,7 +123,14 @@
                body       : M.consequent.map(from_moz)
            });
        },
-        Literal : function(M) {
+        VariableDeclaration: function(M) {
+            return new (M.kind === "const" ? AST_Const : AST_Var)({
+                start       : my_start_token(M),
+                end         : my_end_token(M),
+                definitions : M.declarations.map(from_moz)
+            });
+        },
+        Literal: function(M) {
            var val = M.value, args = {
                start  : my_start_token(M),
                end    : my_end_token(M)
@@ -128,12 +150,9 @@
                return new AST_RegExp(args);
            }
        },
-        UnaryExpression: From_Moz_Unary,
-        UpdateExpression: From_Moz_Unary,
        Identifier: function(M) {
            var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
-            return new (M.name == "this" ? AST_This
-                        : p.type == "LabeledStatement" ? AST_Label
+            return new (  p.type == "LabeledStatement" ? AST_Label
                        : p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : AST_SymbolVar)
                        : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
                        : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
@@ -147,7 +166,8 @@
        }
    };

-    function From_Moz_Unary(M) {
+    MOZ_TO_ME.UpdateExpression =
+    MOZ_TO_ME.UnaryExpression = function To_Moz_Unary(M) {
        var prefix = "prefix" in M ? M.prefix
            : M.type == "UnaryExpression" ? true : false;
        return new (prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({
@@ -158,14 +178,9 @@
        });
    };

-    var ME_TO_MOZ = {};
-
-    map("Node", AST_Node);
    map("Program", AST_Toplevel, "body@body");
-    map("Function", AST_Function, "id>name, params@argnames, body%body");
    map("EmptyStatement", AST_EmptyStatement);
    map("BlockStatement", AST_BlockStatement, "body@body");
-    map("ExpressionStatement", AST_SimpleStatement, "expression>body");
    map("IfStatement", AST_If, "test>condition, consequent>body, alternate>alternative");
    map("LabeledStatement", AST_LabeledStatement, "label>label, body>body");
    map("BreakStatement", AST_Break, "label>label");
@@ -180,71 +195,261 @@
    map("ForInStatement", AST_ForIn, "left>init, right>object, body>body");
    map("DebuggerStatement", AST_Debugger);
    map("FunctionDeclaration", AST_Defun, "id>name, params@argnames, body%body");
-    map("VariableDeclaration", AST_Var, "declarations@definitions");
    map("VariableDeclarator", AST_VarDef, "id>name, init>value");
+    map("CatchClause", AST_Catch, "param>argname, body%body");

    map("ThisExpression", AST_This);
    map("ArrayExpression", AST_Array, "elements@elements");
    map("FunctionExpression", AST_Function, "id>name, params@argnames, body%body");
    map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right");
-    map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
    map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right");
+    map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
    map("ConditionalExpression", AST_Conditional, "test>condition, consequent>consequent, alternate>alternative");
    map("NewExpression", AST_New, "callee>expression, arguments@args");
    map("CallExpression", AST_Call, "callee>expression, arguments@args");

+    def_to_moz(AST_Directive, function To_Moz_Directive(M) {
+        return {
+            type: "ExpressionStatement",
+            expression: {
+                type: "Literal",
+                value: M.value
+            }
+        };
+    });
+
+    def_to_moz(AST_SimpleStatement, function To_Moz_ExpressionStatement(M) {
+        return {
+            type: "ExpressionStatement",
+            expression: to_moz(M.body)
+        };
+    });
+
+    def_to_moz(AST_SwitchBranch, function To_Moz_SwitchCase(M) {
+        return {
+            type: "SwitchCase",
+            test: to_moz(M.expression),
+            consequent: M.body.map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_Try, function To_Moz_TryStatement(M) {
+        return {
+            type: "TryStatement",
+            block: to_moz_block(M),
+            handler: to_moz(M.bcatch),
+            guardedHandlers: [],
+            finalizer: to_moz(M.bfinally)
+        };
+    });
+
+    def_to_moz(AST_Catch, function To_Moz_CatchClause(M) {
+        return {
+            type: "CatchClause",
+            param: to_moz(M.argname),
+            guard: null,
+            body: to_moz_block(M)
+        };
+    });
+
+    def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
+        return {
+            type: "VariableDeclaration",
+            kind: M instanceof AST_Const ? "const" : "var",
+            declarations: M.definitions.map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_Seq, function To_Moz_SequenceExpression(M) {
+        return {
+            type: "SequenceExpression",
+            expressions: M.to_array().map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) {
+        var isComputed = M instanceof AST_Sub;
+        return {
+            type: "MemberExpression",
+            object: to_moz(M.expression),
+            computed: isComputed,
+            property: isComputed ? to_moz(M.property) : {type: "Identifier", name: M.property}
+        };
+    });
+
+    def_to_moz(AST_Unary, function To_Moz_Unary(M) {
+        return {
+            type: M.operator == "++" || M.operator == "--" ? "UpdateExpression" : "UnaryExpression",
+            operator: M.operator,
+            prefix: M instanceof AST_UnaryPrefix,
+            argument: to_moz(M.expression)
+        };
+    });
+
+    def_to_moz(AST_Binary, function To_Moz_BinaryExpression(M) {
+        return {
+            type: M.operator == "&&" || M.operator == "||" ? "LogicalExpression" : "BinaryExpression",
+            left: to_moz(M.left),
+            operator: M.operator,
+            right: to_moz(M.right)
+        };
+    });
+
+    def_to_moz(AST_Object, function To_Moz_ObjectExpression(M) {
+        return {
+            type: "ObjectExpression",
+            properties: M.properties.map(to_moz)
+        };
+    });
+
+    def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
+        var key = (
+            is_identifier(M.key)
+            ? {type: "Identifier", name: M.key}
+            : {type: "Literal", value: M.key}
+        );
+        var kind;
+        if (M instanceof AST_ObjectKeyVal) {
+            kind = "init";
+        } else
+        if (M instanceof AST_ObjectGetter) {
+            kind = "get";
+        } else
+        if (M instanceof AST_ObjectSetter) {
+            kind = "set";
+        }
+        return {
+            type: "Property",
+            kind: kind,
+            key: key,
+            value: to_moz(M.value)
+        };
+    });
+
+    def_to_moz(AST_Symbol, function To_Moz_Identifier(M) {
+        var def = M.definition();
+        return {
+            type: "Identifier",
+            name: def ? def.mangled_name || def.name : M.name
+        };
+    });
+
+    def_to_moz(AST_Constant, function To_Moz_Literal(M) {
+        var value = M.value;
+        if (typeof value === 'number' && (value < 0 || (value === 0 && 1 / value < 0))) {
+            return {
+                type: "UnaryExpression",
+                operator: "-",
+                prefix: true,
+                argument: {
+                    type: "Literal",
+                    value: -value
+                }
+            };
+        }
+        return {
+            type: "Literal",
+            value: value
+        };
+    });
+
+    def_to_moz(AST_Atom, function To_Moz_Atom(M) {
+        return {
+            type: "Identifier",
+            name: String(M.value)
+        };
+    });
+
+    AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
+    AST_Null.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
+    AST_Hole.DEFMETHOD("to_mozilla_ast", function To_Moz_ArrayHole() { return null });
+
+    AST_Block.DEFMETHOD("to_mozilla_ast", AST_BlockStatement.prototype.to_mozilla_ast);
+    AST_Lambda.DEFMETHOD("to_mozilla_ast", AST_Function.prototype.to_mozilla_ast);
+
    /* -----[ tools ]----- */

    function my_start_token(moznode) {
+        var loc = moznode.loc, start = loc && loc.start;
+        var range = moznode.range;
        return new AST_Token({
-            file   : moznode.loc && moznode.loc.source,
-            line   : moznode.loc && moznode.loc.start.line,
-            col    : moznode.loc && moznode.loc.start.column,
-            pos    : moznode.start,
-            endpos : moznode.start
+            file    : loc && loc.source,
+            line    : start && start.line,
+            col     : start && start.column,
+            pos     : range ? range[0] : moznode.start,
+            endline : start && start.line,
+            endcol  : start && start.column,
+            endpos  : range ? range[0] : moznode.start
        });
    };

    function my_end_token(moznode) {
+        var loc = moznode.loc, end = loc && loc.end;
+        var range = moznode.range;
        return new AST_Token({
-            file   : moznode.loc && moznode.loc.source,
-            line   : moznode.loc && moznode.loc.end.line,
-            col    : moznode.loc && moznode.loc.end.column,
-            pos    : moznode.end,
-            endpos : moznode.end
+            file    : loc && loc.source,
+            line    : end && end.line,
+            col     : end && end.column,
+            pos     : range ? range[1] : moznode.end,
+            endline : end && end.line,
+            endcol  : end && end.column,
+            endpos  : range ? range[1] : moznode.end
        });
    };

    function map(moztype, mytype, propmap) {
        var moz_to_me = "function From_Moz_" + moztype + "(M){\n";
-        moz_to_me += "return new mytype({\n" +
+        moz_to_me += "return new " + mytype.name + "({\n" +
            "start: my_start_token(M),\n" +
            "end: my_end_token(M)";

+        var me_to_moz = "function To_Moz_" + moztype + "(M){\n";
+        me_to_moz += "return {\n" +
+            "type: " + JSON.stringify(moztype);
+
        if (propmap) propmap.split(/\s*,\s*/).forEach(function(prop){
            var m = /([a-z0-9$_]+)(=|@|>|%)([a-z0-9$_]+)/i.exec(prop);
            if (!m) throw new Error("Can't understand property map: " + prop);
-            var moz = "M." + m[1], how = m[2], my = m[3];
+            var moz = m[1], how = m[2], my = m[3];
            moz_to_me += ",\n" + my + ": ";
-            if (how == "@") {
-                moz_to_me += moz + ".map(from_moz)";
-            } else if (how == ">") {
-                moz_to_me += "from_moz(" + moz + ")";
-            } else if (how == "=") {
-                moz_to_me += moz;
-            } else if (how == "%") {
-                moz_to_me += "from_moz(" + moz + ").body";
-            } else throw new Error("Can't understand operator in propmap: " + prop);
+            me_to_moz += ",\n" + moz + ": ";
+            switch (how) {
+                case "@":
+                    moz_to_me += "M." + moz + ".map(from_moz)";
+                    me_to_moz += "M." +  my + ".map(to_moz)";
+                    break;
+                case ">":
+                    moz_to_me += "from_moz(M." + moz + ")";
+                    me_to_moz += "to_moz(M." + my + ")";
+                    break;
+                case "=":
+                    moz_to_me += "M." + moz;
+                    me_to_moz += "M." + my;
+                    break;
+                case "%":
+                    moz_to_me += "from_moz(M." + moz + ").body";
+                    me_to_moz += "to_moz_block(M)";
+                    break;
+                default:
+                    throw new Error("Can't understand operator in propmap: " + prop);
+            }
        });
-        moz_to_me += "\n})}";

-        // moz_to_me = parse(moz_to_me).print_to_string({ beautify: true });
-        // console.log(moz_to_me);
+        moz_to_me += "\n})\n}";
+        me_to_moz += "\n}\n}";

-        moz_to_me = new Function("mytype", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
-            mytype, my_start_token, my_end_token, from_moz
+        //moz_to_me = parse(moz_to_me).print_to_string({ beautify: true });
+        //me_to_moz = parse(me_to_moz).print_to_string({ beautify: true });
+        //console.log(moz_to_me);
+
+        moz_to_me = new Function("my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
+            my_start_token, my_end_token, from_moz
        );
-        return MOZ_TO_ME[moztype] = moz_to_me;
+        me_to_moz = new Function("to_moz", "to_moz_block", "return(" + me_to_moz + ")")(
+            to_moz, to_moz_block
+        );
+        MOZ_TO_ME[moztype] = moz_to_me;
+        def_to_moz(mytype, me_to_moz);
    };

    var FROM_MOZ_STACK = null;
@@ -264,4 +469,39 @@
        return ast;
    };

+    function set_moz_loc(mynode, moznode, myparent) {
+        var start = mynode.start;
+        var end = mynode.end;
+        if (start.pos != null && end.endpos != null) {
+            moznode.range = [start.pos, end.endpos];
+        }
+        if (start.line) {
+            moznode.loc = {
+                start: {line: start.line, column: start.col},
+                end: end.endline ? {line: end.endline, column: end.endcol} : null
+            };
+            if (start.file) {
+                moznode.loc.source = start.file;
+            }
+        }
+        return moznode;
+    };
+
+    function def_to_moz(mytype, handler) {
+        mytype.DEFMETHOD("to_mozilla_ast", function() {
+            return set_moz_loc(this, handler(this));
+        });
+    };
+
+    function to_moz(node) {
+        return node != null ? node.to_mozilla_ast() : null;
+    };
+
+    function to_moz_block(node) {
+        return {
+            type: "BlockStatement",
+            body: node.body.map(to_moz)
+        };
+    };
+
 })();
--- a/lib/output.js
+++ b/lib/output.js
@@ -46,22 +46,24 @@
 function OutputStream(options) {

    options = defaults(options, {
-        indent_start  : 0,
-        indent_level  : 4,
-        quote_keys    : false,
-        space_colon   : true,
-        ascii_only    : false,
-        inline_script : false,
-        width         : 80,
-        max_line_len  : 32000,
-        beautify      : false,
-        source_map    : null,
-        bracketize    : false,
-        semicolons    : true,
-        comments      : false,
-        preserve_line : false,
-        screw_ie8     : false,
-        preamble      : null,
+        indent_start     : 0,
+        indent_level     : 4,
+        quote_keys       : false,
+        space_colon      : true,
+        ascii_only       : false,
+        unescape_regexps : false,
+        inline_script    : false,
+        width            : 80,
+        max_line_len     : 32000,
+        beautify         : false,
+        source_map       : null,
+        bracketize       : false,
+        semicolons       : true,
+        comments         : false,
+        preserve_line    : false,
+        screw_ie8        : false,
+        preamble         : null,
+        quote_style      : 0
    }, true);

    var indentation = 0;
@@ -83,9 +85,9 @@ function OutputStream(options) {
        });
    };

-    function make_string(str) {
+    function make_string(str, quote) {
        var dq = 0, sq = 0;
-        str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029\0]/g, function(s){
+        str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029\0\ufeff]/g, function(s){
            switch (s) {
              case "\\": return "\\\\";
              case "\b": return "\\b";
@@ -97,16 +99,31 @@ function OutputStream(options) {
              case '"': ++dq; return '"';
              case "'": ++sq; return "'";
              case "\0": return "\\x00";
+              case "\ufeff": return "\\ufeff";
            }
            return s;
        });
+        function quote_single() {
+            return "'" + str.replace(/\x27/g, "\\'") + "'";
+        }
+        function quote_double() {
+            return '"' + str.replace(/\x22/g, '\\"') + '"';
+        }
        if (options.ascii_only) str = to_ascii(str);
-        if (dq > sq) return "'" + str.replace(/\x27/g, "\\'") + "'";
-        else return '"' + str.replace(/\x22/g, '\\"') + '"';
+        switch (options.quote_style) {
+          case 1:
+            return quote_single();
+          case 2:
+            return quote_double();
+          case 3:
+            return quote == "'" ? quote_single() : quote_double();
+          default:
+            return dq > sq ? quote_single() : quote_double();
+        }
    };

-    function encode_string(str) {
-        var ret = make_string(str);
+    function encode_string(str, quote) {
+        var ret = make_string(str, quote);
        if (options.inline_script)
            ret = ret.replace(/<\x2fscript([>\/\t\n\f\r ])/gi, "<\\/script$1");
        return ret;
@@ -220,7 +237,7 @@ function OutputStream(options) {

    var newline = options.beautify ? function() {
        print("\n");
-    } : noop;
+    } : maybe_newline;

    var semicolon = options.beautify ? function() {
        print(";");
@@ -322,7 +339,7 @@ function OutputStream(options) {
        force_semicolon : force_semicolon,
        to_ascii        : to_ascii,
        print_name      : function(name) { print(make_name(name)) },
-        print_string    : function(str) { print(encode_string(str)) },
+        print_string    : function(str, quote) { print(encode_string(str, quote)) },
        next_indent     : next_indent,
        with_indent     : with_indent,
        with_block      : with_block,
@@ -386,13 +403,20 @@ function OutputStream(options) {
                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
-                    && self.value.start.comments_before.length > 0) {
-                    comments = comments.concat(self.value.start.comments_before);
-                    self.value.start.comments_before = [];
+                //               and https://github.com/mishoo/UglifyJS2/issues/372
+                if (self instanceof AST_Exit && self.value) {
+                    self.value.walk(new TreeWalker(function(node){
+                        if (node.start && node.start.comments_before) {
+                            comments = comments.concat(node.start.comments_before);
+                            node.start.comments_before = [];
+                        }
+                        if (node instanceof AST_Function ||
+                            node instanceof AST_Array ||
+                            node instanceof AST_Object)
+                        {
+                            return true; // don't go inside.
+                        }
+                    }));
                }

                if (c.test) {
@@ -404,6 +428,15 @@ function OutputStream(options) {
                        return c(self, comment);
                    });
                }
+
+                // Keep single line comments after nlb, after nlb
+                if (!output.option("beautify") && comments.length > 0 &&
+                    /comment[134]/.test(comments[0].type) &&
+                    output.col() !== 0 && comments[0].nlb)
+                {
+                    output.print("\n");
+                }
+
                comments.forEach(function(c){
                    if (/comment[134]/.test(c.type)) {
                        output.print("//" + c.value + "\n");
@@ -426,7 +459,13 @@ function OutputStream(options) {
    /* -----[ PARENTHESES ]----- */

    function PARENS(nodetype, func) {
-        nodetype.DEFMETHOD("needs_parens", func);
+        if (Array.isArray(nodetype)) {
+            nodetype.forEach(function(nodetype){
+                PARENS(nodetype, func);
+            });
+        } else {
+            nodetype.DEFMETHOD("needs_parens", func);
+        }
    };

    PARENS(AST_Node, function(){
@@ -445,7 +484,7 @@ function OutputStream(options) {
        return first_in_statement(output);
    });

-    PARENS(AST_Unary, function(output){
+    PARENS([ AST_Unary, AST_Undefined ], function(output){
        var p = output.parent();
        return p instanceof AST_PropAccess && p.expression === this;
    });
@@ -456,7 +495,7 @@ function OutputStream(options) {
            || p instanceof AST_Unary            // !(foo, bar, baz)
            || p instanceof AST_Binary           // 1 + (2, 3) + 4 ==> 8
            || p instanceof AST_VarDef           // var a = (1, 2), b = a + a; ==> b == 4
-            || p instanceof AST_Dot              // (1, {foo:2}).foo ==> 2
+            || p instanceof AST_PropAccess       // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
            || p instanceof AST_Array            // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
            || p instanceof AST_ObjectProperty   // { foo: (1, 2) }.foo ==> 2
            || p instanceof AST_Conditional      /* (false, true) ? (a = 10, b = 20) : (c = 30)
@@ -535,13 +574,7 @@ function OutputStream(options) {
            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) {
+    PARENS([ AST_Assign, AST_Conditional ], function (output){
        var p = output.parent();
        // !(a = false) → true
        if (p instanceof AST_Unary)
@@ -558,15 +591,12 @@ function OutputStream(options) {
        // (a = foo)["prop"] —or— (a = foo).prop
        if (p instanceof AST_PropAccess && p.expression === this)
            return true;
-    };
-
-    PARENS(AST_Assign, assign_and_conditional_paren_rules);
-    PARENS(AST_Conditional, assign_and_conditional_paren_rules);
+    });

    /* -----[ PRINTERS ]----- */

    DEFPRINT(AST_Directive, function(self, output){
-        output.print_string(self.value);
+        output.print_string(self.value, self.quote);
        output.semicolon();
    });
    DEFPRINT(AST_Debugger, function(self, output){
@@ -648,7 +678,7 @@ function OutputStream(options) {
        output.print("for");
        output.space();
        output.with_parens(function(){
-            if (self.init) {
+            if (self.init && !(self.init instanceof AST_EmptyStatement)) {
                if (self.init instanceof AST_Definitions) {
                    self.init.print(output);
                } else {
@@ -988,8 +1018,12 @@ function OutputStream(options) {
    DEFPRINT(AST_UnaryPrefix, function(self, output){
        var op = self.operator;
        output.print(op);
-        if (/^[a-z]/i.test(op))
+        if (/^[a-z]/i.test(op)
+            || (/[+-]$/.test(op)
+                && self.expression instanceof AST_UnaryPrefix
+                && /^[+-]/.test(self.expression.operator))) {
            output.space();
+        }
        self.expression.print(output);
    });
    DEFPRINT(AST_UnaryPostfix, function(self, output){
@@ -1058,6 +1092,7 @@ function OutputStream(options) {
    });
    DEFPRINT(AST_ObjectKeyVal, function(self, output){
        var key = self.key;
+        var quote = self.quote;
        if (output.option("quote_keys")) {
            output.print_string(key + "");
        } else if ((typeof key == "number"
@@ -1068,7 +1103,7 @@ function OutputStream(options) {
        } else if (RESERVED_WORDS(key) ? output.option("screw_ie8") : is_identifier_string(key)) {
            output.print_name(key);
        } else {
-            output.print_string(key);
+            output.print_string(key, quote);
        }
        output.colon();
        self.value.print(output);
@@ -1094,10 +1129,10 @@ function OutputStream(options) {
    });
    DEFPRINT(AST_Hole, noop);
    DEFPRINT(AST_Infinity, function(self, output){
-        output.print("1/0");
+        output.print("Infinity");
    });
    DEFPRINT(AST_NaN, function(self, output){
-        output.print("0/0");
+        output.print("NaN");
    });
    DEFPRINT(AST_This, function(self, output){
        output.print("this");
@@ -1106,15 +1141,52 @@ function OutputStream(options) {
        output.print(self.getValue());
    });
    DEFPRINT(AST_String, function(self, output){
-        output.print_string(self.getValue());
+        output.print_string(self.getValue(), self.quote);
    });
    DEFPRINT(AST_Number, function(self, output){
        output.print(make_num(self.getValue()));
    });
+
+    function regexp_safe_literal(code) {
+        return [
+            0x5c   , // \
+            0x2f   , // /
+            0x2e   , // .
+            0x2b   , // +
+            0x2a   , // *
+            0x3f   , // ?
+            0x28   , // (
+            0x29   , // )
+            0x5b   , // [
+            0x5d   , // ]
+            0x7b   , // {
+            0x7d   , // }
+            0x24   , // $
+            0x5e   , // ^
+            0x3a   , // :
+            0x7c   , // |
+            0x21   , // !
+            0x0a   , // \n
+            0x0d   , // \r
+            0x00   , // \0
+            0xfeff , // Unicode BOM
+            0x2028 , // unicode "line separator"
+            0x2029 , // unicode "paragraph separator"
+        ].indexOf(code) < 0;
+    };
+
    DEFPRINT(AST_RegExp, function(self, output){
        var str = self.getValue().toString();
-        if (output.option("ascii_only"))
+        if (output.option("ascii_only")) {
            str = output.to_ascii(str);
+        } else if (output.option("unescape_regexps")) {
+            str = str.split("\\\\").map(function(str){
+                return str.replace(/\\u[0-9a-fA-F]{4}|\\x[0-9a-fA-F]{2}/g, function(s){
+                    var code = parseInt(s.substr(2), 16);
+                    return regexp_safe_literal(code) ? String.fromCharCode(code) : s;
+                });
+            }).join("\\\\");
+        }
        output.print(str);
        var p = output.parent();
        if (p instanceof AST_Binary && /^in/.test(p.operator) && p.left === self)
--- a/lib/parse.js
+++ b/lib/parse.js
@@ -46,7 +46,7 @@

 var KEYWORDS = 'break case catch const continue debugger default delete do else finally for function if in instanceof new return switch throw try typeof var void while with';
 var KEYWORDS_ATOM = 'false null true';
-var RESERVED_WORDS = 'abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized this throws transient volatile'
+var RESERVED_WORDS = 'abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized this throws transient volatile yield'
    + " " + KEYWORDS_ATOM + " " + KEYWORDS;
 var KEYWORDS_BEFORE_EXPRESSION = 'return new delete throw else case';

@@ -120,7 +120,8 @@ var REGEXP_MODIFIERS = makePredicate(characters("gmsiy"));

 // regexps adapted from http://xregexp.com/plugins/#unicode
 var UNICODE = {
-    letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971\\u0972\\u097B-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D3D\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC\\u0EDD\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8B\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10D0-\\u10FA\\u10FC\\u1100-\\u1159\\u115F-\\u11A2\\u11A8-\\u11F9\\u1200-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u1676\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19A9\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u2094\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2C6F\\u2C71-\\u2C7D\\u2C80-\\u2CE4\\u2D00-\\u2D25\\u2D30-\\u2D65\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31B7\\u31F0-\\u31FF\\u3400\\u4DB5\\u4E00\\u9FC3\\uA000-\\uA48C\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA65F\\uA662-\\uA66E\\uA67F-\\uA697\\uA717-\\uA71F\\uA722-\\uA788\\uA78B\\uA78C\\uA7FB-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA90A-\\uA925\\uA930-\\uA946\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAC00\\uD7A3\\uF900-\\uFA2D\\uFA30-\\uFA6A\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"),
+    letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B2\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FCC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA78E\\uA790-\\uA7AD\\uA7B0\\uA7B1\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB5F\\uAB64\\uAB65\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"),
+    digit: new RegExp("[\\u0030-\\u0039\\u0660-\\u0669\\u06F0-\\u06F9\\u07C0-\\u07C9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE6-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0DE6-\\u0DEF\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29\\u1040-\\u1049\\u1090-\\u1099\\u17E0-\\u17E9\\u1810-\\u1819\\u1946-\\u194F\\u19D0-\\u19D9\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1B50-\\u1B59\\u1BB0-\\u1BB9\\u1C40-\\u1C49\\u1C50-\\u1C59\\uA620-\\uA629\\uA8D0-\\uA8D9\\uA900-\\uA909\\uA9D0-\\uA9D9\\uA9F0-\\uA9F9\\uAA50-\\uAA59\\uABF0-\\uABF9\\uFF10-\\uFF19]"),
    non_spacing_mark: new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065E\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0900-\\u0902\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F90-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1DC0-\\u1DE6\\u1DFD-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA67C\\uA67D\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"),
    space_combining_mark: new RegExp("[\\u0903\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u0982\\u0983\\u09BE-\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u09D7\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B3E\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0B57\\u0BBE\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD7\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0-\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D57\\u0D82\\u0D83\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0F3E\\u0F3F\\u0F7F\\u102B\\u102C\\u1031\\u1038\\u103B\\u103C\\u1056\\u1057\\u1062-\\u1064\\u1067-\\u106D\\u1083\\u1084\\u1087-\\u108C\\u108F\\u109A-\\u109C\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A19-\\u1A1B\\u1A55\\u1A57\\u1A61\\u1A63\\u1A64\\u1A6D-\\u1A72\\u1B04\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF2\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BD-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAA7B\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]"),
    connector_punctuation: new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]")
@@ -133,13 +134,17 @@ function is_letter(code) {
 };

 function is_digit(code) {
-    return code >= 48 && code <= 57; //XXX: find out if "UnicodeDigit" means something else than 0..9
+    return code >= 48 && code <= 57;
 };

 function is_alphanumeric_char(code) {
    return is_digit(code) || is_letter(code);
 };

+function is_unicode_digit(code) {
+    return UNICODE.digit.test(String.fromCharCode(code));
+}
+
 function is_unicode_combining_mark(ch) {
    return UNICODE.non_spacing_mark.test(ch) || UNICODE.space_combining_mark.test(ch);
 };
@@ -164,18 +169,12 @@ function is_identifier_char(ch) {
        || code == 8205 // \u200d: zero-width joiner <ZWJ> (in my ECMA-262 PDF, this is also 200c)
        || is_unicode_combining_mark(ch)
        || is_unicode_connector_punctuation(ch)
+        || is_unicode_digit(code)
    ;
 };

 function is_identifier_string(str){
-    var i = str.length;
-    if (i == 0) return false;
-    if (!is_identifier_start(str.charCodeAt(0))) return false;
-    while (--i >= 0) {
-        if (!is_identifier_char(str.charAt(i)))
-            return false;
-    }
-    return true;
+    return /^[a-z_$][a-z0-9_$]*$/i.test(str);
 };

 function parse_js_number(num) {
@@ -213,7 +212,7 @@ var EX_EOF = {};
 function tokenizer($TEXT, filename, html5_comments) {

    var S = {
-        text            : $TEXT.replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/\uFEFF/g, ''),
+        text            : $TEXT.replace(/\uFEFF/g, ''),
        filename        : filename,
        pos             : 0,
        tokpos          : 0,
@@ -232,10 +231,15 @@ function tokenizer($TEXT, filename, html5_comments) {
        var ch = S.text.charAt(S.pos++);
        if (signal_eof && !ch)
            throw EX_EOF;
-        if (ch == "\n") {
+        if ("\r\n\u2028\u2029".indexOf(ch) >= 0) {
            S.newline_before = S.newline_before || !in_string;
            ++S.line;
            S.col = 0;
+            if (!in_string && ch == "\r" && peek() == "\n") {
+                // treat a \r\n sequence as a single \n
+                ++S.pos;
+                ch = "\n";
+            }
        } else {
            ++S.col;
        }
@@ -269,14 +273,16 @@ function tokenizer($TEXT, filename, html5_comments) {
                           (type == "punc" && PUNC_BEFORE_EXPRESSION(value)));
        prev_was_dot = (type == "punc" && value == ".");
        var ret = {
-            type   : type,
-            value  : value,
-            line   : S.tokline,
-            col    : S.tokcol,
-            pos    : S.tokpos,
-            endpos : S.pos,
-            nlb    : S.newline_before,
-            file   : filename
+            type    : type,
+            value   : value,
+            line    : S.tokline,
+            col     : S.tokcol,
+            pos     : S.tokpos,
+            endline : S.line,
+            endcol  : S.col,
+            endpos  : S.pos,
+            nlb     : S.newline_before,
+            file    : filename
        };
        if (!is_comment) {
            ret.comments_before = S.comments_before;
@@ -361,7 +367,7 @@ function tokenizer($TEXT, filename, html5_comments) {
        return num;
    };

-    var read_string = with_eof_error("Unterminated string constant", function(){
+    var read_string = with_eof_error("Unterminated string constant", function(quote_char){
        var quote = next(), ret = "";
        for (;;) {
            var ch = next(true);
@@ -386,7 +392,9 @@ function tokenizer($TEXT, filename, html5_comments) {
            else if (ch == quote) break;
            ret += ch;
        }
-        return token("string", ret);
+        var tok = token("string", ret);
+        tok.quote = quote_char;
+        return tok;
    });

    function skip_line_comment(type) {
@@ -399,6 +407,7 @@ function tokenizer($TEXT, filename, html5_comments) {
            ret = S.text.substring(S.pos, i);
            S.pos = i;
        }
+        S.col = S.tokcol + (S.pos - S.tokpos);
        S.comments_before.push(token(type, ret, true));
        S.regex_allowed = regex_allowed;
        return next_token();
@@ -540,7 +549,7 @@ function tokenizer($TEXT, filename, html5_comments) {
        if (!ch) return token("eof");
        var code = ch.charCodeAt(0);
        switch (code) {
-          case 34: case 39: return read_string();
+          case 34: case 39: return read_string(ch);
          case 46: return handle_dot();
          case 47: return handle_slash();
        }
@@ -616,6 +625,7 @@ function parse($TEXT, options) {
        toplevel       : null,
        expression     : false,
        html5_comments : true,
+        bare_returns   : false,
    });

    var S = {
@@ -729,8 +739,14 @@ function parse($TEXT, options) {
          case "string":
            var dir = S.in_directives, stat = simple_statement();
            // XXXv2: decide how to fix directives
-            if (dir && stat.body instanceof AST_String && !is("punc", ","))
-                return new AST_Directive({ value: stat.body.value });
+            if (dir && stat.body instanceof AST_String && !is("punc", ",")) {
+                return new AST_Directive({
+                    start : stat.body.start,
+                    end   : stat.body.end,
+                    quote : stat.body.quote,
+                    value : stat.body.value,
+                });
+            }
            return stat;
          case "num":
          case "regexp":
@@ -795,7 +811,7 @@ function parse($TEXT, options) {
                return if_();

              case "return":
-                if (S.in_function == 0)
+                if (S.in_function == 0 && !options.bare_returns)
                    croak("'return' outside of function");
                return new AST_Return({
                    value: ( is("punc", ";")
@@ -1116,7 +1132,12 @@ function parse($TEXT, options) {
            ret = new AST_Number({ start: tok, end: tok, value: tok.value });
            break;
          case "string":
-            ret = new AST_String({ start: tok, end: tok, value: tok.value });
+            ret = new AST_String({
+                start : tok,
+                end   : tok,
+                value : tok.value,
+                quote : tok.quote
+            });
            break;
          case "regexp":
            ret = new AST_RegExp({ start: tok, end: tok, value: tok.value });
@@ -1229,6 +1250,7 @@ function parse($TEXT, options) {
            expect(":");
            a.push(new AST_ObjectKeyVal({
                start : start,
+                quote : start.quote,
                key   : name,
                value : expression(false),
                end   : prev()
@@ -1381,7 +1403,7 @@ function parse($TEXT, options) {
                condition   : expr,
                consequent  : yes,
                alternative : expression(false, no_in),
-                end         : peek()
+                end         : prev()
            });
        }
        return expr;
--- a/lib/scope.js
+++ b/lib/scope.js
@@ -57,9 +57,14 @@ function SymbolDef(scope, index, orig) {

 SymbolDef.prototype = {
    unmangleable: function(options) {
-        return (this.global && !(options && options.toplevel))
+        if (!options) options = {};
+
+        return (this.global && !options.toplevel)
            || this.undeclared
-            || (!(options && options.eval) && (this.scope.uses_eval || this.scope.uses_with));
+            || (!options.eval && (this.scope.uses_eval || this.scope.uses_with))
+            || (options.keep_fnames
+                && (this.orig[0] instanceof AST_SymbolLambda
+                    || this.orig[0] instanceof AST_SymbolDefun));
    },
    mangle: function(options) {
        if (!this.mangled_name && !this.unmangleable(options)) {
@@ -322,11 +327,12 @@ AST_Symbol.DEFMETHOD("global", function(){

 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
    return defaults(options, {
-        except   : [],
-        eval     : false,
-        sort     : false,
-        toplevel : false,
-        screw_ie8 : false
+        except      : [],
+        eval        : false,
+        sort        : false,
+        toplevel    : false,
+        screw_ie8   : false,
+        keep_fnames : false
    });
 });

@@ -365,6 +371,10 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
            node.mangled_name = name;
            return true;
        }
+        if (options.screw_ie8 && node instanceof AST_SymbolCatch) {
+            to_mangle.push(node.definition());
+            return;
+        }
    });
    this.walk(tw);
    to_mangle.forEach(function(def){ def.mangle(options) });
@@ -467,7 +477,9 @@ var base54 = (function() {
    base54.freq = function(){ return frequency };
    function base54(num) {
        var ret = "", base = 54;
+        num++;
        do {
+            num--;
            ret += String.fromCharCode(chars[num % base]);
            num = Math.floor(num / base);
            base = 64;
@@ -528,6 +540,7 @@ AST_Toplevel.DEFMETHOD("scope_warnings", function(options){
        }
        if (options.unreferenced
            && (node instanceof AST_SymbolDeclaration || node instanceof AST_Label)
+            && !(node instanceof AST_SymbolCatch)
            && node.unreferenced()) {
            AST_Node.warn("{type} {name} is declared but not referenced [{file}:{line},{col}]", {
                type: node instanceof AST_Label ? "Label" : "Symbol",
--- a/lib/sourcemap.js
+++ b/lib/sourcemap.js
@@ -53,21 +53,29 @@ function SourceMap(options) {
        orig_line_diff : 0,
        dest_line_diff : 0,
    });
-    var generator = new MOZ_SourceMap.SourceMapGenerator({
-        file       : options.file,
-        sourceRoot : options.root
-    });
    var orig_map = options.orig && new MOZ_SourceMap.SourceMapConsumer(options.orig);
+    var generator;
+    if (orig_map) {
+      generator = MOZ_SourceMap.SourceMapGenerator.fromSourceMap(orig_map);
+    } else {
+        generator = new MOZ_SourceMap.SourceMapGenerator({
+            file       : options.file,
+            sourceRoot : options.root
+        });
+    }
    function add(source, gen_line, gen_col, orig_line, orig_col, name) {
        if (orig_map) {
            var info = orig_map.originalPositionFor({
                line: orig_line,
                column: orig_col
            });
+            if (info.source === null) {
+                return;
+            }
            source = info.source;
            orig_line = info.line;
            orig_col = info.column;
-            name = info.name;
+            name = info.name || name;
        }
        generator.addMapping({
            generated : { line: gen_line + options.dest_line_diff, column: gen_col },
@@ -75,10 +83,10 @@ function SourceMap(options) {
            source    : source,
            name      : name
        });
-    };
+    }
    return {
        add        : add,
        get        : function() { return generator },
-        toString   : function() { return generator.toString() }
+        toString   : function() { return JSON.stringify(generator.toJSON()); }
    };
 };
--- a/package.json
+++ b/package.json
@@ -1,9 +1,9 @@
 {
-    "name": "uglify-js",
-    "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
+  "name": "uglify-js",
+  "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
    "homepage": "http://lisperator.net/uglifyjs",
    "main": "tools/node.js",
-    "version": "2.4.8",
+    "version": "2.4.17",
    "engines": { "node" : ">=0.4.0" },
    "maintainers": [{
        "name": "Mihai Bazon",
@@ -16,15 +16,22 @@
    },
    "dependencies": {
        "async"      : "~0.2.6",
-        "source-map" : "~0.1.7",
-        "optimist"   : "~0.3.5",
+        "source-map" : "0.1.34",
+        "yargs": "~1.3.3",
        "uglify-to-browserify": "~1.0.0"
    },
+    "devDependencies": {
+        "acorn": "~0.6.0",
+        "escodegen": "~1.3.3",
+        "esfuzz": "~0.3.1",
+        "estraverse": "~1.5.1"
+    },
    "browserify": {
        "transform": [ "uglify-to-browserify" ]
    },
    "bin": {
        "uglifyjs" : "bin/uglifyjs"
    },
+    "license": "BSD",
    "scripts": {"test": "node test/run-tests.js"}
 }
--- a/test/compress/angular-inject.js
+++ b/test/compress/angular-inject.js
@@ -0,0 +1,67 @@
+ng_inject_defun: {
+    options = {
+        angular: true
+    };
+    input: {
+        /*@ngInject*/
+        function Controller(dependency) {
+            return dependency;
+        }
+    }
+    expect: {
+        function Controller(dependency) {
+            return dependency;
+        }
+        Controller.$inject=['dependency']
+    }
+}
+
+ng_inject_assignment: {
+    options = {
+        angular: true
+    };
+    input: {
+        /*@ngInject*/
+        var Controller = function(dependency) {
+            return dependency;
+        }
+    }
+    expect: {
+        var Controller = function(dependency) {
+            return dependency;
+        }
+        Controller.$inject=['dependency']
+    }
+}
+
+ng_inject_inline: {
+    options = {
+        angular: true
+    };
+    input: {
+        angular.module('a').
+            factory('b',
+                /*@ngInject*/
+                function(dependency) {
+                    return dependency;
+                }).
+            directive('c',
+                /*@ngInject*/
+                function(anotherDependency) {
+                    return anotherDependency;
+                })
+    }
+    expect: {
+        angular.module('a').
+            factory('b',[
+                'dependency',
+                function(dependency) {
+                    return dependency;
+                }]).
+            directive('c',[
+                'anotherDependency',
+                function(anotherDependency) {
+                    return anotherDependency;
+                }])
+    }
+}
--- a/test/compress/conditionals.js
+++ b/test/compress/conditionals.js
@@ -53,6 +53,7 @@ ifs_3_should_warn: {
        booleans     : true
    };
    input: {
+        var x, y;
        if (x && !(x + "1") && y) { // 1
            var qq;
            foo();
@@ -68,6 +69,7 @@ ifs_3_should_warn: {
        }
    }
    expect: {
+        var x, y;
        var qq; bar();          // 1
        var jj; foo();          // 2
    }
@@ -141,3 +143,228 @@ ifs_6: {
        x = foo || bar || baz || boo ? 20 : 10;
    }
 }
+
+cond_1: {
+    options = {
+        conditionals: true
+    };
+    input: {
+        if (some_condition()) {
+            do_something(x);
+        } else {
+            do_something(y);
+        }
+    }
+    expect: {
+        do_something(some_condition() ? x : y);
+    }
+}
+
+cond_2: {
+    options = {
+        conditionals: true
+    };
+    input: {
+        if (some_condition()) {
+            x = new FooBar(1);
+        } else {
+            x = new FooBar(2);
+        }
+    }
+    expect: {
+        x = new FooBar(some_condition() ? 1 : 2);
+    }
+}
+
+cond_3: {
+    options = {
+        conditionals: true
+    };
+    input: {
+        if (some_condition()) {
+            new FooBar(1);
+        } else {
+            FooBar(2);
+        }
+    }
+    expect: {
+        some_condition() ? new FooBar(1) : FooBar(2);
+    }
+}
+
+cond_4: {
+    options = {
+        conditionals: true
+    };
+    input: {
+        if (some_condition()) {
+            do_something();
+        } else {
+            do_something();
+        }
+    }
+    expect: {
+        some_condition(), do_something();
+    }
+}
+
+cond_5: {
+    options = {
+        conditionals: true
+    };
+    input: {
+        if (some_condition()) {
+            if (some_other_condition()) {
+                do_something();
+            } else {
+                alternate();
+            }
+        } else {
+            alternate();
+        }
+
+        if (some_condition()) {
+            if (some_other_condition()) {
+                do_something();
+            }
+        }
+    }
+    expect: {
+        some_condition() && some_other_condition() ? do_something() : alternate();
+        some_condition() && some_other_condition() && do_something();
+    }
+}
+
+cond_7: {
+    options = {
+        conditionals: true,
+        evaluate    : true
+    };
+    input: {
+        var x, y, z, a, b;
+        // compress these
+        if (y) {
+            x = 1+1;
+        } else {
+            x = 2;
+        }
+
+        if (y) {
+            x = 1+1;
+        } else if (z) {
+            x = 2;
+        } else {
+            x = 3-1;
+        }
+
+        x = y ? 'foo' : 'fo'+'o';
+
+        x = y ? 'foo' : y ? 'foo' : 'fo'+'o';
+
+        // Compress conditions that have side effects
+        if (condition()) {
+            x = 10+10;
+        } else {
+            x = 20;
+        }
+
+        if (z) {
+            x = 'fuji';
+        } else if (condition()) {
+            x = 'fu'+'ji';
+        } else {
+            x = 'fuji';
+        }
+
+        x = condition() ? 'foobar' : 'foo'+'bar';
+
+        // don't compress these
+        x = y ? a : b;
+
+        x = y ? 'foo' : 'fo';
+    }
+    expect: {
+        var x, y, z, a, b;
+        x = 2;
+        x = 2;
+        x = 'foo';
+        x = 'foo';
+        x = (condition(), 20);
+        x = z ? 'fuji' : (condition(), 'fuji');
+        x = (condition(), 'foobar');
+        x = y ? a : b;
+        x = y ? 'foo' : 'fo';
+    }
+}
+
+cond_7_1: {
+    options = {
+        conditionals: true,
+        evaluate    : true
+    };
+    input: {
+        // access to global should be assumed to have side effects
+        if (y) {
+            x = 1+1;
+        } else {
+            x = 2;
+        }
+    }
+    expect: {
+        x = (y, 2);
+    }
+}
+
+cond_8: {
+    options = {
+        conditionals: true,
+        evaluate    : true
+    };
+    input: {
+        // compress these
+        a = condition ? true : false;
+
+        a = !condition ? true : false;
+
+        a = condition() ? true : false;
+
+        if (condition) {
+            a = true;
+        } else {
+            a = false;
+        }
+
+        a = condition ? false : true;
+
+        a = !condition ? false : true;
+
+        a = condition() ? false : true;
+
+        if (condition) {
+            a = false;
+        } else {
+            a = true;
+        }
+
+        // don't compress these
+        a = condition ? 1 : false;
+
+        a = !condition ? true : 0;
+
+        a = condition ? 1 : 0;
+
+    }
+    expect: {
+        a = !!condition;
+        a = !condition;
+        a = !!condition();
+        a = !!condition;
+        a = !condition;
+        a = !!condition;
+        a = !condition();
+        a = !condition;
+        a = condition ? 1 : false;
+        a = condition ? 0 : true;
+        a = condition ? 1 : 0;
+    }
+}
--- a/test/compress/dead-code.js
+++ b/test/compress/dead-code.js
@@ -1,89 +1,89 @@
-dead_code_1: {
-    options = {
-        dead_code: true
-    };
-    input: {
-        function f() {
-            a();
-            b();
-            x = 10;
-            return;
-            if (x) {
-                y();
-            }
-        }
-    }
-    expect: {
-        function f() {
-            a();
-            b();
-            x = 10;
-            return;
-        }
-    }
-}
-
-dead_code_2_should_warn: {
-    options = {
-        dead_code: true
-    };
-    input: {
-        function f() {
-            g();
-            x = 10;
-            throw "foo";
-            // completely discarding the `if` would introduce some
-            // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
-            // we copy any declarations to the upper scope.
-            if (x) {
-                y();
-                var x;
-                function g(){};
-                // but nested declarations should not be kept.
-                (function(){
-                    var q;
-                    function y(){};
-                })();
-            }
-        }
-    }
-    expect: {
-        function f() {
-            g();
-            x = 10;
-            throw "foo";
-            var x;
-            function g(){};
-        }
-    }
-}
-
-dead_code_constant_boolean_should_warn_more: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true
-    };
-    input: {
-        while (!((foo && bar) || (x + "0"))) {
-            console.log("unreachable");
-            var foo;
-            function bar() {}
-        }
-        for (var x = 10; x && (y || x) && (!typeof x); ++x) {
-            asdf();
-            foo();
-            var moo;
-        }
-    }
-    expect: {
-        var foo;
-        function bar() {}
-        // nothing for the while
-        // as for the for, it should keep:
-        var x = 10;
-        var moo;
-    }
-}
+dead_code_1: {
+    options = {
+        dead_code: true
+    };
+    input: {
+        function f() {
+            a();
+            b();
+            x = 10;
+            return;
+            if (x) {
+                y();
+            }
+        }
+    }
+    expect: {
+        function f() {
+            a();
+            b();
+            x = 10;
+            return;
+        }
+    }
+}
+
+dead_code_2_should_warn: {
+    options = {
+        dead_code: true
+    };
+    input: {
+        function f() {
+            g();
+            x = 10;
+            throw "foo";
+            // completely discarding the `if` would introduce some
+            // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
+            // we copy any declarations to the upper scope.
+            if (x) {
+                y();
+                var x;
+                function g(){};
+                // but nested declarations should not be kept.
+                (function(){
+                    var q;
+                    function y(){};
+                })();
+            }
+        }
+    }
+    expect: {
+        function f() {
+            g();
+            x = 10;
+            throw "foo";
+            var x;
+            function g(){};
+        }
+    }
+}
+
+dead_code_constant_boolean_should_warn_more: {
+    options = {
+        dead_code    : true,
+        loops        : true,
+        booleans     : true,
+        conditionals : true,
+        evaluate     : true
+    };
+    input: {
+        while (!((foo && bar) || (x + "0"))) {
+            console.log("unreachable");
+            var foo;
+            function bar() {}
+        }
+        for (var x = 10, y; x && (y || x) && (!typeof x); ++x) {
+            asdf();
+            foo();
+            var moo;
+        }
+    }
+    expect: {
+        var foo;
+        function bar() {}
+        // nothing for the while
+        // as for the for, it should keep:
+        var x = 10, y;
+        var moo;
+    }
+}
--- a/test/compress/drop-console.js
+++ b/test/compress/drop-console.js
@@ -0,0 +1,24 @@
+drop_console_1: {
+    options = {};
+    input: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+    expect: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+}
+
+drop_console_1: {
+    options = { drop_console: true };
+    input: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+    expect: {
+        // with regular compression these will be stripped out as well
+        void 0;
+        void 0;
+    }
+}
--- a/test/compress/drop-unused.js
+++ b/test/compress/drop-unused.js
@@ -163,3 +163,17 @@ used_var_in_catch: {
        }
    }
 }
+
+keep_fnames: {
+    options = { unused: true, keep_fnames: true };
+    input: {
+        function foo() {
+            return function bar(baz) {};
+        }
+    }
+    expect: {
+        function foo() {
+            return function bar() {};
+        }
+    }
+}
--- a/test/compress/issue-597.js
+++ b/test/compress/issue-597.js
@@ -0,0 +1,25 @@
+NaN_and_Infinity_must_have_parens: {
+    options = {};
+    input: {
+        Infinity.toString();
+        NaN.toString();
+    }
+    expect: {
+        (1/0).toString();
+        (0/0).toString();
+    }
+}
+
+NaN_and_Infinity_should_not_be_replaced_when_they_are_redefined: {
+    options = {};
+    input: {
+        var Infinity, NaN;
+        Infinity.toString();
+        NaN.toString();
+    }
+    expect: {
+        var Infinity, NaN;
+        Infinity.toString();
+        NaN.toString();
+    }
+}
--- a/test/compress/issue-611.js
+++ b/test/compress/issue-611.js
@@ -0,0 +1,21 @@
+issue_611: {
+  options = {
+    sequences: true,
+    side_effects: true
+  };
+  input: {
+    define(function() {
+      function fn() {}
+      if (fn()) {
+        fn();
+        return void 0;
+      }
+    });
+  }
+  expect: {
+    define(function() {
+      function fn(){}
+      if (fn()) return void fn();
+    });
+  }
+}
--- a/test/compress/issue-637.js
+++ b/test/compress/issue-637.js
@@ -0,0 +1,22 @@
+wrongly_optimized: {
+    options = {
+        conditionals: true,
+        booleans: true,
+        evaluate: true
+    };
+    input: {
+        function func() {
+            foo();
+        }
+        if (func() || true) {
+            bar();
+        }
+    }
+    expect: {
+        function func() {
+            foo();
+        }
+        // TODO: optimize to `func(), bar()`
+        (func(), 0) || bar();
+    }
+}
--- a/test/compress/negate-iife.js
+++ b/test/compress/negate-iife.js
@@ -60,16 +60,16 @@ negate_iife_4: {
    };
    input: {
        if ((function(){ return true })()) {
-            console.log(true);
+            foo(true);
        } else {
-            console.log(false);
+            bar(false);
        }
        (function(){
            console.log("something");
        })();
    }
    expect: {
-        !function(){ return true }() ? console.log(false) : console.log(true), function(){
+        !function(){ return true }() ? bar(false) : foo(true), function(){
            console.log("something");
        }();
    }
--- a/test/compress/properties.js
+++ b/test/compress/properties.js
@@ -26,7 +26,7 @@ dot_properties: {
        a.foo = "bar";
        a["if"] = "if";
        a["*"] = "asterisk";
-        a.\u0EB3 = "unicode";
+        a["\u0EB3"] = "unicode";
        a[""] = "whitespace";
        a["1_1"] = "foo";
    }
@@ -48,7 +48,27 @@ dot_properties_es5: {
        a.foo = "bar";
        a.if = "if";
        a["*"] = "asterisk";
-        a.\u0EB3 = "unicode";
+        a["\u0EB3"] = "unicode";
        a[""] = "whitespace";
    }
 }
+
+evaluate_length: {
+    options = {
+        properties: true,
+        unsafe: true,
+        evaluate: true
+    };
+    input: {
+        a = "foo".length;
+        a = ("foo" + "bar")["len" + "gth"];
+        a = b.length;
+        a = ("foo" + b).length;
+    }
+    expect: {
+        a = 3;
+        a = 6;
+        a = b.length;
+        a = ("foo" + b).length;
+    }
+}
--- a/test/compress/sequences.js
+++ b/test/compress/sequences.js
@@ -91,9 +91,11 @@ make_sequences_4: {
 lift_sequences_1: {
    options = { sequences: true };
    input: {
+        var foo, x, y, bar;
        foo = !(x(), y(), bar());
    }
    expect: {
+        var foo, x, y, bar;
        x(), y(), foo = !bar();
    }
 }
@@ -101,10 +103,12 @@ lift_sequences_1: {
 lift_sequences_2: {
    options = { sequences: true, evaluate: true };
    input: {
+        var foo, bar;
        foo.x = (foo = {}, 10);
        bar = (bar = {}, 10);
    }
    expect: {
+        var foo, bar;
        foo.x = (foo = {}, 10),
        bar = {}, bar = 10;
    }
@@ -113,9 +117,11 @@ lift_sequences_2: {
 lift_sequences_3: {
    options = { sequences: true, conditionals: true };
    input: {
+        var x, foo, bar, baz;
        x = (foo(), bar(), baz()) ? 10 : 20;
    }
    expect: {
+        var x, foo, bar, baz;
        foo(), bar(), x = baz() ? 10 : 20;
    }
 }
@@ -123,9 +129,11 @@ lift_sequences_3: {
 lift_sequences_4: {
    options = { side_effects: true };
    input: {
+        var x, foo, bar, baz;
        x = (foo, bar, baz);
    }
    expect: {
+        var x, foo, bar, baz;
        x = baz;
    }
 }
--- a/test/compress/unicode.js
+++ b/test/compress/unicode.js
@@ -0,0 +1,17 @@
+unicode_parse_variables: {
+    options = {};
+    input: {
+        var a = {};
+        a.你好 = 456;
+
+        var ↂωↂ = 123;
+        var l০ = 3; // 2nd char is a unicode digit
+    }
+    expect: {
+        var a = {};
+        a.你好 = 456;
+
+        var ↂωↂ = 123;
+        var l০ = 3;
+    }
+}
--- a/test/mozilla-ast.js
+++ b/test/mozilla-ast.js
@@ -0,0 +1,103 @@
+// Testing UglifyJS <-> SpiderMonkey AST conversion
+// through generative testing.
+
+var UglifyJS = require(".."),
+    escodegen = require("escodegen"),
+    esfuzz = require("esfuzz"),
+    estraverse = require("estraverse"),
+    prefix = Array(20).join("\b") + "    ";
+
+// Normalizes input AST for UglifyJS in order to get correct comparison.
+
+function normalizeInput(ast) {
+    return estraverse.replace(ast, {
+        enter: function(node, parent) {
+            switch (node.type) {
+                // Internally mark all the properties with semi-standard type "Property".
+                case "ObjectExpression":
+                    node.properties.forEach(function (property) {
+                        property.type = "Property";
+                    });
+                    break;
+
+                // Since UglifyJS doesn"t recognize different types of property keys,
+                // decision on SpiderMonkey node type is based on check whether key
+                // can be valid identifier or not - so we do in input AST.
+                case "Property":
+                    var key = node.key;
+                    if (key.type === "Literal" && typeof key.value === "string" && UglifyJS.is_identifier(key.value)) {
+                        node.key = {
+                            type: "Identifier",
+                            name: key.value
+                        };
+                    } else if (key.type === "Identifier" && !UglifyJS.is_identifier(key.name)) {
+                        node.key = {
+                            type: "Literal",
+                            value: key.name
+                        };
+                    }
+                    break;
+
+                // UglifyJS internally flattens all the expression sequences - either
+                // to one element (if sequence contains only one element) or flat list.
+                case "SequenceExpression":
+                    node.expressions = node.expressions.reduce(function flatten(list, expr) {
+                        return list.concat(expr.type === "SequenceExpression" ? expr.expressions.reduce(flatten, []) : [expr]);
+                    }, []);
+                    if (node.expressions.length === 1) {
+                        return node.expressions[0];
+                    }
+                    break;
+            }
+        }
+    });
+}
+
+module.exports = function(options) {
+    console.log("--- UglifyJS <-> Mozilla AST conversion");
+
+    for (var counter = 0; counter < options.iterations; counter++) {
+        process.stdout.write(prefix + counter + "/" + options.iterations);
+
+        var ast1 = normalizeInput(esfuzz.generate({
+            maxDepth: options.maxDepth
+        }));
+        
+        var ast2 =
+            UglifyJS
+            .AST_Node
+            .from_mozilla_ast(ast1)
+            .to_mozilla_ast();
+
+        var astPair = [
+            {name: 'expected', value: ast1},
+            {name: 'actual', value: ast2}
+        ];
+
+        var jsPair = astPair.map(function(item) {
+            return {
+                name: item.name,
+                value: escodegen.generate(item.value)
+            }
+        });
+
+        if (jsPair[0].value !== jsPair[1].value) {
+            var fs = require("fs");
+            var acorn = require("acorn");
+
+            fs.existsSync("tmp") || fs.mkdirSync("tmp");
+
+            jsPair.forEach(function (item) {
+                var fileName = "tmp/dump_" + item.name;
+                var ast = acorn.parse(item.value);
+                fs.writeFileSync(fileName + ".js", item.value);
+                fs.writeFileSync(fileName + ".json", JSON.stringify(ast, null, 2));
+            });
+
+            process.stdout.write("\n");
+            throw new Error("Got different outputs, check out tmp/dump_*.{js,json} for codes and ASTs.");
+        }
+    }
+
+    process.stdout.write(prefix + "Probability of error is less than " + (100 / options.iterations) + "%, stopping.\n");
+};
--- a/test/run-tests.js
+++ b/test/run-tests.js
@@ -17,6 +17,12 @@ if (failures) {
    process.exit(1);
 }

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

 function tmpl() {
--- a/tools/node.js
+++ b/tools/node.js
@@ -6,6 +6,8 @@ var sys = require("util");
 var UglifyJS = vm.createContext({
    sys           : sys,
    console       : console,
+    process       : process,
+    Buffer        : Buffer,
    MOZ_SourceMap : require("source-map")
 });

@@ -33,7 +35,7 @@ var FILES = exports.FILES = [
    "../lib/sourcemap.js",
    "../lib/mozilla-ast.js"
 ].map(function(file){
-    return path.join(path.dirname(fs.realpathSync(__filename)), file);
+    return fs.realpathSync(path.join(path.dirname(__filename), file));
 });

 FILES.forEach(load_global);
@@ -51,6 +53,7 @@ for (var i in UglifyJS) {

 exports.minify = function(files, options) {
    options = UglifyJS.defaults(options, {
+        spidermonkey : false,
        outSourceMap : null,
        sourceRoot   : null,
        inSourceMap  : null,
@@ -60,22 +63,28 @@ exports.minify = function(files, options) {
        output       : null,
        compress     : {}
    });
-    if (typeof files == "string")
-        files = [ files ];
-
    UglifyJS.base54.reset();

    // 1. parse
-    var toplevel = null;
-    files.forEach(function(file){
-        var code = options.fromString
-            ? file
-            : fs.readFileSync(file, "utf8");
-        toplevel = UglifyJS.parse(code, {
-            filename: options.fromString ? "?" : file,
-            toplevel: toplevel
+    var toplevel = null,
+        sourcesContent = {};
+
+    if (options.spidermonkey) {
+        toplevel = UglifyJS.AST_Node.from_mozilla_ast(files);
+    } else {
+        if (typeof files == "string")
+            files = [ files ];
+        files.forEach(function(file){
+            var code = options.fromString
+                ? file
+                : fs.readFileSync(file, "utf8");
+            sourcesContent[file] = code;
+            toplevel = UglifyJS.parse(code, {
+                filename: options.fromString ? "?" : file,
+                toplevel: toplevel
+            });
        });
-    });
+    }

    // 2. compress
    if (options.compress) {
@@ -88,8 +97,8 @@ exports.minify = function(files, options) {

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

@@ -105,15 +114,33 @@ exports.minify = function(files, options) {
            orig: inMap,
            root: options.sourceRoot
        });
+        if (options.sourceMapIncludeSources) {
+            for (var file in sourcesContent) {
+                if (sourcesContent.hasOwnProperty(file)) {
+                    output.source_map.get().setSourceContent(file, sourcesContent[file]);
+                }
+            }
+        }
+
    }
    if (options.output) {
        UglifyJS.merge(output, options.output);
    }
    var stream = UglifyJS.OutputStream(output);
    toplevel.print(stream);
+
+    if(options.outSourceMap){
+        stream += "\n//# sourceMappingURL=" + options.outSourceMap;
+    }
+
+    var source_map = output.source_map;
+    if (source_map) {
+        source_map = source_map + "";
+    }
+
    return {
        code : stream + "",
-        map  : output.source_map + ""
+        map  : source_map
    };
 };
Author	SHA1	Message	Date
Mihai Bazon	c7d3c07f5a	v2.4.17	2015-03-11 00:03:12 +02:00
Richard van Velzen	61e850ceb5	Clean up unit test breakage In `992b6b9fcc` unit test broke (which I missed). This was due to undeclared variables not being side-effects free. However, since they're really not side-effect free, just declare them in the test cases.	2015-02-11 21:27:21 +01:00
Richard van Velzen	992b6b9fcc	Fix invalid removal of left side in && and \|\| compression See #637. This does not produce the optimal result, but it does prevent the removal of non-side-effect-free code.	2015-02-11 21:08:41 +01:00
Anthony Van de Gejuchte	7b71344051	Parse regexes properly	2015-02-11 18:29:15 +01:00
Richard van Velzen	605362f89d	Drop all `console` statements properly Because the base reference can be an member expression as well, we have to dig a bit deeper to find the leftmost base reference. Fixes #451	2015-01-31 13:24:44 +01:00
Mihai Bazon	fbbaa42ee5	Add option to preserve/enforce string quote style `-q 0` (default) use single or double quotes such as to minimize the number of bytes (prefers double quotes when both will do); this is the previous behavior. `-q 1` -- always use single quotes `-q 2` -- always use double quotes `-q 3` or just `-q` -- always use the original quotes. Related codegen option: `quote_style`. Close #495 Close #460 Some `yargs` guru please tell me why `uglifyjs --help` doesn't display the help string for `-q` / `--quotes`, and why it doesn't output the expected argument types anymore, like good old `optimist` did.	2015-01-27 22:26:27 +02:00
Anthony Van de Gejuchte	099992ecae	Keep single line comments after nlb, after nlb Fixes #583	2015-01-26 12:11:52 +01:00
Richard van Velzen	d78ae20e64	Make empty source map values more reasonable in .minify() `"null"` isn't a very usable value. `JSON.parse(null)` also gives `null`, which makes this fully backwards compatible. Closes #616	2015-01-26 12:07:44 +01:00
Bryce Cronkite-Ratcliff	5c02d65ddb	fixes issue #621 SourceMap toString JSON format The correct format of a sourcemap is acquired from a mozilla source map generator by calling toJSON on this object. This patch alters the toString function on mozilla generators to print the format that is to spec instead of the generator's internal representation of itself.	2015-01-24 00:33:02 -08:00
Mihai Bazon	d36067cd35	Merge pull request #615 from avdg/unicode Give parser more unicode support	2015-01-20 13:00:31 +02:00
Anthony Van de Gejuchte	f1b2134dd1	Add test	2015-01-20 00:31:44 +01:00
Anthony Van de Gejuchte	74cda80d3b	Add unicode digit parsing support	2015-01-20 00:17:24 +01:00
Anthony Van de Gejuchte	9a3a848cc8	Update unicode letter	2015-01-20 00:17:03 +01:00
Tal Ater	a1a4c2ada7	Optimize conditionals where the consequent and alternative are both booleans and not equivalent	2015-01-13 18:27:21 +01:00
Mihai Bazon	189dbf02b6	Merge pull request #612 from rvanvelzen/issue-611 Replace the correct node when replacing in `void` sequences	2015-01-12 18:18:55 +02:00
Richard van Velzen	42ecd42ac0	Replace the correct node when replacing in `void` sequences Close #611.	2015-01-12 17:09:34 +01:00
Mihai Bazon	a10f6a96d7	Merge pull request #482 from arty-name/inline-ng-inject added @ngInject support for inline functions	2015-01-11 12:10:42 +02:00
Mihai Bazon	0d232a1422	Merge pull request #606 from rvanvelzen/document-double-dash Document `--` for usage in CLI class	2015-01-07 23:17:08 +02:00
Richard van Velzen	285bffd2c6	Document `--` for usage in CLI class Close #518	2015-01-07 19:04:10 +01:00
Mihai Bazon	61c233a08e	Fix make_node_from_constant for Regexp-s Close #588	2015-01-07 11:20:04 +02:00
Mihai Bazon	d2d716483a	aborts(AST_If) returns the `if` node Previously it returned the abort node from the alternative branch. This is not much use as it can be different from the one in the body branch (i.e. return vs. throw) and can trick us into issues like #591. Fix #591	2015-01-06 14:01:35 +02:00
Ingvar Stepanyan	f16033aafd	Location fix for Mozilla AST start token.	2015-01-06 11:32:41 +01:00
Ingvar Stepanyan	ae5366a31d	Track ending lines/columns; fix end locations in Mozilla AST.	2015-01-06 11:32:41 +01:00
Mihai Bazon	6b23cbc852	AST_Do nodes: walk body before condition	2015-01-06 12:29:07 +02:00
Richard van Velzen	7f9bc9e863	Pass mangle options to `figure_out_scope` and `compute_char_frequence` Fix #219. Because the options were not set and `toplevel` is `false` by default, some toplevel names would sometimes not be mangled correctly.	2015-01-05 19:10:32 +01:00
Mihai Bazon	13219cebcb	Fix handling \r\n Close #437	2015-01-05 12:14:42 +02:00
Mihai Bazon	93a6e5780e	Declare boolean type for --keep-fnames	2015-01-05 11:20:00 +02:00
Mihai Bazon	fe55e0d93d	Merge branch 'keep-function-expression-names' of https://github.com/rvanvelzen/UglifyJS2	2015-01-05 11:11:38 +02:00
Mihai Bazon	e1f0747e4c	Support keep_fnames in compressor, and --keep-fnames. #552 Passing `--keep-fnames` will enable it both for compressor/mangler, so that function names will not be dropped (when unused) nor mangled.	2015-01-05 11:03:13 +02:00
Richard van Velzen	e37b67d013	Add an option to prevent function names from being mangled See #552. This is mostly useful for having the actual function names in traces.	2015-01-04 21:48:43 +01:00
Caridy Patino	ad18689d92	using the original sourcemap as the base * Creates a new SourceMapGenerator based on a SourceMapConsumer: https://github.com/mozilla/source-map#sourcemapgeneratorfromsourcemapsourcemapconsumer	2015-01-04 21:08:29 +01:00
truiken	0f80b1058d	Resolve the relative path to lib files last This allows usage of UglifyJS on build systems which have a flat (or non-matching relative) directory structure for source files.	2015-01-04 21:01:11 +01:00
Richard van Velzen	0d48af3f36	Add a "keep_fnames" option to the compressor to retain function expression names See #552. This is useful for stack traces.	2015-01-04 20:14:38 +01:00
achingbrain	4613644cce	passes in references to process and Buffer to silence ReferenceErrors	2015-01-04 19:26:47 +01:00
Derek Wickern	718e475613	Fix backslashes in source-map paths on Windows	2015-01-04 19:08:19 +01:00
Austin Brown	aa5dd15352	Update README.md otions => options	2015-01-04 16:01:53 +01:00
Peter Dave Hello	5bff65c132	Use svg instead of png to get better image quality	2015-01-04 15:58:00 +01:00
Richard van Velzen	24bc09b79b	Fix #556 `\uFEFF` (ZERO WIDTH NO-BREAK SPACE) is removed when parsing, but was un-escaped for the output when `ascii_only` was false. When using UglifyJS multiple times (creating packages from minified sources, for example), this would lead to problems because the byte was removed when parsing for the second time.	2015-01-04 15:01:55 +01:00
Richard van Velzen	37c17d5541	Merge pull request #570 from rvanvelzen/fix-569 Fix #569	2015-01-04 14:02:08 +01:00
Richard van Velzen	120948fa48	Merge pull request #584 from clyfish/fix-base54 fix base54	2015-01-04 14:00:23 +01:00
Richard van Velzen	66e6f0c3cb	Merge pull request #592 from micschro/patch-1 Fix max_line_len not working for JSON files	2015-01-04 13:53:31 +01:00
Richard van Velzen	f7447efa8c	Merge pull request #600 from KenPowers/master Use yargs instead of optimist.	2015-01-04 13:52:02 +01:00
Richard van Velzen	f4d36a58c2	Fix #569 When no arguments are given to `new Function()`, it should be treated as a regular anonymous function (http://es5.github.io/#x15.3.2.1)	2015-01-04 13:37:59 +01:00
Kenneth Powers	6d1c3e1aec	Use yargs instead of optimist.	2015-01-01 01:04:54 -05:00
Mihai Bazon	73cc0505f5	Merge pull request #599 from rvanvelzen/fix-597 Fix #597	2014-12-31 14:18:31 +02:00
Richard van Velzen	c75f5a1fd8	Fix #597 NaN and Infinity were replaced in the output generation, instead of during compression. This could lead to results where `1/0` was inserted without parens leading to invalid output. The nodes are replaced in the compression step now, and the output generation returns their regular names. This should not be a problem, since they're already only constructed from the original name.	2014-12-31 12:23:00 +01:00
micschro	39d8880f2c	Fix max_line_len not working for JSON files As `maybe_newline()` is only called when `might_need_semicolon` is `true`, the `max_line_len` option has no effect for files without (or with very few) semicolons (like JSON files). A simple for this problem is to use `maybe_newline()` instead of `noop` as the `newline()` function in non-beautify mode.	2014-12-17 16:31:03 +01:00
Mihai Bazon	5538ec7bd8	v2.4.16	2014-12-09 15:21:44 +02:00
Mihai Bazon	f101d6429b	Merge pull request #546 from jacobk/patch-1 Use uglify source map token names if missing	2014-12-04 14:07:08 +02:00
Cheng Liangyu	fe06fc85d3	fix base54	2014-12-01 13:16:44 +08:00
Mihai Bazon	f36a1eaa8b	Add option to allow return outside of functions. Close #288	2014-10-20 18:12:13 +03:00
Mihai Bazon	a64bdda9ae	Document `keep_fargs`. Close #557	2014-09-28 12:36:36 +03:00
Mihai Bazon	01d19b4b52	Referencing a global is assumed to have side effects. Close #550	2014-09-28 11:18:25 +03:00
Mihai Bazon	f0c1a01bc2	Merge pull request #549 from Arnavion/unreferenced-catch-symbol Don't warn for an unreferenced exception symbol in a catch block.	2014-09-13 09:29:34 +03:00
Arnavion	7be680d3f8	Don't warn for an unreferenced exception symbol in a catch block.	2014-09-12 21:01:19 -07:00
Mihai Bazon	57dab1e1db	Merge pull request #541 from TalAter/conditional-improvements Conditional assignment of equivalent constants compressed ( x=y?1:1 --> x=1 )	2014-09-09 18:45:12 +03:00
Jacob Kristhammar	21b3c890a1	Use uglify source map token names if missing	2014-09-09 13:02:50 +02:00
Tal Ater	fb0ec720a4	Compress conditions that have side effects using sequences	2014-09-04 02:57:49 +03:00
Tal Ater	7971ed33d1	Added a test for else if	2014-09-03 01:35:30 +03:00
Tal Ater	885835a655	Compress conditional assignments where all possible outcomes are equivalant and condition has no side effects	2014-09-02 23:30:25 +03:00
Mihai Bazon	4c64554808	Turn foo.new into foo["new"] when not --screw-ie8. Fix #534	2014-08-26 10:11:01 +03:00
Mihai Bazon	548beeb6b1	Prevent error for Function(""). Close #538	2014-08-20 09:16:34 +03:00
Mihai Bazon	e3066f9577	Merge pull request #529 from RReverser/master Added example for usage with SpiderMonkey AST	2014-08-04 23:05:29 +03:00
Ingvar Stepanyan	e391367488	Added example for usage with SpiderMonkey AST.	2014-08-04 20:48:14 +03:00
Mihai Bazon	18ddf2f7b5	Merge branch 'master' of https://github.com/RReverser/UglifyJS2	2014-08-04 09:01:19 +03:00
Ingvar Stepanyan	f8ee5a0785	Install newest NPM on oldest Node.js.	2014-08-03 21:44:59 +03:00
Ingvar Stepanyan	b467a3c877	Added generative testing for AST conversions.	2014-08-03 20:48:59 +03:00
Mihai Bazon	f2d48e9019	Merge branch 'patch-1' of https://github.com/gdw2/UglifyJS2	2014-08-03 11:08:39 +03:00
Ingvar Stepanyan	5e314bf3e9	SpiderMonkey `Identifier` nodes should contain mangled names.	2014-08-03 01:28:58 +03:00
Ingvar Stepanyan	05ba26c7c8	Small fixes for AST conversion.	2014-08-02 13:18:27 +03:00
Ingvar Stepanyan	87b72364a4	Fixes and improvements for UglifyJS->SM AST conversion. * Explicitly forbidden multiple catch clauses as SM-specific feature. * Simplified describing of UglifyJS->Mozilla AST conversion rules. * Moved alias rules to single place. * Removed usage of dynamic type bindings in generated code (speed-up).	2014-08-01 23:45:37 +03:00
Ingvar Stepanyan	0e3ff1f970	Improved UglifyJS<->SpiderMonkey AST conversions. * Added directives recognition in SM AST. * Moved semi-standard SM `Property` type to separate handler. * Added `const` recognition from SM AST. * Removed redundant `this`-as-identifier recognition. * Removed redundant rules for abstract SM types. * Described `CatchClause` using string syntax. * Added support for semi-standard `range` tuple as location source. * Added back-conversion support (to be improved).	2014-08-01 23:42:34 +03:00
gdw2	ec3e74d7f4	Added license	2014-07-28 13:49:44 -07:00
Mihai Bazon	62bda71c85	Fix parens for AST_Undefined Do the same as for AST_Unary, since we output undefined as `void 0`. Reported at https://github.com/mishoo/UglifyJS2/issues/338#issuecomment-48858341	2014-07-18 11:31:41 +03:00
Mihai Bazon	83e0939088	v2.4.15	2014-07-09 18:01:40 +03:00
Mihai Bazon	9798d96e37	Lock source-map to 0.1.34	2014-07-09 18:01:23 +03:00
Artemy Tregubenko	6006dd933d	added newline at the end of the file	2014-07-08 11:16:35 +02:00
Mihai Bazon	ac2caf1088	Check for the case an AST_For's init is an EmptyStatement (lame fix for #503)	2014-07-01 23:10:44 +03:00
Dan Wolff	8511e80f48	Evaluate "foo".length ==> 3	2014-07-01 11:06:51 +03:00
Mihai Bazon	91bc3f1f92	Merge pull request #499 from shinnn/master Update .travis.yml to pass the test on Travis CI	2014-06-26 09:30:25 +03:00
Shinnosuke Watanabe	8463b48f90	Do not run a test for Node v0.4 Travis CI doesn’t support Node v0.4. http://docs.travis-ci.com/user/languages/javascript-with-nodejs/#Provide d-Node.js-Versions	2014-06-26 13:17:59 +09:00
Mihai Bazon	e3342a3cf6	v2.4.14	2014-06-12 17:24:33 +03:00
Artemy Tregubenko	524a8a42a4	added @ngInject support for inline functions	2014-05-11 14:01:08 +02:00
Mihai Bazon	7bf59b5bcd	Actually, even better. #475 - also handle x = + ++y, x = - --y; - don't use parens, a space suffices.	2014-04-27 21:42:14 +03:00
Mihai Bazon	025f3e9596	Better fix for #475	2014-04-27 20:54:54 +03:00
Mihai Bazon	8258edd8a5	Fix parens in +(+x). Close #475	2014-04-27 20:51:01 +03:00
Mihai Bazon	8669ca219b	Merge branch 'master' of github.com:mishoo/UglifyJS2	2014-04-24 10:56:57 +03:00
Mihai Bazon	71652690b6	Merge pull request #445 from ConradIrwin/try-statement Handle TryStatements trees from acorn >=0.2.0	2014-04-24 10:46:53 +03:00
Mihai Bazon	37693d2812	Update tests.	2014-04-18 11:19:52 +03:00
Mihai Bazon	8fbe200012	Always quote property names that contain non-ASCII characters. Fix #328	2014-04-18 10:48:44 +03:00
Mihai Bazon	1a34a13e33	Merge pull request #470 from ebednarz/master Fix sourceMapIncludeSources exception in Node API	2014-04-13 12:54:12 +03:00
OiNutter	ef772b0049	add sourceMappingUrl to output in node module If options.outSourceMap is specified the sourceMappingURL comment should be appended to the output stream	2014-04-13 11:48:38 +02:00
ebednarz	6fcabbde08	Fix sourceMapIncludeSources exception in Node API https://github.com/mishoo/UglifyJS2/issues/459	2014-04-13 11:16:10 +02:00
Mihai Bazon	14f290f8ab	Merge pull request #454 from Arnavion/allow-colons-in-wrap_enclose Allow colons in the pairs passed to AST_Toplevel.wrap_enclose	2014-03-24 15:10:35 +02:00
Arnavion	e2e09d5754	Allow colons in the pairs passed to AST_Toplevel.wrap_enclose	2014-03-22 18:02:21 -07:00
Mihai Bazon	448a8d3845	v2.4.13	2014-03-11 15:22:37 +02:00
Conrad Irwin	514936beb8	Handle TryStatements trees from acorn >=0.2.0	2014-03-06 17:07:49 -08:00
Mihai Bazon	f5c09d0bbf	Merge pull request #439 from Arnavion/null-source-in-sourcemap Handle the case when SourceMapConsumer.originalPositionFor returns null source.	2014-03-03 09:19:39 +02:00
Arnavion	014f655c5f	Handle the case when SourceMapConsumer.originalPositionFor returns null source. This happens when SourceMapConsumer does not have a valid position to map the input line and column. This is a change in mozilla/source-map starting from version 0.1.33 Fixes #436	2014-03-02 19:20:19 -08:00
Mihai Bazon	bf30dc3038	Mangle name of exception when --screw-ie8. Fix #430 . The effect of not mangling it was visible only with --screw-ie8 (otherwise the names would be mangled exactly because they leaked into the parent scope).	2014-02-14 13:58:14 +02:00
Mihai Bazon	ef2ef07cbd	Add option `keep_fargs`. By default it's `false`. Pass `true` if you need to keep unused function arguments. Close #188.	2014-02-08 12:33:56 +02:00
Mihai Bazon	1a4440080d	Merge pull request #424 from mattbasta/simplify_conditionals Simplify nested conditionals if possible	2014-02-07 11:31:11 +02:00
Matt Basta	ac0086a745	Simplify nested conditionals if possible	2014-02-06 12:39:13 -08:00
Mihai Bazon	2494daaf68	Merge pull request #422 from mourner/patch-1 Fix readme typo (when -> with)	2014-02-06 18:13:10 +02:00
Vladimir Agafonkin	9b404f9de6	fix readme typo (when -> with)	2014-02-06 18:11:33 +02:00
Mihai Bazon	5344b7dab8	Fix if_return dropping the alternative. Close #413	2014-01-31 10:44:13 +02:00
Mihai Bazon	0007a53b9c	Update source-map	2014-01-26 10:18:20 +02:00
Mihai Bazon	1dd05f44eb	Merge branch 'sourcesContent' of https://github.com/arty-name/UglifyJS2 into arty-name-sourcesContent	2014-01-26 10:15:24 +02:00
Mihai Bazon	bf7b122ab2	v2.4.12	2014-01-26 10:11:00 +02:00
Mihai Bazon	e29048b54a	Merge branch 'master' of github.com:mishoo/UglifyJS2	2014-01-26 10:07:10 +02:00
Mihai Bazon	2eeb640eca	Merge pull request #408 from danielstutzman/escape-null-in-regex Don't unescape \x00 in regexes (it breaks IE8)	2014-01-26 00:06:19 -08:00
Mihai Bazon	ceb200fe81	Move unescaping regexps under a codegen option (`unescape_regexps`)	2014-01-26 10:05:55 +02:00
Daniel Stutzman	f5f8239057	Don't unescape \x00 in regexes (it breaks IE8)	2014-01-25 11:55:39 -07:00
Mihai Bazon	6f9d051784	v2.4.11	2014-01-21 11:44:28 +02:00
Mihai Bazon	931862e97f	More chars that cannot be unescaped in regexps.	2014-01-21 11:44:00 +02:00
Mihai Bazon	1d0127de21	Fix end token for conditionals. Close #404	2014-01-21 10:38:59 +02:00
Mihai Bazon	2d8fc61677	Merge pull request #402 from lautis/bom-regexps Don't unescape byte order marks in regexps	2014-01-19 06:14:12 -08:00
Ville Lautanala	1e31011874	Don't unescape byte order marks in regexps	2014-01-19 12:27:03 +02:00
Mihai Bazon	75cdbf19aa	v2.4.10	2014-01-18 12:32:45 +02:00
Mihai Bazon	4339bd5cfa	Don't unescape \x2f (slash) in regexps. #54	2014-01-18 12:31:50 +02:00
Mihai Bazon	1ab2fdaa10	Fix example	2014-01-17 15:48:47 +02:00
Mihai Bazon	eda540f6ec	v2.4.9	2014-01-15 22:31:09 +02:00
Mihai Bazon	90a330da16	simplify	2014-01-10 10:36:15 +02:00
Mihai Bazon	cad1f9cbd1	Unescape Unicode sequences in regexps when ascii_only is false. #54	2014-01-10 10:33:58 +02:00
Artemy Tregubenko	f6203bd5a8	added hasOwnProperty check to avoid warnings	2014-01-09 15:20:05 +01:00
Artemy Tregubenko	03cf94ebe8	Added support for sourcesContent property of source map	2014-01-09 15:12:00 +01:00
Mihai Bazon	c3087dd179	Better process_for_angular before other statement reductions. #395	2014-01-08 11:39:24 +02:00
Mihai Bazon	2c305af478	Support @ngInject with `angular` compressor option. Close #395 .	2014-01-08 11:28:32 +02:00
Mihai Bazon	72e6f64ca8	Disable node 0.6 since the build fails consistently and it's not our fault.	2014-01-07 18:56:18 +02:00
Mihai Bazon	b9fac687ff	Support SpiderMonkey AST in UglifyJS.minify. Fix #393 .	2014-01-07 18:42:48 +02:00
Mihai Bazon	2c88eb6fbe	doh.	2014-01-07 12:54:14 +02:00
Mihai Bazon	a67e3bfdd3	Fix #392	2014-01-07 12:48:54 +02:00
Mihai Bazon	27142df4f5	minor: exp["10"] => exp[10]	2014-01-07 12:48:21 +02:00
Mihai Bazon	5e4c7f4245	Fix parens for property access -- (foo, bar)["baz"]	2014-01-05 11:48:01 +02:00
Mihai Bazon	b521b4b926	Conditional/call optimization foo ? bar(x) : bar(y) ==> bar(foo ? x : y)	2013-12-29 10:31:30 +02:00
Mihai Bazon	aa9de76370	Mark `yield` as reserved word. Close #375 .	2013-12-22 20:52:19 +02:00
Mihai Bazon	5a083a938d	Optimize seq,void 0. Close #377 . (x, void 0) => void x (x, undefined) => void x	2013-12-22 11:36:45 +02:00
Mihai Bazon	7a30d826b8	Better fix for comments in AST_Exit Close #374	2013-12-18 15:54:12 +02:00
Mihai Bazon	be55a09edf	Take out all comments from an AST_Exit's value Fix #372	2013-12-18 13:30:26 +02:00