v2.5.0

* Use `npm run shrinkwrap` to create a shrinkwrap file with all dependencies pinned
* Update dependency `source-map` to latest (Closes #738)

.gitignore

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

.travis.yml

@@ -1,6 +1,10 @@
 language: node_js
 before_install: "npm install -g npm"
 node_js:
-    - "0.8"
+    - "iojs"
+    - "0.12"
     - "0.10"
-    - "0.11"
+    - "4"
+matrix:
+  fast_finish: true
+sudo: false

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,73 +44,96 @@ variable/function declared in another file will be matched properly.
 If you want to read from STDIN instead, pass a single dash instead of input
 files.
 
+If you wish to pass your options before the input files, separate the two with
+a double dash to prevent input files being used as option arguments:
+
+    uglifyjs --compress --mangle -- input.js
+
 The available options are:
 
 ```
-  --source-map       Specify an output file where to generate source map.
+  --source-map                  Specify an output file where to generate source
-                                                                        [string]
+                                map.
-  --source-map-root  The path to the original source to be included in the
+  --source-map-root             The path to the original source to be included
-                     source map.                                        [string]
+                                in the source map.
-  --source-map-url   The path to the source map to be added in //#
+  --source-map-url              The path to the source map to be added in //#
-                     sourceMappingURL.  Defaults to the value passed with
+                                sourceMappingURL.  Defaults to the value passed
-                     --source-map.                                      [string]
+                                with --source-map.
-  --source-map-include-sources
+  --source-map-include-sources  Pass this flag if you want to include the
-                     Pass this flag if you want to include the content of
+                                content of source files in the source map as
-                     source files in the source map as sourcesContent
+                                sourcesContent property.
-                     property.                                         [boolean]
+  --in-source-map               Input source map, useful if you're compressing
-  --in-source-map    Input source map, useful if you're compressing JS that was
+                                JS that was generated from some other original
-                     generated from some other original code.
+                                code.
-  --screw-ie8        Pass this flag if you don't care about full compliance
+  --screw-ie8                   Pass this flag if you don't care about full
-                     with Internet Explorer 6-8 quirks (by default UglifyJS
+                                compliance with Internet Explorer 6-8 quirks
-                     will try to be IE-proof).                         [boolean]
+                                (by default UglifyJS will try to be IE-proof).
-  --expr             Parse a single expression, rather than a program (for
+  --expr                        Parse a single expression, rather than a
-                     parsing JSON)                                     [boolean]
+                                program (for parsing JSON)
-  -p, --prefix       Skip prefix for original filenames that appear in source
+  -p, --prefix                  Skip prefix for original filenames that appear
-                     maps. For example -p 3 will drop 3 directories from file
+                                in source maps. For example -p 3 will drop 3
-                     names and ensure they are relative paths. You can also
+                                directories from file names and ensure they are
-                     specify -p relative, which will make UglifyJS figure out
+                                relative paths. You can also specify -p
-                     itself the relative paths between original sources, the
+                                relative, which will make UglifyJS figure out
-                     source map and the output file.                    [string]
+                                itself the relative paths between original
-  -o, --output       Output file (default STDOUT).
+                                sources, the source map and the output file.
-  -b, --beautify     Beautify output/specify output options.            [string]
+  -o, --output                  Output file (default STDOUT).
-  -m, --mangle       Mangle names/pass mangler options.                 [string]
+  -b, --beautify                Beautify output/specify output options.
-  -r, --reserved     Reserved names to exclude from mangling.
+  -m, --mangle                  Mangle names/pass mangler options.
-  -c, --compress     Enable compressor/pass compressor options. Pass options
+  -r, --reserved                Reserved names to exclude from mangling.
-                     like -c hoist_vars=false,if_return=false. Use -c with no
+  -c, --compress                Enable compressor/pass compressor options. Pass
-                     argument to use the default compression options.   [string]
+                                options like -c
-  -d, --define       Global definitions                                 [string]
+                                hoist_vars=false,if_return=false. Use -c with
-  -e, --enclose      Embed everything in a big function, with a configurable
+                                no argument to use the default compression
-                     parameter/argument list.                           [string]
+                                options.
-  --comments         Preserve copyright comments in the output. By default this
+  -d, --define                  Global definitions
-                     works like Google Closure, keeping JSDoc-style comments
+  -e, --enclose                 Embed everything in a big function, with a
-                     that contain "@license" or "@preserve". You can optionally
+                                configurable parameter/argument list.
-                     pass one of the following arguments to this flag:
+  --comments                    Preserve copyright comments in the output. By
-                     - "all" to keep all comments
+                                default this works like Google Closure, keeping
-                     - a valid JS regexp (needs to start with a slash) to keep
+                                JSDoc-style comments that contain "@license" or
-                     only comments that match.
+                                "@preserve". You can optionally pass one of the
-                     Note that currently not *all* comments can be kept when
+                                following arguments to this flag:
-                     compression is on, because of dead code removal or
+                                - "all" to keep all comments
-                     cascading statements into sequences.               [string]
+                                - a valid JS regexp (needs to start with a
-  --preamble         Preamble to prepend to the output.  You can use this to
+                                slash) to keep only comments that match.
-                     insert a comment, for example for licensing information.
+                                Note that currently not *all* comments can be
-                     This will not be parsed, but the source map will adjust
+                                kept when compression is on, because of dead
-                     for its presence.
+                                code removal or cascading statements into
-  --stats            Display operations run time on STDERR.            [boolean]
+                                sequences.
-  --acorn            Use Acorn for parsing.                            [boolean]
+  --preamble                    Preamble to prepend to the output.  You can use
-  --spidermonkey     Assume input files are SpiderMonkey AST format (as JSON).
+                                this to insert a comment, for example for
-                                                                       [boolean]
+                                licensing information.  This will not be
-  --self             Build itself (UglifyJS2) as a library (implies
+                                parsed, but the source map will adjust for its
-                     --wrap=UglifyJS --export-all)                     [boolean]
+                                presence.
-  --wrap             Embed everything in a big function, making the “exports”
+  --stats                       Display operations run time on STDERR.
-                     and “global” variables available. You need to pass an
+  --acorn                       Use Acorn for parsing.
-                     argument to this option to specify the name that your
+  --spidermonkey                Assume input files are SpiderMonkey AST format
-                     module will take when included in, say, a browser.
+                                (as JSON).
-                                                                        [string]
+  --self                        Build itself (UglifyJS2) as a library (implies
-  --export-all       Only used when --wrap, this tells UglifyJS to add code to
+                                --wrap=UglifyJS --export-all)
-                     automatically export all globals.                 [boolean]
+  --wrap                        Embed everything in a big function, making the
-  --lint             Display some scope warnings                       [boolean]
+                                “exports” and “global” variables available. You
-  -v, --verbose      Verbose                                           [boolean]
+                                need to pass an argument to this option to
-  -V, --version      Print version number and exit.                    [boolean]
+                                specify the name that your module will take
+                                when included in, say, a browser.
+  --export-all                  Only used when --wrap, this tells UglifyJS to
+                                add code to automatically export all globals.
+  --lint                        Display some scope warnings
+  -v, --verbose                 Verbose
+  -V, --version                 Print version number and exit.
+  --noerr                       Don't throw an error for unknown options in -c,
+                                -b or -m.
+  --bare-returns                Allow return outside of functions.  Useful when
+                                minifying CommonJS modules.
+  --keep-fnames                 Do not mangle/drop function names.  Useful for
+                                code relying on Function.prototype.name.
+  --reserved-file               File containing reserved names
+  --reserve-domprops            Make (most?) DOM properties reserved for
+                                --mangle-props
+  --mangle-props                Mangle property names
+  --mangle-regex                Only mangle property names matching the regex
+  --name-cache                  File to hold mangled names mappings
 ```
 
 Specify `--output` (`-o`) to declare the output file.  Otherwise the output
@@ -184,6 +207,73 @@ comma-separated list of names.  For example:
 
 to prevent the `require`, `exports` and `$` names from being changed.
 
+### Mangling property names (`--mangle-props`)
+
+**Note:** this will probably break your code.  Mangling property names is a
+separate step, different from variable name mangling.  Pass
+`--mangle-props`.  It will mangle all properties that are seen in some
+object literal, or that are assigned to.  For example:
+
+```js
+var x = {
+  foo: 1
+};
+
+x.bar = 2;
+x["baz"] = 3;
+x[condition ? "moo" : "boo"] = 4;
+console.log(x.something());
+```
+
+In the above code, `foo`, `bar`, `baz`, `moo` and `boo` will be replaced
+with single characters, while `something()` will be left as is.
+
+In order for this to be of any use, we should avoid mangling standard JS
+names.  For instance, if your code would contain `x.length = 10`, then
+`length` becomes a candidate for mangling and it will be mangled throughout
+the code, regardless if it's being used as part of your own objects or
+accessing an array's length.  To avoid that, you can use `--reserved-file`
+to pass a filename that should contain the names to be excluded from
+mangling.  This file can be used both for excluding variable names and
+property names.  It could look like this, for example:
+
+```js
+{
+  "vars": [ "define", "require", ... ],
+  "props": [ "length", "prototype", ... ]
+}
+```
+
+`--reserved-file` can be an array of file names (either a single
+comma-separated argument, or you can pass multiple `--reserved-file`
+arguments) — in this case it will exclude names from all those files.
+
+A default exclusion file is provided in `tools/domprops.json` which should
+cover most standard JS and DOM properties defined in various browsers.  Pass
+`--reserve-domprops` to read that in.
+
+You can also use a regular expression to define which property names should be
+mangled.  For example, `--mangle-regex="/^_/"` will only mangle property names
+that start with an underscore.
+
+When you compress multiple files using this option, in order for them to
+work together in the end we need to ensure somehow that one property gets
+mangled to the same name in all of them.  For this, pass `--name-cache
+filename.json` and UglifyJS will maintain these mappings in a file which can
+then be reused.  It should be initially empty.  Example:
+
+```
+rm -f /tmp/cache.json  # start fresh
+uglifyjs file1.js file2.js --mangle-props --name-cache /tmp/cache.json -o part1.js
+uglifyjs file3.js file4.js --mangle-props --name-cache /tmp/cache.json -o part2.js
+```
+
+Now, `part1.js` and `part2.js` will be consistent with each other in terms
+of mangled property names.
+
+Using the name cache is not necessary if you compress all your files in a
+single call to UglifyJS.
+
 ## Compressor options
 
 You need to pass `--compress` (`-c`) to enable the compressor.  Optionally
@@ -260,6 +350,11 @@ to set `true`; it's effectively a shortcut for `foo=true`).
   compressor from discarding unused function arguments.  You need this
   for code which relies on `Function.length`.
 
+- `keep_fnames` -- default `false`.  Pass `true` to prevent the
+  compressor from mangling/discarding function names.  Useful for code relying on
+  `Function.prototype.name`.
+
+
 ### The `unsafe` option
 
 It enables some transformations that *might* break code logic in certain
@@ -267,14 +362,15 @@ contrived cases, but should be fine for most code.  You might want to try it
 on your own code, it should reduce the minified size.  Here's what happens
 when this flag is on:
 
-- `new Array(1, 2, 3)` or `Array(1, 2, 3)` → `[1, 2, 3 ]`
+- `new Array(1, 2, 3)` or `Array(1, 2, 3)` → `[ 1, 2, 3 ]`
 - `new Object()` → `{}`
 - `String(exp)` or `exp.toString()` → `"" + exp`
 - `new Object/RegExp/Function/Error/Array (...)` → we discard the `new`
 - `typeof foo == "undefined"` → `foo === void 0`
 - `void 0` → `undefined` (if there is a variable named "undefined" in
   scope; we do it because the variable name will be mangled, typically
-  reduced to a single character).
+  reduced to a single character)
+- discards unused function arguments (affects `function.length`)
 
 ### Conditional compilation
 
@@ -347,6 +443,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
 
@@ -498,6 +601,16 @@ var result = UglifyJS.minify("compiled.js", {
 // same as before, it returns `code` and `map`
 ```
 
+If your input source map is not in a file, you can pass it in as an object
+using the `inSourceMap` argument:
+
+```javascript
+var result = UglifyJS.minify("compiled.js", {
+	inSourceMap: JSON.parse(my_source_map_string),
+	outSourceMap: "minified.js.map"
+});
+```
+
 The `inSourceMap` is only used if you also request `outSourceMap` (it makes
 no sense otherwise).
 
@@ -612,7 +725,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`.
 

bin/extract-props.js

@@ -0,0 +1,77 @@
+#! /usr/bin/env node
+
+"use strict";
+
+var U2 = require("../tools/node");
+var fs = require("fs");
+var yargs = require("yargs");
+var ARGS = yargs
+    .describe("o", "Output file")
+    .argv;
+var files = ARGS._.slice();
+var output = {
+    vars: {},
+    props: {}
+};
+
+if (ARGS.o) try {
+    output = JSON.parse(fs.readFileSync(ARGS.o, "utf8"));
+} catch(ex) {}
+
+files.forEach(getProps);
+
+if (ARGS.o) {
+    fs.writeFileSync(ARGS.o, JSON.stringify(output, null, 2), "utf8");
+} else {
+    console.log("%s", JSON.stringify(output, null, 2));
+}
+
+function getProps(filename) {
+    var code = fs.readFileSync(filename, "utf8");
+    var ast = U2.parse(code);
+
+    ast.walk(new U2.TreeWalker(function(node){
+        if (node instanceof U2.AST_ObjectKeyVal) {
+            add(node.key);
+        }
+        else if (node instanceof U2.AST_ObjectProperty) {
+            add(node.key.name);
+        }
+        else if (node instanceof U2.AST_Dot) {
+            add(node.property);
+        }
+        else if (node instanceof U2.AST_Sub) {
+            addStrings(node.property);
+        }
+    }));
+
+    function addStrings(node) {
+        var out = {};
+        try {
+            (function walk(node){
+                node.walk(new U2.TreeWalker(function(node){
+                    if (node instanceof U2.AST_Seq) {
+                        walk(node.cdr);
+                        return true;
+                    }
+                    if (node instanceof U2.AST_String) {
+                        add(node.value);
+                        return true;
+                    }
+                    if (node instanceof U2.AST_Conditional) {
+                        walk(node.consequent);
+                        walk(node.alternative);
+                        return true;
+                    }
+                    throw out;
+                }));
+            })(node);
+        } catch(ex) {
+            if (ex !== out) throw ex;
+        }
+    }
+
+    function add(name) {
+        output.props[name] = true;
+    }
+}

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\
@@ -65,6 +65,13 @@ You need to pass an argument to this option to specify the name that your module
     .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)")
+    .describe("reserved-file", "File containing reserved names")
+    .describe("reserve-domprops", "Make (most?) DOM properties reserved for --mangle-props")
+    .describe("mangle-props", "Mangle property names")
+    .describe("mangle-regex", "Only mangle property names matching the regex")
+    .describe("name-cache", "File to hold mangled names mappings")
 
     .alias("p", "prefix")
     .alias("o", "output")
@@ -76,18 +83,27 @@ 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")
     .string("source-map-url")
     .string("b")
+    .string("beautify")
     .string("m")
+    .string("mangle")
     .string("c")
+    .string("compress")
     .string("d")
+    .string("define")
     .string("e")
+    .string("enclose")
     .string("comments")
     .string("wrap")
     .string("p")
+    .string("prefix")
+    .string("name-cache")
+    .array("reserved-file")
 
     .boolean("expr")
     .boolean("source-map-include-sources")
@@ -95,13 +111,18 @@ You need to pass an argument to this option to specify the name that your module
     .boolean("export-all")
     .boolean("self")
     .boolean("v")
+    .boolean("verbose")
     .boolean("stats")
     .boolean("acorn")
     .boolean("spidermonkey")
     .boolean("lint")
     .boolean("V")
+    .boolean("version")
     .boolean("noerr")
     .boolean("bare-returns")
+    .boolean("keep-fnames")
+    .boolean("mangle-props")
+    .boolean("reserve-domprops")
 
     .wrap(80)
 
@@ -112,24 +133,24 @@ normalize(ARGS);
 
 if (ARGS.noerr) {
     UglifyJS.DefaultsError.croak = function(msg, defs) {
-        sys.error("WARN: " + msg);
+        print_error("WARN: " + msg);
     };
 }
 
 if (ARGS.version || ARGS.V) {
     var json = require("../package.json");
-    sys.puts(json.name + ' ' + json.version);
+    print(json.name + ' ' + json.version);
     process.exit(0);
 }
 
 if (ARGS.ast_help) {
     var desc = UglifyJS.describe_ast();
-    sys.puts(typeof desc == "string" ? desc : JSON.stringify(desc, null, 2));
+    print(typeof desc == "string" ? desc : JSON.stringify(desc, null, 2));
     process.exit(0);
 }
 
 if (ARGS.h || ARGS.help) {
-    sys.puts(optimist.help());
+    print(yargs.help());
     process.exit(0);
 }
 
@@ -140,6 +161,15 @@ if (ARGS.acorn) {
 var COMPRESS = getOptions("c", true);
 var MANGLE = getOptions("m", true);
 var BEAUTIFY = getOptions("b", true);
+var RESERVED = null;
+
+if (ARGS.reserved_file) ARGS.reserved_file.forEach(function(filename){
+    RESERVED = UglifyJS.readReservedFile(filename, RESERVED);
+});
+
+if (ARGS.reserve_domprops) {
+    RESERVED = UglifyJS.readDefaultReservedFile(RESERVED);
+}
 
 if (ARGS.d) {
     if (COMPRESS) COMPRESS.global_defs = getOptions("d");
@@ -149,9 +179,36 @@ if (ARGS.r) {
     if (MANGLE) MANGLE.except = ARGS.r.replace(/^\s+|\s+$/g).split(/\s*,+\s*/);
 }
 
+if (RESERVED && MANGLE) {
+    if (!MANGLE.except) MANGLE.except = RESERVED.vars;
+    else MANGLE.except = MANGLE.except.concat(RESERVED.vars);
+}
+
+function readNameCache(key) {
+    return UglifyJS.readNameCache(ARGS.name_cache, key);
+}
+
+function writeNameCache(key, cache) {
+    return UglifyJS.writeNameCache(ARGS.name_cache, key, cache);
+}
+
+function extractRegex(str) {
+  if (/^\/.*\/[a-zA-Z]*$/.test(str)) {
+    var regex_pos = str.lastIndexOf("/");
+    return new RegExp(str.substr(1, regex_pos - 1), str.substr(regex_pos + 1));
+  } else {
+    throw new Error("Invalid regular expression: " + str);
+  }
+}
+
+if (ARGS.quotes === true) {
+    ARGS.quotes = 3;
+}
+
 var OUTPUT_OPTIONS = {
-    beautify: BEAUTIFY ? true : false,
+    beautify    : BEAUTIFY ? true : false,
-    preamble: ARGS.preamble || null,
+    preamble    : ARGS.preamble || null,
+    quote_style : ARGS.quotes != null ? ARGS.quotes : 0
 };
 
 if (ARGS.screw_ie8) {
@@ -160,12 +217,21 @@ 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 (ARGS.comments != null) {
-    if (/^\//.test(ARGS.comments)) {
+    if (/^\/.*\/[a-zA-Z]*$/.test(ARGS.comments)) {
-        OUTPUT_OPTIONS.comments = new Function("return(" + ARGS.comments + ")")();
+        try {
+            OUTPUT_OPTIONS.comments = extractRegex(ARGS.comments);
+        } catch (e) {
+            print_error("ERROR: Invalid --comments: " + e.message);
+        }
     } else if (ARGS.comments == "all") {
         OUTPUT_OPTIONS.comments = true;
     } else {
@@ -184,11 +250,10 @@ var files = ARGS._.slice();
 
 if (ARGS.self) {
     if (files.length > 0) {
-        sys.error("WARN: Ignoring input files since --self was passed");
+        print_error("WARN: Ignoring input files since --self was passed");
     }
     files = UglifyJS.FILES;
     if (!ARGS.wrap) ARGS.wrap = "UglifyJS";
-    ARGS.export_all = true;
 }
 
 var ORIG_MAP = ARGS.in_source_map;
@@ -196,7 +261,7 @@ var ORIG_MAP = ARGS.in_source_map;
 if (ORIG_MAP) {
     ORIG_MAP = JSON.parse(fs.readFileSync(ORIG_MAP));
     if (files.length == 0) {
-        sys.error("INFO: Using file from the input source map: " + ORIG_MAP.file);
+        print_error("INFO: Using file from the input source map: " + ORIG_MAP.file);
         files = [ ORIG_MAP.file ];
     }
     if (ARGS.source_map_root == null) {
@@ -209,12 +274,12 @@ if (files.length == 0) {
 }
 
 if (files.indexOf("-") >= 0 && ARGS.source_map) {
-    sys.error("ERROR: Source map doesn't work with input from STDIN");
+    print_error("ERROR: Source map doesn't work with input from STDIN");
     process.exit(1);
 }
 
 if (files.filter(function(el){ return el == "-" }).length > 1) {
-    sys.error("ERROR: Can read a single file from STDIN (two or more dashes specified)");
+    print_error("ERROR: Can read a single file from STDIN (two or more dashes specified)");
     process.exit(1);
 }
 
@@ -237,9 +302,9 @@ try {
     var compressor = COMPRESS && UglifyJS.Compressor(COMPRESS);
 } catch(ex) {
     if (ex instanceof UglifyJS.DefaultsError) {
-        sys.error(ex.msg);
+        print_error(ex.msg);
-        sys.error("Supported options:");
+        print_error("Supported options:");
-        sys.error(sys.inspect(ex.defs));
+        print_error(sys.inspect(ex.defs));
         process.exit(1);
     }
 }
@@ -247,12 +312,12 @@ try {
 async.eachLimit(files, 1, function (file, cb) {
     read_whole_file(file, function (err, code) {
         if (err) {
-            sys.error("ERROR: can't read file: " + file);
+            print_error("ERROR: can't read file: " + file);
             process.exit(1);
         }
         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)) {
@@ -284,9 +349,9 @@ async.eachLimit(files, 1, function (file, cb) {
                     });
                 } catch(ex) {
                     if (ex instanceof UglifyJS.JS_Parse_Error) {
-                        sys.error("Parse error at " + file + ":" + ex.line + "," + ex.col);
+                        print_error("Parse error at " + file + ":" + ex.line + "," + ex.col);
-                        sys.error(ex.message);
+                        print_error(ex.message);
-                        sys.error(ex.stack);
+                        print_error(ex.stack);
                         process.exit(1);
                     }
                     throw ex;
@@ -300,11 +365,11 @@ async.eachLimit(files, 1, function (file, cb) {
         TOPLEVEL = UglifyJS.AST_Node.from_mozilla_ast(TOPLEVEL);
     });
 
-    if (ARGS.wrap) {
+    if (ARGS.wrap != null) {
         TOPLEVEL = TOPLEVEL.wrap_commonjs(ARGS.wrap, ARGS.export_all);
     }
 
-    if (ARGS.enclose) {
+    if (ARGS.enclose != null) {
         var arg_parameter_list = ARGS.enclose;
         if (arg_parameter_list === true) {
             arg_parameter_list = [];
@@ -315,16 +380,35 @@ async.eachLimit(files, 1, function (file, cb) {
         TOPLEVEL = TOPLEVEL.wrap_enclose(arg_parameter_list);
     }
 
-    var SCOPE_IS_NEEDED = COMPRESS || MANGLE || ARGS.lint;
+    if (ARGS.mangle_props || ARGS.name_cache) (function(){
+        var reserved = RESERVED ? RESERVED.props : null;
+        var cache = readNameCache("props");
+        var regex;
 
-    if (SCOPE_IS_NEEDED) {
+        try {
-        time_it("scope", function(){
+          regex = ARGS.mangle_regex ? extractRegex(ARGS.mangle_regex) : null;
-            TOPLEVEL.figure_out_scope({ screw_ie8: ARGS.screw_ie8 });
+        } catch (e) {
-            if (ARGS.lint) {
+            print_error("ERROR: Invalid --mangle-regex: " + e.message);
-                TOPLEVEL.scope_warnings();
+            process.exit(1);
-            }
+        }
+
+        TOPLEVEL = UglifyJS.mangle_properties(TOPLEVEL, {
+            reserved   : reserved,
+            cache      : cache,
+            only_cache : !ARGS.mangle_props,
+            regex      : regex
         });
-    }
+        writeNameCache("props", cache);
+    })();
+
+    var TL_CACHE = readNameCache("vars");
+
+    time_it("scope", function(){
+        TOPLEVEL.figure_out_scope({ screw_ie8: ARGS.screw_ie8, cache: TL_CACHE });
+        if (ARGS.lint) {
+            TOPLEVEL.scope_warnings();
+        }
+    });
 
     if (COMPRESS) {
         time_it("squeeze", function(){
@@ -332,19 +416,20 @@ async.eachLimit(files, 1, function (file, cb) {
         });
     }
 
-    if (SCOPE_IS_NEEDED) {
+    time_it("scope", function(){
-        time_it("scope", function(){
+        TOPLEVEL.figure_out_scope({ screw_ie8: ARGS.screw_ie8, cache: TL_CACHE });
-            TOPLEVEL.figure_out_scope({ screw_ie8: ARGS.screw_ie8 });
+        if (MANGLE && !TL_CACHE) {
-            if (MANGLE) {
+            TOPLEVEL.compute_char_frequency(MANGLE);
-                TOPLEVEL.compute_char_frequency(MANGLE);
+        }
-            }
+    });
-        });
-    }
 
     if (MANGLE) time_it("mangle", function(){
+        MANGLE.cache = TL_CACHE;
         TOPLEVEL.mangle_names(MANGLE);
     });
 
+    writeNameCache("vars", TL_CACHE);
+
     if (ARGS.source_map_include_sources) {
         for (var file in SOURCES_CONTENT) {
             if (SOURCES_CONTENT.hasOwnProperty(file)) {
@@ -372,15 +457,15 @@ async.eachLimit(files, 1, function (file, cb) {
     if (OUTPUT_FILE) {
         fs.writeFileSync(OUTPUT_FILE, output, "utf8");
     } else {
-        sys.print(output);
+        print(output);
     }
 
     if (ARGS.stats) {
-        sys.error(UglifyJS.string_template("Timing information (compressed {count} files):", {
+        print_error(UglifyJS.string_template("Timing information (compressed {count} files):", {
             count: files.length
         }));
         for (var i in STATS) if (STATS.hasOwnProperty(i)) {
-            sys.error(UglifyJS.string_template("- {name}: {time}s", {
+            print_error(UglifyJS.string_template("- {name}: {time}s", {
                 name: i,
                 time: (STATS[i] / 1000).toFixed(3)
             }));
@@ -399,15 +484,15 @@ function normalize(o) {
 
 function getOptions(x, constants) {
     x = ARGS[x];
-    if (!x) return null;
+    if (x == null) return null;
     var ret = {};
-    if (x !== true) {
+    if (x !== "") {
         var ast;
         try {
             ast = UglifyJS.parse(x, { expression: true });
         } catch(ex) {
             if (ex instanceof UglifyJS.JS_Parse_Error) {
-                sys.error("Error parsing arguments in: " + x);
+                print_error("Error parsing arguments in: " + x);
                 process.exit(1);
             }
         }
@@ -426,8 +511,8 @@ function getOptions(x, constants) {
                 ret[name] = true;
                 return true;    // no descend
             }
-            sys.error(node.TYPE)
+            print_error(node.TYPE)
-            sys.error("Error parsing arguments in: " + x);
+            print_error("Error parsing arguments in: " + x);
             process.exit(1);
         }));
     }
@@ -459,3 +544,11 @@ function time_it(name, cont) {
     }
     return ret;
 }
+
+function print_error(msg) {
+    console.error("%s", msg);
+}
+
+function print(txt) {
+    console.log("%s", txt);
+}

lib/ast.js

@@ -81,10 +81,11 @@ function DEFNODE(type, props, methods, base) {
     ctor.DEFMETHOD = function(name, method) {
         this.prototype[name] = method;
     };
+    exports["AST_" + type] = ctor;
     return ctor;
 };
 
-var AST_Token = DEFNODE("Token", "type value line col pos endpos nlb comments_before file", {
+var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before file", {
 }, null);
 
 var AST_Node = DEFNODE("Node", "start end", {
@@ -120,11 +121,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 +207,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", {
@@ -322,12 +330,11 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
                 }
             }));
         }
-        var wrapped_tl = "(function(exports, global){ global['" + name + "'] = exports; '$ORIG'; '$EXPORTS'; }({}, (function(){return this}())))";
+        var wrapped_tl = "(function(exports, global){ '$ORIG'; '$EXPORTS'; global['" + name + "'] = exports; }({}, (function(){return this}())))";
         wrapped_tl = parse(wrapped_tl);
         wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node){
-            if (node instanceof AST_SimpleStatement) {
+            if (node instanceof AST_Directive) {
-                node = node.body;
+                switch (node.value) {
-                if (node instanceof AST_String) switch (node.getValue()) {
                   case "$ORIG":
                     return MAP.splice(self.body);
                   case "$EXPORTS":
@@ -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,17 +856,19 @@ var AST_Constant = DEFNODE("Constant", null, {
     }
 });
 
-var AST_String = DEFNODE("String", "value", {
+var AST_String = DEFNODE("String", "value quote", {
     $documentation: "A string literal",
     $propdoc: {
-        value: "[string] the contents of this string"
+        value: "[string] the contents of this string",
+        quote: "[string] the original quote character"
     }
 }, AST_Constant);
 
-var AST_Number = DEFNODE("Number", "value", {
+var AST_Number = DEFNODE("Number", "value literal", {
     $documentation: "A number literal",
     $propdoc: {
-        value: "[number] the numeric value"
+        value: "[number] the numeric value",
+        literal: "[string] numeric value as string (optional)"
     }
 }, AST_Constant);
 

lib/compress.js

@@ -61,7 +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_fargs    : true,
+        keep_fnames   : false,
         hoist_vars    : false,
         if_return     : !false_by_default,
         join_vars     : !false_by_default,
@@ -110,6 +111,7 @@ merge(Compressor.prototype, {
         node.DEFMETHOD("optimize", function(compressor){
             var self = this;
             if (self._optimized) return self;
+            if (compressor.has_directive("use asm")) return self;
             var opt = optimizer(self, compressor);
             opt._optimized = true;
             if (opt === self) return opt;
@@ -162,10 +164,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
@@ -225,6 +227,17 @@ 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, {
@@ -233,37 +246,56 @@ merge(Compressor.prototype, {
                             expression: make_node(AST_SymbolRef, name, name),
                             property: "$inject"
                         }),
-                        right: make_node(AST_Array, func, {
+                        right: make_array(func, make_arguments_names_list(func))
-                            elements: func.argnames.map(function(sym){
-                                return make_node(AST_String, sym, { value: sym.name });
-                            })
-                        })
                     })
                 });
             }
+            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);
-                var token = stat.start;
+
-                var comments = token.comments_before;
+                if (stat.body && stat.body.args) {
-                if (comments && comments.length > 0) {
+                    check_expression(stat.body);
-                    var last = comments.pop();
+                } else {
-                    if (/@ngInject/.test(last.value)) {
+                    var token = stat.start;
-                        // case 1: defun
+                    var comments = token.comments_before;
-                        if (stat instanceof AST_Defun) {
+                    if (comments && comments.length > 0) {
-                            a.push(make_injector(stat, stat.name));
+                        var last = comments.pop();
-                        }
+                        if (has_inject(last)) {
-                        else if (stat instanceof AST_Definitions) {
+                            // case 1: defun
-                            stat.definitions.forEach(function(def){
+                            if (stat instanceof AST_Defun) {
-                                if (def.value && def.value instanceof AST_Lambda) {
+                                a.push(make_injector(stat, stat.name));
-                                    a.push(make_injector(def.value, def.name));
+                            }
-                                }
+                            else if (stat instanceof AST_Definitions) {
-                            });
+                                stat.definitions.forEach(function(def) {
-                        }
+                                    if (def.value && def.value instanceof AST_Lambda) {
-                        else {
+                                        a.push(make_injector(def.value, def.name));
-                            compressor.warn("Unknown statement marked with @ngInject [{file}:{line},{col}]", token);
+                                    }
+                                });
+                            }
+                            else {
+                                compressor.warn("Unknown statement marked with @ngInject [{file}:{line},{col}]", token);
+                            }
                         }
                     }
                 }
+
                 return a;
             }, []);
         }
@@ -458,7 +490,7 @@ merge(Compressor.prototype, {
                 seq = [];
             };
             statements.forEach(function(stat){
-                if (stat instanceof AST_SimpleStatement) seq.push(stat.body);
+                if (stat instanceof AST_SimpleStatement && seq.length < 2000) seq.push(stat.body);
                 else push_seq(), ret.push(stat);
             });
             push_seq();
@@ -865,6 +897,7 @@ merge(Compressor.prototype, {
         def(AST_Call, function(compressor){
             var pure = compressor.option("pure_funcs");
             if (!pure) return true;
+            if (typeof pure == "function") return pure(this);
             return pure.indexOf(this.expression.print_to_string()) < 0;
         });
 
@@ -949,7 +982,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);
@@ -994,6 +1027,7 @@ merge(Compressor.prototype, {
 
     AST_Scope.DEFMETHOD("drop_unused", function(compressor){
         var self = this;
+        if (compressor.has_directive("use asm")) return self;
         if (compressor.option("unused")
             && !(self instanceof AST_Toplevel)
             && !self.uses_eval
@@ -1137,12 +1171,12 @@ merge(Compressor.prototype, {
                             return make_node(AST_EmptyStatement, node);
                         }
                         if (def.length == 0) {
-                            return side_effects;
+                            return in_list ? MAP.splice(side_effects.body) : side_effects;
                         }
                         node.definitions = def;
                         if (side_effects) {
                             side_effects.body.unshift(node);
-                            node = side_effects;
+                            return in_list ? MAP.splice(side_effects.body) : side_effects;
                         }
                         return node;
                     }
@@ -1173,9 +1207,10 @@ merge(Compressor.prototype, {
     });
 
     AST_Scope.DEFMETHOD("hoist_declarations", function(compressor){
+        var self = this;
+        if (compressor.has_directive("use asm")) return self;
         var hoist_funs = compressor.option("hoist_funs");
         var hoist_vars = compressor.option("hoist_vars");
-        var self = this;
         if (hoist_funs || hoist_vars) {
             var dirs = [];
             var hoisted = [];
@@ -1666,7 +1701,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;
             }
@@ -1722,6 +1757,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
@@ -1837,11 +1877,16 @@ merge(Compressor.prototype, {
             }
         }
         if (compressor.option("drop_console")) {
-            if (self.expression instanceof AST_PropAccess &&
+            if (self.expression instanceof AST_PropAccess) {
-                self.expression.expression instanceof AST_SymbolRef &&
+                var name = self.expression.expression;
-                self.expression.expression.name == "console" &&
+                while (name.expression) {
-                self.expression.expression.undeclared()) {
+                    name = name.expression;
-                return make_node(AST_Undefined, self).transform(compressor);
+                }
+                if (name instanceof AST_SymbolRef
+                    && name.name == "console"
+                    && name.undeclared()) {
+                    return make_node(AST_Undefined, self).transform(compressor);
+                }
             }
         }
         return self.evaluate(compressor)[0];
@@ -1868,15 +1913,11 @@ merge(Compressor.prototype, {
         if (!compressor.option("side_effects"))
             return self;
         if (!self.car.has_side_effects(compressor)) {
-            // we shouldn't compress (1,eval)(something) to
+            // we shouldn't compress (1,func)(something) to
-            // eval(something) because that changes the meaning of
+            // func(something) because that changes the meaning of
-            // eval (becomes lexical instead of global).
+            // the func (becomes lexical instead of global).
-            var p;
+            var p = compressor.parent();
-            if (!(self.cdr instanceof AST_SymbolRef
+            if (!(p instanceof AST_Call && p.expression === self)) {
-                  && self.cdr.name == "eval"
-                  && self.cdr.undeclared()
-                  && (p = compressor.parent()) instanceof AST_Call
-                  && p.expression === self)) {
                 return self.cdr;
             }
         }
@@ -1901,7 +1942,7 @@ merge(Compressor.prototype, {
         if (self.cdr instanceof AST_UnaryPrefix
             && self.cdr.operator == "void"
             && !self.cdr.expression.has_side_effects(compressor)) {
-            self.cdr.operator = self.car;
+            self.cdr.expression = self.car;
             return self.cdr;
         }
         if (self.cdr instanceof AST_Undefined) {
@@ -1990,15 +2031,14 @@ merge(Compressor.prototype, {
     var commutativeOperators = makePredicate("== === != !== * & | ^");
 
     OPT(AST_Binary, function(self, compressor){
-        var reverse = compressor.has_directive("use asm") ? noop
+        function reverse(op, force) {
-            : function(op, force) {
+            if (force || !(self.left.has_side_effects(compressor) || self.right.has_side_effects(compressor))) {
-                if (force || !(self.left.has_side_effects(compressor) || self.right.has_side_effects(compressor))) {
+                if (op) self.operator = op;
-                    if (op) self.operator = op;
+                var tmp = self.left;
-                    var tmp = self.left;
+                self.left = self.right;
-                    self.left = self.right;
+                self.right = tmp;
-                    self.right = tmp;
+            }
-                }
+        }
-            };
         if (commutativeOperators(self.operator)) {
             if (self.right instanceof AST_Constant
                 && !(self.left instanceof AST_Constant)) {
@@ -2063,12 +2103,46 @@ merge(Compressor.prototype, {
             }
             break;
         }
+        if (compressor.option("conditionals")) {
+            if (self.operator == "&&") {
+                var ll = self.left.evaluate(compressor);
+                if (ll.length > 1) {
+                    if (ll[1]) {
+                        compressor.warn("Condition left of && always true [{file}:{line},{col}]", self.start);
+                        var rr = self.right.evaluate(compressor);
+                        return rr[0];
+                    } else {
+                        compressor.warn("Condition left of && always false [{file}:{line},{col}]", self.start);
+                        return ll[0];
+                    }
+                }
+            }
+            else if (self.operator == "||") {
+                var ll = self.left.evaluate(compressor);
+                if (ll.length > 1) {
+                    if (ll[1]) {
+                        compressor.warn("Condition left of || always true [{file}:{line},{col}]", self.start);
+                        return ll[0];
+                    } else {
+                        compressor.warn("Condition left of || always false [{file}:{line},{col}]", self.start);
+                        var rr = self.right.evaluate(compressor);
+                        return rr[0];
+                    }
+                }
+            }
+        }
         if (compressor.option("booleans") && compressor.in_boolean_context()) switch (self.operator) {
           case "&&":
             var ll = self.left.evaluate(compressor);
             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]) {
@@ -2083,6 +2157,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]) {
@@ -2102,7 +2182,7 @@ merge(Compressor.prototype, {
             }
             break;
         }
-        if (compressor.option("comparisons")) {
+        if (compressor.option("comparisons") && self.is_boolean()) {
             if (!(compressor.parent() instanceof AST_Binary)
                 || compressor.parent() instanceof AST_Assign) {
                 var negated = make_node(AST_UnaryPrefix, self, {
@@ -2177,10 +2257,11 @@ merge(Compressor.prototype, {
                 }
             }
         }
-        // x * (y * z)  ==>  x * y * z
+        // x && (y && z)  ==>  x && y && z
+        // x || (y || z)  ==>  x || y || z
         if (self.right instanceof AST_Binary
             && self.right.operator == self.operator
-            && (self.operator == "*" || self.operator == "&&" || self.operator == "||"))
+            && (self.operator == "&&" || self.operator == "||"))
         {
             self.left = make_node(AST_Binary, self.left, {
                 operator : self.operator,
@@ -2194,7 +2275,15 @@ merge(Compressor.prototype, {
     });
 
     OPT(AST_SymbolRef, function(self, compressor){
-        if (self.undeclared()) {
+        function isLHS(symbol, parent) {
+            return (
+                parent instanceof AST_Binary &&
+                parent.operator === '=' &&
+                parent.left === symbol
+            );
+        }
+
+        if (self.undeclared() && !isLHS(self, compressor.parent())) {
             var defines = compressor.option("global_defs");
             if (defines && defines.hasOwnProperty(self.name)) {
                 return make_node_from_constant(compressor, defines[self.name], self);
@@ -2203,14 +2292,22 @@ 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, self, {value: 1}),
+            right    : make_node(AST_Number, self, {value: 0})
+        });
+    });
+
     OPT(AST_Undefined, function(self, compressor){
         if (compressor.option("unsafe")) {
             var scope = compressor.find_parent(AST_Scope);
@@ -2274,6 +2371,7 @@ merge(Compressor.prototype, {
             && alternative instanceof AST_Assign
             && consequent.operator == alternative.operator
             && consequent.left.equivalent_to(alternative.left)
+            && !consequent.left.has_side_effects(compressor)
            ) {
             /*
              * Stuff like this:
@@ -2294,6 +2392,7 @@ merge(Compressor.prototype, {
         if (consequent instanceof AST_Call
             && alternative.TYPE === consequent.TYPE
             && consequent.args.length == alternative.args.length
+            && !consequent.expression.has_side_effects(compressor)
             && consequent.expression.equivalent_to(alternative.expression)) {
             if (consequent.args.length == 0) {
                 return make_node(AST_Seq, self, {
@@ -2334,6 +2433,20 @@ merge(Compressor.prototype, {
 
             }
         }
+        // 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;
     });
 
@@ -2397,7 +2510,7 @@ merge(Compressor.prototype, {
     });
 
     function literals_in_boolean_context(self, compressor) {
-        if (compressor.option("booleans") && compressor.in_boolean_context()) {
+        if (compressor.option("booleans") && compressor.in_boolean_context() && !self.has_side_effects(compressor)) {
             return make_node(AST_True, self);
         }
         return self;

lib/mozilla-ast.js

@@ -370,32 +370,36 @@
     /* -----[ tools ]----- */
 
     function my_start_token(moznode) {
-        var loc = moznode.loc;
+        var loc = moznode.loc, start = loc && loc.start;
         var range = moznode.range;
         return new AST_Token({
-            file   : loc && loc.source,
+            file    : loc && loc.source,
-            line   : loc && loc.start.line,
+            line    : start && start.line,
-            col    : loc && loc.start.column,
+            col     : start && start.column,
-            pos    : range ? range[0] : moznode.start,
+            pos     : range ? range[0] : moznode.start,
-            endpos : 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;
+        var loc = moznode.loc, end = loc && loc.end;
         var range = moznode.range;
         return new AST_Token({
-            file   : loc && loc.source,
+            file    : loc && loc.source,
-            line   : loc && loc.end.line,
+            line    : end && end.line,
-            col    : loc && loc.end.column,
+            col     : end && end.column,
-            pos    : range ? range[1] : moznode.end,
+            pos     : range ? range[1] : moznode.end,
-            endpos : 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.name + "({\n" +
+        moz_to_me += "return new U2." + mytype.name + "({\n" +
             "start: my_start_token(M),\n" +
             "end: my_end_token(M)";
 
@@ -438,8 +442,8 @@
         //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 + ")")(
+        moz_to_me = new Function("U2", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
-            my_start_token, my_end_token, from_moz
+            exports, my_start_token, my_end_token, from_moz
         );
         me_to_moz = new Function("to_moz", "to_moz_block", "return(" + me_to_moz + ")")(
             to_moz, to_moz_block
@@ -465,23 +469,16 @@
         return ast;
     };
 
-    function moz_sub_loc(token) {
+    function set_moz_loc(mynode, moznode, myparent) {
-        return token.line ? {
-            line: token.line,
-            column: token.col
-        } : null;
-    };
-
-    function set_moz_loc(mynode, moznode) {
         var start = mynode.start;
         var end = mynode.end;
-        if (start.pos != null && end.pos != null) {
+        if (start.pos != null && end.endpos != null) {
-            moznode.range = [start.pos, end.pos];
+            moznode.range = [start.pos, end.endpos];
         }
         if (start.line) {
             moznode.loc = {
-                start: moz_sub_loc(start),
+                start: {line: start.line, column: start.col},
-                end: moz_sub_loc(end)
+                end: end.endline ? {line: end.endline, column: end.endcol} : null
             };
             if (start.file) {
                 moznode.loc.source = start.file;

lib/output.js

@@ -60,9 +60,11 @@ function OutputStream(options) {
         bracketize       : false,
         semicolons       : true,
         comments         : false,
+        shebang          : true,
         preserve_line    : false,
         screw_ie8        : false,
         preamble         : null,
+        quote_style      : 0
     }, true);
 
     var indentation = 0;
@@ -84,9 +86,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";
@@ -98,16 +100,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, "\\'") + "'";
+        switch (options.quote_style) {
-        else return '"' + str.replace(/\x22/g, '\\"') + '"';
+          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) {
+    function encode_string(str, quote) {
-        var ret = make_string(str);
+        var ret = make_string(str, quote);
         if (options.inline_script)
             ret = ret.replace(/<\x2fscript([>\/\t\n\f\r ])/gi, "<\\/script$1");
         return ret;
@@ -145,6 +162,8 @@ function OutputStream(options) {
         str = String(str);
         var ch = str.charAt(0);
         if (might_need_semicolon) {
+            might_need_semicolon = false;
+
             if ((!ch || ";}".indexOf(ch) < 0) && !/[;]$/.test(last)) {
                 if (options.semicolons || requireSemicolonChars(ch)) {
                     OUTPUT += ";";
@@ -155,12 +174,17 @@ function OutputStream(options) {
                     current_pos++;
                     current_line++;
                     current_col = 0;
+
+                    if (/^\s+$/.test(str)) {
+                        // reset the semicolon flag, since we didn't print one
+                        // now and might still have to later
+                        might_need_semicolon = true;
+                    }
                 }
+
                 if (!options.beautify)
                     might_need_space = false;
             }
-            might_need_semicolon = false;
-            maybe_newline();
         }
 
         if (!options.beautify && options.preserve_line && stack[stack.length - 1]) {
@@ -221,7 +245,7 @@ function OutputStream(options) {
 
     var newline = options.beautify ? function() {
         print("\n");
-    } : noop;
+    } : maybe_newline;
 
     var semicolon = options.beautify ? function() {
         print(";");
@@ -323,7 +347,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,
@@ -380,54 +404,69 @@ function OutputStream(options) {
 
     AST_Node.DEFMETHOD("add_comments", function(output){
         var c = output.option("comments"), self = this;
-        if (c) {
+        var start = self.start;
-            var start = self.start;
+        if (start && !start._comments_dumped) {
-            if (start && !start._comments_dumped) {
+            start._comments_dumped = true;
-                start._comments_dumped = true;
+            var comments = start.comments_before || [];
-                var comments = start.comments_before || [];
 
-                // XXX: ugly fix for https://github.com/mishoo/UglifyJS2/issues/112
+            // XXX: ugly fix for https://github.com/mishoo/UglifyJS2/issues/112
-                //               and https://github.com/mishoo/UglifyJS2/issues/372
+            //               and https://github.com/mishoo/UglifyJS2/issues/372
-                if (self instanceof AST_Exit && self.value) {
+            if (self instanceof AST_Exit && self.value) {
-                    self.value.walk(new TreeWalker(function(node){
+                self.value.walk(new TreeWalker(function(node){
-                        if (node.start && node.start.comments_before) {
+                    if (node.start && node.start.comments_before) {
-                            comments = comments.concat(node.start.comments_before);
+                        comments = comments.concat(node.start.comments_before);
-                            node.start.comments_before = [];
+                        node.start.comments_before = [];
-                        }
+                    }
-                        if (node instanceof AST_Function ||
+                    if (node instanceof AST_Function ||
-                            node instanceof AST_Array ||
+                        node instanceof AST_Array ||
-                            node instanceof AST_Object)
+                        node instanceof AST_Object)
-                        {
+                    {
-                            return true; // don't go inside.
+                        return true; // don't go inside.
-                        }
+                    }
-                    }));
+                }));
-                }
+            }
 
-                if (c.test) {
+            if (!c) {
-                    comments = comments.filter(function(comment){
+                comments = comments.filter(function(comment) {
-                        return c.test(comment.value);
+                    return comment.type == "comment5";
-                    });
+                });
-                } else if (typeof c == "function") {
+            } else if (c.test) {
-                    comments = comments.filter(function(comment){
+                comments = comments.filter(function(comment){
-                        return c(self, comment);
+                    return c.test(comment.value) || comment.type == "comment5";
-                    });
+                });
-                }
+            } else if (typeof c == "function") {
-                comments.forEach(function(c){
+                comments = comments.filter(function(comment){
-                    if (/comment[134]/.test(c.type)) {
+                    return c(self, comment) || comment.type == "comment5";
-                        output.print("//" + c.value + "\n");
-                        output.indent();
-                    }
-                    else if (c.type == "comment2") {
-                        output.print("/*" + c.value + "*/");
-                        if (start.nlb) {
-                            output.print("\n");
-                            output.indent();
-                        } else {
-                            output.space();
-                        }
-                    }
                 });
             }
+
+            // 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");
+                    output.indent();
+                }
+                else if (c.type == "comment2") {
+                    output.print("/*" + c.value + "*/");
+                    if (start.nlb) {
+                        output.print("\n");
+                        output.indent();
+                    } else {
+                        output.space();
+                    }
+                }
+                else if (output.pos() === 0 && c.type == "comment5" && output.option("shebang")) {
+                    output.print("#!" + c.value + "\n");
+                    output.indent();
+                }
+            });
         }
     });
 
@@ -549,12 +588,6 @@ function OutputStream(options) {
             return true;
     });
 
-    PARENS(AST_NaN, function(output){
-        var p = output.parent();
-        if (p instanceof AST_PropAccess && p.expression === this)
-            return true;
-    });
-
     PARENS([ AST_Assign, AST_Conditional ], function (output){
         var p = output.parent();
         // !(a = false) → true
@@ -577,7 +610,7 @@ function OutputStream(options) {
     /* -----[ 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){
@@ -1073,6 +1106,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"
@@ -1083,7 +1117,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);
@@ -1109,10 +1143,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");
@@ -1121,10 +1155,16 @@ 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()));
+        if (self.literal !== undefined
+            && +self.literal === self.value  /* paranoid check */
+            && self.scope && self.scope.has_directive('use asm')) {
+            output.print(self.literal);
+        } else {
+            output.print(make_num(self.getValue()));
+        }
     });
 
     function regexp_safe_literal(code) {

lib/parse.js

@@ -108,7 +108,7 @@ var OPERATORS = makePredicate([
     "||"
 ]);
 
-var WHITESPACE_CHARS = makePredicate(characters(" \u00a0\n\r\t\f\u000b\u200b\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000"));
+var WHITESPACE_CHARS = makePredicate(characters(" \u00a0\n\r\t\f\u000b\u200b\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\uFEFF"));
 
 var PUNC_BEFORE_EXPRESSION = makePredicate(characters("[{(,.;:"));
 
@@ -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,6 +169,7 @@ 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)
     ;
 };
 
@@ -181,8 +187,9 @@ function parse_js_number(num) {
     }
 };
 
-function JS_Parse_Error(message, line, col, pos) {
+function JS_Parse_Error(message, filename, line, col, pos) {
     this.message = message;
+    this.filename = filename;
     this.line = line;
     this.col = col;
     this.pos = pos;
@@ -194,7 +201,7 @@ JS_Parse_Error.prototype.toString = function() {
 };
 
 function js_error(message, filename, line, col, pos) {
-    throw new JS_Parse_Error(message, line, col, pos);
+    throw new JS_Parse_Error(message, filename, line, col, pos);
 };
 
 function is_token(token, type, val) {
@@ -203,10 +210,10 @@ function is_token(token, type, val) {
 
 var EX_EOF = {};
 
-function tokenizer($TEXT, filename, html5_comments) {
+function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     var S = {
-        text            : $TEXT.replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/\uFEFF/g, ''),
+        text            : $TEXT,
         filename        : filename,
         pos             : 0,
         tokpos          : 0,
@@ -225,10 +232,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;
         }
@@ -262,14 +274,16 @@ function tokenizer($TEXT, filename, html5_comments) {
                            (type == "punc" && PUNC_BEFORE_EXPRESSION(value)));
         prev_was_dot = (type == "punc" && value == ".");
         var ret = {
-            type   : type,
+            type    : type,
-            value  : value,
+            value   : value,
-            line   : S.tokline,
+            line    : S.tokline,
-            col    : S.tokcol,
+            col     : S.tokcol,
-            pos    : S.tokpos,
+            pos     : S.tokpos,
-            endpos : S.pos,
+            endline : S.line,
-            nlb    : S.newline_before,
+            endcol  : S.col,
-            file   : filename
+            endpos  : S.pos,
+            nlb     : S.newline_before,
+            file    : filename
         };
         if (!is_comment) {
             ret.comments_before = S.comments_before;
@@ -284,7 +298,8 @@ function tokenizer($TEXT, filename, html5_comments) {
     };
 
     function skip_whitespace() {
-        while (WHITESPACE_CHARS(peek()))
+        var ch;
+        while (WHITESPACE_CHARS(ch = peek()) || ch == "\u2028" || ch == "\u2029")
             next();
     };
 
@@ -320,7 +335,11 @@ function tokenizer($TEXT, filename, html5_comments) {
         if (prefix) num = prefix + num;
         var valid = parse_js_number(num);
         if (!isNaN(valid)) {
-            return token("num", valid);
+            var tok = token("num", valid);
+            if (num.indexOf('.') >= 0) {
+                tok.literal = num;
+            }
+            return tok;
         } else {
             parse_error("Invalid syntax: " + num);
         }
@@ -339,8 +358,13 @@ function tokenizer($TEXT, filename, html5_comments) {
           case 120 : return String.fromCharCode(hex_bytes(2)); // \x
           case 117 : return String.fromCharCode(hex_bytes(4)); // \u
           case 10  : return ""; // newline
-          default  : return ch;
+          case 13  :            // \r
+            if (peek() == "\n") { // DOS newline
+                next(true, in_string);
+                return "";
+            }
         }
+        return ch;
     };
 
     function hex_bytes(n) {
@@ -354,10 +378,10 @@ 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);
+            var ch = next(true, true);
             if (ch == "\\") {
                 // read OctalEscapeSequence (XXX: deprecated if "strict mode")
                 // https://github.com/mishoo/UglifyJS/issues/178
@@ -379,7 +403,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) {
@@ -392,6 +418,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();
@@ -457,7 +484,11 @@ function tokenizer($TEXT, filename, html5_comments) {
             regexp += ch;
         }
         var mods = read_name();
-        return token("regexp", new RegExp(regexp, mods));
+        try {
+          return token("regexp", new RegExp(regexp, mods));
+        } catch(e) {
+          parse_error(e.message);
+        }
     });
 
     function read_operator(prefix) {
@@ -533,7 +564,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();
         }
@@ -541,6 +572,13 @@ function tokenizer($TEXT, filename, html5_comments) {
         if (PUNC_CHARS(ch)) return token("punc", next());
         if (OPERATOR_CHARS(ch)) return read_operator();
         if (code == 92 || is_identifier_start(code)) return read_word();
+
+        if (shebang) {
+            if (S.pos == 0 && looking_at("#!")) {
+                forward(2);
+                return skip_line_comment("comment5");
+            }
+        }
         parse_error("Unexpected character '" + ch + "'");
     };
 
@@ -610,12 +648,13 @@ function parse($TEXT, options) {
         expression     : false,
         html5_comments : true,
         bare_returns   : false,
+        shebang        : true,
     });
 
     var S = {
         input         : (typeof $TEXT == "string"
                          ? tokenizer($TEXT, options.filename,
-                                     options.html5_comments)
+                                     options.html5_comments, options.shebang)
                          : $TEXT),
         token         : null,
         prev          : null,
@@ -723,8 +762,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", ","))
+            if (dir && stat.body instanceof AST_String && !is("punc", ",")) {
-                return new AST_Directive({ value: stat.body.value });
+                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":
@@ -1081,7 +1126,7 @@ function parse($TEXT, options) {
         });
     };
 
-    var new_ = function() {
+    var new_ = function(allow_calls) {
         var start = S.token;
         expect_token("operator", "new");
         var newexp = expr_atom(false), args;
@@ -1096,7 +1141,7 @@ function parse($TEXT, options) {
             expression : newexp,
             args       : args,
             end        : prev()
-        }), true);
+        }), allow_calls);
     };
 
     function as_atom_node() {
@@ -1107,10 +1152,15 @@ function parse($TEXT, options) {
             ret = _make_symbol(AST_SymbolRef);
             break;
           case "num":
-            ret = new AST_Number({ start: tok, end: tok, value: tok.value });
+            ret = new AST_Number({ start: tok, end: tok, value: tok.value, literal: tok.literal });
             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 });
@@ -1135,7 +1185,7 @@ function parse($TEXT, options) {
 
     var expr_atom = function(allow_calls) {
         if (is("operator", "new")) {
-            return new_();
+            return new_(allow_calls);
         }
         var start = S.token;
         if (is("punc")) {
@@ -1223,6 +1273,7 @@ function parse($TEXT, options) {
             expect(":");
             a.push(new AST_ObjectKeyVal({
                 start : start,
+                quote : start.quote,
                 key   : name,
                 value : expression(false),
                 end   : prev()

lib/propmangle.js

@@ -0,0 +1,223 @@
+/***********************************************************************
+
+  A JavaScript tokenizer / parser / beautifier / compressor.
+  https://github.com/mishoo/UglifyJS2
+
+  -------------------------------- (C) ---------------------------------
+
+                           Author: Mihai Bazon
+                         <mihai.bazon@gmail.com>
+                       http://mihai.bazon.net/blog
+
+  Distributed under the BSD license:
+
+    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+        * Redistributions of source code must retain the above
+          copyright notice, this list of conditions and the following
+          disclaimer.
+
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+
+ ***********************************************************************/
+
+"use strict";
+
+function find_builtins() {
+    var a = [];
+    [ Object, Array, Function, Number,
+      String, Boolean, Error, Math,
+      Date, RegExp
+    ].forEach(function(ctor){
+        Object.getOwnPropertyNames(ctor).map(add);
+        if (ctor.prototype) {
+            Object.getOwnPropertyNames(ctor.prototype).map(add);
+        }
+    });
+    function add(name) {
+        push_uniq(a, name);
+    }
+    return a;
+}
+
+function mangle_properties(ast, options) {
+    options = defaults(options, {
+        reserved : null,
+        cache : null,
+        only_cache : false,
+        regex : null
+    });
+
+    var reserved = options.reserved;
+    if (reserved == null)
+        reserved = find_builtins();
+
+    var cache = options.cache;
+    if (cache == null) {
+        cache = {
+            cname: -1,
+            props: new Dictionary()
+        };
+    }
+
+    var regex = options.regex;
+
+    var names_to_mangle = [];
+    var unmangleable = [];
+
+    // step 1: find candidates to mangle
+    ast.walk(new TreeWalker(function(node){
+        if (node instanceof AST_ObjectKeyVal) {
+            add(node.key);
+        }
+        else if (node instanceof AST_ObjectProperty) {
+            // setter or getter, since KeyVal is handled above
+            add(node.key.name);
+        }
+        else if (node instanceof AST_Dot) {
+            if (this.parent() instanceof AST_Assign) {
+                add(node.property);
+            }
+        }
+        else if (node instanceof AST_Sub) {
+            if (this.parent() instanceof AST_Assign) {
+                addStrings(node.property);
+            }
+        }
+    }));
+
+    // step 2: transform the tree, renaming properties
+    return ast.transform(new TreeTransformer(function(node){
+        if (node instanceof AST_ObjectKeyVal) {
+            node.key = mangle(node.key);
+        }
+        else if (node instanceof AST_ObjectProperty) {
+            // setter or getter
+            node.key.name = mangle(node.key.name);
+        }
+        else if (node instanceof AST_Dot) {
+            node.property = mangle(node.property);
+        }
+        else if (node instanceof AST_Sub) {
+            node.property = mangleStrings(node.property);
+        }
+        // else if (node instanceof AST_String) {
+        //     if (should_mangle(node.value)) {
+        //         AST_Node.warn(
+        //             "Found \"{prop}\" property candidate for mangling in an arbitrary string [{file}:{line},{col}]", {
+        //                 file : node.start.file,
+        //                 line : node.start.line,
+        //                 col  : node.start.col,
+        //                 prop : node.value
+        //             }
+        //         );
+        //     }
+        // }
+    }));
+
+    // only function declarations after this line
+
+    function can_mangle(name) {
+        if (unmangleable.indexOf(name) >= 0) return false;
+        if (reserved.indexOf(name) >= 0) return false;
+        if (options.only_cache) {
+            return cache.props.has(name);
+        }
+        if (/^[0-9.]+$/.test(name)) return false;
+        return true;
+    }
+
+    function should_mangle(name) {
+        if (regex && !regex.test(name)) return false;
+        if (reserved.indexOf(name) >= 0) return false;
+        return cache.props.has(name)
+            || names_to_mangle.indexOf(name) >= 0;
+    }
+
+    function add(name) {
+        if (can_mangle(name))
+            push_uniq(names_to_mangle, name);
+
+        if (!should_mangle(name)) {
+            push_uniq(unmangleable, name);
+        }
+    }
+
+    function mangle(name) {
+        if (!should_mangle(name)) {
+            return name;
+        }
+
+        var mangled = cache.props.get(name);
+        if (!mangled) {
+            do {
+                mangled = base54(++cache.cname);
+            } while (!can_mangle(mangled));
+            cache.props.set(name, mangled);
+        }
+        return mangled;
+    }
+
+    function addStrings(node) {
+        var out = {};
+        try {
+            (function walk(node){
+                node.walk(new TreeWalker(function(node){
+                    if (node instanceof AST_Seq) {
+                        walk(node.cdr);
+                        return true;
+                    }
+                    if (node instanceof AST_String) {
+                        add(node.value);
+                        return true;
+                    }
+                    if (node instanceof AST_Conditional) {
+                        walk(node.consequent);
+                        walk(node.alternative);
+                        return true;
+                    }
+                    throw out;
+                }));
+            })(node);
+        } catch(ex) {
+            if (ex !== out) throw ex;
+        }
+    }
+
+    function mangleStrings(node) {
+        return node.transform(new TreeTransformer(function(node){
+            if (node instanceof AST_Seq) {
+                node.cdr = mangleStrings(node.cdr);
+            }
+            else if (node instanceof AST_String) {
+                node.value = mangle(node.value);
+            }
+            else if (node instanceof AST_Conditional) {
+                node.consequent = mangleStrings(node.consequent);
+                node.alternative = mangleStrings(node.alternative);
+            }
+            return node;
+        }));
+    }
+
+}

lib/scope.js

@@ -57,23 +57,36 @@ 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)) {
+        var cache = options.cache && options.cache.props;
+        if (this.global && cache && cache.has(this.name)) {
+            this.mangled_name = cache.get(this.name);
+        }
+        else if (!this.mangled_name && !this.unmangleable(options)) {
             var s = this.scope;
             if (!options.screw_ie8 && this.orig[0] instanceof AST_SymbolLambda)
                 s = s.parent_scope;
             this.mangled_name = s.next_mangled(options, this);
+            if (this.global && cache) {
+                cache.set(this.name, this.mangled_name);
+            }
         }
     }
 };
 
 AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     options = defaults(options, {
-        screw_ie8: false
+        screw_ie8: false,
+        cache: null
     });
 
     // pass 1: setup scope chaining and handle definitions
@@ -106,6 +119,10 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             push_uniq(scope.directives, node.value);
             return true;
         }
+        if (node instanceof AST_Number) {
+            node.scope = scope;
+            return true;
+        }
         if (node instanceof AST_With) {
             for (var s = scope; s; s = s.parent_scope)
                 s.uses_with = true;
@@ -178,6 +195,10 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
         }
     });
     self.walk(tw);
+
+    if (options.cache) {
+        this.cname = options.cache.cname;
+    }
 });
 
 AST_Scope.DEFMETHOD("init_scope_vars", function(nesting){
@@ -322,11 +343,12 @@ AST_Symbol.DEFMETHOD("global", function(){
 
 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
     return defaults(options, {
-        except   : [],
+        except      : [],
-        eval     : false,
+        eval        : false,
-        sort     : false,
+        sort        : false,
-        toplevel : false,
+        toplevel    : false,
-        screw_ie8 : false
+        screw_ie8   : false,
+        keep_fnames : false
     });
 });
 
@@ -338,6 +360,15 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
     // the AST_SymbolDeclaration that it points to).
     var lname = -1;
     var to_mangle = [];
+
+    if (options.cache) {
+        this.globals.each(function(symbol){
+            if (options.except.indexOf(symbol.name) < 0) {
+                to_mangle.push(symbol);
+            }
+        });
+    }
+
     var tw = new TreeWalker(function(node, descend){
         if (node instanceof AST_LabeledStatement) {
             // lname is incremented when we get to the AST_Label
@@ -372,6 +403,10 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
     });
     this.walk(tw);
     to_mangle.forEach(function(def){ def.mangle(options) });
+
+    if (options.cache) {
+        options.cache.cname = this.cname;
+    }
 });
 
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
@@ -471,7 +506,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;

lib/sourcemap.js

@@ -53,11 +53,16 @@ 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({
@@ -78,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()); }
     };
 };

lib/utils.js

@@ -106,10 +106,12 @@ function defaults(args, defs, croak) {
 };
 
 function merge(obj, ext) {
+    var count = 0;
     for (var i in ext) if (ext.hasOwnProperty(i)) {
         obj[i] = ext[i];
+        count++;
     }
-    return obj;
+    return count;
 };
 
 function noop() {};
@@ -298,5 +300,11 @@ Dictionary.prototype = {
         for (var i in this._values)
             ret.push(f(this._values[i], i.substr(1)));
         return ret;
-    }
+    },
+    toObject: function() { return this._values }
+};
+Dictionary.fromObject = function(obj) {
+    var dict = new Dictionary();
+    dict._size = merge(dict._values, obj);
+    return dict;
 };

npm-shrinkwrap.json

@@ -0,0 +1,128 @@
+{
+  "name": "uglify-js",
+  "version": "2.4.24",
+  "dependencies": {
+    "abbrev": {
+      "version": "1.0.7",
+      "from": "abbrev@>=1.0.0 <2.0.0",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.0.7.tgz"
+    },
+    "amdefine": {
+      "version": "1.0.0",
+      "from": "amdefine@>=0.0.4",
+      "resolved": "https://registry.npmjs.org/amdefine/-/amdefine-1.0.0.tgz"
+    },
+    "async": {
+      "version": "0.2.10",
+      "from": "async@>=0.2.6 <0.3.0",
+      "resolved": "https://registry.npmjs.org/async/-/async-0.2.10.tgz"
+    },
+    "camelcase": {
+      "version": "1.2.1",
+      "from": "camelcase@>=1.0.2 <2.0.0",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-1.2.1.tgz"
+    },
+    "decamelize": {
+      "version": "1.0.0",
+      "from": "decamelize@>=1.0.0 <2.0.0",
+      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.0.0.tgz"
+    },
+    "deep-is": {
+      "version": "0.1.3",
+      "from": "deep-is@>=0.1.2 <0.2.0",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz"
+    },
+    "esprima": {
+      "version": "1.1.1",
+      "from": "esprima@>=1.1.1 <1.2.0",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.1.1.tgz"
+    },
+    "estraverse": {
+      "version": "1.5.1",
+      "from": "estraverse@>=1.5.1 <1.6.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-1.5.1.tgz"
+    },
+    "esutils": {
+      "version": "1.0.0",
+      "from": "esutils@>=1.0.0 <1.1.0",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-1.0.0.tgz"
+    },
+    "fast-levenshtein": {
+      "version": "1.0.7",
+      "from": "fast-levenshtein@>=1.0.0 <1.1.0",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-1.0.7.tgz"
+    },
+    "levn": {
+      "version": "0.2.5",
+      "from": "levn@>=0.2.5 <0.3.0",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.2.5.tgz"
+    },
+    "nopt": {
+      "version": "2.1.2",
+      "from": "nopt@>=2.1.2 <2.2.0",
+      "resolved": "https://registry.npmjs.org/nopt/-/nopt-2.1.2.tgz"
+    },
+    "optionator": {
+      "version": "0.5.0",
+      "from": "optionator@>=0.5.0 <0.6.0",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.5.0.tgz"
+    },
+    "prelude-ls": {
+      "version": "1.1.2",
+      "from": "prelude-ls@>=1.1.1 <1.2.0",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz"
+    },
+    "reflect": {
+      "version": "0.1.3",
+      "from": "git://github.com/zaach/reflect.js.git",
+      "resolved": "git://github.com/zaach/reflect.js.git#286bcd79661c96ecc404357d3c0e35fdb54a6967"
+    },
+    "source-map": {
+      "version": "0.5.1",
+      "from": "source-map@>=0.5.1 <0.6.0",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.1.tgz"
+    },
+    "type-check": {
+      "version": "0.3.1",
+      "from": "type-check@>=0.3.1 <0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.1.tgz"
+    },
+    "uglify-js": {
+      "version": "2.4.24",
+      "from": "git://github.com/mishoo/UglifyJS2.git",
+      "resolved": "git://github.com/mishoo/UglifyJS2.git#2a06c7758e24a64740473c8031eafbb7fefa213f",
+      "dependencies": {
+        "source-map": {
+          "version": "0.1.34",
+          "from": "source-map@0.1.34",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.1.34.tgz"
+        }
+      }
+    },
+    "uglify-to-browserify": {
+      "version": "1.0.2",
+      "from": "uglify-to-browserify@>=1.0.0 <1.1.0",
+      "resolved": "https://registry.npmjs.org/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz"
+    },
+    "window-size": {
+      "version": "0.1.0",
+      "from": "window-size@0.1.0",
+      "resolved": "https://registry.npmjs.org/window-size/-/window-size-0.1.0.tgz"
+    },
+    "wordwrap": {
+      "version": "0.0.2",
+      "from": "wordwrap@0.0.2",
+      "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.2.tgz"
+    },
+    "yargs": {
+      "version": "3.5.4",
+      "from": "yargs@>=3.5.4 <3.6.0",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-3.5.4.tgz"
+    },
+    "zeparser": {
+      "version": "0.0.7",
+      "from": "git://github.com/qfox/ZeParser.git",
+      "resolved": "git://github.com/qfox/ZeParser.git#c99240c5ba7054c467733800ff38265958a2dda9"
+    }
+  }
+}

package.json

@@ -1,37 +1,52 @@
 {
   "name": "uglify-js",
   "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
-    "homepage": "http://lisperator.net/uglifyjs",
+  "homepage": "http://lisperator.net/uglifyjs",
-    "main": "tools/node.js",
+  "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
-    "version": "2.4.16",
+  "license": "BSD-2-Clause",
-    "engines": { "node" : ">=0.4.0" },
+  "version": "2.5.0",
-    "maintainers": [{
+  "engines": {
-        "name": "Mihai Bazon",
+    "node": ">=0.8.0"
-        "email": "mihai.bazon@gmail.com",
+  },
-        "web": "http://lisperator.net/"
+  "maintainers": [
-    }],
+    "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)"
-    "repository": {
+  ],
-        "type": "git",
+  "repository": {
-        "url": "https://github.com/mishoo/UglifyJS2.git"
+    "type": "git",
-    },
+    "url": "https://github.com/mishoo/UglifyJS2.git"
-    "dependencies": {
+  },
-        "async"      : "~0.2.6",
+  "bugs": {
-        "source-map" : "0.1.34",
+    "url": "https://github.com/mishoo/UglifyJS2/issues"
-        "optimist": "~0.3.5",
+  },
-        "uglify-to-browserify": "~1.0.0"
+  "main": "tools/node.js",
-    },
+  "bin": {
-    "devDependencies": {
+    "uglifyjs": "bin/uglifyjs"
-        "acorn": "~0.6.0",
+  },
-        "escodegen": "~1.3.3",
+  "files": [
-        "esfuzz": "~0.3.1",
+    "bin",
-        "estraverse": "~1.5.1"
+    "lib",
-    },
+    "tools",
-    "browserify": {
+    "LICENSE"
-        "transform": [ "uglify-to-browserify" ]
+  ],
-    },
+  "dependencies": {
-    "bin": {
+    "async": "~0.2.6",
-        "uglifyjs" : "bin/uglifyjs"
+    "source-map": "~0.5.1",
-    },
+    "uglify-to-browserify": "~1.0.0",
-    "license": "BSD",
+    "yargs": "~3.5.4"
-    "scripts": {"test": "node test/run-tests.js"}
+  },
+  "devDependencies": {
+    "acorn": "~0.6.0",
+    "escodegen": "~1.3.3",
+    "esfuzz": "~0.3.1",
+    "estraverse": "~1.5.1"
+  },
+  "browserify": {
+    "transform": [
+      "uglify-to-browserify"
+    ]
+  },
+  "scripts": {
+    "shrinkwrap": "rm ./npm-shrinkwrap.json; rm -rf ./node_modules; npm i && npm shrinkwrap && npm outdated",
+    "test": "node test/run-tests.js"
+  }
 }

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

test/compress/asm.js

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

test/compress/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
     }
@@ -84,7 +86,9 @@ ifs_4: {
             x(foo)[10].bar.baz = something_else();
     }
     expect: {
-        x(foo)[10].bar.baz = (foo && bar) ? something() : something_else();
+        foo && bar
+            ? x(foo)[10].bar.baz = something()
+            : x(foo)[10].bar.baz = something_else();
     }
 }
 
@@ -131,6 +135,7 @@ ifs_6: {
         comparisons: true
     };
     input: {
+        var x;
         if (!foo && !bar && !baz && !boo) {
             x = 10;
         } else {
@@ -138,6 +143,7 @@ ifs_6: {
         }
     }
     expect: {
+        var x;
         x = foo || bar || baz || boo ? 20 : 10;
     }
 }
@@ -147,6 +153,7 @@ cond_1: {
         conditionals: true
     };
     input: {
+        var do_something; // if undeclared it's assumed to have side-effects
         if (some_condition()) {
             do_something(x);
         } else {
@@ -154,6 +161,7 @@ cond_1: {
         }
     }
     expect: {
+        var do_something;
         do_something(some_condition() ? x : y);
     }
 }
@@ -163,6 +171,7 @@ cond_2: {
         conditionals: true
     };
     input: {
+        var x, FooBar;
         if (some_condition()) {
             x = new FooBar(1);
         } else {
@@ -170,6 +179,7 @@ cond_2: {
         }
     }
     expect: {
+        var x, FooBar;
         x = new FooBar(some_condition() ? 1 : 2);
     }
 }
@@ -179,6 +189,7 @@ cond_3: {
         conditionals: true
     };
     input: {
+        var FooBar;
         if (some_condition()) {
             new FooBar(1);
         } else {
@@ -186,6 +197,7 @@ cond_3: {
         }
     }
     expect: {
+        var FooBar;
         some_condition() ? new FooBar(1) : FooBar(2);
     }
 }
@@ -195,6 +207,7 @@ cond_4: {
         conditionals: true
     };
     input: {
+        var do_something;
         if (some_condition()) {
             do_something();
         } else {
@@ -202,6 +215,7 @@ cond_4: {
         }
     }
     expect: {
+        var do_something;
         some_condition(), do_something();
     }
 }
@@ -301,6 +315,7 @@ cond_7_1: {
         evaluate    : true
     };
     input: {
+        var x;
         // access to global should be assumed to have side effects
         if (y) {
             x = 1+1;
@@ -309,6 +324,223 @@ cond_7_1: {
         }
     }
     expect: {
+        var x;
         x = (y, 2);
     }
 }
+
+cond_8: {
+    options = {
+        conditionals: true,
+        evaluate    : true
+    };
+    input: {
+        var a;
+        // 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: {
+        var a;
+        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;
+    }
+}
+
+conditional_and: {
+    options = {
+        conditionals: true,
+        evaluate    : true
+    };
+    input: {
+        var a;
+        // compress these
+
+        a = true     && condition;
+        a = 1        && console.log("a");
+        a = 2 * 3    && 2 * condition;
+        a = 5 == 5   && condition + 3;
+        a = "string" && 4 - condition;
+        a = 5 + ""   && condition / 5;
+        a = -4.5     && 6 << condition;
+        a = 6        && 7;
+
+        a = false     && condition;
+        a = NaN       && console.log("b");
+        a = 0         && console.log("c");
+        a = undefined && 2 * condition;
+        a = null      && condition + 3;
+        a = 2 * 3 - 6 && 4 - condition;
+        a = 10 == 7   && condition / 5;
+        a = !"string" && 6 % condition;
+        a = 0         && 7;
+
+        // don't compress these
+
+        a = condition        && true;
+        a = console.log("a") && 2;
+        a = 4 - condition    && "string";
+        a = 6 << condition   && -4.5;
+
+        a = condition        && false;
+        a = console.log("b") && NaN;
+        a = console.log("c") && 0;
+        a = 2 * condition    && undefined;
+        a = condition + 3    && null;
+
+    }
+    expect: {
+        var a;
+
+        a = condition;
+        a = console.log("a");
+        a = 2 * condition;
+        a = condition + 3;
+        a = 4 - condition;
+        a = condition / 5;
+        a = 6 << condition;
+        a = 7;
+
+        a = false;
+        a = NaN;
+        a = 0;
+        a = void 0;
+        a = null;
+        a = 0;
+        a = false;
+        a = false;
+        a = 0;
+
+        a = condition        && true;
+        a = console.log("a") && 2;
+        a = 4 - condition    && "string";
+        a = 6 << condition   && -4.5;
+
+        a = condition        && false;
+        a = console.log("b") && NaN;
+        a = console.log("c") && 0;
+        a = 2 * condition    && void 0;
+        a = condition + 3    && null;
+    }
+}
+
+conditional_or: {
+    options = {
+        conditionals: true,
+        evaluate    : true
+    };
+    input: {
+        var a;
+        // compress these
+
+        a = true     || condition;
+        a = 1        || console.log("a");
+        a = 2 * 3    || 2 * condition;
+        a = 5 == 5   || condition + 3;
+        a = "string" || 4 - condition;
+        a = 5 + ""   || condition / 5;
+        a = -4.5     || 6 << condition;
+        a = 6        || 7;
+
+        a = false     || condition;
+        a = 0         || console.log("b");
+        a = NaN       || console.log("c");
+        a = undefined || 2 * condition;
+        a = null      || condition + 3;
+        a = 2 * 3 - 6 || 4 - condition;
+        a = 10 == 7   || condition / 5;
+        a = !"string" || 6 % condition;
+        a = null      || 7;
+
+        a = console.log(undefined && condition || null);
+        a = console.log(undefined || condition && null);
+
+        // don't compress these
+
+        a = condition        || true;
+        a = console.log("a") || 2;
+        a = 4 - condition    || "string";
+        a = 6 << condition   || -4.5;
+
+        a = condition        || false;
+        a = console.log("b") || NaN;
+        a = console.log("c") || 0;
+        a = 2 * condition    || undefined;
+        a = condition + 3    || null;
+
+    }
+    expect: {
+        var a;
+
+        a = true;
+        a = 1;
+        a = 6;
+        a = true;
+        a = "string";
+        a = "5";
+        a = -4.5;
+        a = 6;
+
+        a = condition;
+        a = console.log("b");
+        a = console.log("c");
+        a = 2 * condition;
+        a = condition + 3;
+        a = 4 - condition;
+        a = condition / 5;
+        a = 6 % condition;
+        a = 7;
+
+        a = console.log(null);
+        a = console.log(condition && null);
+
+        a = condition        || true;
+        a = console.log("a") || 2;
+        a = 4 - condition    || "string";
+        a = 6 << condition   || -4.5;
+
+        a = condition        || false;
+        a = console.log("b") || NaN;
+        a = console.log("c") || 0;
+        a = 2 * condition    || void 0;
+        a = condition + 3    || null;
+    }
+}

test/compress/dead-code.js

@@ -1,89 +1,89 @@
-dead_code_1: {
+dead_code_1: {
-    options = {
+    options = {
-        dead_code: true
+        dead_code: true
-    };
+    };
-    input: {
+    input: {
-        function f() {
+        function f() {
-            a();
+            a();
-            b();
+            b();
-            x = 10;
+            x = 10;
-            return;
+            return;
-            if (x) {
+            if (x) {
-                y();
+                y();
-            }
+            }
-        }
+        }
-    }
+    }
-    expect: {
+    expect: {
-        function f() {
+        function f() {
-            a();
+            a();
-            b();
+            b();
-            x = 10;
+            x = 10;
-            return;
+            return;
-        }
+        }
-    }
+    }
-}
+}
-
+
-dead_code_2_should_warn: {
+dead_code_2_should_warn: {
-    options = {
+    options = {
-        dead_code: true
+        dead_code: true
-    };
+    };
-    input: {
+    input: {
-        function f() {
+        function f() {
-            g();
+            g();
-            x = 10;
+            x = 10;
-            throw "foo";
+            throw "foo";
-            // completely discarding the `if` would introduce some
+            // completely discarding the `if` would introduce some
-            // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
+            // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
-            // we copy any declarations to the upper scope.
+            // we copy any declarations to the upper scope.
-            if (x) {
+            if (x) {
-                y();
+                y();
-                var x;
+                var x;
-                function g(){};
+                function g(){};
-                // but nested declarations should not be kept.
+                // but nested declarations should not be kept.
-                (function(){
+                (function(){
-                    var q;
+                    var q;
-                    function y(){};
+                    function y(){};
-                })();
+                })();
-            }
+            }
-        }
+        }
-    }
+    }
-    expect: {
+    expect: {
-        function f() {
+        function f() {
-            g();
+            g();
-            x = 10;
+            x = 10;
-            throw "foo";
+            throw "foo";
-            var x;
+            var x;
-            function g(){};
+            function g(){};
-        }
+        }
-    }
+    }
-}
+}
-
+
-dead_code_constant_boolean_should_warn_more: {
+dead_code_constant_boolean_should_warn_more: {
-    options = {
+    options = {
-        dead_code    : true,
+        dead_code    : true,
-        loops        : true,
+        loops        : true,
-        booleans     : true,
+        booleans     : true,
-        conditionals : true,
+        conditionals : true,
-        evaluate     : true
+        evaluate     : true
-    };
+    };
-    input: {
+    input: {
-        while (!((foo && bar) || (x + "0"))) {
+        while (!((foo && bar) || (x + "0"))) {
-            console.log("unreachable");
+            console.log("unreachable");
-            var foo;
+            var foo;
-            function bar() {}
+            function bar() {}
-        }
+        }
-        for (var x = 10; x && (y || x) && (!typeof x); ++x) {
+        for (var x = 10, y; x && (y || x) && (!typeof x); ++x) {
-            asdf();
+            asdf();
-            foo();
+            foo();
-            var moo;
+            var moo;
-        }
+        }
-    }
+    }
-    expect: {
+    expect: {
-        var foo;
+        var foo;
-        function bar() {}
+        function bar() {}
-        // nothing for the while
+        // nothing for the while
-        // as for the for, it should keep:
+        // as for the for, it should keep:
-        var x = 10;
+        var x = 10, y;
-        var moo;
+        var moo;
-    }
+    }
-}
+}

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

test/compress/drop-unused.js

@@ -1,5 +1,5 @@
 unused_funarg_1: {
-    options = { unused: true };
+    options = { unused: true, keep_fargs: false };
     input: {
         function f(a, b, c, d, e) {
             return a + b;
@@ -13,7 +13,7 @@ unused_funarg_1: {
 }
 
 unused_funarg_2: {
-    options = { unused: true };
+    options = { unused: true, keep_fargs: false };
     input: {
         function f(a, b, c, d, e) {
             return a + c;
@@ -163,3 +163,17 @@ used_var_in_catch: {
         }
     }
 }
+
+keep_fnames: {
+    options = { unused: true, keep_fnames: true, unsafe: true };
+    input: {
+        function foo() {
+            return function bar(baz) {};
+        }
+    }
+    expect: {
+        function foo() {
+            return function bar(baz) {};
+        }
+    }
+}

test/compress/issue-208.js

@@ -0,0 +1,11 @@
+do_not_update_lhs: {
+    options = { global_defs: { DEBUG: false } };
+    input: { DEBUG = false; }
+    expect: { DEBUG = false; }
+}
+
+do_update_rhs: {
+    options = { global_defs: { DEBUG: false } };
+    input: { MY_DEBUG = DEBUG; }
+    expect: { MY_DEBUG = false; }
+}

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();
+        NaN.toString();         // transformation to 0/0 dropped
+    }
+}
+
+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();
+    }
+}

test/compress/issue-611.js

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

test/compress/issue-637.js

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

test/compress/issue-747.js

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

test/compress/issue-751.js

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

test/compress/issue-782.js

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

test/compress/new.js

@@ -0,0 +1,12 @@
+new_statement: {
+    input: {
+        new x(1);
+        new x(1)(2);
+        new x(1)(2)(3);
+        new new x(1);
+        new new x(1)(2);
+        new (new x(1))(2);
+        (new new x(1))(2);
+    }
+    expect_exact: "new x(1);new x(1)(2);new x(1)(2)(3);new new x(1);new new x(1)(2);new new x(1)(2);(new new x(1))(2);"
+}

test/compress/unicode.js

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

test/mozilla-ast.js

@@ -100,4 +100,4 @@ module.exports = function(options) {
     }
 
     process.stdout.write(prefix + "Probability of error is less than " + (100 / options.iterations) + "%, stopping.\n");
-};
+};

test/run-tests.js

@@ -31,7 +31,7 @@ function tmpl() {
 
 function log() {
     var txt = tmpl.apply(this, arguments);
-    sys.puts(txt);
+    console.log("%s", txt);
 }
 
 function log_directory(dir) {
@@ -84,9 +84,17 @@ function run_compress_tests() {
                 warnings: false
             });
             var cmp = new U.Compressor(options, true);
-            var expect = make_code(as_toplevel(test.expect), false);
+            var expect;
+            if (test.expect) {
+                expect = make_code(as_toplevel(test.expect), false);
+            } else {
+                expect = test.expect_exact;
+            }
             var input = as_toplevel(test.input);
             var input_code = make_code(test.input);
+            if (test.mangle_props) {
+                input = U.mangle_properties(input, test.mangle_props);
+            }
             var output = input.transform(cmp);
             output.figure_out_scope();
             output = make_code(output, false);
@@ -150,7 +158,7 @@ function parse_test(file) {
             }
             if (node instanceof U.AST_LabeledStatement) {
                 assert.ok(
-                    node.label.name == "input" || node.label.name == "expect",
+                    node.label.name == "input" || node.label.name == "expect" || node.label.name == "expect_exact",
                     tmpl("Unsupported label {name} [{line},{col}]", {
                         name: node.label.name,
                         line: node.label.start.line,
@@ -162,7 +170,16 @@ function parse_test(file) {
                     if (stat.body.length == 1) stat = stat.body[0];
                     else if (stat.body.length == 0) stat = new U.AST_EmptyStatement();
                 }
-                test[node.label.name] = stat;
+                if (node.label.name === "expect_exact") {
+                    if (!(stat.TYPE === "SimpleStatement" && stat.body.TYPE === "String")) {
+                        throw new Error(
+                            "The value of the expect_exact clause should be a string, " +
+                            "like `expect_exact: \"some.exact.javascript;\"`");
+                    }
+                    test[node.label.name] = stat.body.start.value
+                } else {
+                    test[node.label.name] = stat;
+                }
                 return true;
             }
         });

tools/exports.js

@@ -0,0 +1,17 @@
+exports["Compressor"] = Compressor;
+exports["DefaultsError"] = DefaultsError;
+exports["Dictionary"] = Dictionary;
+exports["JS_Parse_Error"] = JS_Parse_Error;
+exports["MAP"] = MAP;
+exports["OutputStream"] = OutputStream;
+exports["SourceMap"] = SourceMap;
+exports["TreeTransformer"] = TreeTransformer;
+exports["TreeWalker"] = TreeWalker;
+exports["base54"] = base54;
+exports["defaults"] = defaults;
+exports["mangle_properties"] = mangle_properties;
+exports["merge"] = merge;
+exports["parse"] = parse;
+exports["push_uniq"] = push_uniq;
+exports["string_template"] = string_template;
+exports["is_identifier"] = is_identifier;

tools/node.js

@@ -1,26 +1,5 @@
 var path = require("path");
 var fs = require("fs");
-var vm = require("vm");
-var sys = require("util");
-
-var UglifyJS = vm.createContext({
-    sys           : sys,
-    console       : console,
-    MOZ_SourceMap : require("source-map")
-});
-
-function load_global(file) {
-    file = path.resolve(path.dirname(module.filename), file);
-    try {
-        var code = fs.readFileSync(file, "utf8");
-        return vm.runInContext(code, UglifyJS, file);
-    } catch(ex) {
-        // XXX: in case of a syntax error, the message is kinda
-        // useless. (no location information).
-        sys.debug("ERROR in file: " + file + " / " + ex);
-        process.exit(1);
-    }
-};
 
 var FILES = exports.FILES = [
     "../lib/utils.js",
@@ -31,24 +10,26 @@ var FILES = exports.FILES = [
     "../lib/output.js",
     "../lib/compress.js",
     "../lib/sourcemap.js",
-    "../lib/mozilla-ast.js"
+    "../lib/mozilla-ast.js",
+    "../lib/propmangle.js",
+    "./exports.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);
+var UglifyJS = exports;
+
+new Function("MOZ_SourceMap", "exports", FILES.map(function(file){
+    return fs.readFileSync(file, "utf8");
+}).join("\n\n"))(
+    require("source-map"),
+    UglifyJS
+);
 
 UglifyJS.AST_Node.warn_function = function(txt) {
-    sys.error("WARN: " + txt);
+    console.error("WARN: %s", txt);
 };
 
-// XXX: perhaps we shouldn't export everything but heck, I'm lazy.
-for (var i in UglifyJS) {
-    if (UglifyJS.hasOwnProperty(i)) {
-        exports[i] = UglifyJS[i];
-    }
-}
-
 exports.minify = function(files, options) {
     options = UglifyJS.defaults(options, {
         spidermonkey : false,
@@ -64,6 +45,7 @@ exports.minify = function(files, options) {
     UglifyJS.base54.reset();
 
     // 1. parse
+    var haveScope = false;
     var toplevel = null,
         sourcesContent = {};
 
@@ -72,35 +54,45 @@ exports.minify = function(files, options) {
     } else {
         if (typeof files == "string")
             files = [ files ];
-        files.forEach(function(file){
+        files.forEach(function(file, i){
             var code = options.fromString
                 ? file
                 : fs.readFileSync(file, "utf8");
             sourcesContent[file] = code;
             toplevel = UglifyJS.parse(code, {
-                filename: options.fromString ? "?" : file,
+                filename: options.fromString ? i : file,
                 toplevel: toplevel
             });
         });
     }
+    if (options.wrap) {
+      toplevel = toplevel.wrap_commonjs(options.wrap, options.exportAll);
+    }
 
     // 2. compress
     if (options.compress) {
         var compress = { warnings: options.warnings };
         UglifyJS.merge(compress, options.compress);
         toplevel.figure_out_scope();
+        haveScope = true;
         var sq = UglifyJS.Compressor(compress);
         toplevel = toplevel.transform(sq);
     }
 
     // 3. mangle
     if (options.mangle) {
-        toplevel.figure_out_scope();
+        toplevel.figure_out_scope(options.mangle);
-        toplevel.compute_char_frequency();
+        haveScope = true;
+        toplevel.compute_char_frequency(options.mangle);
         toplevel.mangle_names(options.mangle);
     }
 
-    // 4. output
+    // 4. scope (if needed)
+    if (!haveScope) {
+        toplevel.figure_out_scope();
+    }
+
+    // 5. output
     var inMap = options.inSourceMap;
     var output = {};
     if (typeof options.inSourceMap == "string") {
@@ -127,13 +119,18 @@ exports.minify = function(files, options) {
     var stream = UglifyJS.OutputStream(output);
     toplevel.print(stream);
 
-    if(options.outSourceMap){
+    if (options.outSourceMap && "string" === typeof 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
     };
 };
 
@@ -185,3 +182,63 @@ exports.describe_ast = function() {
     doitem(UglifyJS.AST_Node);
     return out + "";
 };
+
+function readReservedFile(filename, reserved) {
+    if (!reserved) {
+        reserved = { vars: [], props: [] };
+    }
+    var data = fs.readFileSync(filename, "utf8");
+    data = JSON.parse(data);
+    if (data.vars) {
+        data.vars.forEach(function(name){
+            UglifyJS.push_uniq(reserved.vars, name);
+        });
+    }
+    if (data.props) {
+        data.props.forEach(function(name){
+            UglifyJS.push_uniq(reserved.props, name);
+        });
+    }
+    return reserved;
+}
+
+exports.readReservedFile = readReservedFile;
+
+exports.readDefaultReservedFile = function(reserved) {
+    return readReservedFile(path.join(__dirname, "domprops.json"), reserved);
+};
+
+exports.readNameCache = function(filename, key) {
+    var cache = null;
+    if (filename) {
+        try {
+            var cache = fs.readFileSync(filename, "utf8");
+            cache = JSON.parse(cache)[key];
+            if (!cache) throw "init";
+            cache.props = UglifyJS.Dictionary.fromObject(cache.props);
+        } catch(ex) {
+            cache = {
+                cname: -1,
+                props: new UglifyJS.Dictionary()
+            };
+        }
+    }
+    return cache;
+};
+
+exports.writeNameCache = function(filename, key, cache) {
+    if (filename) {
+        var data;
+        try {
+            data = fs.readFileSync(filename, "utf8");
+            data = JSON.parse(data);
+        } catch(ex) {
+            data = {};
+        }
+        data[key] = {
+            cname: cache.cname,
+            props: cache.props.toObject()
+        };
+        fs.writeFileSync(filename, JSON.stringify(data, null, 2), "utf8");
+    }
+};

tools/props.html

@@ -0,0 +1,61 @@
+<html>
+  <head>
+  </head>
+  <body>
+    <script>(function(){
+      var props = {};
+
+      function addObject(obj) {
+        if (obj == null) return;
+        try {
+          Object.getOwnPropertyNames(obj).forEach(add);
+        } catch(ex) {}
+        if (obj.prototype) {
+          Object.getOwnPropertyNames(obj.prototype).forEach(add);
+        }
+        if (typeof obj == "function") {
+          try {
+            Object.getOwnPropertyNames(new obj).forEach(add);
+          } catch(ex) {}
+        }
+      }
+
+      function add(name) {
+        props[name] = true;
+      }
+
+      Object.getOwnPropertyNames(window).forEach(function(thing){
+        addObject(window[thing]);
+      });
+
+      try {
+        addObject(new Event("click"));
+        addObject(new Event("contextmenu"));
+        addObject(new Event("mouseup"));
+        addObject(new Event("mousedown"));
+        addObject(new Event("keydown"));
+        addObject(new Event("keypress"));
+        addObject(new Event("keyup"));
+      } catch(ex) {}
+
+      var ta = document.createElement("textarea");
+      ta.style.width = "100%";
+      ta.style.height = "20em";
+      ta.style.boxSizing = "border-box";
+      <!-- ta.value = Object.keys(props).sort(cmp).map(function(name){ -->
+      <!--   return JSON.stringify(name); -->
+      <!-- }).join(",\n"); -->
+      ta.value = JSON.stringify({
+        vars: [],
+        props: Object.keys(props).sort(cmp)
+      }, null, 2);
+      document.body.appendChild(ta);
+
+      function cmp(a, b) {
+        a = a.toLowerCase();
+        b = b.toLowerCase();
+        return a < b ? -1 : a > b ? 1 : 0;
+      }
+    })();</script>
+  </body>
+</html>