v3.0.12

Technically not part of ES5, but commonly used code exists in the wild.

.github/ISSUE_TEMPLATE.md

@@ -6,15 +6,15 @@
 
 <!-- Note: for ES6 see: https://github.com/mishoo/UglifyJS2/tree/harmony#harmony -->
 
-**`uglify-js` version (`uglifyjs -V`)**
+**Uglify version (`uglifyjs -V`)**
 
-**JavaScript input - ideally as small as possible.**
+**JavaScript input**  <!-- ideally as small as possible -->
 
 **The `uglifyjs` CLI command executed or `minify()` options used.**
 
-**JavaScript output produced and/or the error or warning.**
+**JavaScript output or error produced.**
 
 <!--
-    Note: the release version of uglify-js only supports ES5. Those wishing
-    to minify ES6 should use the experimental harmony branch.
+    Note: `uglify-js` only supports ES5. 
+    Those wishing to minify ES6 should use `uglify-es`.
 -->

.travis.yml

@@ -1,5 +1,4 @@
 language: node_js
-before_install: "npm install -g npm"
 node_js:
     - "0.10"
     - "0.12"

bin/uglifyjs

@@ -15,15 +15,16 @@ var path = require("path");
 var program = require("commander");
 var UglifyJS = require("../tools/node");
 
+var skip_keys = [ "cname", "enclosed", "parent_scope", "scope", "thedef", "uses_eval", "uses_with" ];
 var files = {};
 var options = {
     compress: false,
     mangle: false
 };
-program._name = info.name;
-program.version(info.version);
+program.version(info.name + ' ' + info.version);
 program.parseArgv = program.parse;
 program.parse = undefined;
+if (process.argv.indexOf("ast") >= 0) program.helpInformation = UglifyJS.describe_ast;
 program.option("-p, --parse <options>", "Specify parser options.", parse_js("parse", true));
 program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js("compress", true));
 program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js("mangle", true));
@@ -38,7 +39,7 @@ program.option("--keep-fnames", "Do not mangle/drop function names. Useful for c
 program.option("--name-cache <file>", "File to hold mangled name mappings.");
 program.option("--self", "Build UglifyJS as a library (implies --wrap UglifyJS)");
 program.option("--source-map [options]", "Enable source map/specify source map options.", parse_source_map());
-program.option("--stats", "Display operations run time on STDERR.")
+program.option("--timings", "Display operations run time on STDERR.")
 program.option("--toplevel", "Compress and/or mangle variables in toplevel scope.");
 program.option("--verbose", "Print diagnostic messages.");
 program.option("--warn", "Print warning messages.");
@@ -89,7 +90,7 @@ if (program.mangleProps) {
         if (typeof program.mangleProps != "object") program.mangleProps = {};
         if (!Array.isArray(program.mangleProps.reserved)) program.mangleProps.reserved = [];
         require("../tools/domprops").forEach(function(name) {
-            UglifyJS.push_uniq(program.mangleProps.reserved, name);
+            UglifyJS._push_uniq(program.mangleProps.reserved, name);
         });
     }
     if (typeof options.mangle != "object") options.mangle = {};
@@ -107,11 +108,17 @@ if (program.nameCache) {
         }
     }
 }
+if (program.output == "ast") {
+    options.output = {
+        ast: true,
+        code: false
+    };
+}
 if (program.parse) {
-    if (program.parse.acorn || program.parse.spidermonkey) {
-        if (program.sourceMap) fatal("ERROR: inline source map only works with built-in parser");
-    } else {
+    if (!program.parse.acorn && !program.parse.spidermonkey) {
         options.parse = program.parse;
+    } else if (program.sourceMap && program.sourceMap.content == "inline") {
+        fatal("ERROR: inline source map only works with built-in parser");
     }
 }
 var convert_path = function(name) {
@@ -165,7 +172,7 @@ function run() {
     UglifyJS.AST_Node.warn_function = function(msg) {
         console.error("WARN:", msg);
     };
-    if (program.stats)  program.stats = Date.now();
+    if (program.timings) options.timings = true;
     try {
         if (program.parse) {
             if (program.parse.acorn) {
@@ -185,9 +192,13 @@ function run() {
                 });
             }
         }
-        var result = UglifyJS.minify(files, options);
     } catch (ex) {
-        if (ex instanceof UglifyJS.JS_Parse_Error) {
+        fatal(ex);
+    }
+    var result = UglifyJS.minify(files, options);
+    if (result.error) {
+        var ex = result.error;
+        if (ex.name == "SyntaxError") {
             console.error("Parse error at " + ex.filename + ":" + ex.line + "," + ex.col);
             var col = ex.col;
             var lines = files[ex.filename].split(/\r?\n/);
@@ -209,10 +220,32 @@ function run() {
             console.error("Supported options:");
             console.error(ex.defs);
         }
-        fatal("ERROR: " + ex.message);
-    }
-    if (program.output == "spidermonkey") {
-        console.log(JSON.stringify(UglifyJS.parse(result.code).to_mozilla_ast(), null, 2));
+        fatal(ex);
+    } else if (program.output == "ast") {
+        console.log(JSON.stringify(result.ast, function(key, value) {
+            if (skip_key(key)) return;
+            if (value instanceof UglifyJS.AST_Token) return;
+            if (value instanceof UglifyJS.Dictionary) return;
+            if (value instanceof UglifyJS.AST_Node) {
+                var result = {
+                    _class: "AST_" + value.TYPE
+                };
+                value.CTOR.PROPS.forEach(function(prop) {
+                    result[prop] = value[prop];
+                });
+                return result;
+            }
+            return value;
+        }, 2));
+    } else if (program.output == "spidermonkey") {
+        console.log(JSON.stringify(UglifyJS.minify(result.code, {
+            compress: false,
+            mangle: false,
+            output: {
+                ast: true,
+                code: false
+            }
+        }).ast.to_mozilla_ast(), null, 2));
     } else if (program.output) {
         fs.writeFileSync(program.output, result.code);
         if (result.map) {
@@ -226,12 +259,15 @@ function run() {
             return value instanceof UglifyJS.Dictionary ? value.toObject() : value;
         }));
     }
-    if (program.stats) console.error("Elapsed:", Date.now() - program.stats);
+    if (result.timings) for (var phase in result.timings) {
+        console.error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
+    }
 }
 
 function fatal(message) {
-  console.error(message);
-  process.exit(1);
+    if (message instanceof Error) message = message.stack.replace(/^\S*?Error:/, "ERROR:")
+    console.error(message);
+    process.exit(1);
 }
 
 // A file glob function that only supports "*" and "?" wildcards in the basename.
@@ -270,7 +306,7 @@ function read_file(path, default_value) {
         return fs.readFileSync(path, "utf8");
     } catch (ex) {
         if (ex.code == "ENOENT" && default_value != null) return default_value;
-        fatal("ERROR: " + ex.message);
+        fatal(ex);
     }
 }
 
@@ -278,9 +314,17 @@ function parse_js(flag, constants) {
     return function(value, options) {
         options = options || {};
         try {
-            UglifyJS.parse(value, {
-                expression: true
-            }).walk(new UglifyJS.TreeWalker(function(node) {
+            UglifyJS.minify(value, {
+                parse: {
+                    expression: true
+                },
+                compress: false,
+                mangle: false,
+                output: {
+                    ast: true,
+                    code: false
+                }
+            }).ast.walk(new UglifyJS.TreeWalker(function(node) {
                 if (node instanceof UglifyJS.AST_Assign) {
                     var name = node.left.print_to_string();
                     var value = node.right;
@@ -337,3 +381,7 @@ function to_cache(key) {
     }
     return cache[key];
 }
+
+function skip_key(key) {
+    return skip_keys.indexOf(key) >= 0;
+}

lib/ast.js

@@ -495,10 +495,10 @@ var AST_Finally = DEFNODE("Finally", null, {
     $documentation: "A `finally` node; only makes sense as part of a `try` statement"
 }, AST_Block);
 
-/* -----[ VAR/CONST ]----- */
+/* -----[ VAR ]----- */
 
 var AST_Definitions = DEFNODE("Definitions", "definitions", {
-    $documentation: "Base class for `var` or `const` nodes (variable declarations/initializations)",
+    $documentation: "Base class for `var` nodes (variable declarations/initializations)",
     $propdoc: {
         definitions: "[AST_VarDef*] array of variable definitions"
     },
@@ -516,14 +516,10 @@ var AST_Var = DEFNODE("Var", null, {
     $documentation: "A `var` statement"
 }, AST_Definitions);
 
-var AST_Const = DEFNODE("Const", null, {
-    $documentation: "A `const` statement"
-}, AST_Definitions);
-
 var AST_VarDef = DEFNODE("VarDef", "name value", {
     $documentation: "A variable declaration; only appears in a AST_Definitions node",
     $propdoc: {
-        name: "[AST_SymbolVar|AST_SymbolConst] name of the variable",
+        name: "[AST_SymbolVar] name of the variable",
         value: "[AST_Node?] initializer, or null of there's no initializer"
     },
     _walk: function(visitor) {
@@ -619,7 +615,7 @@ var AST_UnaryPostfix = DEFNODE("UnaryPostfix", null, {
     $documentation: "Unary postfix expression, i.e. `i++`"
 }, AST_Unary);
 
-var AST_Binary = DEFNODE("Binary", "left operator right", {
+var AST_Binary = DEFNODE("Binary", "operator left right", {
     $documentation: "Binary expression, i.e. `a + b`",
     $propdoc: {
         left: "[AST_Node] left-hand side expression",
@@ -689,8 +685,8 @@ var AST_Object = DEFNODE("Object", "properties", {
 var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
     $documentation: "Base class for literal object properties",
     $propdoc: {
-        key: "[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an arbitrary AST_Node.",
-        value: "[AST_Node] property value.  For setters and getters this is an AST_Function."
+        key: "[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an AST_SymbolAccessor.",
+        value: "[AST_Node] property value.  For setters and getters this is an AST_Accessor."
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
@@ -728,17 +724,13 @@ var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
 }, AST_Symbol);
 
 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
-    $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
+    $documentation: "A declaration symbol (symbol in var, function name or argument, symbol in catch)",
 }, AST_Symbol);
 
 var AST_SymbolVar = DEFNODE("SymbolVar", null, {
     $documentation: "Symbol defining a variable",
 }, AST_SymbolDeclaration);
 
-var AST_SymbolConst = DEFNODE("SymbolConst", null, {
-    $documentation: "A constant declaration"
-}, AST_SymbolDeclaration);
-
 var AST_SymbolFunarg = DEFNODE("SymbolFunarg", null, {
     $documentation: "Symbol naming a function argument",
 }, AST_SymbolVar);

lib/compress.js

@@ -83,9 +83,21 @@ function Compressor(options, false_by_default) {
         unsafe_comps  : false,
         unsafe_math   : false,
         unsafe_proto  : false,
+        unsafe_regexp : false,
         unused        : !false_by_default,
         warnings      : false,
     }, true);
+    var global_defs = this.options["global_defs"];
+    if (typeof global_defs == "object") for (var key in global_defs) {
+        if (/^@/.test(key) && HOP(global_defs, key)) {
+            var ast = parse(global_defs[key]);
+            if (ast.body.length == 1 && ast.body[0] instanceof AST_SimpleStatement) {
+                global_defs[key.slice(1)] = ast.body[0].body;
+            } else throw new Error(string_template("Can't handle expression: {value}", {
+                value: global_defs[key]
+            }));
+        }
+    }
     var pure_funcs = this.options["pure_funcs"];
     if (typeof pure_funcs == "function") {
         this.pure_funcs = pure_funcs;
@@ -354,16 +366,27 @@ merge(Compressor.prototype, {
                         // So existing transformation rules can work on them.
                         node.argnames.forEach(function(arg, i) {
                             var d = arg.definition();
-                            d.fixed = function() {
-                                return iife.args[i] || make_node(AST_Undefined, iife);
-                            };
-                            mark(d, true);
+                            if (!node.uses_arguments && d.fixed === undefined) {
+                                d.fixed = function() {
+                                    return iife.args[i] || make_node(AST_Undefined, iife);
+                                };
+                                mark(d, true);
+                            } else {
+                                d.fixed = false;
+                            }
                         });
                     }
                     descend();
                     pop();
                     return true;
                 }
+                if (node instanceof AST_Accessor) {
+                    var save_ids = safe_ids;
+                    safe_ids = Object.create(null);
+                    descend();
+                    safe_ids = save_ids;
+                    return true;
+                }
                 if (node instanceof AST_Binary
                     && (node.operator == "&&" || node.operator == "||")) {
                     node.left.walk(tw);
@@ -475,8 +498,7 @@ merge(Compressor.prototype, {
             if (def.fixed === false) return false;
             if (def.fixed != null && (!value || def.references.length > 0)) return false;
             return !def.orig.some(function(sym) {
-                return sym instanceof AST_SymbolConst
-                    || sym instanceof AST_SymbolDefun
+                return sym instanceof AST_SymbolDefun
                     || sym instanceof AST_SymbolLambda;
             });
         }
@@ -491,7 +513,9 @@ merge(Compressor.prototype, {
 
         function reset_def(def) {
             def.escaped = false;
-            if (!def.global || def.orig[0] instanceof AST_SymbolConst || compressor.toplevel(def)) {
+            if (def.scope.uses_eval) {
+                def.fixed = false;
+            } else if (!def.global || compressor.toplevel(def)) {
                 def.fixed = undefined;
             } else {
                 def.fixed = false;
@@ -901,12 +925,12 @@ merge(Compressor.prototype, {
                     continue loop;
                   case stat instanceof AST_If:
                     if (stat.body instanceof AST_Return) {
+                        var value = stat.body.value;
                         //---
                         // pretty silly case, but:
                         // if (foo()) return; return; ==> foo(); return;
-                        if (((in_lambda && ret.length == 0)
-                             || (ret[0] instanceof AST_Return && !ret[0].value))
-                            && !stat.body.value && !stat.alternative) {
+                        if ((in_lambda && ret.length == 0 || ret[0] instanceof AST_Return && !ret[0].value)
+                            && !value && !stat.alternative) {
                             CHANGED = true;
                             var cond = make_node(AST_SimpleStatement, stat.condition, {
                                 body: stat.condition
@@ -916,7 +940,7 @@ merge(Compressor.prototype, {
                         }
                         //---
                         // if (foo()) return x; return y; ==> return foo() ? x : y;
-                        if (ret[0] instanceof AST_Return && stat.body.value && ret[0].value && !stat.alternative) {
+                        if (ret[0] instanceof AST_Return && value && ret[0].value && !stat.alternative) {
                             CHANGED = true;
                             stat = stat.clone();
                             stat.alternative = ret[0];
@@ -926,7 +950,7 @@ merge(Compressor.prototype, {
                         //---
                         // if (foo()) return x; [ return ; ] ==> return foo() ? x : undefined;
                         if (multiple_if_returns && (ret.length == 0 || ret[0] instanceof AST_Return)
-                            && stat.body.value && !stat.alternative && in_lambda) {
+                            && value && !stat.alternative && in_lambda) {
                             CHANGED = true;
                             stat = stat.clone();
                             stat.alternative = ret[0] || make_node(AST_Return, stat, {
@@ -936,21 +960,22 @@ merge(Compressor.prototype, {
                             continue loop;
                         }
                         //---
-                        // if (foo()) return; [ else x... ]; y... ==> if (!foo()) { x...; y... }
-                        if (!stat.body.value && in_lambda) {
+                        // if (foo()) return [ void bar() ]; [ else x...; ] y... ==> if (!foo()) { x...; y... } else bar();
+                        if (in_lambda && (!value || value instanceof AST_UnaryPrefix && value.operator == "void")) {
                             CHANGED = true;
                             stat = stat.clone();
                             stat.condition = stat.condition.negate(compressor);
+                            var funs = extract_functions_from_statement_array(ret);
                             var body = as_statement_array(stat.alternative).concat(ret);
-                            var funs = extract_functions_from_statement_array(body);
                             stat.body = make_node(AST_BlockStatement, stat, {
                                 body: body
                             });
-                            stat.alternative = null;
-                            ret = funs.concat([ stat.transform(compressor) ]);
+                            stat.alternative = value ? make_node(AST_SimpleStatement, value, {
+                                body: value.expression
+                            }) : null;
+                            ret = [ stat.transform(compressor) ].concat(funs);
                             continue loop;
                         }
-
                         //---
                         // if (a) return b; if (c) return d; e; ==> return a ? b : c ? d : void e;
                         //
@@ -1197,7 +1222,7 @@ merge(Compressor.prototype, {
                 target.push(node);
                 return true;
             }
-            if (node instanceof AST_Defun) {
+            if (node instanceof AST_Defun && (node === stat || !compressor.has_directive("use strict"))) {
                 target.push(node);
                 return true;
             }
@@ -1215,12 +1240,12 @@ merge(Compressor.prototype, {
                 && !node.expression.has_side_effects(compressor);
     }
 
-    // may_eq_null()
-    // returns true if this node may evaluate to null or undefined
+    // may_throw_on_access()
+    // returns true if this node may be null, undefined or contain `AST_Accessor`
     (function(def) {
-        AST_Node.DEFMETHOD("may_eq_null", function(compressor) {
+        AST_Node.DEFMETHOD("may_throw_on_access", function(compressor) {
             var pure_getters = compressor.option("pure_getters");
-            return !pure_getters || this._eq_null(pure_getters);
+            return !pure_getters || this._throw_on_access(pure_getters);
         });
 
         function is_strict(pure_getters) {
@@ -1232,7 +1257,12 @@ merge(Compressor.prototype, {
         def(AST_Undefined, return_true);
         def(AST_Constant, return_false);
         def(AST_Array, return_false);
-        def(AST_Object, return_false);
+        def(AST_Object, function(pure_getters) {
+            if (!is_strict(pure_getters)) return false;
+            for (var i = this.properties.length; --i >=0;)
+                if (this.properties[i].value instanceof AST_Accessor) return true;
+            return false;
+        });
         def(AST_Function, return_false);
         def(AST_UnaryPostfix, return_false);
         def(AST_UnaryPrefix, function() {
@@ -1241,33 +1271,33 @@ merge(Compressor.prototype, {
         def(AST_Binary, function(pure_getters) {
             switch (this.operator) {
               case "&&":
-                return this.left._eq_null(pure_getters);
+                return this.left._throw_on_access(pure_getters);
               case "||":
-                return this.left._eq_null(pure_getters)
-                    && this.right._eq_null(pure_getters);
+                return this.left._throw_on_access(pure_getters)
+                    && this.right._throw_on_access(pure_getters);
               default:
                 return false;
             }
         })
         def(AST_Assign, function(pure_getters) {
             return this.operator == "="
-                && this.right._eq_null(pure_getters);
+                && this.right._throw_on_access(pure_getters);
         })
         def(AST_Conditional, function(pure_getters) {
-            return this.consequent._eq_null(pure_getters)
-                || this.alternative._eq_null(pure_getters);
+            return this.consequent._throw_on_access(pure_getters)
+                || this.alternative._throw_on_access(pure_getters);
         })
         def(AST_Sequence, function(pure_getters) {
-            return this.expressions[this.expressions.length - 1]._eq_null(pure_getters);
+            return this.expressions[this.expressions.length - 1]._throw_on_access(pure_getters);
         });
         def(AST_SymbolRef, function(pure_getters) {
             if (this.is_undefined) return true;
             if (!is_strict(pure_getters)) return false;
             var fixed = this.fixed_value();
-            return !fixed || fixed._eq_null(pure_getters);
+            return !fixed || fixed._throw_on_access(pure_getters);
         });
     })(function(node, func) {
-        node.DEFMETHOD("_eq_null", func);
+        node.DEFMETHOD("_throw_on_access", func);
     });
 
     /* -----[ boolean/negation helpers ]----- */
@@ -1808,11 +1838,11 @@ merge(Compressor.prototype, {
             return any(this.elements, compressor);
         });
         def(AST_Dot, function(compressor){
-            return this.expression.may_eq_null(compressor)
+            return this.expression.may_throw_on_access(compressor)
                 || this.expression.has_side_effects(compressor);
         });
         def(AST_Sub, function(compressor){
-            return this.expression.may_eq_null(compressor)
+            return this.expression.may_throw_on_access(compressor)
                 || this.expression.has_side_effects(compressor)
                 || this.property.has_side_effects(compressor);
         });
@@ -2221,11 +2251,12 @@ merge(Compressor.prototype, {
                             dirs.push(node);
                             return make_node(AST_EmptyStatement, node);
                         }
-                        if (node instanceof AST_Defun && hoist_funs) {
+                        if (hoist_funs && node instanceof AST_Defun
+                            && (tt.parent() === self || !compressor.has_directive("use strict"))) {
                             hoisted.push(node);
                             return make_node(AST_EmptyStatement, node);
                         }
-                        if (node instanceof AST_Var && hoist_vars) {
+                        if (hoist_vars && node instanceof AST_Var) {
                             node.definitions.forEach(function(def){
                                 vars.set(def.name.name, def);
                                 ++vars_found;
@@ -2365,6 +2396,7 @@ merge(Compressor.prototype, {
             var args = trim(this.args, compressor, first_in_statement);
             return args && make_sequence(this, args);
         });
+        def(AST_Accessor, return_null);
         def(AST_Function, return_null);
         def(AST_Binary, function(compressor, first_in_statement){
             var right = this.right.drop_side_effect_free(compressor);
@@ -2432,11 +2464,11 @@ merge(Compressor.prototype, {
             return values && make_sequence(this, values);
         });
         def(AST_Dot, function(compressor, first_in_statement){
-            if (this.expression.may_eq_null(compressor)) return this;
+            if (this.expression.may_throw_on_access(compressor)) return this;
             return this.expression.drop_side_effect_free(compressor, first_in_statement);
         });
         def(AST_Sub, function(compressor, first_in_statement){
-            if (this.expression.may_eq_null(compressor)) return this;
+            if (this.expression.may_throw_on_access(compressor)) return this;
             var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
             if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement);
             var property = this.property.drop_side_effect_free(compressor);
@@ -3747,7 +3779,7 @@ merge(Compressor.prototype, {
             if (fixed) {
                 if (d.should_replace === undefined) {
                     var init = fixed.evaluate(compressor);
-                    if (init !== fixed) {
+                    if (init !== fixed && (compressor.option("unsafe_regexp") || !(init instanceof RegExp))) {
                         init = make_node_from_constant(init, fixed);
                         var value_length = init.optimize(compressor).print_to_string().length;
                         var fn;

lib/minify.js

@@ -30,9 +30,6 @@ function set_shorthand(name, options, keys) {
 function minify(files, options) {
     var warn_function = AST_Node.warn_function;
     try {
-        if (typeof files == "string") {
-            files = [ files ];
-        }
         options = defaults(options, {
             compress: {},
             ie8: false,
@@ -41,10 +38,14 @@ function minify(files, options) {
             output: {},
             parse: {},
             sourceMap: false,
+            timings: false,
             toplevel: false,
             warnings: false,
             wrap: false,
         }, true);
+        var timings = options.timings && {
+            start: Date.now()
+        };
         set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
         set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
         set_shorthand("toplevel", options, [ "compress", "mangle" ]);
@@ -75,10 +76,14 @@ function minify(files, options) {
                 warnings.push(warning);
             };
         }
+        if (timings) timings.parse = Date.now();
         var toplevel;
         if (files instanceof AST_Toplevel) {
             toplevel = files;
         } else {
+            if (typeof files == "string") {
+                files = [ files ];
+            }
             options.parse = options.parse || {};
             options.parse.toplevel = null;
             for (var name in files) {
@@ -95,51 +100,77 @@ function minify(files, options) {
         if (options.wrap) {
             toplevel = toplevel.wrap_commonjs(options.wrap);
         }
-        if (options.compress) {
-            toplevel.figure_out_scope(options.mangle);
-            toplevel = new Compressor(options.compress).compress(toplevel);
-        }
+        if (timings) timings.scope1 = Date.now();
+        if (options.compress) toplevel.figure_out_scope(options.mangle);
+        if (timings) timings.compress = Date.now();
+        if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
+        if (timings) timings.scope2 = Date.now();
+        if (options.mangle) toplevel.figure_out_scope(options.mangle);
+        if (timings) timings.mangle = Date.now();
         if (options.mangle) {
-            toplevel.figure_out_scope(options.mangle);
             base54.reset();
             toplevel.compute_char_frequency(options.mangle);
             toplevel.mangle_names(options.mangle);
-            if (options.mangle.properties) {
-                toplevel = mangle_properties(toplevel, options.mangle.properties);
-            }
         }
-        if (options.sourceMap) {
-            if (typeof options.sourceMap.content == "string") {
-                options.sourceMap.content = JSON.parse(options.sourceMap.content);
+        if (timings) timings.properties = Date.now();
+        if (options.mangle && options.mangle.properties) {
+            toplevel = mangle_properties(toplevel, options.mangle.properties);
+        }
+        if (timings) timings.output = Date.now();
+        var result = {};
+        if (options.output.ast) {
+            result.ast = toplevel;
+        }
+        if (!HOP(options.output, "code") || options.output.code) {
+            if (options.sourceMap) {
+                if (typeof options.sourceMap.content == "string") {
+                    options.sourceMap.content = JSON.parse(options.sourceMap.content);
+                }
+                options.output.source_map = SourceMap({
+                    file: options.sourceMap.filename,
+                    orig: options.sourceMap.content,
+                    root: options.sourceMap.root
+                });
+                if (options.sourceMap.includeSources) {
+                    if (files instanceof AST_Toplevel) {
+                        throw new Error("original source content unavailable");
+                    } else for (var name in files) {
+                        options.output.source_map.get().setSourceContent(name, files[name]);
+                    }
+                }
             }
-            options.output.source_map = SourceMap({
-                file: options.sourceMap.filename,
-                orig: options.sourceMap.content,
-                root: options.sourceMap.root
-            });
-            if (options.sourceMap.includeSources) {
-                for (var name in files) {
-                    options.output.source_map.get().setSourceContent(name, files[name]);
+            delete options.output.ast;
+            delete options.output.code;
+            var stream = OutputStream(options.output);
+            toplevel.print(stream);
+            result.code = stream.get();
+            if (options.sourceMap) {
+                result.map = options.output.source_map.toString();
+                if (options.sourceMap.url == "inline") {
+                    result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(result.map);
+                } else if (options.sourceMap.url) {
+                    result.code += "\n//# sourceMappingURL=" + options.sourceMap.url;
                 }
             }
         }
-        var stream = OutputStream(options.output);
-        toplevel.print(stream);
-        var result = {
-            code: stream.get()
-        };
-        if (options.sourceMap) {
-            result.map = options.output.source_map.toString();
-            if (options.sourceMap.url == "inline") {
-                result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(result.map);
-            } else if (options.sourceMap.url) {
-                result.code += "\n//# sourceMappingURL=" + options.sourceMap.url;
+        if (timings) {
+            timings.end = Date.now();
+            result.timings = {
+                parse: 1e-3 * (timings.scope1 - timings.parse),
+                scope: 1e-3 * (timings.compress - timings.scope1 + timings.mangle - timings.scope2),
+                compress: 1e-3 * (timings.scope2 - timings.compress),
+                mangle: 1e-3 * (timings.properties - timings.mangle),
+                properties: 1e-3 * (timings.output - timings.properties),
+                output: 1e-3 * (timings.end - timings.output),
+                total: 1e-3 * (timings.end - timings.start)
             }
         }
         if (warnings.length) {
             result.warnings = warnings;
         }
         return result;
+    } catch (ex) {
+        return { error: ex };
     } finally {
         AST_Node.warn_function = warn_function;
     }

lib/mozilla-ast.js

@@ -111,23 +111,19 @@
         },
         Property: function(M) {
             var key = M.key;
-            var name = key.type == "Identifier" ? key.name : key.value;
             var args = {
                 start    : my_start_token(key),
                 end      : my_end_token(M.value),
-                key      : name,
+                key      : key.type == "Identifier" ? key.name : key.value,
                 value    : from_moz(M.value)
             };
-            switch (M.kind) {
-              case "init":
-                return new AST_ObjectKeyVal(args);
-              case "set":
-                args.value.name = from_moz(key);
-                return new AST_ObjectSetter(args);
-              case "get":
-                args.value.name = from_moz(key);
-                return new AST_ObjectGetter(args);
-            }
+            if (M.kind == "init") return new AST_ObjectKeyVal(args);
+            args.key = new AST_SymbolAccessor({
+                name: args.key
+            });
+            args.value = new AST_Accessor(args.value);
+            if (M.kind == "get") return new AST_ObjectGetter(args);
+            if (M.kind == "set") return new AST_ObjectSetter(args);
         },
         ArrayExpression: function(M) {
             return new AST_Array({
@@ -172,7 +168,7 @@
             });
         },
         VariableDeclaration: function(M) {
-            return new (M.kind === "const" ? AST_Const : AST_Var)({
+            return new AST_Var({
                 start       : my_start_token(M),
                 end         : my_end_token(M),
                 definitions : M.declarations.map(from_moz)
@@ -208,7 +204,7 @@
         Identifier: function(M) {
             var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
             return new (  p.type == "LabeledStatement" ? AST_Label
-                        : p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : AST_SymbolVar)
+                        : p.type == "VariableDeclarator" && p.id === M ? AST_SymbolVar
                         : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
                         : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
                         : p.type == "CatchClause" ? AST_SymbolCatch
@@ -260,10 +256,7 @@
     map("CallExpression", AST_Call, "callee>expression, arguments@args");
 
     def_to_moz(AST_Toplevel, function To_Moz_Program(M) {
-        return {
-            type: "Program",
-            body: M.body.map(to_moz)
-        };
+        return to_moz_scope("Program", M);
     });
 
     def_to_moz(AST_Defun, function To_Moz_FunctionDeclaration(M) {
@@ -271,7 +264,7 @@
             type: "FunctionDeclaration",
             id: to_moz(M.name),
             params: M.argnames.map(to_moz),
-            body: to_moz_block(M)
+            body: to_moz_scope("BlockStatement", M)
         }
     });
 
@@ -280,7 +273,7 @@
             type: "FunctionExpression",
             id: to_moz(M.name),
             params: M.argnames.map(to_moz),
-            body: to_moz_block(M)
+            body: to_moz_scope("BlockStatement", M)
         }
     });
 
@@ -331,7 +324,7 @@
     def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
         return {
             type: "VariableDeclaration",
-            kind: M instanceof AST_Const ? "const" : "var",
+            kind: "var",
             declarations: M.definitions.map(to_moz)
         };
     });
@@ -386,11 +379,10 @@
     });
 
     def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
-        var key = (
-            is_identifier(M.key)
-            ? {type: "Identifier", name: M.key}
-            : {type: "Literal", value: M.key}
-        );
+        var key = {
+            type: "Literal",
+            value: M.key instanceof AST_SymbolAccessor ? M.key.name : M.key
+        };
         var kind;
         if (M instanceof AST_ObjectKeyVal) {
             kind = "init";
@@ -551,8 +543,8 @@
         moz_to_me = new Function("U2", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
             exports, my_start_token, my_end_token, from_moz
         );
-        me_to_moz = new Function("to_moz", "to_moz_block", "return(" + me_to_moz + ")")(
-            to_moz, to_moz_block
+        me_to_moz = new Function("to_moz", "to_moz_block", "to_moz_scope", "return(" + me_to_moz + ")")(
+            to_moz, to_moz_block, to_moz_scope
         );
         MOZ_TO_ME[moztype] = moz_to_me;
         def_to_moz(mytype, me_to_moz);
@@ -610,4 +602,14 @@
         };
     };
 
+    function to_moz_scope(type, node) {
+        var body = node.body.map(to_moz);
+        if (node.body[0] instanceof AST_SimpleStatement && node.body[0].body instanceof AST_String) {
+            body.unshift(to_moz(new AST_EmptyStatement(node.body[0])));
+        }
+        return {
+            type: type,
+            body: body
+        };
+    };
 })();

lib/output.js

@@ -70,8 +70,6 @@ function OutputStream(options) {
         semicolons       : true,
         shebang          : true,
         source_map       : null,
-        space_colon      : true,
-        unescape_regexps : false,
         width            : 80,
         wrap_iife        : false,
     }, true);
@@ -191,12 +189,43 @@ function OutputStream(options) {
     var might_need_semicolon = false;
     var might_add_newline = 0;
     var last = "";
+    var mapping_token, mapping_name, mappings = options.source_map && [];
+
+    var do_add_mapping = mappings ? function() {
+        mappings.forEach(function(mapping) {
+            try {
+                options.source_map.add(
+                    mapping.token.file,
+                    mapping.line, mapping.col,
+                    mapping.token.line, mapping.token.col,
+                    !mapping.name && mapping.token.type == "name" ? mapping.token.value : mapping.name
+                );
+            } catch(ex) {
+                AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]", {
+                    file: mapping.token.file,
+                    line: mapping.token.line,
+                    col: mapping.token.col,
+                    cline: mapping.line,
+                    ccol: mapping.col,
+                    name: mapping.name || ""
+                })
+            }
+        });
+        mappings = [];
+    } : noop;
 
     var ensure_line_len = options.max_line_len ? function() {
         if (current_col > options.max_line_len) {
             if (might_add_newline) {
                 var left = OUTPUT.slice(0, might_add_newline);
                 var right = OUTPUT.slice(might_add_newline);
+                if (mappings) {
+                    var delta = right.length - current_col;
+                    mappings.forEach(function(mapping) {
+                        mapping.line++;
+                        mapping.col += delta;
+                    });
+                }
                 OUTPUT = left + "\n" + right;
                 current_line++;
                 current_pos++;
@@ -206,7 +235,10 @@ function OutputStream(options) {
                 AST_Node.warn("Output exceeds {max_line_len} characters", options);
             }
         }
-        might_add_newline = 0;
+        if (might_add_newline) {
+            might_add_newline = 0;
+            do_add_mapping();
+        }
     } : noop;
 
     var requireSemicolonChars = makePredicate("( [ + * / - , .");
@@ -266,6 +298,18 @@ function OutputStream(options) {
             }
             might_need_space = false;
         }
+
+        if (mapping_token) {
+            mappings.push({
+                token: mapping_token,
+                name: mapping_name,
+                line: current_line,
+                col: current_col
+            });
+            mapping_token = false;
+            if (!might_add_newline) do_add_mapping();
+        }
+
         OUTPUT += str;
         current_pos += str.length;
         var a = str.split(/\r?\n/), n = a.length - 1;
@@ -357,27 +401,12 @@ function OutputStream(options) {
 
     function colon() {
         print(":");
-        if (options.space_colon) space();
+        space();
     };
 
-    var add_mapping = options.source_map ? function(token, name) {
-        try {
-            if (token) options.source_map.add(
-                token.file || "?",
-                current_line, current_col,
-                token.line, token.col,
-                (!name && token.type == "name") ? token.value : name
-            );
-        } catch(ex) {
-            AST_Node.warn("Couldn't figure out mapping for {file}:{line},{col} → {cline},{ccol} [{name}]", {
-                file: token.file,
-                line: token.line,
-                col: token.col,
-                cline: current_line,
-                ccol: current_col,
-                name: name || ""
-            })
-        }
+    var add_mapping = mappings ? function(token, name) {
+        mapping_token = token;
+        mapping_name = name;
     } : noop;
 
     function get() {
@@ -1033,9 +1062,6 @@ function OutputStream(options) {
     DEFPRINT(AST_Var, function(self, output){
         self._do_print(output, "var");
     });
-    DEFPRINT(AST_Const, function(self, output){
-        self._do_print(output, "const");
-    });
 
     function parenthesize_for_noin(node, output, noin) {
         if (!noin) node.print(output);
@@ -1264,45 +1290,14 @@ function OutputStream(options) {
         }
     });
 
-    function regexp_safe_literal(code) {
-        return [
-            0x5c   , // \
-            0x2f   , // /
-            0x2e   , // .
-            0x2b   , // +
-            0x2a   , // *
-            0x3f   , // ?
-            0x28   , // (
-            0x29   , // )
-            0x5b   , // [
-            0x5d   , // ]
-            0x7b   , // {
-            0x7d   , // }
-            0x24   , // $
-            0x5e   , // ^
-            0x3a   , // :
-            0x7c   , // |
-            0x21   , // !
-            0x0a   , // \n
-            0x0d   , // \r
-            0x00   , // \0
-            0xfeff , // Unicode BOM
-            0x2028 , // unicode "line separator"
-            0x2029 , // unicode "paragraph separator"
-        ].indexOf(code) < 0;
-    };
-
     DEFPRINT(AST_RegExp, function(self, output){
-        var str = self.getValue().toString();
+        var regexp = self.getValue();
+        var str = regexp.toString();
+        if (regexp.raw_source) {
+            str = "/" + regexp.raw_source + str.slice(str.lastIndexOf("/"));
+        }
         if (output.option("ascii_only")) {
             str = output.to_ascii(str);
-        } else if (output.option("unescape_regexps")) {
-            str = str.split("\\\\").map(function(str){
-                return str.replace(/\\u[0-9a-fA-F]{4}|\\x[0-9a-fA-F]{2}/g, function(s){
-                    var code = parseInt(s.substr(2), 16);
-                    return regexp_safe_literal(code) ? String.fromCharCode(code) : s;
-                });
-            }).join("\\\\");
         }
         output.print(str);
         var p = output.parent();

lib/parse.js

@@ -285,7 +285,11 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         S.regex_allowed = ((type == "operator" && !UNARY_POSTFIX(value)) ||
                            (type == "keyword" && KEYWORDS_BEFORE_EXPRESSION(value)) ||
                            (type == "punc" && PUNC_BEFORE_EXPRESSION(value)));
-        prev_was_dot = (type == "punc" && value == ".");
+        if (type == "punc" && value == ".") {
+            prev_was_dot = true;
+        } else if (!is_comment) {
+            prev_was_dot = false;
+        }
         var ret = {
             type    : type,
             value   : value,
@@ -473,31 +477,33 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         return name;
     };
 
-    var read_regexp = with_eof_error("Unterminated regular expression", function(regexp){
+    var read_regexp = with_eof_error("Unterminated regular expression", function(source) {
         var prev_backslash = false, ch, in_class = false;
         while ((ch = next(true))) if (NEWLINE_CHARS(ch)) {
             parse_error("Unexpected line terminator");
         } else if (prev_backslash) {
-            regexp += "\\" + ch;
+            source += "\\" + ch;
             prev_backslash = false;
         } else if (ch == "[") {
             in_class = true;
-            regexp += ch;
+            source += ch;
         } else if (ch == "]" && in_class) {
             in_class = false;
-            regexp += ch;
+            source += ch;
         } else if (ch == "/" && !in_class) {
             break;
         } else if (ch == "\\") {
             prev_backslash = true;
         } else {
-            regexp += ch;
+            source += ch;
         }
         var mods = read_name();
         try {
-          return token("regexp", new RegExp(regexp, mods));
+            var regexp = new RegExp(source, mods);
+            regexp.raw_source = source;
+            return token("regexp", regexp);
         } catch(e) {
-          parse_error(e.message);
+            parse_error(e.message);
         }
     });
 
@@ -801,28 +807,23 @@ function parse($TEXT, options) {
     };
 
     var statement = embed_tokens(function() {
-        var tmp;
         handle_regexp();
         switch (S.token.type) {
           case "string":
-            var dir = false;
-            if (S.in_directives === true) {
-                if ((is_token(peek(), "punc", ";") || peek().nlb) && S.token.raw.indexOf("\\") === -1) {
+            if (S.in_directives) {
+                var token = peek();
+                if (S.token.raw.indexOf("\\") == -1
+                    && (token.nlb
+                        || is_token(token, "eof")
+                        || is_token(token, "punc", ";")
+                        || is_token(token, "punc", "}"))) {
                     S.input.add_directive(S.token.value);
                 } else {
                     S.in_directives = false;
                 }
             }
             var dir = S.in_directives, stat = simple_statement();
-            if (dir) {
-                return new AST_Directive({
-                    start : stat.body.start,
-                    end   : stat.body.end,
-                    quote : stat.body.quote,
-                    value : stat.body.value,
-                });
-            }
-            return stat;
+            return dir ? new AST_Directive(stat.body) : stat;
           case "num":
           case "regexp":
           case "operator":
@@ -854,75 +855,97 @@ function parse($TEXT, options) {
             }
 
           case "keyword":
-            switch (tmp = S.token.value, next(), tmp) {
+            switch (S.token.value) {
               case "break":
+                next();
                 return break_cont(AST_Break);
 
               case "continue":
+                next();
                 return break_cont(AST_Continue);
 
               case "debugger":
+                next();
                 semicolon();
                 return new AST_Debugger();
 
               case "do":
+                next();
+                var body = in_loop(statement);
+                expect_token("keyword", "while");
+                var condition = parenthesised();
+                semicolon(true);
                 return new AST_Do({
-                    body      : in_loop(statement),
-                    condition : (expect_token("keyword", "while"), tmp = parenthesised(), semicolon(true), tmp)
+                    body      : body,
+                    condition : condition
                 });
 
               case "while":
+                next();
                 return new AST_While({
                     condition : parenthesised(),
                     body      : in_loop(statement)
                 });
 
               case "for":
+                next();
                 return for_();
 
               case "function":
+                next();
                 return function_(AST_Defun);
 
               case "if":
+                next();
                 return if_();
 
               case "return":
                 if (S.in_function == 0 && !options.bare_returns)
                     croak("'return' outside of function");
+                next();
+                var value = null;
+                if (is("punc", ";")) {
+                    next();
+                } else if (!can_insert_semicolon()) {
+                    value = expression(true);
+                    semicolon();
+                }
                 return new AST_Return({
-                    value: ( is("punc", ";")
-                             ? (next(), null)
-                             : can_insert_semicolon()
-                             ? null
-                             : (tmp = expression(true), semicolon(), tmp) )
+                    value: value
                 });
 
               case "switch":
+                next();
                 return new AST_Switch({
                     expression : parenthesised(),
                     body       : in_loop(switch_body_)
                 });
 
               case "throw":
+                next();
                 if (S.token.nlb)
                     croak("Illegal newline after 'throw'");
+                var value = expression(true);
+                semicolon();
                 return new AST_Throw({
-                    value: (tmp = expression(true), semicolon(), tmp)
+                    value: value
                 });
 
               case "try":
+                next();
                 return try_();
 
               case "var":
-                return tmp = var_(), semicolon(), tmp;
-
-              case "const":
-                return tmp = const_(), semicolon(), tmp;
+                next();
+                var node = var_();
+                semicolon();
+                return node;
 
               case "with":
                 if (S.input.has_directive("use strict")) {
                     croak("Strict mode may not include a with statement");
                 }
+                next();
                 return new AST_With({
                     expression : parenthesised(),
                     body       : statement()
@@ -1153,16 +1176,13 @@ function parse($TEXT, options) {
         });
     };
 
-    function vardefs(no_in, in_const) {
+    function vardefs(no_in) {
         var a = [];
         for (;;) {
             a.push(new AST_VarDef({
                 start : S.token,
-                name  : as_symbol(in_const ? AST_SymbolConst : AST_SymbolVar),
-                value : is("operator", "=")
-                    ? (next(), expression(false, no_in))
-                    : in_const && S.input.has_directive("use strict")
-                        ? croak("Missing initializer in const declaration") : null,
+                name  : as_symbol(AST_SymbolVar),
+                value : is("operator", "=") ? (next(), expression(false, no_in)) : null,
                 end   : prev()
             }));
             if (!is("punc", ","))
@@ -1175,15 +1195,7 @@ function parse($TEXT, options) {
     var var_ = function(no_in) {
         return new AST_Var({
             start       : prev(),
-            definitions : vardefs(no_in, false),
-            end         : prev()
-        });
-    };
-
-    var const_ = function() {
-        return new AST_Const({
-            start       : prev(),
-            definitions : vardefs(false, true),
+            definitions : vardefs(no_in),
             end         : prev()
         });
     };
@@ -1324,10 +1336,15 @@ function parse($TEXT, options) {
             var type = start.type;
             var name = as_property_name();
             if (type == "name" && !is("punc", ":")) {
+                var key = new AST_SymbolAccessor({
+                    start: S.token,
+                    name: as_property_name(),
+                    end: prev()
+                });
                 if (name == "get") {
                     a.push(new AST_ObjectGetter({
                         start : start,
-                        key   : as_atom_node(),
+                        key   : key,
                         value : create_accessor(),
                         end   : prev()
                     }));
@@ -1336,7 +1353,7 @@ function parse($TEXT, options) {
                 if (name == "set") {
                     a.push(new AST_ObjectSetter({
                         start : start,
-                        key   : as_atom_node(),
+                        key   : key,
                         value : create_accessor(),
                         end   : prev()
                     }));

lib/scope.js

@@ -156,8 +156,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             // later.
             (node.scope = defun.parent_scope).def_function(node);
         }
-        else if (node instanceof AST_SymbolVar
-            || node instanceof AST_SymbolConst) {
+        else if (node instanceof AST_SymbolVar) {
             defun.def_variable(node);
             if (defun !== scope) {
                 node.mark_enclosed(options);
@@ -184,16 +183,8 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     self.walk(tw);
 
     // pass 2: find back references and eval
-    var func = null;
-    var globals = self.globals = new Dictionary();
+    self.globals = new Dictionary();
     var tw = new TreeWalker(function(node, descend){
-        if (node instanceof AST_Lambda) {
-            var prev_func = func;
-            func = node;
-            descend();
-            func = prev_func;
-            return true;
-        }
         if (node instanceof AST_LoopControl && node.label) {
             node.label.thedef.references.push(node);
             return true;
@@ -268,7 +259,7 @@ AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
     AST_Scope.prototype.init_scope_vars.apply(this, arguments);
     this.uses_arguments = false;
-    this.def_variable(new AST_SymbolConst({
+    this.def_variable(new AST_SymbolFunarg({
         name: "arguments",
         start: this.start,
         end: this.end
@@ -361,15 +352,8 @@ AST_Symbol.DEFMETHOD("unmangleable", function(options){
     return this.definition().unmangleable(options);
 });
 
-// property accessors are not mangleable
-AST_SymbolAccessor.DEFMETHOD("unmangleable", function(){
-    return true;
-});
-
 // labels are always mangleable
-AST_Label.DEFMETHOD("unmangleable", function(){
-    return false;
-});
+AST_Label.DEFMETHOD("unmangleable", return_false);
 
 AST_Symbol.DEFMETHOD("unreferenced", function(){
     return this.definition().references.length == 0
@@ -380,13 +364,9 @@ AST_Symbol.DEFMETHOD("undeclared", function(){
     return this.definition().undeclared;
 });
 
-AST_LabelRef.DEFMETHOD("undeclared", function(){
-    return false;
-});
+AST_LabelRef.DEFMETHOD("undeclared", return_false);
 
-AST_Label.DEFMETHOD("undeclared", function(){
-    return false;
-});
+AST_Label.DEFMETHOD("undeclared", return_false);
 
 AST_Symbol.DEFMETHOD("definition", function(){
     return this.thedef;
@@ -491,8 +471,6 @@ AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
         }
         else if (node instanceof AST_Var)
             base54.consider("var");
-        else if (node instanceof AST_Const)
-            base54.consider("const");
         else if (node instanceof AST_Lambda)
             base54.consider("function");
         else if (node instanceof AST_For)

package.json

@@ -4,7 +4,7 @@
   "homepage": "http://lisperator.net/uglifyjs",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.0.0",
+  "version": "3.0.12",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -33,22 +33,12 @@
     "source-map": "~0.5.1"
   },
   "devDependencies": {
-    "acorn": "~0.6.0",
-    "escodegen": "~1.3.3",
-    "esfuzz": "~0.3.1",
-    "estraverse": "~1.5.1",
-    "mocha": "~2.3.4"
-  },
-  "optionalDependencies": {
-    "uglify-to-browserify": "~1.0.0"
-  },
-  "browserify": {
-    "transform": [
-      "uglify-to-browserify"
-    ]
+    "acorn": "~5.0.3",
+    "mocha": "~2.3.4",
+    "semver": "~5.3.0"
   },
   "scripts": {
     "test": "node test/run-tests.js"
   },
-  "keywords": ["uglify", "uglify-js", "minify", "minifier"]
+  "keywords": ["uglify", "uglify-js", "minify", "minifier", "es5"]
 }

test/benchmark.js

@@ -9,7 +9,7 @@ var args = process.argv.slice(2);
 if (!args.length) {
     args.push("-mc");
 }
-args.push("--stats");
+args.push("--timings");
 var urls = [
     "https://code.jquery.com/jquery-3.2.1.js",
     "https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.4/angular.js",
@@ -29,12 +29,7 @@ function done() {
             var info = results[url];
             console.log();
             console.log(url);
-            var elapsed = 0;
-            console.log(info.log.replace(/Elapsed: ([0-9]+)\s*/g, function(match, time) {
-                elapsed += 1e-3 * parseInt(time);
-                return "";
-            }));
-            console.log("Run-time:", elapsed.toFixed(3), "s");
+            console.log(info.log);
             console.log("Original:", info.input, "bytes");
             console.log("Uglified:", info.output, "bytes");
             console.log("SHA1 sum:", info.sha1);

test/compress/collapse_vars.js

@@ -583,8 +583,8 @@ collapse_vars_assignment: {
             return a = a;
         }
         function f1(c) {
-            const a = 3 / c;
-            const b = 1 - a;
+            var a = 3 / c;
+            var b = 1 - a;
             return b;
         }
         function f2(c) {
@@ -724,10 +724,10 @@ collapse_vars_misc1: {
             return t;
         }
         function f1(x) { var y = 5 - x; return y; }
-        function f2(x) { const z = foo(), y = z / (5 - x); return y; }
+        function f2(x) { var z = foo(), y = z / (5 - x); return y; }
         function f3(x) { var z = foo(), y = (5 - x) / z; return y; }
         function f4(x) { var z = foo(), y = (5 - u) / z; return y; }
-        function f5(x) { const z = foo(), y = (5 - window.x) / z; return y; }
+        function f5(x) { var z = foo(), y = (5 - window.x) / z; return y; }
         function f6() { var b = window.a * window.z; return b && zap(); }
         function f7() { var b = window.a * window.z; return b + b; }
         function f8() { var b = window.a * window.z; var c = b + 5; return b + c; }
@@ -744,7 +744,7 @@ collapse_vars_misc1: {
         function f2(x) { return foo() / (5 - x) }
         function f3(x) { return (5 - x) / foo() }
         function f4(x) { var z = foo(); return (5 - u) / z }
-        function f5(x) { const z = foo(); return (5 - window.x) / z }
+        function f5(x) { var z = foo(); return (5 - window.x) / z }
         function f6() { return window.a * window.z && zap() }
         function f7() { var b = window.a * window.z; return b + b }
         function f8() { var b = window.a * window.z; return b + (b + 5) }

test/compress/const.js

@@ -1,166 +0,0 @@
-issue_1191: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        function foo(rot) {
-            const rotTol = 5;
-            if (rot < -rotTol || rot > rotTol)
-                bar();
-            baz();
-        }
-    }
-    expect: {
-        function foo(rot) {
-            (rot < -5 || rot > 5) && bar();
-            baz();
-        }
-    }
-}
-
-issue_1194: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        function f1() {const a = "X"; return a + a;}
-        function f2() {const aa = "X"; return aa + aa;}
-        function f3() {const aaa = "X"; return aaa + aaa;}
-    }
-    expect: {
-        function f1(){return"XX"}
-        function f2(){return"XX"}
-        function f3(){return"XX"}
-    }
-}
-
-issue_1396: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        function foo(a) {
-            const VALUE = 1;
-            console.log(2 | VALUE);
-            console.log(VALUE + 1);
-            console.log(VALUE);
-            console.log(a & VALUE);
-        }
-        function bar() {
-            const s = "01234567890123456789";
-            console.log(s + s + s + s + s);
-
-            const CONSTANT = "abc";
-            console.log(CONSTANT + CONSTANT + CONSTANT + CONSTANT + CONSTANT);
-        }
-    }
-    expect: {
-        function foo(a) {
-            console.log(3);
-            console.log(2);
-            console.log(1);
-            console.log(1 & a);
-        }
-        function bar() {
-            const s = "01234567890123456789";
-            console.log(s + s + s + s + s);
-
-            console.log("abcabcabcabcabc");
-        }
-    }
-}
-
-unused_regexp_literal: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-    }
-    input: {
-        function f(){ var a = /b/; }
-    }
-    expect: {
-        function f(){}
-    }
-}
-
-regexp_literal_not_const: {
-    options = {
-        evaluate      : true,
-        booleans      : true,
-        comparisons   : true,
-        dead_code     : true,
-        conditionals  : true,
-        side_effects  : true,
-        unused        : true,
-        hoist_funs    : true,
-        if_return     : true,
-        join_vars     : true,
-        sequences     : false,
-        collapse_vars : false,
-        reduce_vars   : true,
-    }
-    input: {
-        (function(){
-            var result;
-            const s = 'acdabcdeabbb';
-            const REGEXP_LITERAL = /ab*/g;
-            while (result = REGEXP_LITERAL.exec(s)) {
-                console.log(result[0]);
-            }
-        })();
-    }
-    expect: {
-        (function() {
-            var result;
-            const REGEXP_LITERAL = /ab*/g;
-            while (result = REGEXP_LITERAL.exec("acdabcdeabbb")) console.log(result[0]);
-        })();
-    }
-    expect_stdout: true
-}

test/compress/dead-code.js

@@ -31,7 +31,7 @@ dead_code_2_should_warn: {
         function f() {
             g();
             x = 10;
-            throw "foo";
+            throw new Error("foo");
             // completely discarding the `if` would introduce some
             // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
             // we copy any declarations to the upper scope.
@@ -46,16 +46,60 @@ dead_code_2_should_warn: {
                 })();
             }
         }
+        f();
     }
     expect: {
         function f() {
             g();
             x = 10;
-            throw "foo";
+            throw new Error("foo");
             var x;
             function g(){};
         }
+        f();
     }
+    expect_stdout: true
+    node_version: "<=4"
+}
+
+dead_code_2_should_warn_strict: {
+    options = {
+        dead_code: true
+    };
+    input: {
+        "use strict";
+        function f() {
+            g();
+            x = 10;
+            throw new Error("foo");
+            // completely discarding the `if` would introduce some
+            // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
+            // we copy any declarations to the upper scope.
+            if (x) {
+                y();
+                var x;
+                function g(){};
+                // but nested declarations should not be kept.
+                (function(){
+                    var q;
+                    function y(){};
+                })();
+            }
+        }
+        f();
+    }
+    expect: {
+        "use strict";
+        function f() {
+            g();
+            x = 10;
+            throw new Error("foo");
+            var x;
+        }
+        f();
+    }
+    expect_stdout: true
+    node_version: "=4"
 }
 
 dead_code_constant_boolean_should_warn_more: {
@@ -78,6 +122,7 @@ dead_code_constant_boolean_should_warn_more: {
             foo();
             var moo;
         }
+        bar();
     }
     expect: {
         var foo;
@@ -86,133 +131,46 @@ dead_code_constant_boolean_should_warn_more: {
         // as for the for, it should keep:
         var x = 10, y;
         var moo;
+        bar();
     }
     expect_stdout: true
+    node_version: "<=4"
 }
 
-dead_code_const_declaration: {
+dead_code_constant_boolean_should_warn_more_strict: {
     options = {
         dead_code    : true,
         loops        : true,
         booleans     : true,
         conditionals : true,
         evaluate     : true,
-        reduce_vars  : true,
+        side_effects : true,
     };
     input: {
-        var unused;
-        const CONST_FOO = false;
-        if (CONST_FOO) {
+        "use strict";
+        while (!((foo && bar) || (x + "0"))) {
             console.log("unreachable");
-            var moo;
+            var foo;
             function bar() {}
         }
-    }
-    expect: {
-        var unused;
-        const CONST_FOO = !1;
-        var moo;
-        function bar() {}
-    }
-    expect_stdout: true
-}
-
-dead_code_const_annotation: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true,
-        reduce_vars  : true,
-        toplevel     : true,
-    };
-    input: {
-        var unused;
-        /** @const */ var CONST_FOO_ANN = false;
-        if (CONST_FOO_ANN) {
-            console.log("unreachable");
+        for (var x = 10, y; x && (y || x) && (!typeof x); ++x) {
+            asdf();
+            foo();
             var moo;
-            function bar() {}
         }
+        bar();
     }
     expect: {
-        var unused;
-        var CONST_FOO_ANN = !1;
+        "use strict";
+        var foo;
+        // nothing for the while
+        // as for the for, it should keep:
+        var x = 10, y;
         var moo;
-        function bar() {}
-    }
-    expect_stdout: true
-}
-
-dead_code_const_annotation_regex: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true
-    };
-    input: {
-        var unused;
-        // @constraint this shouldn't be a constant
-        var CONST_FOO_ANN = false;
-        if (CONST_FOO_ANN) {
-            console.log("reachable");
-        }
-    }
-    expect: {
-        var unused;
-        var CONST_FOO_ANN = !1;
-        CONST_FOO_ANN && console.log('reachable');
-    }
-    expect_stdout: true
-}
-
-dead_code_const_annotation_complex_scope: {
-    options = {
-        dead_code    : true,
-        loops        : true,
-        booleans     : true,
-        conditionals : true,
-        evaluate     : true,
-        reduce_vars  : true,
-        toplevel     : true,
-    };
-    input: {
-        var unused_var;
-        /** @const */ var test = 'test';
-        // @const
-        var CONST_FOO_ANN = false;
-        var unused_var_2;
-        if (CONST_FOO_ANN) {
-            console.log("unreachable");
-            var moo;
-            function bar() {}
-        }
-        if (test === 'test') {
-            var beef = 'good';
-            /** @const */ var meat = 'beef';
-            var pork = 'bad';
-            if (meat === 'pork') {
-                console.log('also unreachable');
-            } else if (pork === 'good') {
-                console.log('reached, not const');
-            }
-        }
-    }
-    expect: {
-        var unused_var;
-        var test = 'test';
-        var CONST_FOO_ANN = !1;
-        var unused_var_2;
-        var moo;
-        function bar() {}
-        var beef = 'good';
-        var meat = 'beef';
-        var pork = 'bad';
+        bar();
     }
     expect_stdout: true
+    node_version: ">=4"
 }
 
 try_catch_finally: {
@@ -256,3 +214,19 @@ try_catch_finally: {
         "1",
     ]
 }
+
+accessor: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        ({
+            get a() {},
+            set a(v){
+                this.b = 2;
+            },
+            b: 1
+        });
+    }
+    expect: {}
+}

test/compress/drop-unused.js

@@ -649,37 +649,6 @@ drop_value: {
     }
 }
 
-const_assign: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            const b = 2;
-            return 1 + b;
-        }
-
-        function g() {
-            const b = 2;
-            b = 3;
-            return 1 + b;
-        }
-    }
-    expect: {
-        function f() {
-            return 3;
-        }
-
-        function g() {
-            const b = 2;
-            b = 3;
-            return 1 + b;
-        }
-    }
-}
-
 issue_1539: {
     options = {
         cascade: true,
@@ -816,10 +785,6 @@ issue_1709: {
                 var x = 1;
                 return x;
             }(),
-            function y() {
-                const y = 2;
-                return y;
-            }(),
             function z() {
                 function z() {}
                 return z;
@@ -832,10 +797,6 @@ issue_1709: {
                 var x = 1;
                 return x;
             }(),
-            function() {
-                const y = 2;
-                return y;
-            }(),
             function() {
                 function z() {}
                 return z;

test/compress/evaluate.js

@@ -645,16 +645,17 @@ call_args: {
     options = {
         evaluate: true,
         reduce_vars: true,
+        toplevel: true,
     }
     input: {
-        const a = 1;
+        var a = 1;
         console.log(a);
         +function(a) {
             return a;
         }(a);
     }
     expect: {
-        const a = 1;
+        var a = 1;
         console.log(1);
         +(1, 1);
     }
@@ -666,17 +667,17 @@ call_args_drop_param: {
         evaluate: true,
         keep_fargs: false,
         reduce_vars: true,
+        toplevel: true,
         unused: true,
     }
     input: {
-        const a = 1;
+        var a = 1;
         console.log(a);
         +function(a) {
             return a;
         }(a, b);
     }
     expect: {
-        const a = 1;
         console.log(1);
         +(b, 1);
     }
@@ -989,3 +990,50 @@ Infinity_NaN_undefined_LHS: {
         "}",
     ]
 }
+
+issue_1964_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe_regexp: false,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect_stdout: "b"
+}
+
+issue_1964_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unsafe_regexp: true,
+        unused: true,
+    }
+    input: {
+        function f() {
+            var long_variable_name = /\s/;
+            return "a b c".split(long_variable_name)[1];
+        }
+        console.log(f());
+    }
+    expect: {
+        function f() {
+            return "a b c".split(/\s/)[1];
+        }
+        console.log(f());
+    }
+    expect_stdout: "b"
+}

test/compress/functions.js

@@ -167,3 +167,81 @@ function_returning_constant_literal: {
     }
     expect_stdout: "Hello there"
 }
+
+hoist_funs: {
+    options = {
+        hoist_funs: true,
+    }
+    input: {
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            function f() {}
+            console.log(5, typeof f, typeof g);
+        }
+        function g() {}
+        console.log(6, typeof f, typeof g);
+    }
+    expect: {
+        function f() {}
+        function g() {}
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            console.log(5, typeof f, typeof g);
+        }
+        console.log(6, typeof f, typeof g);
+    }
+    expect_stdout: [
+        "1 'function' 'function'",
+        "2 'function' 'function'",
+        "4 'function' 'function'",
+        "5 'function' 'function'",
+        "6 'function' 'function'",
+    ]
+    node_version: "<=4"
+}
+
+hoist_funs_strict: {
+    options = {
+        hoist_funs: true,
+    }
+    input: {
+        "use strict";
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            function f() {}
+            console.log(5, typeof f, typeof g);
+        }
+        function g() {}
+        console.log(6, typeof f, typeof g);
+    }
+    expect: {
+        "use strict";
+        function g() {}
+        console.log(1, typeof f, typeof g);
+        if (console.log(2, typeof f, typeof g))
+            console.log(3, typeof f, typeof g);
+        else {
+            console.log(4, typeof f, typeof g);
+            function f() {}
+            console.log(5, typeof f, typeof g);
+        }
+        console.log(6, typeof f, typeof g);
+    }
+    expect_stdout: [
+        "1 'undefined' 'function'",
+        "2 'undefined' 'function'",
+        "4 'function' 'function'",
+        "5 'function' 'function'",
+        "6 'undefined' 'function'",
+    ]
+    node_version: "=4"
+}

test/compress/global_defs.js

@@ -120,7 +120,7 @@ mixed: {
         properties: true,
     }
     input: {
-        const FOO = { BAR: 0 };
+        var FOO = { BAR: 0 };
         console.log(FOO.BAR);
         console.log(++CONFIG.DEBUG);
         console.log(++CONFIG.VALUE);
@@ -130,7 +130,7 @@ mixed: {
         console.log(CONFIG);
     }
     expect: {
-        const FOO = { BAR: 0 };
+        var FOO = { BAR: 0 };
         console.log("moo");
         console.log(++CONFIG.DEBUG);
         console.log(++CONFIG.VALUE);
@@ -160,3 +160,17 @@ issue_1801: {
         console.log(!0);
     }
 }
+
+issue_1986: {
+    options = {
+        global_defs: {
+            "@alert": "console.log",
+        },
+    }
+    input: {
+        alert(42);
+    }
+    expect: {
+        console.log(42);
+    }
+}

test/compress/if_return.js

@@ -302,3 +302,25 @@ issue_1437_conditionals: {
         }
     }
 }
+
+issue_512: {
+    options = {
+        conditionals: true,
+        if_return: true,
+    }
+    input: {
+        function a() {
+            if (b()) {
+                c();
+                return;
+            }
+            throw e;
+        }
+    }
+    expect: {
+        function a() {
+            if (!b()) throw e;
+            c();
+        }
+    }
+}

test/compress/issue-1034.js

@@ -116,3 +116,137 @@ non_hoisted_function_after_return_2b: {
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:101,12]",
     ]
 }
+
+non_hoisted_function_after_return_strict: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar();
+                not_called1();
+            } else {
+                return baz();
+                not_called2();
+            }
+            function bar() { return 7; }
+            return not_reached;
+            function UnusedFunction() {}
+            function baz() { return 8; }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return x ? bar() : baz();
+            function bar() { return 7 }
+            function baz() { return 8 }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect_stdout: "8 7"
+    expect_warnings: [
+        'WARN: Dropping unreachable code [test/compress/issue-1034.js:131,16]',
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:134,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:137,12]",
+        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:138,21]"
+    ]
+}
+
+non_hoisted_function_after_return_2a_strict: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        collapse_vars: false, passes: 2, warnings: "verbose"
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar(1);
+                var a = not_called(1);
+            } else {
+                return bar(2);
+                var b = not_called(2);
+            }
+            var c = bar(3);
+            function bar(x) { return 7 - x; }
+            function nope() {}
+            return b || c;
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return bar(x ? 1 : 2);
+            function bar(x) {
+                return 7 - x;
+            }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect_stdout: "5 6"
+    expect_warnings: [
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:173,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:173,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:176,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:176,16]",
+        "WARN: Dropping unused variable a [test/compress/issue-1034.js:173,20]",
+        "WARN: Dropping unused function nope [test/compress/issue-1034.js:180,21]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:178,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:178,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:181,12]",
+        "WARN: Dropping unused variable b [test/compress/issue-1034.js:176,20]",
+        "WARN: Dropping unused variable c [test/compress/issue-1034.js:178,16]",
+    ]
+}
+
+non_hoisted_function_after_return_2b_strict: {
+    options = {
+        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
+        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
+        if_return: true, join_vars: true, cascade: true, side_effects: true,
+        collapse_vars: false
+    }
+    input: {
+        "use strict";
+        function foo(x) {
+            if (x) {
+                return bar(1);
+            } else {
+                return bar(2);
+                var b;
+            }
+            var c = bar(3);
+            function bar(x) {
+                return 7 - x;
+            }
+            return b || c;
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect: {
+        "use strict";
+        function foo(x) {
+            return bar(x ? 1 : 2);
+            function bar(x) { return 7 - x; }
+        }
+        console.log(foo(0), foo(1));
+    }
+    expect_stdout: "5 6"
+    expect_warnings: [
+        // duplicate warnings no longer emitted
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:225,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:225,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:227,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:227,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:231,12]",
+    ]
+}

test/compress/issue-1041.js

@@ -1,16 +1,3 @@
-const_declaration: {
-    options = {
-        evaluate: true
-    };
-
-    input: {
-        const goog = goog || {};
-    }
-    expect: {
-        const goog = goog || {};
-    }
-}
-
 const_pragma: {
     options = {
         evaluate: true,

test/compress/issue-1052.js

@@ -1,90 +1,91 @@
 multiple_functions: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             function f() {}
             function g() {}
         } )();
     }
     expect: {
         ( function() {
-            function f() {}
-            function g() {}
-
             // NOTE: other compression steps will reduce this
             // down to just `window`.
             if ( window );
+            function f() {}
+            function g() {}
         } )();
     }
 }
 
 single_function: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             function f() {}
         } )();
     }
     expect: {
         ( function() {
-            function f() {}
-
             if ( window );
+            function f() {}
         } )();
     }
 }
 
 deeply_nested: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             function f() {}
             function g() {}
-
             if ( !document ) {
                 return;
             }
-
             function h() {}
         } )();
     }
     expect: {
         ( function() {
-            function f() {}
-            function g() {}
-
-            function h() {}
-
             // NOTE: other compression steps will reduce this
             // down to just `window`.
             if ( window )
                 if (document);
+            function f() {}
+            function g() {}
+            function h() {}
         } )();
     }
 }
 
 not_hoisted_when_already_nested: {
-    options = { if_return: true, hoist_funs: false };
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
     input: {
         ( function() {
             if ( !window ) {
                 return;
             }
-
             if ( foo ) function f() {}
-
         } )();
     }
     expect: {
@@ -94,3 +95,48 @@ not_hoisted_when_already_nested: {
         } )();
     }
 }
+
+defun_if_return: {
+    options = {
+        hoist_funs: false,
+        if_return: true,
+    }
+    input: {
+        function e() {
+            function f() {}
+            if (!window) return;
+            else function g() {}
+            function h() {}
+        }
+    }
+    expect: {
+        function e() {
+            function f() {}
+            if (window) function g() {}
+            function h() {}
+        }
+    }
+}
+
+defun_hoist_funs: {
+    options = {
+        hoist_funs: true,
+        if_return: true,
+    }
+    input: {
+        function e() {
+            function f() {}
+            if (!window) return;
+            else function g() {}
+            function h() {}
+        }
+    }
+    expect: {
+        function e() {
+            function f() {}
+            function g() {}
+            function h() {}
+            !window;
+        }
+    }
+}

test/compress/issue-1588.js

@@ -85,15 +85,3 @@ unsafe_undefined: {
     }
     expect_stdout: true
 }
-
-runtime_error: {
-    input: {
-        const a = 1;
-        console.log(a++);
-    }
-    expect: {
-        const a = 1;
-        console.log(a++);
-    }
-    expect_stdout: true
-}

test/compress/issue-1943.js

@@ -0,0 +1,31 @@
+operator: {
+    input: {
+        a. //comment
+        typeof
+    }
+    expect_exact: "a.typeof;"
+}
+
+name: {
+    input: {
+        a. //comment
+        b
+    }
+    expect_exact: "a.b;"
+}
+
+keyword: {
+    input: {
+        a. //comment
+        default
+    }
+    expect_exact: "a.default;"
+}
+
+atom: {
+    input: {
+        a. //comment
+        true
+    }
+    expect_exact: "a.true;"
+}

test/compress/issue-208.js

@@ -38,7 +38,7 @@ mixed: {
         }
     }
     input: {
-        const ENV = 3;
+        var ENV = 3;
         var FOO = 4;
         f(ENV * 10);
         --FOO;
@@ -49,7 +49,7 @@ mixed: {
         x = DEBUG;
     }
     expect: {
-        const ENV = 3;
+        var ENV = 3;
         var FOO = 4;
         f(10);
         --FOO;
@@ -60,7 +60,7 @@ mixed: {
         x = 0;
     }
     expect_warnings: [
-        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,14]',
+        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,12]',
         'WARN: global_defs FOO redefined [test/compress/issue-208.js:42,12]',
         'WARN: global_defs FOO redefined [test/compress/issue-208.js:44,10]',
         'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:45,8]',

test/compress/loops.js

@@ -146,50 +146,6 @@ parse_do_while_without_semicolon: {
     }
 }
 
-
-keep_collapse_const_in_own_block_scope: {
-    options = {
-        join_vars: true,
-        loops: true
-    }
-    input: {
-        var i=2;
-        const c=5;
-        while(i--)
-            console.log(i);
-        console.log(c);
-    }
-    expect: {
-        var i=2;
-        const c=5;
-        for(;i--;)
-            console.log(i);
-        console.log(c);
-    }
-    expect_stdout: true
-}
-
-keep_collapse_const_in_own_block_scope_2: {
-    options = {
-        join_vars: true,
-        loops: true
-    }
-    input: {
-        const c=5;
-        var i=2; // Moves to loop, while it did not in previous test
-        while(i--)
-            console.log(i);
-        console.log(c);
-    }
-    expect: {
-        const c=5;
-        for(var i=2;i--;)
-            console.log(i);
-        console.log(c);
-    }
-    expect_stdout: true
-}
-
 evaluate: {
     options = {
         loops: true,

test/compress/node_version.js

@@ -0,0 +1,12 @@
+eval_let: {
+    input: {
+        eval("let a;");
+        console.log();
+    }
+    expect: {
+        eval("let a;");
+        console.log();
+    }
+    expect_stdout: ""
+    node_version: ">=6"
+}

test/compress/pure_getters.js

@@ -119,3 +119,62 @@ chained: {
         a.b.c;
     }
 }
+
+impure_getter_1: {
+    options = {
+        pure_getters: "strict",
+        side_effects: true,
+    }
+    input: {
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).a;
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).b;
+    }
+    expect: {
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).a;
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).b;
+    }
+    expect_stdout: "1"
+}
+
+impure_getter_2: {
+    options = {
+        pure_getters: true,
+        side_effects: true,
+    }
+    input: {
+        // will produce incorrect output because getter is not pure
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).a;
+        ({
+            get a() {
+                console.log(1);
+            },
+            b: 1
+        }).b;
+    }
+    expect: {}
+}

test/compress/reduce_vars.js

@@ -41,20 +41,20 @@ reduce_vars: {
         var A = 1;
         (function() {
             console.log(-3);
-            console.log(-4);
+            console.log(A - 5);
         })();
         (function f1() {
             var a = 2;
-            console.log(-3);
+            console.log(a - 5);
             eval("console.log(a);");
         })();
         (function f2(eval) {
             var a = 2;
-            console.log(-3);
+            console.log(a - 5);
             eval("console.log(a);");
         })(eval);
         "yes";
-        console.log(2);
+        console.log(A + 1);
     }
     expect_stdout: true
 }
@@ -1749,7 +1749,10 @@ redefine_arguments_3: {
         console.log(function() {
             var arguments;
             return typeof arguments;
-        }(), "number", "undefined");
+        }(), "number", function(x) {
+            var arguments = x;
+            return typeof arguments;
+        }());
     }
     expect_stdout: "object number undefined"
 }
@@ -2187,10 +2190,11 @@ issue_1814_1: {
     options = {
         evaluate: true,
         reduce_vars: true,
+        toplevel: true,
         unused: true,
     }
     input: {
-        const a = 42;
+        var a = 42;
         !function() {
             var b = a;
             !function(a) {
@@ -2199,7 +2203,6 @@ issue_1814_1: {
         }();
     }
     expect: {
-        const a = 42;
         !function() {
             !function(a) {
                 console.log(a++, 42);
@@ -2213,10 +2216,11 @@ issue_1814_2: {
     options = {
         evaluate: true,
         reduce_vars: true,
+        toplevel: true,
         unused: true,
     }
     input: {
-        const a = "32";
+        var a = "32";
         !function() {
             var b = a + 1;
             !function(a) {
@@ -2225,7 +2229,6 @@ issue_1814_2: {
         }();
     }
     expect: {
-        const a = "32";
         !function() {
             !function(a) {
                 console.log(a++, "321");
@@ -2461,3 +2464,76 @@ issue_1865: {
     }
     expect_stdout: true
 }
+
+issue_1922_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function(a) {
+            arguments[0] = 2;
+            return a;
+        }(1));
+    }
+    expect: {
+        console.log(function(a) {
+            arguments[0] = 2;
+            return a;
+        }(1));
+    }
+    expect_stdout: "2"
+}
+
+issue_1922_2: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            var a;
+            eval("a = 1");
+            return a;
+        }(1));
+    }
+    expect: {
+        console.log(function() {
+            var a;
+            eval("a = 1");
+            return a;
+        }(1));
+    }
+    expect_stdout: "1"
+}
+
+accessor: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 1;
+        console.log({
+            get a() {
+                a = 2;
+                return a;
+            },
+            b: 1
+        }.b, a);
+    }
+    expect: {
+        var a = 1;
+        console.log({
+            get a() {
+                a = 2;
+                return a;
+            },
+            b: 1
+        }.b, a);
+    }
+    expect_stdout: "1 1"
+}

test/compress/string-literal.js

@@ -8,3 +8,12 @@ octal_escape_sequence: {
         var border_check = "\x20\x30\x38\x30\x00\x30\xc0\x30";
     }
 }
+
+issue_1929: {
+    input: {
+        function f(s) {
+            return s.split(/[\\/]/);
+        }
+    }
+    expect_exact: "function f(s){return s.split(/[\\\\/]/)}"
+}

test/exports.js

@@ -0,0 +1,13 @@
+exports["Compressor"] = Compressor;
+exports["JS_Parse_Error"] = JS_Parse_Error;
+exports["OutputStream"] = OutputStream;
+exports["SourceMap"] = SourceMap;
+exports["TreeWalker"] = TreeWalker;
+exports["base54"] = base54;
+exports["defaults"] = defaults;
+exports["mangle_properties"] = mangle_properties;
+exports["minify"] = minify;
+exports["parse"] = parse;
+exports["string_template"] = string_template;
+exports["tokenizer"] = tokenizer;
+exports["is_identifier"] = is_identifier;

test/input/invalid/const.js

@@ -1,8 +0,0 @@
-function f() {
-    const a;
-}
-
-function g() {
-    "use strict";
-    const a;
-}

test/input/invalid/else.js

@@ -0,0 +1 @@
+if (0) else 1;

test/input/invalid/return.js

@@ -0,0 +1 @@
+return 42;

test/input/issue-505/input.js

@@ -0,0 +1,5 @@
+function test(callback) {
+    'aaaaaaaaaaaaaaaa';
+    callback(err, data);
+    callback(err, data);
+}

test/input/issue-505/output.js

@@ -0,0 +1,5 @@
+function test(a){
+"aaaaaaaaaaaaaaaa"
+;a(err,data),a(err,data)
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsidGVzdCIsImNhbGxiYWNrIiwiZXJyIiwiZGF0YSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsS0FBS0M7QUFDVjtDQUNBQSxFQUFTQyxJQUFLQyxNQUNkRixFQUFTQyxJQUFLQyJ9

test/input/issue-520/output.js

@@ -1,2 +1,2 @@
 new function(){console.log(3)};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUErQyxHQUFyQyxZQUFnQkEsUUFBUUMsSUFBSSIsInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUErQyxJQUFyQyxXQUFnQkEsUUFBUUMsSUFBSSIsInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl19

test/jetstream.js

@@ -14,7 +14,7 @@ if (typeof phantom == "undefined") {
     if (!args.length) {
         args.push("-mc");
     }
-    args.push("--stats");
+    args.push("--timings");
     var child_process = require("child_process");
     try {
         require("phantomjs-prebuilt");

test/mocha/accessorTokens-1492.js

@@ -1,4 +1,4 @@
-var UglifyJS = require('../../');
+var UglifyJS = require("../node");
 var assert = require("assert");
 
 describe("Accessor tokens", function() {
@@ -16,7 +16,7 @@ describe("Accessor tokens", function() {
                 assert.equal(node.start.pos, 12);
                 assert.equal(node.end.endpos, 46);
 
-                assert(node.key instanceof UglifyJS.AST_SymbolRef);
+                assert(node.key instanceof UglifyJS.AST_SymbolAccessor);
                 assert.equal(node.key.start.pos, 16);
                 assert.equal(node.key.end.endpos, 22);
 

test/mocha/arguments.js

@@ -1,4 +1,4 @@
-var UglifyJS = require('../../');
+var UglifyJS = require("../node");
 var assert = require("assert");
 
 describe("arguments", function() {

test/mocha/cli.js

@@ -19,7 +19,9 @@ describe("bin/uglifyjs", function () {
             eval(stdout);
 
             assert.strictEqual(typeof WrappedUglifyJS, 'object');
-            assert.strictEqual(true, WrappedUglifyJS.parse('foo;') instanceof WrappedUglifyJS.AST_Node);
+            var result = WrappedUglifyJS.minify("foo([true,,2+3]);");
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, "foo([!0,,5]);");
 
             done();
         });
@@ -55,15 +57,15 @@ describe("bin/uglifyjs", function () {
         });
     });
     it("Should append source map to output when using --source-map url=inline", function (done) {
-       var command = uglifyjscmd + " test/input/issue-1323/sample.js --source-map url=inline";
+        var command = uglifyjscmd + " test/input/issue-1323/sample.js --source-map url=inline";
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n" +
-               "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=\n");
-           done();
-       });
+            assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n" +
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DIn0=\n");
+            done();
+        });
     });
     it("should not append source map to output when not using --source-map url=inline", function (done) {
         var command = uglifyjscmd + ' test/input/issue-1323/sample.js';
@@ -76,84 +78,84 @@ describe("bin/uglifyjs", function () {
         });
     });
     it("Should work with --keep-fnames (mangle only)", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m';
+        var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
+            done();
+        });
     });
     it("Should work with --keep-fnames (mangle & compress)", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m -c unused=false';
+        var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m -c unused=false';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(5==f(g)());\n");
-           done();
-       });
+            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(5==f(g)());\n");
+            done();
+        });
     });
     it("Should work with keep_fnames under mangler options", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep_fnames=true';
+        var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep_fnames=true';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
+            done();
+        });
     });
     it("Should work with --define (simple)", function (done) {
-       var command = uglifyjscmd + ' test/input/global_defs/simple.js --define D=5 -c';
+        var command = uglifyjscmd + ' test/input/global_defs/simple.js --define D=5 -c';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "console.log(5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "console.log(5);\n");
+            done();
+        });
     });
     it("Should work with --define (nested)", function (done) {
-       var command = uglifyjscmd + ' test/input/global_defs/nested.js --define C.D=5,C.V=3 -c';
+        var command = uglifyjscmd + ' test/input/global_defs/nested.js --define C.D=5,C.V=3 -c';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "console.log(3,5);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "console.log(3,5);\n");
+            done();
+        });
     });
     it("Should work with --define (AST_Node)", function (done) {
-       var command = uglifyjscmd + ' test/input/global_defs/simple.js --define console.log=stdout.println -c';
+        var command = uglifyjscmd + ' test/input/global_defs/simple.js --define console.log=stdout.println -c';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, "stdout.println(D);\n");
-           done();
-       });
+            assert.strictEqual(stdout, "stdout.println(D);\n");
+            done();
+        });
     });
     it("Should work with `--beautify`", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1482/input.js -b';
+        var command = uglifyjscmd + ' test/input/issue-1482/input.js -b';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, read("test/input/issue-1482/default.js"));
-           done();
-       });
+            assert.strictEqual(stdout, read("test/input/issue-1482/default.js"));
+            done();
+        });
     });
     it("Should work with `--beautify bracketize`", function (done) {
-       var command = uglifyjscmd + ' test/input/issue-1482/input.js -b bracketize';
+        var command = uglifyjscmd + ' test/input/issue-1482/input.js -b bracketize';
 
-       exec(command, function (err, stdout) {
-           if (err) throw err;
+        exec(command, function (err, stdout) {
+            if (err) throw err;
 
-           assert.strictEqual(stdout, read("test/input/issue-1482/bracketize.js"));
-           done();
-       });
+            assert.strictEqual(stdout, read("test/input/issue-1482/bracketize.js"));
+            done();
+        });
     });
     it("Should process inline source map", function(done) {
         var command = uglifyjscmd + " test/input/issue-520/input.js -mc toplevel --source-map content=inline,url=inline";
@@ -173,7 +175,7 @@ describe("bin/uglifyjs", function () {
 
             assert.strictEqual(stdout, [
                 "var bar=function(){function foo(bar){return bar}return foo}();",
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=",
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxJQUFJQSxJQUFNLFdBQ04sU0FBU0MsSUFBS0QsS0FDVixPQUFPQSxJQUdYLE9BQU9DIn0=",
                 "",
             ].join("\n"));
             assert.strictEqual(stderr, "WARN: inline source map not found\n");
@@ -185,7 +187,7 @@ describe("bin/uglifyjs", function () {
 
         exec(command, function (err, stdout, stderr) {
             assert.ok(err);
-            assert.strictEqual(stderr, "ERROR: inline source map only works with singular input\n");
+            assert.strictEqual(stderr.split(/\n/)[0], "ERROR: inline source map only works with singular input");
             done();
         });
     });
@@ -260,229 +262,244 @@ describe("bin/uglifyjs", function () {
         });
     });
     it("Should throw syntax error (5--)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_1.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_1.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_1.js:1,18",
-               "console.log(1 || 5--);",
-               "                  ^",
-               "ERROR: Invalid use of -- operator"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_1.js:1,18",
+                "console.log(1 || 5--);",
+                "                  ^",
+                "ERROR: Invalid use of -- operator"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (Math.random() /= 2)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_2.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_2.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_2.js:1,32",
-               "console.log(2 || (Math.random() /= 2));",
-               "                                ^",
-               "ERROR: Invalid assignment"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_2.js:1,32",
+                "console.log(2 || (Math.random() /= 2));",
+                "                                ^",
+                "ERROR: Invalid assignment"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (++this)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_3.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_3.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_3.js:1,17",
-               "console.log(3 || ++this);",
-               "                 ^",
-               "ERROR: Invalid use of ++ operator"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_3.js:1,17",
+                "console.log(3 || ++this);",
+                "                 ^",
+                "ERROR: Invalid use of ++ operator"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (++null)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/assign_4.js';
+        var command = uglifyjscmd + ' test/input/invalid/assign_4.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/assign_4.js:1,0",
-               "++null",
-               "^",
-               "ERROR: Invalid use of ++ operator"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/assign_4.js:1,0",
+                "++null",
+                "^",
+                "ERROR: Invalid use of ++ operator"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (a.=)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/dot_1.js';
+        var command = uglifyjscmd + ' test/input/invalid/dot_1.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/dot_1.js:1,2",
-               "a.=",
-               "  ^",
-               "ERROR: Unexpected token: operator (=)"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/dot_1.js:1,2",
+                "a.=",
+                "  ^",
+                "ERROR: Unexpected token: operator (=)"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (%.a)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/dot_2.js';
+        var command = uglifyjscmd + ' test/input/invalid/dot_2.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/dot_2.js:1,0",
-               "%.a;",
-               "^",
-               "ERROR: Unexpected token: operator (%)"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/dot_2.js:1,0",
+                "%.a;",
+                "^",
+                "ERROR: Unexpected token: operator (%)"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (a./();)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/dot_3.js';
+        var command = uglifyjscmd + ' test/input/invalid/dot_3.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/dot_3.js:1,2",
-               "a./();",
-               "  ^",
-               "ERROR: Unexpected token: operator (/)"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/dot_3.js:1,2",
+                "a./();",
+                "  ^",
+                "ERROR: Unexpected token: operator (/)"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error ({%: 1})", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/object.js';
+        var command = uglifyjscmd + ' test/input/invalid/object.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/object.js:1,13",
-               "console.log({%: 1});",
-               "             ^",
-               "ERROR: Unexpected token: operator (%)"
-           ].join("\n"));
-           done();
-       });
-    });
-    it("Should throw syntax error (const a)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/const.js';
-
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/const.js:7,11",
-               "    const a;",
-               "           ^",
-               "ERROR: Missing initializer in const declaration"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/object.js:1,13",
+                "console.log({%: 1});",
+                "             ^",
+                "ERROR: Unexpected token: operator (%)"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (delete x)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/delete.js';
+        var command = uglifyjscmd + ' test/input/invalid/delete.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/delete.js:13,11",
-               "    delete x;",
-               "           ^",
-               "ERROR: Calling delete on expression not allowed in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/delete.js:13,11",
+                "    delete x;",
+                "           ^",
+                "ERROR: Calling delete on expression not allowed in strict mode"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (function g(arguments))", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/function_1.js';
+        var command = uglifyjscmd + ' test/input/invalid/function_1.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/function_1.js:4,11",
-               "function g(arguments) {",
-               "           ^",
-               "ERROR: Unexpected arguments in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/function_1.js:4,11",
+                "function g(arguments) {",
+                "           ^",
+                "ERROR: Unexpected arguments in strict mode"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (function eval())", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/function_2.js';
+        var command = uglifyjscmd + ' test/input/invalid/function_2.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/function_2.js:4,9",
-               "function eval() {",
-               "         ^",
-               "ERROR: Unexpected eval in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/function_2.js:4,9",
+                "function eval() {",
+                "         ^",
+                "ERROR: Unexpected eval in strict mode"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (iife arguments())", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/function_3.js';
+        var command = uglifyjscmd + ' test/input/invalid/function_3.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/function_3.js:4,10",
-               "!function arguments() {",
-               "          ^",
-               "ERROR: Unexpected arguments in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/function_3.js:4,10",
+                "!function arguments() {",
+                "          ^",
+                "ERROR: Unexpected arguments in strict mode"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (catch(eval))", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/try.js';
+        var command = uglifyjscmd + ' test/input/invalid/try.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/try.js:7,18",
-               "    try {} catch (eval) {}",
-               "                  ^",
-               "ERROR: Unexpected eval in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/try.js:7,18",
+                "    try {} catch (eval) {}",
+                "                  ^",
+                "ERROR: Unexpected eval in strict mode"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should throw syntax error (var eval)", function(done) {
-       var command = uglifyjscmd + ' test/input/invalid/var.js';
+        var command = uglifyjscmd + ' test/input/invalid/var.js';
 
-       exec(command, function (err, stdout, stderr) {
-           assert.ok(err);
-           assert.strictEqual(stdout, "");
-           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-               "Parse error at test/input/invalid/var.js:7,8",
-               "    var eval;",
-               "        ^",
-               "ERROR: Unexpected eval in strict mode"
-           ].join("\n"));
-           done();
-       });
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/var.js:7,8",
+                "    var eval;",
+                "        ^",
+                "ERROR: Unexpected eval in strict mode"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (else)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/else.js';
+
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/else.js:1,7",
+                "if (0) else 1;",
+                "       ^",
+                "ERROR: Unexpected token: keyword (else)"
+            ].join("\n"));
+            done();
+        });
+    });
+    it("Should throw syntax error (return)", function(done) {
+        var command = uglifyjscmd + ' test/input/invalid/return.js';
+
+        exec(command, function (err, stdout, stderr) {
+            assert.ok(err);
+            assert.strictEqual(stdout, "");
+            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+                "Parse error at test/input/invalid/return.js:1,0",
+                "return 42;",
+                "^",
+                "ERROR: 'return' outside of function"
+            ].join("\n"));
+            done();
+        });
     });
     it("Should handle literal string as source map input", function(done) {
         var command = [
@@ -497,7 +514,7 @@ describe("bin/uglifyjs", function () {
 
             assert.strictEqual(stdout, [
                 '"use strict";var foo=function foo(x){return"foo "+x};console.log(foo("bar"));',
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImZvbyIsIngiLCJjb25zb2xlIiwibG9nIl0sIm1hcHBpbmdzIjoiWUFBQSxJQUFJQSxLQUFNLFFBQU5BLEtBQU1DLEdBQUEsTUFBSyxPQUFTQSxFQUN4QkMsU0FBUUMsSUFBSUgsSUFBSSJ9",
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImZvbyIsIngiLCJjb25zb2xlIiwibG9nIl0sIm1hcHBpbmdzIjoiYUFBQSxJQUFJQSxJQUFNLFNBQU5BLElBQU1DLEdBQUEsTUFBSyxPQUFTQSxHQUN4QkMsUUFBUUMsSUFBSUgsSUFBSSJ9",
                 ""
             ].join("\n"));
             done();
@@ -509,4 +526,15 @@ describe("bin/uglifyjs", function () {
             return JSON.stringify(map).replace(/"/g, '\\"');
         }
     });
+    it("Should dump AST as JSON", function(done) {
+        var command = uglifyjscmd + " test/input/global_defs/simple.js -mco ast";
+        exec(command, function (err, stdout) {
+            if (err) throw err;
+
+            var ast = JSON.parse(stdout);
+            assert.strictEqual(ast._class, "AST_Toplevel");
+            assert.ok(Array.isArray(ast.body));
+            done();
+        });
+    });
 });

test/mocha/comment-filter.js

@@ -1,4 +1,4 @@
-var UglifyJS = require('../../');
+var UglifyJS = require("../node");
 var assert = require("assert");
 
 describe("comment filters", function() {

test/mocha/comment.js

@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../../");
+var uglify = require("../node");
 
 describe("Comment", function() {
     it("Should recognize eol of single line comments", function() {

test/mocha/directives.js

@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../../");
+var uglify = require("../node");
 
 describe("Directives", function() {
     it ("Should allow tokenizer to store directives state", function() {
@@ -351,18 +351,28 @@ describe("Directives", function() {
         var tests = [
             [
                 '"use strict";"use strict";"use strict";"use foo";"use strict";;"use sloppy";doSomething("foo");',
-                '"use strict";"use foo";doSomething("foo");'
+                '"use strict";"use foo";doSomething("foo");',
+                'function f(){ "use strict" }',
+                'function f(){ "use asm" }',
+                'function f(){ "use nondirective" }',
+                'function f(){ ;"use strict" }',
+                'function f(){ "use \n"; }',
             ],
             [
                  // Nothing gets optimised in the compressor because "use asm" is the first statement
                 '"use asm";"use\\x20strict";1+1;',
-                '"use asm";;"use strict";1+1;' // Yet, the parser noticed that "use strict" wasn't a directive
+                '"use asm";;"use strict";1+1;', // Yet, the parser noticed that "use strict" wasn't a directive
+                'function f(){"use strict"}',
+                'function f(){"use asm"}',
+                'function f(){"use nondirective"}',
+                'function f(){}',
+                'function f(){}',
             ]
         ];
 
         for (var i = 0; i < tests.length; i++) {
             assert.strictEqual(
-                uglify.minify(tests[i][0], {compress: {collapse_vars: true, side_effects: true}}).code,
+                uglify.minify(tests[i][0]).code,
                 tests[i][1],
                 tests[i][0]
             );

test/mocha/getter-setter.js

@@ -1,4 +1,4 @@
-var UglifyJS = require('../../');
+var UglifyJS = require("../node");
 var assert = require("assert");
 
 describe("Getters and setters", function() {
@@ -71,7 +71,7 @@ describe("Getters and setters", function() {
         var fail = function(data) {
             return function (e) {
                 return e instanceof UglifyJS.JS_Parse_Error &&
-                    e.message === "Invalid getter/setter name: " + data.operator;
+                    e.message === "Unexpected token: operator (" + data.operator + ")";
             };
         };
 

test/mocha/line-endings.js

@@ -1,4 +1,4 @@
-var Uglify = require('../../');
+var Uglify = require("../node");
 var assert = require("assert");
 
 describe("line-endings", function() {

test/mocha/minify.js

@@ -114,17 +114,18 @@ describe("minify", function() {
             }
         });
         it("Should fail with multiple input and inline source map", function() {
-            assert.throws(function() {
-                Uglify.minify([
-                    read("./test/input/issue-520/input.js"),
-                    read("./test/input/issue-520/output.js")
-                ], {
-                    sourceMap: {
-                        content: "inline",
-                        url: "inline"
-                    }
-                });
+            var result = Uglify.minify([
+                read("./test/input/issue-520/input.js"),
+                read("./test/input/issue-520/output.js")
+            ], {
+                sourceMap: {
+                    content: "inline",
+                    url: "inline"
+                }
             });
+            var err = result.error;
+            assert.ok(err instanceof Error);
+            assert.strictEqual(err.stack.split(/\n/)[0], "Error: inline source map only works with singular input");
         });
     });
 
@@ -137,13 +138,25 @@ describe("minify", function() {
             });
             var code = result.code;
             assert.strictEqual(code, "var a=function(n){return n};\n" +
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsiYSIsImZvbyJdLCJtYXBwaW5ncyI6IkFBQUEsR0FBSUEsR0FBSSxTQUFTQyxHQUFPLE1BQU9BIn0=");
+                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIjAiXSwibmFtZXMiOlsiYSIsImZvbyJdLCJtYXBwaW5ncyI6IkFBQUEsSUFBSUEsRUFBSSxTQUFTQyxHQUFPLE9BQU9BIn0=");
         });
         it("should not append source map to output js when sourceMapInline is not enabled", function() {
             var result = Uglify.minify('var a = function(foo) { return foo; };');
             var code = result.code;
             assert.strictEqual(code, "var a=function(n){return n};");
         });
+        it("should work with max_line_len", function() {
+            var result = Uglify.minify(read("./test/input/issue-505/input.js"), {
+                output: {
+                    max_line_len: 20
+                },
+                sourceMap: {
+                    url: "inline"
+                }
+            });
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, read("./test/input/issue-505/output.js"));
+        });
     });
 
     describe("#__PURE__", function() {
@@ -170,26 +183,29 @@ describe("minify", function() {
     });
 
     describe("JS_Parse_Error", function() {
-        it("should throw syntax error", function() {
-            assert.throws(function() {
-                Uglify.minify("function f(a{}");
-            }, function(err) {
-                assert.ok(err instanceof Error);
-                assert.strictEqual(err.stack.split(/\n/)[0], "SyntaxError: Unexpected token punc «{», expected punc «,»");
-                assert.strictEqual(err.filename, "0");
-                assert.strictEqual(err.line, 1);
-                assert.strictEqual(err.col, 12);
-                return true;
-            });
+        it("should return syntax error", function() {
+            var result = Uglify.minify("function f(a{}");
+            var err = result.error;
+            assert.ok(err instanceof Error);
+            assert.strictEqual(err.stack.split(/\n/)[0], "SyntaxError: Unexpected token punc «{», expected punc «,»");
+            assert.strictEqual(err.filename, "0");
+            assert.strictEqual(err.line, 1);
+            assert.strictEqual(err.col, 12);
         });
     });
 
-    describe("Compressor", function() {
-        it("should be backward compatible with ast.transform(compressor)", function() {
-            var ast = Uglify.parse("function f(a){for(var i=0;i<a;i++)console.log(i)}");
-            ast.figure_out_scope();
-            ast = ast.transform(Uglify.Compressor());
-            assert.strictEqual(ast.print_to_string(), "function f(a){for(var i=0;i<a;i++)console.log(i)}");
+    describe("global_defs", function() {
+        it("should throw for non-trivial expressions", function() {
+            var result = Uglify.minify("alert(42);", {
+                compress: {
+                    global_defs: {
+                        "@alert": "debugger"
+                    }
+                }
+            });
+            var err = result.error;
+            assert.ok(err instanceof Error);
+            assert.strictEqual(err.stack.split(/\n/)[0], "Error: Can't handle expression: debugger");
         });
-    })
+    });
 });

test/mocha/number-literal.js

@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../../");
+var uglify = require("../node");
 
 describe("Number literals", function () {
     it("Should not allow legacy octal literals in strict mode", function() {

test/mocha/operator.js

@@ -1,4 +1,4 @@
-var UglifyJS = require("../../");
+var UglifyJS = require("../node");
 var assert = require("assert");
 
 describe("operator", function() {

test/mocha/spidermonkey.js

@@ -1,10 +1,10 @@
 var assert = require("assert");
 var exec = require("child_process").exec;
-var uglify = require("../../");
+var uglify = require("../node");
 
 describe("spidermonkey export/import sanity test", function() {
     it("should produce a functional build when using --self with spidermonkey", function(done) {
-        this.timeout(20000);
+        this.timeout(30000);
 
         var uglifyjs = '"' + process.argv[0] + '" bin/uglifyjs';
         var command = uglifyjs + " --self -cm --wrap SpiderUglify -o spidermonkey | " +
@@ -15,18 +15,9 @@ describe("spidermonkey export/import sanity test", function() {
 
             eval(stdout);
             assert.strictEqual(typeof SpiderUglify, "object");
-
-            var ast = SpiderUglify.parse("foo([true,,2+3]);");
-            assert.strictEqual(true, ast instanceof SpiderUglify.AST_Node);
-
-            ast.figure_out_scope();
-            ast = SpiderUglify.Compressor({}).compress(ast);
-            assert.strictEqual(true, ast instanceof SpiderUglify.AST_Node);
-
-            var stream = SpiderUglify.OutputStream({});
-            ast.print(stream);
-            var code = stream.toString();
-            assert.strictEqual(code, "foo([!0,,5]);");
+            var result = SpiderUglify.minify("foo([true,,2+3]);");
+            assert.strictEqual(result.error, undefined);
+            assert.strictEqual(result.code, "foo([!0,,5]);");
 
             done();
         });

test/mocha/string-literal.js

@@ -1,4 +1,4 @@
-var UglifyJS = require('../../');
+var UglifyJS = require("../node");
 var assert = require("assert");
 
 describe("String literals", function() {

test/mocha/with.js

@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../../");
+var uglify = require("../node");
 
 describe("With", function() {
     it("Should throw syntaxError when using with statement in strict mode", function() {

test/mozilla-ast.js

@@ -1,103 +1,73 @@
 // Testing UglifyJS <-> SpiderMonkey AST conversion
-// through generative testing.
+"use strict";
 
-var UglifyJS = require(".."),
-    escodegen = require("escodegen"),
-    esfuzz = require("esfuzz"),
-    estraverse = require("estraverse"),
-    prefix = "\r    ";
+var acorn = require("acorn");
+var ufuzz = require("./ufuzz");
+var UglifyJS = require("..");
 
-// Normalizes input AST for UglifyJS in order to get correct comparison.
-
-function normalizeInput(ast) {
-    return estraverse.replace(ast, {
-        enter: function(node, parent) {
-            switch (node.type) {
-                // Internally mark all the properties with semi-standard type "Property".
-                case "ObjectExpression":
-                    node.properties.forEach(function (property) {
-                        property.type = "Property";
-                    });
-                    break;
-
-                // Since UglifyJS doesn"t recognize different types of property keys,
-                // decision on SpiderMonkey node type is based on check whether key
-                // can be valid identifier or not - so we do in input AST.
-                case "Property":
-                    var key = node.key;
-                    if (key.type === "Literal" && typeof key.value === "string" && UglifyJS.is_identifier(key.value)) {
-                        node.key = {
-                            type: "Identifier",
-                            name: key.value
-                        };
-                    } else if (key.type === "Identifier" && !UglifyJS.is_identifier(key.name)) {
-                        node.key = {
-                            type: "Literal",
-                            value: key.name
-                        };
-                    }
-                    break;
-
-                // UglifyJS internally flattens all the expression sequences - either
-                // to one element (if sequence contains only one element) or flat list.
-                case "SequenceExpression":
-                    node.expressions = node.expressions.reduce(function flatten(list, expr) {
-                        return list.concat(expr.type === "SequenceExpression" ? expr.expressions.reduce(flatten, []) : [expr]);
-                    }, []);
-                    if (node.expressions.length === 1) {
-                        return node.expressions[0];
-                    }
-                    break;
-            }
+function try_beautify(code) {
+    var beautified = UglifyJS.minify(code, {
+        compress: false,
+        mangle: false,
+        output: {
+            beautify: true,
+            bracketize: true
         }
     });
+    if (beautified.error) {
+        console.log("// !!! beautify failed !!!");
+        console.log(beautified.error.stack);
+        console.log(code);
+    } else {
+        console.log("// (beautified)");
+        console.log(beautified.code);
+    }
 }
 
-module.exports = function(options) {
-    console.log("--- UglifyJS <-> Mozilla AST conversion");
-
-    for (var counter = 0; counter < options.iterations; counter++) {
-        process.stdout.write(prefix + counter + "/" + options.iterations);
-
-        var ast1 = normalizeInput(esfuzz.generate({
-            maxDepth: options.maxDepth
-        }));
-
-        var ast2 =
-            UglifyJS
-            .AST_Node
-            .from_mozilla_ast(ast1)
-            .to_mozilla_ast();
-
-        var astPair = [
-            {name: 'expected', value: ast1},
-            {name: 'actual', value: ast2}
-        ];
-
-        var jsPair = astPair.map(function(item) {
-            return {
-                name: item.name,
-                value: escodegen.generate(item.value)
-            }
-        });
-
-        if (jsPair[0].value !== jsPair[1].value) {
-            var fs = require("fs");
-            var acorn = require("acorn");
-
-            fs.existsSync("tmp") || fs.mkdirSync("tmp");
-
-            jsPair.forEach(function (item) {
-                var fileName = "tmp/dump_" + item.name;
-                var ast = acorn.parse(item.value);
-                fs.writeFileSync(fileName + ".js", item.value);
-                fs.writeFileSync(fileName + ".json", JSON.stringify(ast, null, 2));
-            });
-
-            process.stdout.write("\n");
-            throw new Error("Got different outputs, check out tmp/dump_*.{js,json} for codes and ASTs.");
+function test(original, estree, description) {
+    var transformed = UglifyJS.minify(UglifyJS.AST_Node.from_mozilla_ast(estree), {
+        compress: false,
+        mangle: false
+    });
+    if (transformed.error || original !== transformed.code) {
+        console.log("//=============================================================");
+        console.log("// !!!!!! Failed... round", round);
+        console.log("// original code");
+        try_beautify(original);
+        console.log();
+        console.log();
+        console.log("//-------------------------------------------------------------");
+        console.log("//", description);
+        if (transformed.error) {
+            console.log(transformed.error.stack);
+        } else {
+            try_beautify(transformed.code);
         }
+        console.log("!!!!!! Failed... round", round);
+        process.exit(1);
     }
+}
 
-    process.stdout.write(prefix + "Probability of error is less than " + (100 / options.iterations) + "%, stopping.\n");
-};
+var num_iterations = ufuzz.num_iterations;
+for (var round = 1; round <= num_iterations; round++) {
+    process.stdout.write(round + " of " + num_iterations + "\r");
+    var code = ufuzz.createTopLevelCode();
+    var uglified = UglifyJS.minify(code, {
+        compress: false,
+        mangle: false,
+        output: {
+            ast: true
+        }
+    });
+    test(uglified.code, uglified.ast.to_mozilla_ast(), "AST_Node.to_mozilla_ast()");
+    try {
+        test(uglified.code, acorn.parse(code), "acorn.parse()");
+    } catch (e) {
+        console.log("//=============================================================");
+        console.log("// acorn parser failed... round", round);
+        console.log(e);
+        console.log("// original code");
+        console.log(code);
+    }
+}
+console.log();

test/node.js

@@ -0,0 +1,6 @@
+var fs = require("fs");
+
+new Function("MOZ_SourceMap", "exports", require("../tools/node").FILES.map(function(file) {
+    if (/exports\.js$/.test(file)) file = require.resolve("./exports");
+    return fs.readFileSync(file, "utf8");
+}).join("\n\n"))(require("source-map"), exports);

test/run-tests.js

@@ -1,10 +1,11 @@
 #! /usr/bin/env node
 
-var U = require("../tools/node");
+var U = require("./node");
 var path = require("path");
 var fs = require("fs");
 var assert = require("assert");
 var sandbox = require("./sandbox");
+var semver = require("semver");
 
 var tests_dir = path.dirname(module.filename);
 var failures = 0;
@@ -23,12 +24,6 @@ mocha_tests();
 var run_sourcemaps_tests = require('./sourcemaps');
 run_sourcemaps_tests();
 
-var run_ast_conversion_tests = require("./mozilla-ast");
-
-run_ast_conversion_tests({
-    iterations: 1000
-});
-
 /* -----[ utils ]----- */
 
 function tmpl() {
@@ -170,7 +165,8 @@ function run_compress_tests() {
                         failed_files[file] = 1;
                     }
                 }
-                if (test.expect_stdout) {
+                if (test.expect_stdout
+                    && (!test.node_version || semver.satisfies(process.version, test.node_version))) {
                     var stdout = sandbox.run_code(input_code);
                     if (test.expect_stdout === true) {
                         test.expect_stdout = stdout;
@@ -280,7 +276,14 @@ function parse_test(file) {
             if (node instanceof U.AST_LabeledStatement) {
                 var label = node.label;
                 assert.ok(
-                    ["input", "expect", "expect_exact", "expect_warnings", "expect_stdout"].indexOf(label.name) >= 0,
+                    [
+                        "input",
+                        "expect",
+                        "expect_exact",
+                        "expect_warnings",
+                        "expect_stdout",
+                        "node_version",
+                    ].indexOf(label.name) >= 0,
                     tmpl("Unsupported label {name} [{line},{col}]", {
                         name: label.name,
                         line: label.start.line,
@@ -288,7 +291,7 @@ function parse_test(file) {
                     })
                 );
                 var stat = node.body;
-                if (label.name == "expect_exact") {
+                if (label.name == "expect_exact" || label.name == "node_version") {
                     test[label.name] = read_string(stat);
                 } else if (label.name == "expect_stdout") {
                     if (stat.TYPE == "SimpleStatement" && stat.body instanceof U.AST_Boolean) {

test/sandbox.js

@@ -1,14 +1,17 @@
+var semver = require("semver");
 var vm = require("vm");
 
-function safe_log(arg) {
+function safe_log(arg, level) {
     if (arg) switch (typeof arg) {
       case "function":
         return arg.toString();
       case "object":
         if (/Error$/.test(arg.name)) return arg.toString();
         arg.constructor.toString();
-        for (var key in arg) {
-            arg[key] = safe_log(arg[key]);
+        if (level--) for (var key in arg) {
+            if (!Object.getOwnPropertyDescriptor(arg, key).get) {
+                arg[key] = safe_log(arg[key], level);
+            }
         }
     }
     return arg;
@@ -48,7 +51,9 @@ exports.run_code = function(code) {
         ].join("\n"), {
             console: {
                 log: function() {
-                    return console.log.apply(console, [].map.call(arguments, safe_log));
+                    return console.log.apply(console, [].map.call(arguments, function(arg) {
+                        return safe_log(arg, 3);
+                    }));
                 }
             }
         }, { timeout: 5000 });
@@ -59,7 +64,7 @@ exports.run_code = function(code) {
         process.stdout.write = original_write;
     }
 };
-exports.same_stdout = ~process.version.lastIndexOf("v0.12.", 0) ? function(expected, actual) {
+exports.same_stdout = semver.satisfies(process.version, "0.12") ? function(expected, actual) {
     if (typeof expected != typeof actual) return false;
     if (typeof expected != "string") {
         if (expected.name != actual.name) return false;

test/sourcemaps.js

@@ -26,11 +26,11 @@ module.exports = function () {
 }
 
 function source_map(js) {
-    var source_map = UglifyJS.SourceMap();
-    var stream = UglifyJS.OutputStream({ source_map: source_map });
-    var parsed = UglifyJS.parse(js);
-    parsed.print(stream);
-    return JSON.parse(source_map.toString());
+    return JSON.parse(UglifyJS.minify(js, {
+        compress: false,
+        mangle: false,
+        sourceMap: true
+    }).map);
 }
 
 // Run standalone

test/ufuzz.js

@@ -12,7 +12,7 @@
         stream._handle.setBlocking(true);
 });
 
-var UglifyJS = require("..");
+var UglifyJS = require("./node");
 var randomBytes = require("crypto").randomBytes;
 var sandbox = require("./sandbox");
 
@@ -48,8 +48,9 @@ var STMT_COUNT_FROM_GLOBAL = true; // count statement depth from nearest functio
 var num_iterations = +process.argv[2] || 1/0;
 var verbose = false; // log every generated test
 var verbose_interval = false; // log every 100 generated tests
-var verbose_error = false;
 var use_strict = false;
+var catch_redef = require.main === module;
+var generate_directive = require.main === module;
 for (var i = 2; i < process.argv.length; ++i) {
     switch (process.argv[i]) {
       case '-v':
@@ -58,9 +59,6 @@ for (var i = 2; i < process.argv.length; ++i) {
       case '-V':
         verbose_interval = true;
         break;
-      case '-E':
-        verbose_error = true;
-        break;
       case '-t':
         MAX_GENERATED_TOPLEVELS_PER_RUN = +process.argv[++i];
         if (!MAX_GENERATED_TOPLEVELS_PER_RUN) throw new Error('Must generate at least one toplevel per run');
@@ -79,6 +77,12 @@ for (var i = 2; i < process.argv.length; ++i) {
         STMT_SECOND_LEVEL_OVERRIDE = STMT_ARG_TO_ID[name];
         if (!(STMT_SECOND_LEVEL_OVERRIDE >= 0)) throw new Error('Unknown statement name; use -? to get a list');
         break;
+      case '--no-catch-redef':
+        catch_redef = false;
+        break;
+      case '--no-directive':
+        generate_directive = false;
+        break;
       case '--use-strict':
         use_strict = true;
         break;
@@ -103,11 +107,12 @@ for (var i = 2; i < process.argv.length; ++i) {
         console.log('<number>: generate this many cases (if used must be first arg)');
         console.log('-v: print every generated test case');
         console.log('-V: print every 100th generated test case');
-        console.log('-E: print generated test case with runtime error');
         console.log('-t <int>: generate this many toplevels per run (more take longer)');
         console.log('-r <int>: maximum recursion depth for generator (higher takes longer)');
         console.log('-s1 <statement name>: force the first level statement to be this one (see list below)');
         console.log('-s2 <statement name>: force the second level statement to be this one (see list below)');
+        console.log('--no-catch-redef: do not redefine catch variables');
+        console.log('--no-directive: do not generate directives');
         console.log('--use-strict: generate "use strict"');
         console.log('--stmt-depth-from-func: reset statement depth counter at each function, counts from global otherwise');
         console.log('--only-stmt <statement names>: a comma delimited white list of statements that may be generated');
@@ -192,12 +197,33 @@ var ASSIGNMENTS = [
     '=',
     '=',
     '=',
+    '=',
+    '=',
+    '=',
+    '=',
+
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
+    '=',
 
-    '==',
-    '!=',
-    '===',
-    '!==',
     '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+    '+=',
+
     '-=',
     '*=',
     '/=',
@@ -207,7 +233,8 @@ var ASSIGNMENTS = [
     '<<=',
     '>>=',
     '>>>=',
-    '%=' ];
+    '%=',
+];
 
 var UNARY_SAFE = [
     '+',
@@ -276,6 +303,7 @@ var TYPEOF_OUTCOMES = [
     'symbol',
     'crap' ];
 
+var unique_vars = [];
 var loops = 0;
 var funcs = 0;
 var labels = 10000;
@@ -290,6 +318,10 @@ function strictMode() {
 }
 
 function createTopLevelCode() {
+    VAR_NAMES.length = INITIAL_NAMES_LEN; // prune any previous names still in the list
+    unique_vars.length = 0;
+    loops = 0;
+    funcs = 0;
     return [
         strictMode(),
         'var a = 100, b = 10, c = 0;',
@@ -325,33 +357,36 @@ function createArgs() {
     return args.join(', ');
 }
 
+function filterDirective(s) {
+    if (!generate_directive && !s[1] && /\("/.test(s[2])) s[2] = ';' + s[2];
+    return s;
+}
+
 function createFunction(recurmax, inGlobal, noDecl, canThrow, stmtDepth) {
     if (--recurmax < 0) { return ';'; }
     if (!STMT_COUNT_FROM_GLOBAL) stmtDepth = 0;
     var func = funcs++;
     var namesLenBefore = VAR_NAMES.length;
-    var name = (inGlobal || rng(5) > 0) ? 'f' + func : createVarName(MANDATORY, noDecl);
-    if (name === 'a' || name === 'b' || name === 'c') name = 'f' + func; // quick hack to prevent assignment to func names of being called
-    var s = '';
+    var name;
+    if (inGlobal || rng(5) > 0) name = 'f' + func;
+    else {
+        unique_vars.push('a', 'b', 'c');
+        name = createVarName(MANDATORY, noDecl);
+        unique_vars.length -= 3;
+    }
+    var s = [
+        'function ' + name + '(' + createParams() + '){',
+        strictMode()
+    ];
     if (rng(5) === 0) {
         // functions with functions. lower the recursion to prevent a mess.
-        s = [
-            'function ' + name + '(' + createParams() + '){',
-            strictMode(),
-            createFunctions(rng(5) + 1, Math.ceil(recurmax * 0.7), NOT_GLOBAL, ANY_TYPE, canThrow, stmtDepth),
-            '}',
-            ''
-        ].join('\n');
+        s.push(createFunctions(rng(5) + 1, Math.ceil(recurmax * 0.7), NOT_GLOBAL, ANY_TYPE, canThrow, stmtDepth));
     } else {
         // functions with statements
-        s = [
-            'function ' + name + '(' + createParams() + '){',
-            strictMode(),
-            createStatements(3, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
-            '}',
-            ''
-        ].join('\n');
+        s.push(createStatements(3, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth));
     }
+    s.push('}', '');
+    s = filterDirective(s).join('\n');
 
     VAR_NAMES.length = namesLenBefore;
 
@@ -359,7 +394,6 @@ function createFunction(recurmax, inGlobal, noDecl, canThrow, stmtDepth) {
     // avoid "function statements" (decl inside statements)
     else if (inGlobal || rng(10) > 0) s += 'var ' + createVarName(MANDATORY) + ' = ' + name + '(' + createArgs() + ');';
 
-
     return s;
 }
 
@@ -406,7 +440,7 @@ function getLabel(label) {
     return label && " L" + label;
 }
 
-function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) {
+function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth, target) {
     ++stmtDepth;
     var loop = ++loops;
     if (--recurmax < 0) {
@@ -414,10 +448,11 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
     }
 
     // allow to forcefully generate certain structures at first or second recursion level
-    var target = 0;
-    if (stmtDepth === 1 && STMT_FIRST_LEVEL_OVERRIDE >= 0) target = STMT_FIRST_LEVEL_OVERRIDE;
-    else if (stmtDepth === 2 && STMT_SECOND_LEVEL_OVERRIDE >= 0) target = STMT_SECOND_LEVEL_OVERRIDE;
-    else target = STMTS_TO_USE[rng(STMTS_TO_USE.length)];
+    if (target === undefined) {
+        if (stmtDepth === 1 && STMT_FIRST_LEVEL_OVERRIDE >= 0) target = STMT_FIRST_LEVEL_OVERRIDE;
+        else if (stmtDepth === 2 && STMT_SECOND_LEVEL_OVERRIDE >= 0) target = STMT_SECOND_LEVEL_OVERRIDE;
+        else target = STMTS_TO_USE[rng(STMTS_TO_USE.length)];
+    }
 
     switch (target) {
       case STMT_BLOCK:
@@ -460,20 +495,22 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
       case STMT_VAR:
         switch (rng(3)) {
           case 0:
+            unique_vars.push('c');
             var name = createVarName(MANDATORY);
-            if (name === 'c') name = 'a';
+            unique_vars.pop();
             return 'var ' + name + ';';
           case 1:
             // initializer can only have one expression
+            unique_vars.push('c');
             var name = createVarName(MANDATORY);
-            if (name === 'c') name = 'b';
+            unique_vars.pop();
             return 'var ' + name + ' = ' + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + ';';
           default:
             // initializer can only have one expression
+            unique_vars.push('c');
             var n1 = createVarName(MANDATORY);
-            if (n1 === 'c') n1 = 'b';
             var n2 = createVarName(MANDATORY);
-            if (n2 === 'c') n2 = 'b';
+            unique_vars.pop();
             return 'var ' + n1 + ' = ' + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + ', ' + n2 + ' = ' + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + ';';
         }
       case STMT_RETURN_ETC:
@@ -514,8 +551,11 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
             var nameLenBefore = VAR_NAMES.length;
             var catchName = createVarName(MANDATORY);
             var freshCatchName = VAR_NAMES.length !== nameLenBefore;
+            if (!catch_redef) unique_vars.push(catchName);
             s += ' catch (' + catchName + ') { ' + createStatements(3, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + ' }';
-            if (freshCatchName) VAR_NAMES.splice(nameLenBefore, 1); // remove catch name
+            // remove catch name
+            if (!catch_redef) unique_vars.pop();
+            if (freshCatchName) VAR_NAMES.splice(nameLenBefore, 1);
         }
         if (n !== 0) s += ' finally { ' + createStatements(3, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + ' }';
         return s;
@@ -593,8 +633,9 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
       case p++:
       case p++:
         var nameLenBefore = VAR_NAMES.length;
+        unique_vars.push('c');
         var name = createVarName(MAYBE); // note: this name is only accessible from _within_ the function. and immutable at that.
-        if (name == 'c') name = 'a';
+        unique_vars.pop();
         var s = [];
         switch (rng(5)) {
           case 0:
@@ -636,7 +677,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
                 strictMode()
             );
             if (instantiate) for (var i = rng(4); --i >= 0;) {
-                if (rng(2)) s.push('this.' + getDotKey() + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ';');
+                if (rng(2)) s.push('this.' + getDotKey(true) + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ';');
                 else  s.push('this[' + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']' + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ';');
             }
             s.push(
@@ -646,7 +687,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
             break;
         }
         VAR_NAMES.length = nameLenBefore;
-        return s.join('\n');
+        return filterDirective(s).join('\n');
       case p++:
       case p++:
         return createTypeofExpr(recurmax, stmtDepth, canThrow);
@@ -689,19 +730,19 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
             ") || " + rng(10) + ").toString()[" +
             createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "] ";
       case p++:
-        return createArrayLiteral(recurmax, COMMA_OK, stmtDepth, canThrow);
+        return createArrayLiteral(recurmax, stmtDepth, canThrow);
       case p++:
-        return createObjectLiteral(recurmax, COMMA_OK, stmtDepth, canThrow);
+        return createObjectLiteral(recurmax, stmtDepth, canThrow);
       case p++:
-        return createArrayLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '[' +
+        return createArrayLiteral(recurmax, stmtDepth, canThrow) + '[' +
             createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']';
       case p++:
-        return createObjectLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '[' +
+        return createObjectLiteral(recurmax, stmtDepth, canThrow) + '[' +
             createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']';
       case p++:
-        return createArrayLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '.' + getDotKey();
+        return createArrayLiteral(recurmax, stmtDepth, canThrow) + '.' + getDotKey();
       case p++:
-        return createObjectLiteral(recurmax, COMMA_OK, stmtDepth, canThrow) + '.' + getDotKey();
+        return createObjectLiteral(recurmax, stmtDepth, canThrow) + '.' + getDotKey();
       case p++:
         var name = getVarName();
         return name + ' && ' + name + '[' + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + ']';
@@ -713,7 +754,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
     return _createExpression(recurmax, noComma, stmtDepth, canThrow);
 }
 
-function createArrayLiteral(recurmax, noComma, stmtDepth, canThrow) {
+function createArrayLiteral(recurmax, stmtDepth, canThrow) {
     recurmax--;
     var arr = "[";
     for (var i = rng(6); --i >= 0;) {
@@ -746,18 +787,56 @@ var KEYS = [
     "3",
 ].concat(SAFE_KEYS);
 
-function getDotKey() {
-    return SAFE_KEYS[rng(SAFE_KEYS.length)];
+function getDotKey(assign) {
+    var key;
+    do {
+        key = SAFE_KEYS[rng(SAFE_KEYS.length)];
+    } while (assign && key == "length");
+    return key;
 }
 
-function createObjectLiteral(recurmax, noComma, stmtDepth, canThrow) {
-    recurmax--;
-    var obj = "({";
-    for (var i = rng(6); --i >= 0;) {
-        var key = KEYS[rng(KEYS.length)];
-        obj += key + ":(" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "), ";
+function createAccessor(recurmax, stmtDepth, canThrow) {
+    var namesLenBefore = VAR_NAMES.length;
+    var s;
+    var prop1 = getDotKey();
+    if (rng(2) == 0) {
+        s = [
+            'get ' + prop1 + '(){',
+            strictMode(),
+            createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
+            createStatement(recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth, STMT_RETURN_ETC),
+            '},'
+        ];
+    } else {
+        var prop2;
+        do {
+            prop2 = getDotKey();
+        } while (prop1 == prop2);
+        s = [
+            'set ' + prop1 + '(' + createVarName(MANDATORY) + '){',
+            strictMode(),
+            createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
+            'this.' + prop2 + createAssignment() + _createBinaryExpr(recurmax, COMMA_OK, stmtDepth, canThrow) + ';',
+            '},'
+        ];
     }
-    return obj + "})";
+    VAR_NAMES.length = namesLenBefore;
+    return filterDirective(s).join('\n');
+}
+
+function createObjectLiteral(recurmax, stmtDepth, canThrow) {
+    recurmax--;
+    var obj = ['({'];
+    for (var i = rng(6); --i >= 0;) {
+        if (rng(20) == 0) {
+            obj.push(createAccessor(recurmax, stmtDepth, canThrow));
+        } else {
+            var key = KEYS[rng(KEYS.length)];
+            obj.push(key + ':(' + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + '),');
+        }
+    }
+    obj.push('})');
+    return obj.join('\n');
 }
 
 function createNestedBinaryExpr(recurmax, noComma, stmtDepth, canThrow) {
@@ -787,7 +866,7 @@ function _createSimpleBinaryExpr(recurmax, noComma, stmtDepth, canThrow) {
         return canThrow && rng(10) == 0 ? expr : '(' + assignee + ' && ' + expr + ')';
       case 4:
         assignee = getVarName();
-        expr = '(' + assignee + '.' + getDotKey() + createAssignment()
+        expr = '(' + assignee + '.' + getDotKey(true) + createAssignment()
             + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ')';
         return canThrow && rng(10) == 0 ? expr : '(' + assignee + ' && ' + expr + ')';
       default:
@@ -844,35 +923,40 @@ function getVarName() {
 
 function createVarName(maybe, dontStore) {
     if (!maybe || rng(2)) {
-        var name = VAR_NAMES[rng(VAR_NAMES.length)];
         var suffix = rng(3);
-        if (suffix) {
-            name += '_' + suffix;
-            if (!dontStore) VAR_NAMES.push(name);
-        }
+        var name;
+        do {
+            name = VAR_NAMES[rng(VAR_NAMES.length)];
+            if (suffix) name += '_' + suffix;
+        } while (unique_vars.indexOf(name) >= 0);
+        if (suffix && !dontStore) VAR_NAMES.push(name);
         return name;
     }
     return '';
 }
 
+if (require.main !== module) {
+    exports.createTopLevelCode = createTopLevelCode;
+    exports.num_iterations = num_iterations;
+    return;
+}
+
 function try_beautify(code, result) {
-    try {
-        var beautified = UglifyJS.minify(code, {
-            compress: false,
-            mangle: false,
-            output: {
-                beautify: true,
-                bracketize: true,
-            },
-        }).code;
-        if (sandbox.same_stdout(sandbox.run_code(beautified), result)) {
-            console.log("// (beautified)");
-            console.log(beautified);
-            return;
-        }
-    } catch (e) {
+    var beautified = UglifyJS.minify(code, {
+        compress: false,
+        mangle: false,
+        output: {
+            beautify: true,
+            bracketize: true,
+        },
+    });
+    if (beautified.error) {
         console.log("// !!! beautify failed !!!");
-        console.log(e.stack);
+        console.log(beautified.error.stack);
+    } else if (sandbox.same_stdout(sandbox.run_code(beautified.code), result)) {
+        console.log("// (beautified)");
+        console.log(beautified.code);
+        return;
     }
     console.log("//");
     console.log(code);
@@ -908,12 +992,13 @@ function log_suspects(minify_options, component) {
             var o = JSON.parse(JSON.stringify(options));
             o[name] = false;
             m[component] = o;
-            try {
-                var r = sandbox.run_code(UglifyJS.minify(original_code, m).code);
-                return sandbox.same_stdout(original_result, r);
-            } catch (e) {
+            var result = UglifyJS.minify(original_code, m);
+            if (result.error) {
                 console.log("Error testing options." + component + "." + name);
-                console.log(e);
+                console.log(result.error);
+            } else {
+                var r = sandbox.run_code(result.code);
+                return sandbox.same_stdout(original_result, r);
             }
         }
     });
@@ -974,28 +1059,22 @@ var uglify_code, uglify_result, ok;
 for (var round = 1; round <= num_iterations; round++) {
     process.stdout.write(round + " of " + num_iterations + "\r");
 
-    VAR_NAMES.length = INITIAL_NAMES_LEN; // prune any previous names still in the list
-    loops = 0;
-    funcs = 0;
-
     original_code = createTopLevelCode();
     original_result = sandbox.run_code(original_code);
     (typeof original_result != "string" ? fallback_options : minify_options).forEach(function(options) {
-        try {
-            uglify_code = UglifyJS.minify(original_code, JSON.parse(options)).code;
-        } catch (e) {
-            uglify_code = e;
-        }
-
-        ok = typeof uglify_code == "string";
-        if (ok) {
+        uglify_code = UglifyJS.minify(original_code, JSON.parse(options));
+        if (!uglify_code.error) {
+            uglify_code = uglify_code.code;
             uglify_result = sandbox.run_code(uglify_code);
             ok = sandbox.same_stdout(original_result, uglify_result);
-        } else if (typeof original_result != "string") {
-            ok = uglify_code.name == original_result.name;
+        } else {
+            uglify_code = uglify_code.error;
+            if (typeof original_result != "string") {
+                ok = uglify_code.name == original_result.name;
+            }
         }
         if (verbose || (verbose_interval && !(round % INTERVAL_COUNT)) || !ok) log(options);
-        else if (verbose_error && typeof original_result != "string") {
+        else if (typeof original_result != "string") {
             console.log("//=============================================================");
             console.log("// original code");
             try_beautify(original_code, original_result);

tools/exports.js

@@ -1,15 +1,5 @@
-exports["Compressor"] = Compressor;
 exports["Dictionary"] = Dictionary;
-exports["JS_Parse_Error"] = JS_Parse_Error;
-exports["OutputStream"] = OutputStream;
-exports["SourceMap"] = SourceMap;
 exports["TreeWalker"] = TreeWalker;
-exports["base54"] = base54;
-exports["defaults"] = defaults;
-exports["mangle_properties"] = mangle_properties;
+exports["TreeTransformer"] = TreeTransformer;
 exports["minify"] = minify;
-exports["parse"] = parse;
-exports["push_uniq"] = push_uniq;
-exports["string_template"] = string_template;
-exports["tokenizer"] = tokenizer;
-exports["is_identifier"] = is_identifier;
+exports["_push_uniq"] = push_uniq;

tools/node.js

@@ -18,15 +18,19 @@ var FILES = UglifyJS.FILES = [
     return require.resolve(file);
 });
 
-new Function("MOZ_SourceMap", "exports", FILES.map(function(file){
-    return fs.readFileSync(file, "utf8");
-}).join("\n\n"))(
+new Function("MOZ_SourceMap", "exports", function() {
+    var code = FILES.map(function(file) {
+        return fs.readFileSync(file, "utf8");
+    });
+    code.push("exports.describe_ast = " + describe_ast.toString());
+    return code.join("\n\n");
+}())(
     require("source-map"),
     UglifyJS
 );
 
-UglifyJS.describe_ast = function() {
-    var out = UglifyJS.OutputStream({ beautify: true });
+function describe_ast() {
+    var out = OutputStream({ beautify: true });
     function doitem(ctor) {
         out.print("AST_" + ctor.TYPE);
         var props = ctor.SELF_PROPS.filter(function(prop){
@@ -56,6 +60,6 @@ UglifyJS.describe_ast = function() {
             });
         }
     };
-    doitem(UglifyJS.AST_Node);
-    return out + "";
-};
+    doitem(AST_Node);
+    return out + "\n";
+}