v2.8.29

fixes #2040

.github/ISSUE_TEMPLATE.md

@@ -1,20 +1,9 @@
-**Bug report or feature request?** 
-
-<!-- Note: sub-optimal but correct code is not a bug -->
-
-**ES5 or ES6+ input?** 
-
-<!-- Note: for ES6 see: https://github.com/mishoo/UglifyJS2/tree/harmony#harmony -->
-
-**Uglify version (`uglifyjs -V`)**
-
-**JavaScript input**  <!-- ideally as small as possible -->
-
-**The `uglifyjs` CLI command executed or `minify()` options used.**
-
-**JavaScript output or error produced.**
-
+- Bug report or feature request? <!-- Note: sub-optimal but correct code is not a bug -->
+- `uglify-js` version (`uglifyjs -V`)
+- JavaScript input - ideally as small as possible.
+- The `uglifyjs` CLI command executed or `minify()` options used.
+- An example of JavaScript output produced and/or the error or warning.
 <!--
-    Note: `uglify-js` only supports ES5. 
-    Those wishing to minify ES6 should use `uglify-es`.
+    Note: the release version of uglify-js only supports ES5. Those wishing
+    to minify ES6 should use the experimental harmony branch.
 -->

bin/extract-props.js

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

bin/uglifyjs

@@ -3,382 +3,633 @@
 
 "use strict";
 
-// workaround for tty output truncation upon process.exit()
-[process.stdout, process.stderr].forEach(function(stream){
-    if (stream._handle && stream._handle.setBlocking)
-        stream._handle.setBlocking(true);
-});
-
-var fs = require("fs");
-var info = require("../package.json");
-var path = require("path");
-var program = require("commander");
 var UglifyJS = require("../tools/node");
+var sys = require("util");
+var yargs = require("yargs");
+var fs = require("fs");
+var path = require("path");
+var acorn;
+var screw_ie8 = true;
+var ARGS = yargs
+    .usage("$0 input1.js [input2.js ...] [options]\n\
+Use a single dash to read input from the standard input.\
+\n\n\
+NOTE: by default there is no mangling/compression.\n\
+Without [options] it will simply parse input files and dump the AST\n\
+with whitespace and comments discarded.  To achieve compression and\n\
+mangling you need to use `-c` and `-m`.\
+")
+    .describe("source-map", "Specify an output file where to generate source map.")
+    .describe("source-map-root", "The path to the original source to be included in the source map.")
+    .describe("source-map-url", "The path to the source map to be added in //# sourceMappingURL.  Defaults to the value passed with --source-map.")
+    .describe("source-map-inline", "Write base64-encoded source map to the end of js output.  Disabled by default")
+    .describe("source-map-include-sources", "Pass this flag if you want to include the content of source files in the source map as sourcesContent property.")
+    .describe("in-source-map", "Input source map, useful if you're compressing JS that was generated from some other original code.")
+    .describe("screw-ie8", "Do not support Internet Explorer 6/7/8. This flag is enabled by default.")
+    .describe("support-ie8", "Support non-standard Internet Explorer 6/7/8 javascript.")
+    .describe("expr", "Parse a single expression, rather than a program (for parsing JSON)")
+    .describe("p", "Skip prefix for original filenames that appear in source maps. \
+For example -p 3 will drop 3 directories from file names and ensure they are relative paths. \
+You can also specify -p relative, which will make UglifyJS figure out itself the relative paths between original sources, \
+the source map and the output file.")
+    .describe("o", "Output file (default STDOUT).")
+    .describe("b", "Beautify output/specify output options.")
+    .describe("m", "Mangle names/pass mangler options.")
+    .describe("r", "Reserved names to exclude from mangling.")
+    .describe("c", "Enable compressor/pass compressor options. \
+Pass options like -c hoist_vars=false,if_return=false. \
+Use -c with no argument to use the default compression options.")
+    .describe("d", "Global definitions")
+    .describe("e", "Embed everything in a big function, with a configurable parameter/argument list.")
 
-var skip_keys = [ "cname", "enclosed", "parent_scope", "scope", "thedef", "uses_eval", "uses_with" ];
-var files = {};
-var options = {
-    compress: false,
-    mangle: false
-};
-program.version(info.name + ' ' + info.version);
-program.parseArgv = program.parse;
-program.parse = undefined;
-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));
-program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js("mangle-props", true));
-program.option("-b, --beautify [options]", "Beautify output/specify output options.", parse_js("beautify", true));
-program.option("-o, --output <file>", "Output file (default STDOUT).");
-program.option("--comments [filter]", "Preserve copyright comments in the output.");
-program.option("--config-file <file>", "Read minify() options from JSON file.");
-program.option("-d, --define <expr>[=value]", "Global definitions.", parse_js("define"));
-program.option("--ie8", "Support non-standard Internet Explorer 8.");
-program.option("--keep-fnames", "Do not mangle/drop function names. Useful for code relying on Function.prototype.name.");
-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("--toplevel", "Compress and/or mangle variables in toplevel scope.");
-program.option("--verbose", "Print diagnostic messages.");
-program.option("--warn", "Print warning messages.");
-program.option("--wrap <name>", "Embed everything as a function with “exports” corresponding to “name” globally.");
-program.arguments("[files...]").parseArgv(process.argv);
-if (program.configFile) {
-    options = JSON.parse(read_file(program.configFile));
+    .describe("comments", "Preserve copyright comments in the output. \
+By default this works like Google Closure, keeping JSDoc-style comments that contain \"@license\" or \"@preserve\". \
+You can optionally pass one of the following arguments to this flag:\n\
+- \"all\" to keep all comments\n\
+- a valid JS RegExp like `/foo/`or `/^!/` to keep only matching comments.\n\
+\
+Note that currently not *all* comments can be kept when compression is on, \
+because of dead code removal or cascading statements into sequences.")
+
+    .describe("preamble", "Preamble to prepend to the output.  You can use this to insert a \
+comment, for example for licensing information.  This will not be \
+parsed, but the source map will adjust for its presence.")
+
+    .describe("stats", "Display operations run time on STDERR.")
+    .describe("acorn", "Use Acorn for parsing.")
+    .describe("spidermonkey", "Assume input files are SpiderMonkey AST format (as JSON).")
+    .describe("self", "Build itself (UglifyJS2) as a library (implies --wrap=UglifyJS --export-all)")
+    .describe("wrap", "Embed everything in a big function, making the “exports” and “global” variables available. \
+You need to pass an argument to this option to specify the name that your module will take when included in, say, a browser.")
+    .describe("export-all", "Only used when --wrap, this tells UglifyJS to add code to automatically export all globals.")
+    .describe("lint", "Display some scope warnings")
+    .describe("v", "Verbose")
+    .describe("V", "Print version number and exit.")
+    .describe("noerr", "Don't throw an error for unknown options in -c, -b or -m.")
+    .describe("bare-returns", "Allow return outside of functions.  Useful when minifying CommonJS modules.")
+    .describe("keep-fnames", "Do not mangle/drop function names.  Useful for code relying on Function.prototype.name.")
+    .describe("quotes", "Quote style (0 - auto, 1 - single, 2 - double, 3 - original)")
+    .describe("reserved-file", "File containing reserved names")
+    .describe("reserve-domprops", "Make (most?) DOM properties reserved for --mangle-props")
+    .describe("mangle-props", "Mangle property names (0 - disabled, 1 - mangle all properties, 2 - mangle unquoted properies)")
+    .describe("mangle-regex", "Only mangle property names matching the regex")
+    .describe("name-cache", "File to hold mangled names mappings")
+    .describe("pure-funcs", "List of functions that can be safely removed if their return value is not used")
+    .describe("dump-spidermonkey-ast", "Dump SpiderMonkey AST to stdout.")
+    .describe("wrap-iife", "Wrap IIFEs in parenthesis. Note: this disables the negate_iife compression option")
+
+    .alias("p", "prefix")
+    .alias("o", "output")
+    .alias("v", "verbose")
+    .alias("b", "beautify")
+    .alias("m", "mangle")
+    .alias("c", "compress")
+    .alias("d", "define")
+    .alias("r", "reserved")
+    .alias("V", "version")
+    .alias("e", "enclose")
+    .alias("q", "quotes")
+
+    .string("source-map")
+    .string("source-map-root")
+    .string("source-map-url")
+    .string("b")
+    .string("beautify")
+    .string("m")
+    .string("mangle")
+    .string("mangle-props-debug")
+    .string("c")
+    .string("compress")
+    .string("d")
+    .string("define")
+    .string("e")
+    .string("enclose")
+    .string("comments")
+    .string("wrap")
+    .string("p")
+    .string("prefix")
+    .string("name-cache")
+
+    .array("reserved-file")
+    .array("pure-funcs")
+
+    .boolean("expr")
+    .boolean("source-map-inline")
+    .boolean("source-map-include-sources")
+    .boolean("screw-ie8")
+    .boolean("support-ie8")
+    .boolean("export-all")
+    .boolean("self")
+    .boolean("v")
+    .boolean("verbose")
+    .boolean("stats")
+    .boolean("acorn")
+    .boolean("spidermonkey")
+    .boolean("dump-spidermonkey-ast")
+    .boolean("lint")
+    .boolean("V")
+    .boolean("version")
+    .boolean("noerr")
+    .boolean("bare-returns")
+    .boolean("keep-fnames")
+    .boolean("reserve-domprops")
+    .boolean("wrap-iife")
+
+    .wrap(80)
+
+    .argv
+;
+
+normalize(ARGS);
+
+if (ARGS.noerr) {
+    UglifyJS.DefaultsError.croak = function(msg, defs) {
+        print_error("WARN: " + msg);
+    };
 }
-if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
-    fatal("ERROR: cannot write source map to STDOUT");
+
+if (ARGS.version || ARGS.V) {
+    var json = require("../package.json");
+    print(json.name + ' ' + json.version);
+    process.exit(0);
 }
-[
-    "compress",
-    "ie8",
-    "mangle",
-    "sourceMap",
-    "toplevel",
-    "wrap"
-].forEach(function(name) {
-    if (name in program) {
-        options[name] = program[name];
-    }
+
+if (ARGS.ast_help) {
+    var desc = UglifyJS.describe_ast();
+    print(typeof desc == "string" ? desc : JSON.stringify(desc, null, 2));
+    process.exit(0);
+}
+
+if (ARGS.h || ARGS.help) {
+    print(yargs.help());
+    process.exit(0);
+}
+
+if (ARGS.acorn) {
+    acorn = require("acorn");
+}
+
+var COMPRESS = getOptions("c", true);
+var MANGLE = getOptions("m", true);
+var BEAUTIFY = getOptions("b", true);
+var RESERVED = null;
+
+if (ARGS.reserved_file) ARGS.reserved_file.forEach(function(filename){
+    RESERVED = UglifyJS.readReservedFile(filename, RESERVED);
 });
-if (program.beautify) {
-    options.output = typeof program.beautify == "object" ? program.beautify : {};
-    if (!("beautify" in options.output)) {
-        options.output.beautify = true;
-    }
+
+if (ARGS.reserve_domprops) {
+    RESERVED = UglifyJS.readDefaultReservedFile(RESERVED);
 }
-if (program.comments) {
-    if (typeof options.output != "object") options.output = {};
-    options.output.comments = typeof program.comments == "string" ? program.comments : "some";
+
+if (ARGS.d) {
+    if (COMPRESS) COMPRESS.global_defs = getOptions("d");
 }
-if (program.define) {
-    if (typeof options.compress != "object") options.compress = {};
-    if (typeof options.compress.global_defs != "object") options.compress.global_defs = {};
-    for (var expr in program.define) {
-        options.compress.global_defs[expr] = program.define[expr];
-    }
+
+if (ARGS.pure_funcs) {
+    if (COMPRESS) COMPRESS.pure_funcs = ARGS.pure_funcs;
 }
-if (program.keepFnames) {
-    options.keep_fnames = true;
+
+if (ARGS.r) {
+    if (MANGLE) MANGLE.except = ARGS.r.replace(/^\s+|\s+$/g).split(/\s*,+\s*/);
 }
-if (program.mangleProps) {
-    if (program.mangleProps.domprops) {
-        delete program.mangleProps.domprops;
-    } else {
-        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);
-        });
-    }
-    if (typeof options.mangle != "object") options.mangle = {};
-    options.mangle.properties = program.mangleProps;
+
+if (RESERVED && MANGLE) {
+    if (!MANGLE.except) MANGLE.except = RESERVED.vars;
+    else MANGLE.except = MANGLE.except.concat(RESERVED.vars);
 }
-var cache;
-if (program.nameCache) {
-    cache = JSON.parse(read_file(program.nameCache, "{}"));
-    if (options.mangle) {
-        if (typeof options.mangle != "object") options.mangle = {};
-        options.mangle.cache = to_cache("vars");
-        if (options.mangle.properties) {
-            if (typeof options.mangle.properties != "object") options.mangle.properties = {};
-            options.mangle.properties.cache = to_cache("props");
-        }
-    }
+
+function readNameCache(key) {
+    return UglifyJS.readNameCache(ARGS.name_cache, key);
 }
-if (program.output == "ast") {
-    options.output = {
-        ast: true,
-        code: false
-    };
+
+function writeNameCache(key, cache) {
+    return UglifyJS.writeNameCache(ARGS.name_cache, key, cache);
 }
-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 {
-        options.parse = program.parse;
-    }
+
+function extractRegex(str) {
+  if (/^\/.*\/[a-zA-Z]*$/.test(str)) {
+    var regex_pos = str.lastIndexOf("/");
+    return new RegExp(str.substr(1, regex_pos - 1), str.substr(regex_pos + 1));
+  } else {
+    throw new Error("Invalid regular expression: " + str);
+  }
 }
-var convert_path = function(name) {
-    return name;
+
+if (ARGS.quotes === true) {
+    ARGS.quotes = 3;
+}
+
+if (ARGS.mangle_props === true) {
+    ARGS.mangle_props = 1;
+} else if (ARGS.mangle_props === "unquoted") {
+    ARGS.mangle_props = 2;
+}
+
+var OUTPUT_OPTIONS = {
+    beautify     : BEAUTIFY ? true : false,
+    max_line_len : 32000,
+    preamble     : ARGS.preamble || null,
+    quote_style  : ARGS.quotes != null ? ARGS.quotes : 0,
 };
-if (typeof program.sourceMap == "object" && "base" in program.sourceMap) {
-    convert_path = function() {
-        var base = program.sourceMap.base;
-        delete options.sourceMap.base;
-        return function(name) {
-            return path.relative(base, name);
-        };
-    }();
+
+if (ARGS.mangle_props == 2) {
+    OUTPUT_OPTIONS.keep_quoted_props = true;
+    if (COMPRESS && !("properties" in COMPRESS))
+        COMPRESS.properties = false;
 }
-if (program.verbose) {
-    options.warnings = "verbose";
-} else if (program.warn) {
-    options.warnings = true;
+
+if (ARGS.support_ie8 === true && ARGS.screw_ie8 !== true) {
+    screw_ie8 = false;
 }
-if (program.self) {
-    if (program.args.length) {
-        console.error("WARN: Ignoring input files since --self was passed");
-    }
-    if (!options.wrap) options.wrap = "UglifyJS";
-    simple_glob(UglifyJS.FILES).forEach(function(name) {
-        files[convert_path(name)] = read_file(name);
-    });
-    run();
-} else if (program.args.length) {
-    simple_glob(program.args).forEach(function(name) {
-        files[convert_path(name)] = read_file(name);
-    });
-    run();
+
+if (COMPRESS) COMPRESS.screw_ie8 = screw_ie8;
+if (MANGLE) MANGLE.screw_ie8 = screw_ie8;
+OUTPUT_OPTIONS.screw_ie8 = screw_ie8;
+
+if (ARGS.keep_fnames) {
+    if (COMPRESS) COMPRESS.keep_fnames = true;
+    if (MANGLE) MANGLE.keep_fnames = true;
+}
+
+if (ARGS.wrap_iife) {
+    if (COMPRESS) COMPRESS.negate_iife = false;
+    OUTPUT_OPTIONS.wrap_iife = true;
+}
+
+if (BEAUTIFY)
+    UglifyJS.merge(OUTPUT_OPTIONS, BEAUTIFY);
+
+if (ARGS.comments === "") {
+    OUTPUT_OPTIONS.comments = "some";
 } else {
-    var chunks = [];
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", function(chunk) {
-        chunks.push(chunk);
-    }).on("end", function() {
-        files = [ chunks.join("") ];
-        run();
-    });
-    process.stdin.resume();
+    OUTPUT_OPTIONS.comments = ARGS.comments;
 }
 
-function convert_ast(fn) {
-    return UglifyJS.AST_Node.from_mozilla_ast(Object.keys(files).reduce(fn, null));
+var files = ARGS._.slice();
+
+if (process.platform === "win32")
+    files = UglifyJS.simple_glob(files);
+
+if (ARGS.self) {
+    if (files.length > 0) {
+        print_error("WARN: Ignoring input files since --self was passed");
+    }
+    files = UglifyJS.FILES;
+    if (!ARGS.wrap) ARGS.wrap = "UglifyJS";
 }
 
-function run() {
-    UglifyJS.AST_Node.warn_function = function(msg) {
-        console.error("WARN:", msg);
-    };
-    if (program.stats) program.stats = Date.now();
-    try {
-        if (program.parse) {
-            if (program.parse.acorn) {
-                files = convert_ast(function(toplevel, name) {
-                    return require("acorn").parse(files[name], {
-                        locations: true,
-                        program: toplevel,
-                        sourceFile: name
-                    });
-                });
-            } else if (program.parse.spidermonkey) {
-                files = convert_ast(function(toplevel, name) {
-                    var obj = JSON.parse(files[name]);
-                    if (!toplevel) return obj;
-                    toplevel.body = toplevel.body.concat(obj.body);
-                    return toplevel;
-                });
-            }
-        }
-    } catch (ex) {
-        fatal(ex);
+var ORIG_MAP = ARGS.in_source_map;
+
+if (ORIG_MAP && ORIG_MAP != "inline") {
+    ORIG_MAP = JSON.parse(fs.readFileSync(ORIG_MAP));
+    if (files.length == 0) {
+        print_error("INFO: Using file from the input source map: " + ORIG_MAP.file);
+        files = [ ORIG_MAP.file ];
     }
-    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/);
-            var line = lines[ex.line - 1];
-            if (!line && !col) {
-                line = lines[ex.line - 2];
-                col = line.length;
-            }
-            if (line) {
-                if (col > 40) {
-                    line = line.slice(col - 40);
-                    col = 40;
-                }
-                console.error(line.slice(0, 80));
-                console.error(line.slice(0, col).replace(/\S/g, " ") + "^");
-            }
-        }
-        if (ex.defs) {
-            console.error("Supported options:");
-            console.error(ex.defs);
-        }
-        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) {
-            fs.writeFileSync(program.output + ".map", result.map);
-        }
-    } else {
-        console.log(result.code);
-    }
-    if (program.nameCache) {
-        fs.writeFileSync(program.nameCache, JSON.stringify(cache, function(key, value) {
-            return value instanceof UglifyJS.Dictionary ? value.toObject() : value;
-        }));
-    }
-    if (program.stats) console.error("Elapsed:", Date.now() - program.stats);
 }
 
-function fatal(message) {
-    if (message instanceof Error) message = message.stack.replace(/^\S*?Error:/, "ERROR:")
-    console.error(message);
+if (files.length == 0) {
+    files = [ "-" ];
+}
+
+if (ORIG_MAP == "inline") {
+    if (files.length > 1) {
+        print_error("ERROR: Inline source map only works with singular input");
+        process.exit(1);
+    }
+    if (ARGS.acorn || ARGS.spidermonkey) {
+        print_error("ERROR: Inline source map only works with built-in parser");
+        process.exit(1);
+    }
+}
+
+if (files.indexOf("-") >= 0 && ARGS.source_map) {
+    print_error("ERROR: Source map doesn't work with input from STDIN");
     process.exit(1);
 }
 
-// A file glob function that only supports "*" and "?" wildcards in the basename.
-// Example: "foo/bar/*baz??.*.js"
-// Argument `glob` may be a string or an array of strings.
-// Returns an array of strings. Garbage in, garbage out.
-function simple_glob(glob) {
-    if (Array.isArray(glob)) {
-        return [].concat.apply([], glob.map(simple_glob));
-    }
-    if (glob.match(/\*|\?/)) {
-        var dir = path.dirname(glob);
-        try {
-            var entries = fs.readdirSync(dir);
-        } catch (ex) {}
-        if (entries) {
-            var pattern = "^" + path.basename(glob)
-                .replace(/[.+^$[\]\\(){}]/g, "\\$&")
-                .replace(/\*/g, "[^/\\\\]*")
-                .replace(/\?/g, "[^/\\\\]") + "$";
-            var mod = process.platform === "win32" ? "i" : "";
-            var rx = new RegExp(pattern, mod);
-            var results = entries.filter(function(name) {
-                return rx.test(name);
-            }).map(function(name) {
-                return path.join(dir, name);
-            });
-            if (results.length) return results;
+if (files.filter(function(el){ return el == "-" }).length > 1) {
+    print_error("ERROR: Can read a single file from STDIN (two or more dashes specified)");
+    process.exit(1);
+}
+
+var STATS = {};
+var TOPLEVEL = null;
+var P_RELATIVE = ARGS.p && ARGS.p == "relative";
+var SOURCES_CONTENT = {};
+var index = 0;
+
+!function cb() {
+    if (index == files.length) return done();
+    var file = files[index++];
+    read_whole_file(file, function (err, code) {
+        if (err) {
+            print_error("ERROR: can't read file: " + file);
+            process.exit(1);
         }
-    }
-    return [ glob ];
-}
-
-function read_file(path, default_value) {
-    try {
-        return fs.readFileSync(path, "utf8");
-    } catch (ex) {
-        if (ex.code == "ENOENT" && default_value != null) return default_value;
-        fatal(ex);
-    }
-}
-
-function parse_js(flag, constants) {
-    return function(value, options) {
-        options = options || {};
-        try {
-            UglifyJS.minify(value, {
-                parse: {
-                    expression: true
-                },
-                compress: false,
-                mangle: false,
-                output: {
-                    ast: true,
-                    code: false
+        if (ORIG_MAP == "inline") {
+            ORIG_MAP = read_source_map(code);
+        }
+        if (ARGS.p != null) {
+            if (P_RELATIVE) {
+                file = path.relative(path.dirname(ARGS.source_map), file).replace(/\\/g, '/');
+            } else {
+                var p = parseInt(ARGS.p, 10);
+                if (!isNaN(p)) {
+                    file = file.replace(/^\/+/, "").split(/\/+/).slice(ARGS.p).join("/");
                 }
-            }).ast.walk(new UglifyJS.TreeWalker(function(node) {
-                if (node instanceof UglifyJS.AST_Assign) {
-                    var name = node.left.print_to_string();
-                    var value = node.right;
-                    if (!constants) {
-                        options[name] = value;
-                    } else if (value instanceof UglifyJS.AST_Array) {
-                        options[name] = value.elements.map(to_string);
-                    } else {
-                        options[name] = to_string(value);
-                    }
-                    return true;
-                }
-                if (node instanceof UglifyJS.AST_Symbol || node instanceof UglifyJS.AST_PropAccess) {
-                    var name = node.print_to_string();
-                    options[name] = true;
-                    return true;
-                }
-                if (!(node instanceof UglifyJS.AST_Sequence)) throw node;
-
-                function to_string(value) {
-                    return value instanceof UglifyJS.AST_Constant ? value.getValue() : value.print_to_string({
-                        quote_keys: true
+            }
+        }
+        SOURCES_CONTENT[file] = code;
+        time_it("parse", function(){
+            if (ARGS.spidermonkey) {
+                var program = JSON.parse(code);
+                if (!TOPLEVEL) TOPLEVEL = program;
+                else TOPLEVEL.body = TOPLEVEL.body.concat(program.body);
+            }
+            else if (ARGS.acorn) {
+                TOPLEVEL = acorn.parse(code, {
+                    locations     : true,
+                    sourceFile    : file,
+                    program       : TOPLEVEL
+                });
+            }
+            else {
+                try {
+                    TOPLEVEL = UglifyJS.parse(code, {
+                        filename     : file,
+                        toplevel     : TOPLEVEL,
+                        expression   : ARGS.expr,
+                        bare_returns : ARGS.bare_returns,
                     });
+                } catch(ex) {
+                    if (ex instanceof UglifyJS.JS_Parse_Error) {
+                        print_error("Parse error at " + file + ":" + ex.line + "," + ex.col);
+                        var col = ex.col;
+                        var lines = code.split(/\r?\n/);
+                        var line = lines[ex.line - 1];
+                        if (!line && !col) {
+                            line = lines[ex.line - 2];
+                            col = line.length;
+                        }
+                        if (line) {
+                            if (col > 40) {
+                                line = line.slice(col - 40);
+                                col = 40;
+                            }
+                            print_error(line.slice(0, 80));
+                            print_error(line.slice(0, col).replace(/\S/g, " ") + "^");
+                        }
+                        print_error(ex.stack);
+                        process.exit(1);
+                    }
+                    throw ex;
                 }
-            }));
-        } catch(ex) {
-            fatal("Error parsing arguments for '" + flag + "': " + value);
-        }
-        return options;
-    }
-}
+            };
+        });
+        cb();
+    });
+}();
 
-function parse_source_map() {
-    var parse = parse_js("sourceMap", true);
-    return function(value, options) {
-        var hasContent = options && options.sourceMap && "content" in options.sourceMap;
-        var settings = parse(value, options);
-        if (!hasContent && settings.content && settings.content != "inline") {
-            console.error("INFO: Using input source map:", settings.content);
-            settings.content = read_file(settings.content, settings.content);
-        }
-        return settings;
-    }
-}
+function done() {
+    var OUTPUT_FILE = ARGS.o;
 
-function to_cache(key) {
-    if (cache[key]) {
-        cache[key].props = UglifyJS.Dictionary.fromObject(cache[key].props);
+    var SOURCE_MAP = (ARGS.source_map || ARGS.source_map_inline) ? UglifyJS.SourceMap({
+        file: P_RELATIVE ? path.relative(path.dirname(ARGS.source_map), OUTPUT_FILE) : OUTPUT_FILE,
+        root: ARGS.source_map_root || ORIG_MAP && ORIG_MAP.sourceRoot,
+        orig: ORIG_MAP,
+    }) : null;
+
+    OUTPUT_OPTIONS.source_map = SOURCE_MAP;
+
+    try {
+        var output = UglifyJS.OutputStream(OUTPUT_OPTIONS);
+        var compressor = COMPRESS && UglifyJS.Compressor(COMPRESS);
+    } catch(ex) {
+        if (ex instanceof UglifyJS.DefaultsError) {
+            print_error(ex.message);
+            print_error("Supported options:");
+            print_error(sys.inspect(ex.defs));
+            process.exit(1);
+        }
+    }
+
+    if (ARGS.acorn || ARGS.spidermonkey) time_it("convert_ast", function(){
+        TOPLEVEL = UglifyJS.AST_Node.from_mozilla_ast(TOPLEVEL);
+    });
+
+    if (ARGS.wrap != null) {
+        TOPLEVEL = TOPLEVEL.wrap_commonjs(ARGS.wrap, ARGS.export_all);
+    }
+
+    if (ARGS.enclose != null) {
+        var arg_parameter_list = ARGS.enclose;
+        if (arg_parameter_list === true) {
+            arg_parameter_list = [];
+        }
+        else if (!(arg_parameter_list instanceof Array)) {
+            arg_parameter_list = [arg_parameter_list];
+        }
+        TOPLEVEL = TOPLEVEL.wrap_enclose(arg_parameter_list);
+    }
+
+    if (ARGS.mangle_props || ARGS.name_cache) (function(){
+        var reserved = RESERVED ? RESERVED.props : null;
+        var cache = readNameCache("props");
+        var regex;
+
+        try {
+          regex = ARGS.mangle_regex ? extractRegex(ARGS.mangle_regex) : null;
+        } catch (e) {
+            print_error("ERROR: Invalid --mangle-regex: " + e.message);
+            process.exit(1);
+        }
+
+        TOPLEVEL = UglifyJS.mangle_properties(TOPLEVEL, {
+            reserved      : reserved,
+            cache         : cache,
+            only_cache    : !ARGS.mangle_props,
+            regex         : regex,
+            ignore_quoted : ARGS.mangle_props == 2,
+            debug         : typeof ARGS.mangle_props_debug === "undefined" ? false : ARGS.mangle_props_debug
+        });
+        writeNameCache("props", cache);
+    })();
+
+    var SCOPE_IS_NEEDED = COMPRESS || MANGLE || ARGS.lint
+    var TL_CACHE = readNameCache("vars");
+    if (MANGLE) MANGLE.cache = TL_CACHE;
+
+    if (SCOPE_IS_NEEDED) {
+        time_it("scope", function(){
+            TOPLEVEL.figure_out_scope(MANGLE || { screw_ie8: screw_ie8, cache: TL_CACHE });
+            if (ARGS.lint) {
+                TOPLEVEL.scope_warnings();
+            }
+        });
+    }
+
+    if (COMPRESS) {
+        time_it("squeeze", function(){
+            TOPLEVEL = compressor.compress(TOPLEVEL);
+        });
+    }
+
+    if (SCOPE_IS_NEEDED) {
+        time_it("scope", function(){
+            TOPLEVEL.figure_out_scope(MANGLE || { screw_ie8: screw_ie8, cache: TL_CACHE });
+            if (MANGLE && !TL_CACHE) {
+                TOPLEVEL.compute_char_frequency(MANGLE);
+            }
+        });
+    }
+
+    if (MANGLE) time_it("mangle", function(){
+        TOPLEVEL.mangle_names(MANGLE);
+    });
+
+    writeNameCache("vars", TL_CACHE);
+
+    if (ARGS.source_map_include_sources) {
+        for (var file in SOURCES_CONTENT) {
+            if (SOURCES_CONTENT.hasOwnProperty(file)) {
+                SOURCE_MAP.get().setSourceContent(file, SOURCES_CONTENT[file]);
+            }
+        }
+    }
+
+    if (ARGS.dump_spidermonkey_ast) {
+        print(JSON.stringify(TOPLEVEL.to_mozilla_ast(), null, 2));
     } else {
-        cache[key] = {
-            cname: -1,
-            props: new UglifyJS.Dictionary()
-        };
+        time_it("generate", function(){
+            TOPLEVEL.print(output);
+        });
+
+        output = output.get();
+
+        if (SOURCE_MAP) {
+            if (ARGS.source_map_inline) {
+                var base64_string = new Buffer(SOURCE_MAP.toString()).toString('base64');
+                output += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + base64_string;
+            } else {
+                fs.writeFileSync(ARGS.source_map, SOURCE_MAP, "utf8");
+                var source_map_url = ARGS.source_map_url || (
+                    P_RELATIVE
+                        ? path.relative(path.dirname(OUTPUT_FILE), ARGS.source_map)
+                        : ARGS.source_map
+                );
+                output += "\n//# sourceMappingURL=" + source_map_url;
+            }
+        }
+
+        if (OUTPUT_FILE) {
+            fs.writeFileSync(OUTPUT_FILE, output, "utf8");
+        } else {
+            print(output);
+        }
+    }
+
+    if (ARGS.stats) {
+        print_error(UglifyJS.string_template("Timing information (compressed {count} files):", {
+            count: files.length
+        }));
+        for (var i in STATS) if (STATS.hasOwnProperty(i)) {
+            print_error(UglifyJS.string_template("- {name}: {time}s", {
+                name: i,
+                time: (STATS[i] / 1000).toFixed(3)
+            }));
+        }
     }
-    return cache[key];
 }
 
-function skip_key(key) {
-    return skip_keys.indexOf(key) >= 0;
+/* -----[ functions ]----- */
+
+function normalize(o) {
+    for (var i in o) if (o.hasOwnProperty(i) && /-/.test(i)) {
+        o[i.replace(/-/g, "_")] = o[i];
+        delete o[i];
+    }
+}
+
+function getOptions(flag, constants) {
+    var x = ARGS[flag];
+    if (x == null || x === false) return null;
+    var ret = {};
+    if (x !== "") {
+        if (Array.isArray(x)) x = x.map(function (v) { return "(" + v + ")"; }).join(", ");
+
+        var ast;
+        try {
+            ast = UglifyJS.parse(x, { cli: true, expression: true });
+        } catch(ex) {
+            if (ex instanceof UglifyJS.JS_Parse_Error) {
+                print_error("Error parsing arguments for flag `" + flag + "': " + x);
+                process.exit(1);
+            }
+        }
+        ast.walk(new UglifyJS.TreeWalker(function(node){
+            if (node instanceof UglifyJS.AST_Seq) return; // descend
+            if (node instanceof UglifyJS.AST_Assign) {
+                var name = node.left.print_to_string().replace(/-/g, "_");
+                var value = node.right;
+                if (constants)
+                    value = new Function("return (" + value.print_to_string() + ")")();
+                ret[name] = value;
+                return true;    // no descend
+            }
+            if (node instanceof UglifyJS.AST_Symbol || node instanceof UglifyJS.AST_Binary) {
+                var name = node.print_to_string().replace(/-/g, "_");
+                ret[name] = true;
+                return true;    // no descend
+            }
+            print_error(node.TYPE)
+            print_error("Error parsing arguments for flag `" + flag + "': " + x);
+            process.exit(1);
+        }));
+    }
+    return ret;
+}
+
+function read_whole_file(filename, cb) {
+    if (filename == "-") {
+        var chunks = [];
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', function (chunk) {
+            chunks.push(chunk);
+        }).on('end', function () {
+            cb(null, chunks.join(""));
+        });
+        process.openStdin();
+    } else {
+        fs.readFile(filename, "utf-8", cb);
+    }
+}
+
+function read_source_map(code) {
+    var match = /\n\/\/# sourceMappingURL=data:application\/json(;.*?)?;base64,(.*)/.exec(code);
+    if (!match) {
+        print_error("WARN: inline source map not found");
+        return null;
+    }
+    return JSON.parse(new Buffer(match[2], "base64"));
+}
+
+function time_it(name, cont) {
+    var t1 = new Date().getTime();
+    var ret = cont();
+    if (ARGS.stats) {
+        var spent = new Date().getTime() - t1;
+        if (STATS[name]) STATS[name] += spent;
+        else STATS[name] = spent;
+    }
+    return ret;
+}
+
+function print_error(msg) {
+    console.error("%s", msg);
+}
+
+function print(txt) {
+    console.log("%s", txt);
 }

lib/ast.js

@@ -182,13 +182,21 @@ var AST_BlockStatement = DEFNODE("BlockStatement", null, {
 }, AST_Block);
 
 var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
-    $documentation: "The empty statement (empty block or simply a semicolon)"
+    $documentation: "The empty statement (empty block or simply a semicolon)",
+    _walk: function(visitor) {
+        return visitor._visit(this);
+    }
 }, AST_Statement);
 
 var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", {
     $documentation: "Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`",
     $propdoc: {
         body: "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.body._walk(visitor);
+        });
     }
 }, AST_Statement);
 
@@ -318,13 +326,62 @@ var AST_Toplevel = DEFNODE("Toplevel", "globals", {
     $propdoc: {
         globals: "[Object/S] a map of name -> SymbolDef for all undeclared names",
     },
-    wrap_commonjs: function(name) {
-        var body = this.body;
-        var wrapped_tl = "(function(exports){'$ORIG';})(typeof " + name + "=='undefined'?(" + name + "={}):" + name + ");";
+    wrap_enclose: function(arg_parameter_pairs) {
+        var self = this;
+        var args = [];
+        var parameters = [];
+
+        arg_parameter_pairs.forEach(function(pair) {
+            var splitAt = pair.lastIndexOf(":");
+
+            args.push(pair.substr(0, splitAt));
+            parameters.push(pair.substr(splitAt + 1));
+        });
+
+        var wrapped_tl = "(function(" + parameters.join(",") + "){ '$ORIG'; })(" + args.join(",") + ")";
         wrapped_tl = parse(wrapped_tl);
         wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node){
             if (node instanceof AST_Directive && node.value == "$ORIG") {
-                return MAP.splice(body);
+                return MAP.splice(self.body);
+            }
+        }));
+        return wrapped_tl;
+    },
+    wrap_commonjs: function(name, export_all) {
+        var self = this;
+        var to_export = [];
+        if (export_all) {
+            self.figure_out_scope();
+            self.walk(new TreeWalker(function(node){
+                if (node instanceof AST_SymbolDeclaration && node.definition().global) {
+                    if (!find_if(function(n){ return n.name == node.name }, to_export))
+                        to_export.push(node);
+                }
+            }));
+        }
+        var wrapped_tl = "(function(exports, global){ '$ORIG'; '$EXPORTS'; global['" + name + "'] = exports; }({}, (function(){return this}())))";
+        wrapped_tl = parse(wrapped_tl);
+        wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node){
+            if (node instanceof AST_Directive) {
+                switch (node.value) {
+                  case "$ORIG":
+                    return MAP.splice(self.body);
+                  case "$EXPORTS":
+                    var body = [];
+                    to_export.forEach(function(sym){
+                        body.push(new AST_SimpleStatement({
+                            body: new AST_Assign({
+                                left: new AST_Sub({
+                                    expression: new AST_SymbolRef({ name: "exports" }),
+                                    property: new AST_String({ value: sym.name }),
+                                }),
+                                operator: "=",
+                                right: new AST_SymbolRef(sym),
+                            }),
+                        }));
+                    });
+                    return MAP.splice(body);
+                }
             }
         }));
         return wrapped_tl;
@@ -495,10 +552,10 @@ var AST_Finally = DEFNODE("Finally", null, {
     $documentation: "A `finally` node; only makes sense as part of a `try` statement"
 }, AST_Block);
 
-/* -----[ VAR ]----- */
+/* -----[ VAR/CONST ]----- */
 
 var AST_Definitions = DEFNODE("Definitions", "definitions", {
-    $documentation: "Base class for `var` nodes (variable declarations/initializations)",
+    $documentation: "Base class for `var` or `const` nodes (variable declarations/initializations)",
     $propdoc: {
         definitions: "[AST_VarDef*] array of variable definitions"
     },
@@ -516,10 +573,14 @@ 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] name of the variable",
+        name: "[AST_SymbolVar|AST_SymbolConst] name of the variable",
         value: "[AST_Node?] initializer, or null of there's no initializer"
     },
     _walk: function(visitor) {
@@ -540,11 +601,11 @@ var AST_Call = DEFNODE("Call", "expression args", {
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
+            this.expression._walk(visitor);
             var args = this.args;
             for (var i = 0, len = args.length; i < len; i++) {
                 args[i]._walk(visitor);
             }
-            this.expression._walk(visitor);
         });
     }
 });
@@ -553,16 +614,68 @@ var AST_New = DEFNODE("New", null, {
     $documentation: "An object instantiation.  Derives from a function call since it has exactly the same properties"
 }, AST_Call);
 
-var AST_Sequence = DEFNODE("Sequence", "expressions", {
-    $documentation: "A sequence expression (comma-separated expressions)",
+var AST_Seq = DEFNODE("Seq", "car cdr", {
+    $documentation: "A sequence expression (two comma-separated expressions)",
     $propdoc: {
-        expressions: "[AST_Node*] array of expressions (at least two)"
+        car: "[AST_Node] first element in sequence",
+        cdr: "[AST_Node] second element in sequence"
+    },
+    $cons: function(x, y) {
+        var seq = new AST_Seq(x);
+        seq.car = x;
+        seq.cdr = y;
+        return seq;
+    },
+    $from_array: function(array) {
+        if (array.length == 0) return null;
+        if (array.length == 1) return array[0].clone();
+        var list = null;
+        for (var i = array.length; --i >= 0;) {
+            list = AST_Seq.cons(array[i], list);
+        }
+        var p = list;
+        while (p) {
+            if (p.cdr && !p.cdr.cdr) {
+                p.cdr = p.cdr.car;
+                break;
+            }
+            p = p.cdr;
+        }
+        return list;
+    },
+    to_array: function() {
+        var p = this, a = [];
+        while (p) {
+            a.push(p.car);
+            if (p.cdr && !(p.cdr instanceof AST_Seq)) {
+                a.push(p.cdr);
+                break;
+            }
+            p = p.cdr;
+        }
+        return a;
+    },
+    add: function(node) {
+        var p = this;
+        while (p) {
+            if (!(p.cdr instanceof AST_Seq)) {
+                var cell = AST_Seq.cons(p.cdr, node);
+                return p.cdr = cell;
+            }
+            p = p.cdr;
+        }
+    },
+    len: function() {
+        if (this.cdr instanceof AST_Seq) {
+            return this.cdr.len() + 1;
+        } else {
+            return 2;
+        }
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            this.expressions.forEach(function(node) {
-                node._walk(visitor);
-            });
+            this.car._walk(visitor);
+            if (this.cdr) this.cdr._walk(visitor);
         });
     }
 });
@@ -615,7 +728,7 @@ var AST_UnaryPostfix = DEFNODE("UnaryPostfix", null, {
     $documentation: "Unary postfix expression, i.e. `i++`"
 }, AST_Unary);
 
-var AST_Binary = DEFNODE("Binary", "operator left right", {
+var AST_Binary = DEFNODE("Binary", "left operator right", {
     $documentation: "Binary expression, i.e. `a + b`",
     $propdoc: {
         left: "[AST_Node] left-hand side expression",
@@ -724,13 +837,17 @@ var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
 }, AST_Symbol);
 
 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
-    $documentation: "A declaration symbol (symbol in var, function name or argument, symbol in catch)",
+    $documentation: "A declaration symbol (symbol in var/const, 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);
@@ -865,7 +982,7 @@ TreeWalker.prototype = {
     parent: function(n) {
         return this.stack[this.stack.length - 2 - (n || 0)];
     },
-    push: function(node) {
+    push: function (node) {
         if (node instanceof AST_Lambda) {
             this.directives = Object.create(this.directives);
         } else if (node instanceof AST_Directive && !this.directives[node.value]) {

lib/minify.js

@@ -1,154 +0,0 @@
-"use strict";
-
-var to_ascii = typeof atob == "undefined" ? function(b64) {
-    return new Buffer(b64, "base64").toString();
-} : atob;
-var to_base64 = typeof btoa == "undefined" ? function(str) {
-    return new Buffer(str).toString("base64");
-} : btoa;
-
-function read_source_map(code) {
-    var match = /\n\/\/# sourceMappingURL=data:application\/json(;.*?)?;base64,(.*)/.exec(code);
-    if (!match) {
-        AST_Node.warn("inline source map not found");
-        return null;
-    }
-    return to_ascii(match[2]);
-}
-
-function set_shorthand(name, options, keys) {
-    if (options[name]) {
-        keys.forEach(function(key) {
-            if (options[key]) {
-                if (typeof options[key] != "object") options[key] = {};
-                if (!(name in options[key])) options[key][name] = options[name];
-            }
-        });
-    }
-}
-
-function minify(files, options) {
-    var warn_function = AST_Node.warn_function;
-    try {
-        if (typeof files == "string") {
-            files = [ files ];
-        }
-        options = defaults(options, {
-            compress: {},
-            ie8: false,
-            keep_fnames: false,
-            mangle: {},
-            output: {},
-            parse: {},
-            sourceMap: false,
-            toplevel: false,
-            warnings: false,
-            wrap: false,
-        }, true);
-        set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
-        set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
-        set_shorthand("toplevel", options, [ "compress", "mangle" ]);
-        set_shorthand("warnings", options, [ "compress" ]);
-        if (options.mangle) {
-            options.mangle = defaults(options.mangle, {
-                cache: null,
-                eval: false,
-                ie8: false,
-                keep_fnames: false,
-                properties: false,
-                reserved: [],
-                toplevel: false,
-            }, true);
-        }
-        if (options.sourceMap) {
-            options.sourceMap = defaults(options.sourceMap, {
-                content: null,
-                filename: null,
-                includeSources: false,
-                root: null,
-                url: null,
-            }, true);
-        }
-        var warnings = [];
-        if (options.warnings && !AST_Node.warn_function) {
-            AST_Node.warn_function = function(warning) {
-                warnings.push(warning);
-            };
-        }
-        var toplevel;
-        if (files instanceof AST_Toplevel) {
-            toplevel = files;
-        } else {
-            options.parse = options.parse || {};
-            options.parse.toplevel = null;
-            for (var name in files) {
-                options.parse.filename = name;
-                options.parse.toplevel = parse(files[name], options.parse);
-                if (options.sourceMap && options.sourceMap.content == "inline") {
-                    if (Object.keys(files).length > 1)
-                        throw new Error("inline source map only works with singular input");
-                    options.sourceMap.content = read_source_map(files[name]);
-                }
-            }
-            toplevel = options.parse.toplevel;
-        }
-        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 (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);
-            }
-        }
-        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) {
-                    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;
-                }
-            }
-        }
-        if (warnings.length) {
-            result.warnings = warnings;
-        }
-        return result;
-    } catch (ex) {
-        return { error: ex };
-    } finally {
-        AST_Node.warn_function = warn_function;
-    }
-}

lib/mozilla-ast.js

@@ -145,11 +145,7 @@
             });
         },
         SequenceExpression: function(M) {
-            return new AST_Sequence({
-                start      : my_start_token(M),
-                end        : my_end_token(M),
-                expressions: M.expressions.map(from_moz)
-            });
+            return AST_Seq.from_array(M.expressions.map(from_moz));
         },
         MemberExpression: function(M) {
             return new (M.computed ? AST_Sub : AST_Dot)({
@@ -168,7 +164,7 @@
             });
         },
         VariableDeclaration: function(M) {
-            return new AST_Var({
+            return new (M.kind === "const" ? AST_Const : AST_Var)({
                 start       : my_start_token(M),
                 end         : my_end_token(M),
                 definitions : M.declarations.map(from_moz)
@@ -204,7 +200,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 ? AST_SymbolVar
+                        : p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : AST_SymbolVar)
                         : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
                         : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
                         : p.type == "CatchClause" ? AST_SymbolCatch
@@ -324,15 +320,15 @@
     def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
         return {
             type: "VariableDeclaration",
-            kind: "var",
+            kind: M instanceof AST_Const ? "const" : "var",
             declarations: M.definitions.map(to_moz)
         };
     });
 
-    def_to_moz(AST_Sequence, function To_Moz_SequenceExpression(M) {
+    def_to_moz(AST_Seq, function To_Moz_SequenceExpression(M) {
         return {
             type: "SequenceExpression",
-            expressions: M.expressions.map(to_moz)
+            expressions: M.to_array().map(to_moz)
         };
     });
 

lib/output.js

@@ -57,7 +57,6 @@ function OutputStream(options) {
         beautify         : false,
         bracketize       : false,
         comments         : false,
-        ie8              : false,
         indent_level     : 4,
         indent_start     : 0,
         inline_script    : true,
@@ -67,6 +66,7 @@ function OutputStream(options) {
         preserve_line    : false,
         quote_keys       : false,
         quote_style      : 0,
+        screw_ie8        : true,
         semicolons       : true,
         shebang          : true,
         source_map       : null,
@@ -136,7 +136,7 @@ function OutputStream(options) {
               case "\t": return "\\t";
               case "\b": return "\\b";
               case "\f": return "\\f";
-              case "\x0B": return options.ie8 ? "\\x0B" : "\\v";
+              case "\x0B": return options.screw_ie8 ? "\\v" : "\\x0B";
               case "\u2028": return "\\u2028";
               case "\u2029": return "\\u2029";
               case "\ufeff": return "\\ufeff";
@@ -588,7 +588,7 @@ function OutputStream(options) {
             || p instanceof AST_Call && p.expression === this;
     });
 
-    PARENS(AST_Sequence, function(output){
+    PARENS(AST_Seq, function(output){
         var p = output.parent();
         return p instanceof AST_Call             // (foo, bar)() or foo(1, (2, 3), 4)
             || p instanceof AST_Unary            // !(foo, bar, baz)
@@ -677,7 +677,7 @@ function OutputStream(options) {
         }
     });
 
-    PARENS([ AST_Assign, AST_Conditional ], function(output){
+    PARENS([ AST_Assign, AST_Conditional ], function (output){
         var p = output.parent();
         // !(a = false) → true
         if (p instanceof AST_Unary)
@@ -902,7 +902,7 @@ function OutputStream(options) {
     function make_then(self, output) {
         var b = self.body;
         if (output.option("bracketize")
-            || output.option("ie8") && b instanceof AST_Do)
+            || !output.option("screw_ie8") && b instanceof AST_Do)
             return make_block(b, output);
         // The squeezer replaces "block"-s that contain only a single
         // statement with the statement itself; technically, the AST
@@ -1033,6 +1033,9 @@ 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);
@@ -1080,19 +1083,18 @@ function OutputStream(options) {
         AST_Call.prototype._codegen(self, output);
     });
 
-    AST_Sequence.DEFMETHOD("_do_print", function(output){
-        this.expressions.forEach(function(node, index) {
-            if (index > 0) {
-                output.comma();
-                if (output.should_break()) {
-                    output.newline();
-                    output.indent();
-                }
+    AST_Seq.DEFMETHOD("_do_print", function(output){
+        this.car.print(output);
+        if (this.cdr) {
+            output.comma();
+            if (output.should_break()) {
+                output.newline();
+                output.indent();
             }
-            node.print(output);
-        });
+            this.cdr.print(output);
+        }
     });
-    DEFPRINT(AST_Sequence, function(self, output){
+    DEFPRINT(AST_Seq, function(self, output){
         self._do_print(output);
         // var p = output.parent();
         // if (p instanceof AST_Statement) {
@@ -1205,9 +1207,8 @@ function OutputStream(options) {
         });
         else output.print("{}");
     });
-    DEFPRINT(AST_ObjectKeyVal, function(self, output){
-        var key = self.key;
-        var quote = self.quote;
+
+    function print_property_name(key, quote, output) {
         if (output.option("quote_keys")) {
             output.print_string(key + "");
         } else if ((typeof key == "number"
@@ -1215,7 +1216,7 @@ function OutputStream(options) {
                     && +key + "" == key)
                    && parseFloat(key) >= 0) {
             output.print(make_num(key));
-        } else if (RESERVED_WORDS(key) ? !output.option("ie8") : is_identifier_string(key)) {
+        } else if (RESERVED_WORDS(key) ? output.option("screw_ie8") : is_identifier_string(key)) {
             if (quote && output.option("keep_quoted_props")) {
                 output.print_string(key, quote);
             } else {
@@ -1224,20 +1225,24 @@ function OutputStream(options) {
         } else {
             output.print_string(key, quote);
         }
+    }
+
+    DEFPRINT(AST_ObjectKeyVal, function(self, output){
+        print_property_name(self.key, self.quote, output);
         output.colon();
         self.value.print(output);
     });
-    DEFPRINT(AST_ObjectSetter, function(self, output){
-        output.print("set");
+    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, output) {
+        output.print(type);
         output.space();
-        self.key.print(output);
-        self.value._do_print(output, true);
+        print_property_name(this.key.name, this.quote, output);
+        this.value._do_print(output, true);
+    });
+    DEFPRINT(AST_ObjectSetter, function(self, output){
+        self._print_getter_setter("set", output);
     });
     DEFPRINT(AST_ObjectGetter, function(self, output){
-        output.print("get");
-        output.space();
-        self.key.print(output);
-        self.value._do_print(output, true);
+        self._print_getter_setter("get", output);
     });
     DEFPRINT(AST_Symbol, function(self, output){
         var def = self.definition();

lib/parse.js

@@ -633,7 +633,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     }
 
     next_token.has_directive = function(directive) {
-        return S.directives[directive] > 0;
+        return S.directives[directive] !== undefined &&
+            S.directives[directive] > 0;
     }
 
     return next_token;
@@ -692,6 +693,7 @@ function parse($TEXT, options) {
 
     options = defaults(options, {
         bare_returns   : false,
+        cli            : false,
         expression     : false,
         filename       : null,
         html5_comments : true,
@@ -939,6 +941,12 @@ function parse($TEXT, options) {
                 semicolon();
                 return node;
 
+              case "const":
+                next();
+                var node = const_();
+                semicolon();
+                return node;
+
               case "with":
                 if (S.input.has_directive("use strict")) {
                     croak("Strict mode may not include a with statement");
@@ -1053,32 +1061,29 @@ function parse($TEXT, options) {
         if (in_statement && !name)
             unexpected();
         expect("(");
-        var argnames = [];
-        for (var first = true; !is("punc", ")");) {
-            if (first) first = false; else expect(",");
-            argnames.push(as_symbol(AST_SymbolFunarg));
-        }
-        next();
-        var loop = S.in_loop;
-        var labels = S.labels;
-        ++S.in_function;
-        S.in_directives = true;
-        S.input.push_directives_stack();
-        S.in_loop = 0;
-        S.labels = [];
-        var body = block_();
-        if (S.input.has_directive("use strict")) {
-            if (name) strict_verify_symbol(name);
-            argnames.forEach(strict_verify_symbol);
-        }
-        S.input.pop_directives_stack();
-        --S.in_function;
-        S.in_loop = loop;
-        S.labels = labels;
         return new ctor({
             name: name,
-            argnames: argnames,
-            body: body
+            argnames: (function(first, a){
+                while (!is("punc", ")")) {
+                    if (first) first = false; else expect(",");
+                    a.push(as_symbol(AST_SymbolFunarg));
+                }
+                next();
+                return a;
+            })(true, []),
+            body: (function(loop, labels){
+                ++S.in_function;
+                S.in_directives = true;
+                S.input.push_directives_stack();
+                S.in_loop = 0;
+                S.labels = [];
+                var a = block_();
+                S.input.pop_directives_stack();
+                --S.in_function;
+                S.in_loop = loop;
+                S.labels = labels;
+                return a;
+            })(S.in_loop, S.labels)
         });
     };
 
@@ -1174,12 +1179,12 @@ function parse($TEXT, options) {
         });
     };
 
-    function vardefs(no_in) {
+    function vardefs(no_in, in_const) {
         var a = [];
         for (;;) {
             a.push(new AST_VarDef({
                 start : S.token,
-                name  : as_symbol(AST_SymbolVar),
+                name  : as_symbol(in_const ? AST_SymbolConst : AST_SymbolVar),
                 value : is("operator", "=") ? (next(), expression(false, no_in)) : null,
                 end   : prev()
             }));
@@ -1193,7 +1198,15 @@ function parse($TEXT, options) {
     var var_ = function(no_in) {
         return new AST_Var({
             start       : prev(),
-            definitions : vardefs(no_in),
+            definitions : vardefs(no_in, false),
+            end         : prev()
+        });
+    };
+
+    var const_ = function() {
+        return new AST_Const({
+            start       : prev(),
+            definitions : vardefs(false, true),
             end         : prev()
         });
     };
@@ -1404,20 +1417,12 @@ function parse($TEXT, options) {
         });
     };
 
-    function strict_verify_symbol(sym) {
-        if (sym.name == "arguments" || sym.name == "eval")
-            croak("Unexpected " + sym.name + " in strict mode", sym.start.line, sym.start.col, sym.start.pos);
-    }
-
     function as_symbol(type, noerror) {
         if (!is("name")) {
             if (!noerror) croak("Name expected");
             return null;
         }
         var sym = _make_symbol(type);
-        if (S.input.has_directive("use strict") && sym instanceof AST_SymbolDeclaration) {
-            strict_verify_symbol(sym);
-        }
         next();
         return sym;
     };
@@ -1478,17 +1483,8 @@ function parse($TEXT, options) {
 
     function make_unary(ctor, token, expr) {
         var op = token.value;
-        switch (op) {
-          case "++":
-          case "--":
-            if (!is_assignable(expr))
-                croak("Invalid use of " + op + " operator", token.line, token.col, token.pos);
-            break;
-          case "delete":
-            if (expr instanceof AST_SymbolRef && S.input.has_directive("use strict"))
-                croak("Calling delete on expression not allowed in strict mode", expr.start.line, expr.start.col, expr.start.pos);
-            break;
-        }
+        if ((op == "++" || op == "--") && !is_assignable(expr))
+            croak("Invalid use of " + op + " operator", token.line, token.col, token.pos);
         return new ctor({ operator: op, expression: expr });
     };
 
@@ -1533,6 +1529,7 @@ function parse($TEXT, options) {
     };
 
     function is_assignable(expr) {
+        if (options.cli) return true;
         return expr instanceof AST_PropAccess || expr instanceof AST_SymbolRef;
     };
 
@@ -1557,18 +1554,17 @@ function parse($TEXT, options) {
 
     var expression = function(commas, no_in) {
         var start = S.token;
-        var exprs = [];
-        while (true) {
-            exprs.push(maybe_assign(no_in));
-            if (!commas || !is("punc", ",")) break;
+        var expr = maybe_assign(no_in);
+        if (commas && is("punc", ",")) {
             next();
-            commas = true;
+            return new AST_Seq({
+                start  : start,
+                car    : expr,
+                cdr    : expression(true, no_in),
+                end    : peek()
+            });
         }
-        return exprs.length == 1 ? exprs[0] : new AST_Sequence({
-            start       : start,
-            expressions : exprs,
-            end         : peek()
-        });
+        return expr;
     };
 
     function in_loop(cont) {

lib/propmangle.js

@@ -43,16 +43,16 @@
 
 "use strict";
 
-function find_builtins(reserved) {
+function find_builtins() {
     // NaN will be included due to Number.NaN
-    [
+    var a = [
         "null",
         "true",
         "false",
         "Infinity",
         "-Infinity",
         "undefined",
-    ].forEach(add);
+    ];
     [ Object, Array, Function, Number,
       String, Boolean, Error, Math,
       Date, RegExp
@@ -63,23 +63,24 @@ function find_builtins(reserved) {
         }
     });
     function add(name) {
-        push_uniq(reserved, name);
+        push_uniq(a, name);
     }
+    return a;
 }
 
 function mangle_properties(ast, options) {
     options = defaults(options, {
-        builtins: false,
         cache: null,
         debug: false,
-        keep_quoted: false,
+        ignore_quoted: false,
         only_cache: false,
         regex: null,
         reserved: null,
     });
 
-    var reserved = options.reserved || [];
-    if (!options.builtins) find_builtins(reserved);
+    var reserved = options.reserved;
+    if (reserved == null)
+        reserved = find_builtins();
 
     var cache = options.cache;
     if (cache == null) {
@@ -90,12 +91,12 @@ function mangle_properties(ast, options) {
     }
 
     var regex = options.regex;
-    var keep_quoted = options.keep_quoted;
+    var ignore_quoted = options.ignore_quoted;
 
     // note debug is either false (disabled), or a string of the debug suffix to use (enabled).
     // note debug may be enabled as an empty string, which is falsey. Also treat passing 'true'
     // the same as passing an empty string.
-    var debug = options.debug !== false;
+    var debug = (options.debug !== false);
     var debug_name_suffix;
     if (debug) {
         debug_name_suffix = (options.debug === true ? "" : options.debug);
@@ -103,12 +104,12 @@ function mangle_properties(ast, options) {
 
     var names_to_mangle = [];
     var unmangleable = [];
-    var to_keep = {};
+    var ignored = {};
 
     // step 1: find candidates to mangle
     ast.walk(new TreeWalker(function(node){
         if (node instanceof AST_ObjectKeyVal) {
-            add(node.key, keep_quoted && node.quote);
+            add(node.key, ignore_quoted && node.quote);
         }
         else if (node instanceof AST_ObjectProperty) {
             // setter or getter, since KeyVal is handled above
@@ -118,14 +119,14 @@ function mangle_properties(ast, options) {
             add(node.property);
         }
         else if (node instanceof AST_Sub) {
-            addStrings(node.property, keep_quoted);
+            addStrings(node.property, ignore_quoted);
         }
     }));
 
     // step 2: transform the tree, renaming properties
     return ast.transform(new TreeTransformer(function(node){
         if (node instanceof AST_ObjectKeyVal) {
-            if (!(keep_quoted && node.quote))
+            if (!(ignore_quoted && node.quote))
                 node.key = mangle(node.key);
         }
         else if (node instanceof AST_ObjectProperty) {
@@ -136,7 +137,7 @@ function mangle_properties(ast, options) {
             node.property = mangle(node.property);
         }
         else if (node instanceof AST_Sub) {
-            if (!keep_quoted)
+            if (!ignore_quoted)
                 node.property = mangleStrings(node.property);
         }
         // else if (node instanceof AST_String) {
@@ -166,16 +167,16 @@ function mangle_properties(ast, options) {
     }
 
     function should_mangle(name) {
-        if (keep_quoted && name in to_keep) return false;
+        if (ignore_quoted && name in ignored) return false;
         if (regex && !regex.test(name)) return false;
         if (reserved.indexOf(name) >= 0) return false;
         return cache.props.has(name)
             || names_to_mangle.indexOf(name) >= 0;
     }
 
-    function add(name, keep) {
-        if (keep) {
-            to_keep[name] = true;
+    function add(name, ignore) {
+        if (ignore) {
+            ignored[name] = true;
             return;
         }
 
@@ -198,19 +199,19 @@ function mangle_properties(ast, options) {
                 // debug mode: use a prefix and suffix to preserve readability, e.g. o.foo -> o._$foo$NNN_.
                 var debug_mangled = "_$" + name + "$" + debug_name_suffix + "_";
 
-                if (can_mangle(debug_mangled) && !(keep_quoted && debug_mangled in to_keep)) {
+                if (can_mangle(debug_mangled) && !(ignore_quoted && debug_mangled in ignored)) {
                     mangled = debug_mangled;
                 }
             }
 
             // either debug mode is off, or it is on and we could not use the mangled name
             if (!mangled) {
-                // Note: `can_mangle()` does not check if the name collides with the `to_keep` set
-                // (filled with quoted properties when `keep_quoted` is set). Make sure we add this
+                // note can_mangle() does not check if the name collides with the 'ignored' set
+                // (filled with quoted properties when ignore_quoted set). Make sure we add this
                 // check so we don't collide with a quoted name.
                 do {
                     mangled = base54(++cache.cname);
-                } while (!can_mangle(mangled) || keep_quoted && mangled in to_keep);
+                } while (!can_mangle(mangled) || (ignore_quoted && mangled in ignored));
             }
 
             cache.props.set(name, mangled);
@@ -218,17 +219,17 @@ function mangle_properties(ast, options) {
         return mangled;
     }
 
-    function addStrings(node, keep) {
+    function addStrings(node, ignore) {
         var out = {};
         try {
             (function walk(node){
                 node.walk(new TreeWalker(function(node){
-                    if (node instanceof AST_Sequence) {
-                        walk(node.expressions[node.expressions.length - 1]);
+                    if (node instanceof AST_Seq) {
+                        walk(node.cdr);
                         return true;
                     }
                     if (node instanceof AST_String) {
-                        add(node.value, keep);
+                        add(node.value, ignore);
                         return true;
                     }
                     if (node instanceof AST_Conditional) {
@@ -246,9 +247,8 @@ function mangle_properties(ast, options) {
 
     function mangleStrings(node) {
         return node.transform(new TreeTransformer(function(node){
-            if (node instanceof AST_Sequence) {
-                var last = node.expressions.length - 1;
-                node.expressions[last] = mangleStrings(node.expressions[last]);
+            if (node instanceof AST_Seq) {
+                node.cdr = mangleStrings(node.cdr);
             }
             else if (node instanceof AST_String) {
                 node.value = mangle(node.value);
@@ -260,4 +260,5 @@ function mangle_properties(ast, options) {
             return node;
         }));
     }
+
 }

lib/scope.js

@@ -76,7 +76,7 @@ SymbolDef.prototype = {
         else if (!this.mangled_name && !this.unmangleable(options)) {
             var s = this.scope;
             var sym = this.orig[0];
-            if (options.ie8 && sym instanceof AST_SymbolLambda)
+            if (!options.screw_ie8 && sym instanceof AST_SymbolLambda)
                 s = s.parent_scope;
             var def;
             if (this.defun && (def = this.defun.variables.get(this.name))) {
@@ -93,7 +93,7 @@ SymbolDef.prototype = {
 AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     options = defaults(options, {
         cache: null,
-        ie8: false,
+        screw_ie8: true,
     });
 
     // pass 1: setup scope chaining and handle definitions
@@ -156,7 +156,8 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             // later.
             (node.scope = defun.parent_scope).def_function(node);
         }
-        else if (node instanceof AST_SymbolVar) {
+        else if (node instanceof AST_SymbolVar
+            || node instanceof AST_SymbolConst) {
             defun.def_variable(node);
             if (defun !== scope) {
                 node.mark_enclosed(options);
@@ -219,7 +220,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     self.walk(tw);
 
     // pass 3: fix up any scoping issue with IE8
-    if (options.ie8) {
+    if (!options.screw_ie8) {
         self.walk(new TreeWalker(function(node, descend) {
             if (node instanceof AST_SymbolCatch) {
                 var name = node.name;
@@ -267,7 +268,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_SymbolFunarg({
+    this.def_variable(new AST_SymbolVar({
         name: "arguments",
         start: this.start,
         end: this.end
@@ -324,8 +325,8 @@ AST_Scope.DEFMETHOD("next_mangled", function(options){
         if (!is_identifier(m)) continue; // skip over "do"
 
         // https://github.com/mishoo/UglifyJS2/issues/242 -- do not
-        // shadow a name reserved from mangling.
-        if (options.reserved.indexOf(m) >= 0) continue;
+        // shadow a name excepted from mangling.
+        if (options.except.indexOf(m) >= 0) continue;
 
         // we must ensure that the mangled name does not shadow a name
         // from some parent scope that is referenced in this or in
@@ -393,9 +394,10 @@ AST_Symbol.DEFMETHOD("global", function(){
 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
     return defaults(options, {
         eval        : false,
-        ie8         : false,
+        except      : [],
         keep_fnames : false,
-        reserved    : [],
+        screw_ie8   : true,
+        sort        : false, // Ignored. Flag retained for backwards compatibility.
         toplevel    : false,
     });
 });
@@ -404,7 +406,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
     options = this._default_mangler_options(options);
 
     // Never mangle arguments
-    options.reserved.push('arguments');
+    options.except.push('arguments');
 
     // We only need to mangle declaration nodes.  Special logic wired
     // into the code generator will display the mangled name if it's
@@ -415,7 +417,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
 
     if (options.cache) {
         this.globals.each(function(symbol){
-            if (options.reserved.indexOf(symbol.name) < 0) {
+            if (options.except.indexOf(symbol.name) < 0) {
                 to_mangle.push(symbol);
             }
         });
@@ -432,7 +434,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
         if (node instanceof AST_Scope) {
             var p = tw.parent(), a = [];
             node.variables.each(function(symbol){
-                if (options.reserved.indexOf(symbol.name) < 0) {
+                if (options.except.indexOf(symbol.name) < 0) {
                     a.push(symbol);
                 }
             });
@@ -445,7 +447,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
             node.mangled_name = name;
             return true;
         }
-        if (!options.ie8 && node instanceof AST_SymbolCatch) {
+        if (options.screw_ie8 && node instanceof AST_SymbolCatch) {
             to_mangle.push(node.definition());
             return;
         }
@@ -485,6 +487,8 @@ 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)
@@ -564,3 +568,89 @@ var base54 = (function() {
     };
     return base54;
 })();
+
+AST_Toplevel.DEFMETHOD("scope_warnings", function(options){
+    options = defaults(options, {
+        assign_to_global : true,
+        eval             : true,
+        func_arguments   : true,
+        nested_defuns    : true,
+        undeclared       : false, // this makes a lot of noise
+        unreferenced     : true,
+    });
+    var tw = new TreeWalker(function(node){
+        if (options.undeclared
+            && node instanceof AST_SymbolRef
+            && node.undeclared())
+        {
+            // XXX: this also warns about JS standard names,
+            // i.e. Object, Array, parseInt etc.  Should add a list of
+            // exceptions.
+            AST_Node.warn("Undeclared symbol: {name} [{file}:{line},{col}]", {
+                name: node.name,
+                file: node.start.file,
+                line: node.start.line,
+                col: node.start.col
+            });
+        }
+        if (options.assign_to_global)
+        {
+            var sym = null;
+            if (node instanceof AST_Assign && node.left instanceof AST_SymbolRef)
+                sym = node.left;
+            else if (node instanceof AST_ForIn && node.init instanceof AST_SymbolRef)
+                sym = node.init;
+            if (sym
+                && (sym.undeclared()
+                    || (sym.global() && sym.scope !== sym.definition().scope))) {
+                AST_Node.warn("{msg}: {name} [{file}:{line},{col}]", {
+                    msg: sym.undeclared() ? "Accidental global?" : "Assignment to global",
+                    name: sym.name,
+                    file: sym.start.file,
+                    line: sym.start.line,
+                    col: sym.start.col
+                });
+            }
+        }
+        if (options.eval
+            && node instanceof AST_SymbolRef
+            && node.undeclared()
+            && node.name == "eval") {
+            AST_Node.warn("Eval is used [{file}:{line},{col}]", node.start);
+        }
+        if (options.unreferenced
+            && (node instanceof AST_SymbolDeclaration || node instanceof AST_Label)
+            && !(node instanceof AST_SymbolCatch)
+            && node.unreferenced()) {
+            AST_Node.warn("{type} {name} is declared but not referenced [{file}:{line},{col}]", {
+                type: node instanceof AST_Label ? "Label" : "Symbol",
+                name: node.name,
+                file: node.start.file,
+                line: node.start.line,
+                col: node.start.col
+            });
+        }
+        if (options.func_arguments
+            && node instanceof AST_Lambda
+            && node.uses_arguments) {
+            AST_Node.warn("arguments used in function {name} [{file}:{line},{col}]", {
+                name: node.name ? node.name.name : "anonymous",
+                file: node.start.file,
+                line: node.start.line,
+                col: node.start.col
+            });
+        }
+        if (options.nested_defuns
+            && node instanceof AST_Defun
+            && !(tw.parent() instanceof AST_Scope)) {
+            AST_Node.warn("Function {name} declared in nested statement \"{type}\" [{file}:{line},{col}]", {
+                name: node.name.name,
+                type: tw.parent().TYPE,
+                file: node.start.file,
+                line: node.start.line,
+                col: node.start.col
+            });
+        }
+    });
+    this.walk(tw);
+});

lib/transform.js

@@ -174,8 +174,9 @@ TreeTransformer.prototype = new TreeWalker;
         self.args = do_list(self.args, tw);
     });
 
-    _(AST_Sequence, function(self, tw){
-        self.expressions = do_list(self.expressions, tw);
+    _(AST_Seq, function(self, tw){
+        self.car = self.car.transform(tw);
+        self.cdr = self.cdr.transform(tw);
     });
 
     _(AST_Dot, function(self, tw){

lib/utils.js

@@ -346,7 +346,7 @@ function first_in_statement(stack) {
     for (var i = 0, p; p = stack.parent(i); i++) {
         if (p instanceof AST_Statement && p.body === node)
             return true;
-        if ((p instanceof AST_Sequence      && p.expressions[0] === node) ||
+        if ((p instanceof AST_Seq           && p.car === node        ) ||
             (p instanceof AST_Call          && p.expression === node && !(p instanceof AST_New) ) ||
             (p instanceof AST_Dot           && p.expression === node ) ||
             (p instanceof AST_Sub           && p.expression === node ) ||

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.7",
+  "version": "2.8.29",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -29,13 +29,21 @@
     "LICENSE"
   ],
   "dependencies": {
-    "commander": "~2.9.0",
-    "source-map": "~0.5.1"
+    "source-map": "~0.5.1",
+    "yargs": "~3.10.0"
   },
   "devDependencies": {
     "acorn": "~5.0.3",
     "mocha": "~2.3.4"
   },
+  "optionalDependencies": {
+    "uglify-to-browserify": "~1.0.0"
+  },
+  "browserify": {
+    "transform": [
+      "uglify-to-browserify"
+    ]
+  },
   "scripts": {
     "test": "node test/run-tests.js"
   },

test/benchmark.js

@@ -7,7 +7,7 @@ var createHash = require("crypto").createHash;
 var fork = require("child_process").fork;
 var args = process.argv.slice(2);
 if (!args.length) {
-    args.push("-mc");
+    args.push("-mc", "warnings=false");
 }
 args.push("--stats");
 var urls = [
@@ -29,11 +29,11 @@ function done() {
             var info = results[url];
             console.log();
             console.log(url);
+            console.log(info.log);
             var elapsed = 0;
-            console.log(info.log.replace(/Elapsed: ([0-9]+)\s*/g, function(match, time) {
-                elapsed += 1e-3 * parseInt(time);
-                return "";
-            }));
+            info.log.replace(/: ([0-9]+\.[0-9]{3})s/g, function(match, time) {
+                elapsed += parseFloat(time);
+            });
             console.log("Run-time:", elapsed.toFixed(3), "s");
             console.log("Original:", info.input, "bytes");
             console.log("Uglified:", info.output, "bytes");

test/compress/angular-inject.js

@@ -0,0 +1,67 @@
+ng_inject_defun: {
+    options = {
+        angular: true
+    };
+    input: {
+        /*@ngInject*/
+        function Controller(dependency) {
+            return dependency;
+        }
+    }
+    expect: {
+        function Controller(dependency) {
+            return dependency;
+        }
+        Controller.$inject=['dependency']
+    }
+}
+
+ng_inject_assignment: {
+    options = {
+        angular: true
+    };
+    input: {
+        /*@ngInject*/
+        var Controller = function(dependency) {
+            return dependency;
+        }
+    }
+    expect: {
+        var Controller = function(dependency) {
+            return dependency;
+        }
+        Controller.$inject=['dependency']
+    }
+}
+
+ng_inject_inline: {
+    options = {
+        angular: true
+    };
+    input: {
+        angular.module('a').
+            factory('b',
+                /*@ngInject*/
+                function(dependency) {
+                    return dependency;
+                }).
+            directive('c',
+                /*@ngInject*/
+                function(anotherDependency) {
+                    return anotherDependency;
+                })
+    }
+    expect: {
+        angular.module('a').
+            factory('b',[
+                'dependency',
+                function(dependency) {
+                    return dependency;
+                }]).
+            directive('c',[
+                'anotherDependency',
+                function(anotherDependency) {
+                    return anotherDependency;
+                }])
+    }
+}

test/compress/ascii.js

@@ -2,7 +2,7 @@ ascii_only_true: {
     options = {}
     beautify = {
         ascii_only : true,
-        ie8        : false,
+        screw_ie8  : true,
         beautify   : false,
     }
     input: {
@@ -20,7 +20,7 @@ ascii_only_false: {
     options = {}
     beautify = {
         ascii_only : false,
-        ie8        : false,
+        screw_ie8  : true,
         beautify   : false,
     }
     input: {
@@ -33,3 +33,4 @@ ascii_only_false: {
     }
     expect_exact: 'function f(){return"\\x000\\x001\\x007\\08\\0"+"\\0\x01\x02\x03\x04\x05\x06\x07\\b\\t\\n\\v\\f\\r\x0e\x0f"+"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"+\' !"# ... }~\x7f\x80\x81 ... \xfe\xff\u0fff\uffff\'}'
 }
+

test/compress/collapse_vars.js

@@ -2,7 +2,7 @@ collapse_vars_side_effects_1: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true, reduce_vars:true
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
     }
     input: {
         function f1() {
@@ -68,10 +68,11 @@ collapse_vars_side_effects_1: {
             log(x, s.charAt(i++), y, 7);
         }
         function f4() {
-            var i = 10,
+            var log = console.log.bind(console),
+                i = 10,
                 x = i += 2,
                 y = i += 3;
-            console.log.bind(console)(x, i += 4, y, i);
+            log(x, i += 4, y, i);
         }
         f1(), f2(), f3(), f4();
     }
@@ -150,7 +151,7 @@ collapse_vars_issue_721: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true, reduce_vars:true
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
     }
     input: {
         define(["require", "exports", 'handlebars'], function (require, exports, hb) {
@@ -216,7 +217,7 @@ collapse_vars_properties: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true, reduce_vars:true
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
     }
     input: {
         function f1(obj) {
@@ -243,7 +244,7 @@ collapse_vars_if: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true, reduce_vars:true
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
     }
     input: {
         function f1() {
@@ -293,7 +294,7 @@ collapse_vars_while: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:false, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true, reduce_vars:true
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
     }
     input: {
         function f1(y) {
@@ -392,9 +393,9 @@ collapse_vars_do_while: {
         }
         function f3(y) {
             function fn(n) { console.log(n); }
-            var a = 2, x = 7;
+            var a = 2;
             do {
-                fn(a = x);
+                fn(a = 7);
                 break;
             } while (y);
         }
@@ -467,9 +468,8 @@ collapse_vars_do_while_drop_assign: {
         }
         function f3(y) {
             function fn(n) { console.log(n); }
-            var x = 7;
             do {
-                fn(x);
+                fn(7);
                 break;
             } while (y);
         }
@@ -583,8 +583,8 @@ collapse_vars_assignment: {
             return a = a;
         }
         function f1(c) {
-            var a = 3 / c;
-            var b = 1 - a;
+            const a = 3 / c;
+            const b = 1 - a;
             return b;
         }
         function f2(c) {
@@ -670,8 +670,8 @@ collapse_vars_lvalues: {
         function f4(x) { var a = (x -= 3); return x + a; }
         function f5(x) { var w = e1(), v = e2(), c = v = --x; return (w = x) - c; }
         function f6(x) { var w = e1(), v = e2(); return (v = --x) - (w = x); }
-        function f7(x) { var w = e1(); return (w = x) - (e2() - x); }
-        function f8(x) { var w = e1(); return (w = x) - (e2() - x); }
+        function f7(x) { var w = e1(), v = e2(), c = v - x; return (w = x) - c; }
+        function f8(x) { var w = e1(), v = e2(); return (w = x) - (v - x); }
         function f9(x) { var w = e1(); return e2() - x - (w = x); }
     }
 }
@@ -700,10 +700,10 @@ collapse_vars_lvalues_drop_assign: {
         function f2(x) { var z = x, a = ++z; return z += a; }
         function f3(x) { var a = (x -= 3); return x + a; }
         function f4(x) { var a = (x -= 3); return x + a; }
-        function f5(x) { e1(); var v = e2(), c = v = --x; return x - c; }
+        function f5(x) { var v = (e1(), e2()), c = v = --x; return x - c; }
         function f6(x) { e1(), e2(); return --x - x; }
-        function f7(x) { e1(); return x - (e2() - x); }
-        function f8(x) { e1(); return x - (e2() - x); }
+        function f7(x) { var v = (e1(), e2()), c = v - x; return x - c; }
+        function f8(x) { var v = (e1(), e2()); return x - (v - x); }
         function f9(x) { e1(); return e2() - x - x; }
     }
 }
@@ -712,7 +712,7 @@ collapse_vars_misc1: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true, reduce_vars:true
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
     }
     input: {
         function f0(o, a, h) {
@@ -724,10 +724,10 @@ collapse_vars_misc1: {
             return t;
         }
         function f1(x) { var y = 5 - x; return y; }
-        function f2(x) { var z = foo(), y = z / (5 - x); return y; }
+        function f2(x) { const 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) { var z = foo(), y = (5 - window.x) / z; return y; }
+        function f5(x) { const 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) { var z = foo(); return (5 - window.x) / z }
+        function f5(x) { const 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) }
@@ -789,7 +789,7 @@ collapse_vars_repeated: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true, reduce_vars:true
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
     }
     input: {
         function f1() {
@@ -812,17 +812,19 @@ collapse_vars_repeated: {
     }
     expect: {
         function f1() {
-            return -3;
+            return -3
         }
         function f2(x) {
-            return x;
+            return x
         }
         (function(x){
-             console.log("GOOD!!");
-        })(),
+             var a = "GOOD" + x, e = "BAD", e = a;
+             console.log(e + "!");
+        })("!"),
         (function(x){
-             console.log("GOOD!!");
-        })();
+            var a = "GOOD" + x, e = "BAD" + x, e = a;
+            console.log(e + "!");
+        })("!");
     }
     expect_stdout: true
 }
@@ -831,7 +833,7 @@ collapse_vars_closures: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true, reduce_vars:true
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
     }
     input: {
         function constant_vars_can_be_replaced_in_any_scope() {
@@ -921,7 +923,7 @@ collapse_vars_try: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true, reduce_vars:true
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
     }
     input: {
         function f1() {
@@ -1046,9 +1048,10 @@ collapse_vars_object: {
     }
     expect: {
         function f0(x, y) {
+            var z = x + y;
             return {
                 get b() { return 7; },
-                r: x + y
+                r: z
             };
         }
         function f1(x, y) {
@@ -1118,7 +1121,7 @@ collapse_vars_constants: {
     options = {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true, reduce_vars:true
+        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
     }
     input: {
         function f1(x) {
@@ -1156,7 +1159,7 @@ collapse_vars_arguments: {
         collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
         comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
         keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true,
-        toplevel:true, reduce_vars:true
+        toplevel:true
     }
     input: {
         var outer = function() {
@@ -1283,7 +1286,6 @@ collapse_vars_regexp: {
         join_vars:     true,
         cascade:       true,
         side_effects:  true,
-        reduce_vars:   true,
     }
     input: {
         function f1() {
@@ -1317,8 +1319,8 @@ collapse_vars_regexp: {
             };
         }
         (function(){
-            var result, rx = /ab*/g;
-            while (result = rx.exec("acdabcdeabbb"))
+            var result, s = "acdabcdeabbb", rx = /ab*/g;
+            while (result = rx.exec(s))
                 console.log(result[0]);
         })();
     }
@@ -1342,10 +1344,7 @@ issue_1537: {
 issue_1562: {
     options = {
         collapse_vars: true,
-        evaluate: true,
-        reduce_vars: true,
         toplevel: true,
-        unused: true,
     }
     input: {
         var v = 1, B = 2;
@@ -1364,11 +1363,14 @@ issue_1562: {
         var v = 1;
         for (v in objs) f(2);
 
-        while(5) bar(10);
+        var x = 3;
+        while(x + 2) bar(10);
 
-        do bar(20); while(6);
+        var y = 4;
+        do bar(20); while(y + 2);
 
-        for (; f(7) ;) bar(30);
+        var z = 5;
+        for (; f(z + 2) ;) bar(30);
     }
 }
 
@@ -1591,598 +1593,48 @@ var_side_effects_3: {
     expect_stdout: true
 }
 
-reduce_vars_assign: {
+reassign_const_1: {
     options = {
         collapse_vars: true,
-        reduce_vars: true,
-    }
-    input: {
-        !function() {
-            var a = 1;
-            a = [].length,
-            console.log(a);
-        }();
-    }
-    expect: {
-        !function() {
-            var a = 1;
-            a = [].length,
-            console.log(a);
-        }();
-    }
-    expect_stdout: "0"
-}
-
-iife_1: {
-    options = {
-        collapse_vars: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var log = function(x) {
-            console.log(x);
-        }, foo = bar();
-        log(foo);
-    }
-    expect: {
-        (function(x) {
-            console.log(x);
-        })(bar());
-    }
-}
-
-iife_2: {
-    options = {
-        collapse_vars: true,
-        reduce_vars: false,
-        toplevel: true,
-        unused: false,
-    }
-    input: {
-        var foo = bar();
-        !function(x) {
-            console.log(x);
-        }(foo);
-    }
-    expect: {
-        !function(x) {
-            console.log(x);
-        }(bar());
-    }
-}
-
-var_defs: {
-    options = {
-        collapse_vars:true, sequences:true, properties:true, dead_code:true, conditionals:true,
-        comparisons:true, evaluate:true, booleans:true, loops:true, unused:true, hoist_funs:true,
-        keep_fargs:true, if_return:true, join_vars:true, cascade:true, side_effects:true
-    }
-    input: {
-        var f1 = function(x, y) {
-            var a, b, r = x + y, q = r * r, z = q - r, a = z, b = 7;
-            console.log(a + b);
-        };
-        f1("1", 0);
-    }
-    expect: {
-        var f1 = function(x, y) {
-            var r = x + y, a = r * r - r, b = 7;
-            console.log(a + b);
-        };
-        f1("1", 0);
-    }
-    expect_stdout: "97"
-}
-
-assignment: {
-    options = {
-        collapse_vars: true,
-        unused: true,
     }
     input: {
         function f() {
-            var a;
-            a = x;
+            const a = 1;
+            a = 2;
             return a;
         }
+        console.log(f());
     }
     expect: {
         function f() {
-            return x;
+            const a = 1;
+            a = 2;
+            return a;
         }
-    }
-}
-
-for_init: {
-    options = {
-        collapse_vars: true,
-        unused: true,
-    }
-    input: {
-        function f(x, y) {
-            var a = x;
-            var b = y;
-            for (a; b;);
-        }
-    }
-    expect: {
-        function f(x, y) {
-            var b = y;
-            for (x; b;);
-        }
-    }
-}
-
-switch_case: {
-    options = {
-        collapse_vars: true,
-        unused: true,
-    }
-    input: {
-        function f(x, y, z) {
-            var a = x();
-            var b = y();
-            var c = z;
-            switch (a) {
-              default: d();
-              case b: e();
-              case c: f();
-            }
-        }
-    }
-    expect: {
-        function f(x, y, z) {
-            var c = z;
-            switch (x()) {
-              default: d();
-              case y(): e();
-              case c: f();
-            }
-        }
-    }
-}
-
-issue_27: {
-    options = {
-        collapse_vars: true,
-        unused: true,
-    }
-    input: {
-        (function(jQuery) {
-            var $;
-            $ = jQuery;
-            $("body").addClass("foo");
-        })(jQuery);
-    }
-    expect: {
-        (function(jQuery) {
-            jQuery("body").addClass("foo");
-        })(jQuery);
-    }
-}
-
-modified: {
-    options = {
-        collapse_vars: true,
-        unused: true,
-    }
-    input: {
-        function f1(b) {
-            var a = b;
-            return b + a;
-        }
-        function f2(b) {
-            var a = b;
-            return b++ + a;
-        }
-        function f3(b) {
-            var a = b++;
-            return b + a;
-        }
-        function f4(b) {
-            var a = b++;
-            return b++ + a;
-        }
-        function f5(b) {
-            var a = function() {
-                return b;
-            }();
-            return b++ + a;
-        }
-        console.log(f1(1), f2(1), f3(1), f4(1), f5(1));
-    }
-    expect: {
-        function f1(b) {
-            return b + b;
-        }
-        function f2(b) {
-            var a = b;
-            return b++ + a;
-        }
-        function f3(b) {
-            var a = b++;
-            return b + a;
-        }
-        function f4(b) {
-            var a = b++;
-            return b++ + a;
-        }
-        function f5(b) {
-            var a = function() {
-                return b;
-            }();
-            return b++ + a;
-        }
-        console.log(f1(1), f2(1), f3(1), f4(1), f5(1));
-    }
-    expect_stdout: "2 2 3 3 2"
-}
-
-issue_1858: {
-    options = {
-        collapse_vars: true,
-        pure_getters: true,
-        unused: true,
-    }
-    input: {
-        console.log(function(x) {
-            var a = {}, b = a.b = x;
-            return a.b + b;
-        }(1));
-    }
-    expect: {
-        console.log(function(x) {
-            var a = {}, b = a.b = x;
-            return a.b + b;
-        }(1));
-    }
-    expect_stdout: "2"
-}
-
-anonymous_function: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        console.log(function f(a) {
-            f ^= 0;
-            return f * a;
-        }(1));
-    }
-    expect: {
-        console.log(function f(a) {
-            f ^= 0;
-            return f * a;
-        }(1));
+        console.log(f());
     }
     expect_stdout: true
 }
 
-side_effects_property: {
+reassign_const_2: {
     options = {
         collapse_vars: true,
     }
     input: {
-        var a = [];
-        var b = 0;
-        a[b++] = function() { return 42;};
-        var c = a[b++]();
-        console.log(c);
-    }
-    expect: {
-        var a = [];
-        var b = 0;
-        a[b++] = function() { return 42;};
-        var c = a[b++]();
-        console.log(c);
-    }
-    expect_stdout: true
-}
-
-undeclared: {
-    options = {
-        collapse_vars: true,
-        unused: true,
-    }
-    input: {
-        function f(x, y) {
-            var a;
-            a = x;
-            b = y;
-            return b + a;
+        function f() {
+            const a = 1;
+            ++a;
+            return a;
         }
+        console.log(f());
     }
     expect: {
-        function f(x, y) {
-            var a;
-            a = x;
-            b = y;
-            return b + a;
+        function f() {
+            const a = 1;
+            ++a;
+            return a;
         }
-    }
-}
-
-ref_scope: {
-    options = {
-        collapse_vars: true,
-        unused: true,
-    }
-    input: {
-        console.log(function() {
-            var a = 1, b = 2, c = 3;
-            var a = c++, b = b /= a;
-            return function() {
-                return a;
-            }() + b;
-        }());
-    }
-    expect: {
-        console.log(function() {
-            var a = 1, b = 2, c = 3;
-            b = b /= a = c++;
-            return function() {
-                return a;
-            }() + b;
-        }());
+        console.log(f());
     }
     expect_stdout: true
 }
-
-chained_1: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        var a = 2;
-        var a = 3 / a;
-        console.log(a);
-    }
-    expect: {
-        var a = 3 / (a = 2);
-        console.log(a);
-    }
-    expect_stdout: true
-}
-
-chained_2: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        var a;
-        var a = 2;
-        a = 3 / a;
-        console.log(a);
-    }
-    expect: {
-        var a;
-        a = 3 / (a = 2);
-        console.log(a);
-    }
-    expect_stdout: true
-}
-
-chained_3: {
-    options = {
-        collapse_vars: true,
-        unused: true,
-    }
-    input: {
-        console.log(function(a, b) {
-            var c = a, c = b;
-            b++;
-            return c;
-        }(1, 2));
-    }
-    expect: {
-        console.log(function(a, b) {
-            var c = a, c = b;
-            b++;
-            return c;
-        }(1, 2));
-    }
-    expect_stdout: "2"
-}
-
-boolean_binary_1: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        var a = 1;
-        a++;
-        (function() {} || a || 3).toString();
-        console.log(a);
-    }
-    expect: {
-        var a = 1;
-        a++;
-        (function() {} || a || 3).toString();
-        console.log(a);
-    }
-    expect_stdout: true
-}
-
-boolean_binary_2: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        var c = 0;
-        c += 1;
-        (function() {
-            c = 1 + c;
-        } || 9).toString();
-        console.log(c);
-    }
-    expect: {
-        var c = 0;
-        c += 1;
-        (function() {
-            c = 1 + c;
-        } || 9).toString();
-        console.log(c);
-    }
-    expect_stdout: true
-}
-
-inner_lvalues: {
-    options = {
-        collapse_vars: true,
-        unused: true,
-    }
-    input: {
-        var a, b = 10;
-        var a = (--b || a || 3).toString(), c = --b + -a;
-        console.log(null, a, b);
-    }
-    expect: {
-        var a, b = 10;
-        var a = (--b || a || 3).toString(), c = --b + -a;
-        console.log(null, a, b);
-    }
-    expect_stdout: true
-}
-
-double_def: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        var a = x, a = a && y;
-        a();
-    }
-    expect: {
-        var a = x;
-        (a = a && y)();
-    }
-}
-
-toplevel_single_reference: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        var a;
-        for (var b in x) {
-            var a = b;
-            b(a);
-        }
-    }
-    expect: {
-        var a;
-        for (var b in x)
-            b(a = b);
-    }
-}
-
-unused_orig: {
-    options = {
-        collapse_vars: true,
-        passes: 2,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        var a = 1;
-        console.log(function(b) {
-            var a;
-            var c = b;
-            for (var d in c) {
-                var a = c[0];
-                return --b + a;
-            }
-            try {
-            } catch (e) {
-                --b + a;
-            }
-            a && a.NaN;
-        }([2]), a);
-    }
-    expect: {
-        var a = 1;
-        console.log(function(b) {
-            var c = b;
-            for (var d in c) {
-                var a = c[0];
-                return --b + a;
-            }
-            a && a.NaN;
-        }([2]), a);
-    }
-    expect_stdout: "3 1"
-}
-
-issue_315: {
-    options = {
-        collapse_vars: true,
-        evaluate: true,
-        keep_fargs: false,
-        reduce_vars: true,
-        sequences: true,
-        unused: true,
-    }
-    input: {
-        console.log(function(s) {
-            var w, _i, _len, _ref, _results;
-            _ref = s.trim().split(" ");
-            _results = [];
-            for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-                w = _ref[_i];
-                _results.push(w.toLowerCase());
-            }
-            return _results;
-        }("test"));
-    }
-    expect: {
-        console.log(function() {
-            var w, _i, _len, _ref, _results;
-            for (_results = [], _i = 0, _len = (_ref = "test".trim().split(" ")).length; _i < _len ; _i++)
-                w = _ref[_i], _results.push(w.toLowerCase());
-            return _results;
-        }());
-    }
-    expect_stdout: true
-}
-
-lvalues_def: {
-    options = {
-        collapse_vars: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        var a = 0, b = 1;
-        var a = b++, b = +function() {}();
-        a && a[a++];
-        console.log(a, b);
-    }
-    expect: {
-        var a = 0, b = 1;
-        var a = b++, b = +void 0;
-        a && a[a++];
-        console.log(a, b);
-    }
-    expect_stdout: true
-}
-
-compound_assignment: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        var a;
-        a = 1;
-        a += a + 2;
-        console.log(a);
-    }
-    expect: {
-        var a;
-        a = 1;
-        a += a + 2;
-        console.log(a);
-    }
-    expect_stdout: "4"
-}

test/compress/conditionals.js

@@ -979,12 +979,12 @@ delete_conditional_1: {
         console.log(delete (1 ? 0 / 0 : x));
     }
     expect: {
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
+        console.log((void 0, !0));
+        console.log((void 0, !0));
+        console.log((1 / 0, !0));
+        console.log((1 / 0, !0));
+        console.log((NaN, !0));
+        console.log((NaN, !0));
     }
     expect_stdout: true
 }
@@ -1006,12 +1006,12 @@ delete_conditional_2: {
         console.log(delete (0 ? x : 0 / 0));
     }
     expect: {
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
+        console.log((void 0, !0));
+        console.log((void 0, !0));
+        console.log((Infinity, !0));
+        console.log((1 / 0, !0));
+        console.log((NaN, !0));
+        console.log((NaN, !0));
     }
     expect_stdout: true
 }

test/compress/const.js

@@ -0,0 +1,166 @@
+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

@@ -90,6 +90,131 @@ dead_code_constant_boolean_should_warn_more: {
     expect_stdout: true
 }
 
+dead_code_const_declaration: {
+    options = {
+        dead_code    : true,
+        loops        : true,
+        booleans     : true,
+        conditionals : true,
+        evaluate     : true,
+        reduce_vars  : true,
+    };
+    input: {
+        var unused;
+        const CONST_FOO = false;
+        if (CONST_FOO) {
+            console.log("unreachable");
+            var moo;
+            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");
+            var moo;
+            function bar() {}
+        }
+    }
+    expect: {
+        var unused;
+        var CONST_FOO_ANN = !1;
+        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';
+    }
+    expect_stdout: true
+}
+
 try_catch_finally: {
     options = {
         conditionals: true,

test/compress/drop-unused.js

@@ -649,6 +649,37 @@ 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,
@@ -785,6 +816,10 @@ issue_1709: {
                 var x = 1;
                 return x;
             }(),
+            function y() {
+                const y = 2;
+                return y;
+            }(),
             function z() {
                 function z() {}
                 return z;
@@ -797,6 +832,10 @@ issue_1709: {
                 var x = 1;
                 return x;
             }(),
+            function() {
+                const y = 2;
+                return y;
+            }(),
             function() {
                 function z() {}
                 return z;
@@ -896,8 +935,7 @@ issue_1715_3: {
             try {
                 console;
             } catch (a) {
-                var a;
-                x();
+                var a = x();
             }
         }
         f();
@@ -992,33 +1030,6 @@ delete_assign_2: {
     expect_stdout: true
 }
 
-drop_var: {
-    options = {
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a;
-        console.log(a, b);
-        var a = 1, b = 2;
-        console.log(a, b);
-        var a = 3;
-        console.log(a, b);
-    }
-    expect: {
-        console.log(a, b);
-        var a = 1, b = 2;
-        console.log(a, b);
-        a = 3;
-        console.log(a, b);
-    }
-    expect_stdout: [
-        "undefined undefined",
-        "1 2",
-        "3 2",
-    ]
-}
-
 issue_1830_1: {
     options = {
         unused: true,
@@ -1054,57 +1065,27 @@ issue_1830_2: {
     expect_stdout: "1"
 }
 
-issue_1838: {
+reassign_const: {
     options = {
-        join_vars: true,
-        loops: true,
-        unused: true,
-    }
-    beautify = {
-        beautify: true,
-    }
-    input: {
-        function f() {
-            var b = a;
-            while (c);
-        }
-    }
-    expect_exact: [
-        "function f() {",
-        "    for (a; c; ) ;",
-        "}",
-    ]
-}
-
-var_catch_toplevel: {
-    options = {
-        conditionals: true,
-        negate_iife: true,
-        reduce_vars: true,
+        cascade: true,
+        sequences: true,
         side_effects: true,
-        toplevel: true,
         unused: true,
     }
     input: {
         function f() {
-            a--;
-            try {
-                a++;
-            } catch(a) {
-                if (a) var a;
-                var a = 10;
-            }
+            const a = 1;
+            a = 2;
+            return a;
         }
-        f();
+        console.log(f());
     }
     expect: {
-        !function() {
-            a--;
-            try {
-                a++;
-            } catch(a) {
-                var a;
-            }
-        }();
+        function f() {
+            const a = 1;
+            return a = 2, a;
+        }
+        console.log(f());
     }
+    expect_stdout: true
 }

test/compress/evaluate.js

@@ -645,17 +645,16 @@ call_args: {
     options = {
         evaluate: true,
         reduce_vars: true,
-        toplevel: true,
     }
     input: {
-        var a = 1;
+        const a = 1;
         console.log(a);
         +function(a) {
             return a;
         }(a);
     }
     expect: {
-        var a = 1;
+        const a = 1;
         console.log(1);
         +(1, 1);
     }
@@ -667,17 +666,17 @@ call_args_drop_param: {
         evaluate: true,
         keep_fargs: false,
         reduce_vars: true,
-        toplevel: true,
         unused: true,
     }
     input: {
-        var a = 1;
+        const a = 1;
         console.log(a);
         +function(a) {
             return a;
         }(a, b);
     }
     expect: {
+        const a = 1;
         console.log(1);
         +(b, 1);
     }
@@ -923,12 +922,12 @@ delete_binary_1: {
         console.log(delete (true && (0 / 0)));
     }
     expect: {
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
+        console.log((void 0, !0));
+        console.log((void 0, !0));
+        console.log((1 / 0, !0));
+        console.log((1 / 0, !0));
+        console.log((NaN, !0));
+        console.log((NaN, !0));
     }
     expect_stdout: true
 }
@@ -949,12 +948,12 @@ delete_binary_2: {
         console.log(delete (false || (0 / 0)));
     }
     expect: {
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
+        console.log((void 0, !0));
+        console.log((void 0, !0));
+        console.log((Infinity, !0));
+        console.log((1 / 0, !0));
+        console.log((NaN, !0));
+        console.log((NaN, !0));
     }
     expect_stdout: true
 }
@@ -990,3 +989,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

@@ -112,8 +112,9 @@ issue_1841_1: {
     expect: {
         var b = 10;
         !function() {
-            for (var key in "hi")
+            for (var key in "hi") {
                 b = 42;
+            }
         }(--b);
         console.log(b);
     }
@@ -138,32 +139,11 @@ issue_1841_2: {
     expect: {
         var b = 10;
         !function(arg) {
-            for (var key in "hi")
+            for (var key in "hi") {
                 arg.baz, b = 42;
+            }
         }(--b);
         console.log(b);
     }
     expect_exact: "42"
 }
-
-function_returning_constant_literal: {
-    options = {
-        reduce_vars: true,
-        unsafe: true,
-        toplevel: true,
-        evaluate: true,
-        cascade: true,
-        unused: true,
-    }
-    input: {
-        function greeter() {
-            return { message: 'Hello there' };
-        }
-        var greeting = greeter();
-        console.log(greeting.message);
-    }
-    expect: {
-        console.log("Hello there");
-    }
-    expect_stdout: "Hello there"
-}

test/compress/global_defs.js

@@ -120,7 +120,7 @@ mixed: {
         properties: true,
     }
     input: {
-        var FOO = { BAR: 0 };
+        const FOO = { BAR: 0 };
         console.log(FOO.BAR);
         console.log(++CONFIG.DEBUG);
         console.log(++CONFIG.VALUE);
@@ -130,7 +130,7 @@ mixed: {
         console.log(CONFIG);
     }
     expect: {
-        var FOO = { BAR: 0 };
+        const FOO = { BAR: 0 };
         console.log("moo");
         console.log(++CONFIG.DEBUG);
         console.log(++CONFIG.VALUE);

test/compress/issue-1041.js

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

test/compress/issue-1321.js

@@ -1,6 +1,6 @@
 issue_1321_no_debug: {
     mangle_props = {
-        keep_quoted: true
+        ignore_quoted: true
     }
     input: {
         var x = {};
@@ -19,7 +19,7 @@ issue_1321_no_debug: {
 
 issue_1321_debug: {
     mangle_props = {
-        keep_quoted: true,
+        ignore_quoted: true,
         debug: ""
     }
     input: {
@@ -39,7 +39,7 @@ issue_1321_debug: {
 
 issue_1321_with_quoted: {
     mangle_props = {
-        keep_quoted: false
+        ignore_quoted: false
     }
     input: {
         var x = {};

test/compress/issue-1446.js

@@ -23,7 +23,7 @@ typeof_eq_undefined: {
 typeof_eq_undefined_ie8: {
     options = {
         comparisons: true,
-        ie8: true,
+        screw_ie8: false
     }
     input: {
         var a = typeof b != "undefined";

test/compress/issue-1588.js

@@ -1,9 +1,9 @@
 screw_ie8: {
     options = {
-        ie8: false,
+        screw_ie8: true,
     }
     mangle = {
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         try { throw "foo"; } catch (x) { console.log(x); }
@@ -16,10 +16,10 @@ screw_ie8: {
 
 support_ie8: {
     options = {
-        ie8: true,
+        screw_ie8: false,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         try { throw "foo"; } catch (x) { console.log(x); }
@@ -85,3 +85,15 @@ 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-1609.js

@@ -18,7 +18,9 @@ chained_evaluation_1: {
     expect: {
         (function() {
             (function() {
-                f(1).bar = 1;
+                var c;
+                c = f(1);
+                c.bar = 1;
             })();
         })();
     }
@@ -44,8 +46,9 @@ chained_evaluation_2: {
     expect: {
         (function() {
             (function() {
-                var b = "long piece of string";
-                f(b).bar = b;
+                var c, b = "long piece of string";
+                c = f(b);
+                c.bar = b;
             })();
         })();
     }

test/compress/issue-1704.js

@@ -1,10 +1,10 @@
 mangle_catch: {
     options = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: false,
     }
     input: {
@@ -22,11 +22,11 @@ mangle_catch: {
 
 mangle_catch_ie8: {
     options = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: false,
     }
     input: {
@@ -44,11 +44,11 @@ mangle_catch_ie8: {
 
 mangle_catch_var: {
     options = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: false,
     }
     input: {
@@ -66,11 +66,11 @@ mangle_catch_var: {
 
 mangle_catch_var_ie8: {
     options = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: false,
     }
     input: {
@@ -88,11 +88,11 @@ mangle_catch_var_ie8: {
 
 mangle_catch_toplevel: {
     options = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: true,
     }
     input: {
@@ -110,11 +110,11 @@ mangle_catch_toplevel: {
 
 mangle_catch_ie8_toplevel: {
     options = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: true,
     }
     input: {
@@ -132,11 +132,11 @@ mangle_catch_ie8_toplevel: {
 
 mangle_catch_var_toplevel: {
     options = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: true,
     }
     input: {
@@ -154,11 +154,11 @@ mangle_catch_var_toplevel: {
 
 mangle_catch_var_ie8_toplevel: {
     options = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: true,
     }
     input: {
@@ -176,11 +176,11 @@ mangle_catch_var_ie8_toplevel: {
 
 mangle_catch_redef_1: {
     options = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: false,
     }
     input: {
@@ -198,11 +198,11 @@ mangle_catch_redef_1: {
 
 mangle_catch_redef_1_ie8: {
     options = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: false,
     }
     input: {
@@ -220,11 +220,11 @@ mangle_catch_redef_1_ie8: {
 
 mangle_catch_redef_1_toplevel: {
     options = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: true,
     }
     input: {
@@ -242,11 +242,11 @@ mangle_catch_redef_1_toplevel: {
 
 mangle_catch_redef_1_ie8_toplevel: {
     options = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: true,
     }
     input: {
@@ -264,11 +264,11 @@ mangle_catch_redef_1_ie8_toplevel: {
 
 mangle_catch_redef_2: {
     options = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: false,
     }
     mangle = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: false,
     }
     input: {
@@ -285,11 +285,11 @@ mangle_catch_redef_2: {
 
 mangle_catch_redef_2_ie8: {
     options = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: false,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: false,
     }
     input: {
@@ -306,11 +306,11 @@ mangle_catch_redef_2_ie8: {
 
 mangle_catch_redef_2_toplevel: {
     options = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: true,
     }
     mangle = {
-        ie8: false,
+        screw_ie8: true,
         toplevel: true,
     }
     input: {
@@ -327,11 +327,11 @@ mangle_catch_redef_2_toplevel: {
 
 mangle_catch_redef_2_ie8_toplevel: {
     options = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: true,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
         toplevel: true,
     }
     input: {

test/compress/issue-1733.js

@@ -1,6 +1,6 @@
 function_iife_catch: {
     mangle = {
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         function f(n) {
@@ -21,7 +21,7 @@ function_iife_catch: {
 
 function_iife_catch_ie8: {
     mangle = {
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         function f(n) {
@@ -42,7 +42,7 @@ function_iife_catch_ie8: {
 
 function_catch_catch: {
     mangle = {
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         var o = 0;
@@ -70,7 +70,7 @@ function_catch_catch: {
 
 function_catch_catch_ie8: {
     mangle = {
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         var o = 0;

test/compress/issue-1787.js

@@ -10,6 +10,10 @@ unary_prefix: {
             return x;
         }());
     }
-    expect_exact: "console.log(-2/3);"
+    expect: {
+        console.log(function() {
+            return -2 / 3;
+        }());
+    }
     expect_stdout: true
 }

test/compress/issue-208.js

@@ -38,7 +38,7 @@ mixed: {
         }
     }
     input: {
-        var ENV = 3;
+        const ENV = 3;
         var FOO = 4;
         f(ENV * 10);
         --FOO;
@@ -49,7 +49,7 @@ mixed: {
         x = DEBUG;
     }
     expect: {
-        var ENV = 3;
+        const 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,12]',
+        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,14]',
         '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/issue-640.js

@@ -159,7 +159,7 @@ negate_iife_4: {
         })();
     }
     expect: {
-        !function(){ return t }() ? console.log(false) : console.log(true), function(){
+        (function(){ return t })() ? console.log(true) : console.log(false), function(){
             console.log("something");
         }();
     }
@@ -183,7 +183,7 @@ negate_iife_5: {
         })();
     }
     expect: {
-        !function(){ return t }() ? bar(false) : foo(true), function(){
+        (function(){ return t })() ? foo(true) : bar(false), function(){
             console.log("something");
         }();
     }
@@ -207,7 +207,7 @@ negate_iife_5_off: {
         })();
     }
     expect: {
-        !function(){ return t }() ? bar(false) : foo(true), function(){
+        (function(){ return t })() ? foo(true) : bar(false), function(){
             console.log("something");
         }();
     }

test/compress/loops.js

@@ -146,6 +146,50 @@ 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,
@@ -201,7 +245,7 @@ issue_1532: {
 issue_186: {
     beautify = {
         beautify: false,
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         var x = 3;
@@ -220,7 +264,7 @@ issue_186: {
 issue_186_ie8: {
     beautify = {
         beautify: false,
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         var x = 3;
@@ -239,7 +283,7 @@ issue_186_ie8: {
 issue_186_beautify: {
     beautify = {
         beautify: true,
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         var x = 3;
@@ -266,7 +310,7 @@ issue_186_beautify: {
 issue_186_beautify_ie8: {
     beautify = {
         beautify: true,
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         var x = 3;
@@ -296,7 +340,7 @@ issue_186_bracketize: {
     beautify = {
         beautify: false,
         bracketize: true,
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         var x = 3;
@@ -316,7 +360,7 @@ issue_186_bracketize_ie8: {
     beautify = {
         beautify: false,
         bracketize: true,
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         var x = 3;
@@ -336,7 +380,7 @@ issue_186_beautify_bracketize: {
     beautify = {
         beautify: true,
         bracketize: true,
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         var x = 3;
@@ -368,7 +412,7 @@ issue_186_beautify_bracketize_ie8: {
     beautify = {
         beautify: true,
         bracketize: true,
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         var x = 3;

test/compress/negate-iife.js

@@ -25,9 +25,11 @@ negate_iife_2: {
         negate_iife: true
     };
     input: {
+        (function(){ return {} })().x = 10; // should not transform this one
+    }
+    expect: {
         (function(){ return {} })().x = 10;
     }
-    expect_exact: "({}).x=10;"
 }
 
 negate_iife_2_side_effects: {
@@ -36,9 +38,11 @@ negate_iife_2_side_effects: {
         side_effects: true,
     }
     input: {
+        (function(){ return {} })().x = 10; // should not transform this one
+    }
+    expect: {
         (function(){ return {} })().x = 10;
     }
-    expect_exact: "({}).x=10;"
 }
 
 negate_iife_3: {

test/compress/properties.js

@@ -13,7 +13,7 @@ keep_properties: {
 dot_properties: {
     options = {
         properties: true,
-        ie8: true,
+        screw_ie8: false
     };
     input: {
         a["foo"] = "bar";
@@ -36,7 +36,7 @@ dot_properties: {
 dot_properties_es5: {
     options = {
         properties: true,
-        ie8: false,
+        screw_ie8: true
     };
     input: {
         a["foo"] = "bar";
@@ -125,7 +125,7 @@ evaluate_string_length: {
 
 mangle_properties: {
     mangle_props = {
-        keep_quoted: false
+        ignore_quoted: false
     };
     input: {
         a["foo"] = "bar";
@@ -148,7 +148,7 @@ mangle_unquoted_properties: {
         properties: false
     }
     mangle_props = {
-        keep_quoted: true
+        ignore_quoted: true
     }
     beautify = {
         beautify: false,
@@ -233,12 +233,12 @@ mangle_debug_suffix: {
     }
 }
 
-mangle_debug_suffix_keep_quoted: {
+mangle_debug_suffix_ignore_quoted: {
     options = {
         properties: false
     }
     mangle_props = {
-        keep_quoted: true,
+        ignore_quoted: true,
         debug: "XYZ",
         reserved: []
     }
@@ -555,3 +555,105 @@ native_prototype: {
         "".indexOf.call(e, "bar");
     }
 }
+
+accessor_boolean: {
+    input: {
+        var a = 1;
+        var b = {
+            get true() {
+                return a;
+            },
+            set false(c) {
+                a = c;
+            }
+        };
+        console.log(b.true, b.false = 2, b.true);
+    }
+    expect_exact: 'var a=1;var b={get true(){return a},set false(c){a=c}};console.log(b.true,b.false=2,b.true);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_get_set: {
+    input: {
+        var a = 1;
+        var b = {
+            get set() {
+                return a;
+            },
+            set get(c) {
+                a = c;
+            }
+        };
+        console.log(b.set, b.get = 2, b.set);
+    }
+    expect_exact: 'var a=1;var b={get set(){return a},set get(c){a=c}};console.log(b.set,b.get=2,b.set);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_null_undefined: {
+    input: {
+        var a = 1;
+        var b = {
+            get null() {
+                return a;
+            },
+            set undefined(c) {
+                a = c;
+            }
+        };
+        console.log(b.null, b.undefined = 2, b.null);
+    }
+    expect_exact: 'var a=1;var b={get null(){return a},set undefined(c){a=c}};console.log(b.null,b.undefined=2,b.null);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_number: {
+    input: {
+        var a = 1;
+        var b = {
+            get 42() {
+                return a;
+            },
+            set 42(c) {
+                a = c;
+            }
+        };
+        console.log(b[42], b[42] = 2, b[42]);
+    }
+    expect_exact: 'var a=1;var b={get 42(){return a},set 42(c){a=c}};console.log(b[42],b[42]=2,b[42]);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_string: {
+    input: {
+        var a = 1;
+        var b = {
+            get "a-b"() {
+                return a;
+            },
+            set "a-b"(c) {
+                a = c;
+            }
+        };
+        console.log(b["a-b"], b["a-b"] = 2, b["a-b"]);
+    }
+    expect_exact: 'var a=1;var b={get"a-b"(){return a},set"a-b"(c){a=c}};console.log(b["a-b"],b["a-b"]=2,b["a-b"]);'
+    expect_stdout: "1 2 2"
+}
+
+accessor_this: {
+    input: {
+        var a = 1;
+        var b = {
+            get this() {
+                return a;
+            },
+            set this(c) {
+                a = c;
+            }
+        };
+        console.log(b.this, b.this = 2, b.this);
+    }
+    expect_exact: 'var a=1;var b={get this(){return a},set this(c){a=c}};console.log(b.this,b.this=2,b.this);'
+    expect_stdout: "1 2 2"
+}

test/compress/reduce_vars.js

@@ -53,7 +53,9 @@ reduce_vars: {
             console.log(a - 5);
             eval("console.log(a);");
         })(eval);
-        "yes";
+        (function() {
+            return "yes";
+        })();
         console.log(A + 1);
     }
     expect_stdout: true
@@ -64,7 +66,7 @@ modified: {
         conditionals  : true,
         evaluate      : true,
         reduce_vars   : true,
-        unused        : true,
+        unused        : true
     }
     input: {
         function f0() {
@@ -134,11 +136,12 @@ modified: {
         }
 
         function f2() {
-            3;
+            var b = 2;
+            b = 3;
+            console.log(1 + b);
+            console.log(b + 3);
             console.log(4);
-            console.log(6);
-            console.log(4);
-            console.log(7);
+            console.log(1 + b + 3);
         }
 
         function f3() {
@@ -387,11 +390,12 @@ passes: {
     }
     expect: {
         function f() {
-            3;
+            var b = 2;
+            b = 3;
+            console.log(1 + b);
+            console.log(b + 3);
             console.log(4);
-            console.log(6);
-            console.log(4);
-            console.log(7);
+            console.log(1 + b + 3);
         }
     }
 }
@@ -584,7 +588,7 @@ inner_var_label: {
     }
 }
 
-inner_var_for_1: {
+inner_var_for: {
     options = {
         evaluate: true,
         reduce_vars: true,
@@ -613,29 +617,6 @@ inner_var_for_1: {
     }
 }
 
-inner_var_for_2: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        !function() {
-            var a = 1;
-            for (var b = 1; --b;) var a = 2;
-            console.log(a);
-        }();
-    }
-    expect: {
-        !function() {
-            a = 1;
-            for (var b = 1; --b;) var a = 2;
-            console.log(a);
-        }();
-    }
-    expect_stdout: "1"
-}
-
 inner_var_for_in_1: {
     options = {
         evaluate: true,
@@ -1673,7 +1654,7 @@ redefine_arguments_1: {
             return typeof arguments;
         }
         function g() {
-            return "number";
+            return"number";
         }
         function h(x) {
             var arguments = x;
@@ -1712,7 +1693,9 @@ redefine_arguments_2: {
         console.log(function() {
             var arguments;
             return typeof arguments;
-        }(), "number", function(x) {
+        }(), function() {
+            return"number";
+        }(), function(x) {
             var arguments = x;
             return typeof arguments;
         }());
@@ -1824,7 +1807,9 @@ redefine_farg_2: {
         console.log(function(a) {
             var a;
             return typeof a;
-        }([]), "number",function(a, b) {
+        }([]), function() {
+            return "number";
+        }(),function(a, b) {
             var a = b;
             return typeof a;
         }([]));
@@ -1861,7 +1846,10 @@ redefine_farg_3: {
         console.log(function(a) {
             var a;
             return typeof a;
-        }([]), "number", "undefined");
+        }([]), "number", function(a) {
+            var a = void 0;
+            return typeof a;
+        }([]));
     }
     expect_stdout: "object number undefined"
 }
@@ -1981,6 +1969,7 @@ pure_getters_2: {
         var a = a && a.b;
     }
     expect: {
+        var a;
         var a = a && a.b;
     }
 }
@@ -2025,176 +2014,14 @@ catch_var: {
     expect_stdout: "true"
 }
 
-var_assign_1: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        !function() {
-            var a;
-            a = 2;
-            console.log(a);
-        }();
-    }
-    expect: {
-        !function() {
-            console.log(2);
-        }();
-    }
-    expect_stdout: "2"
-}
-
-var_assign_2: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        !function() {
-            var a;
-            if (a = 2) console.log(a);
-        }();
-    }
-    expect: {
-        !function() {
-            if (2) console.log(2);
-        }();
-    }
-    expect_stdout: "2"
-}
-
-var_assign_3: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        !function() {
-            var a;
-            while (a = 2);
-            console.log(a);
-        }();
-    }
-    expect: {
-        !function() {
-            var a;
-            while (a = 2);
-            console.log(a);
-        }();
-    }
-}
-
-var_assign_4: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        !function a() {
-            a = 2;
-            console.log(a);
-        }();
-    }
-    expect: {
-        !function a() {
-            a = 2,
-            console.log(a);
-        }();
-    }
-}
-
-var_assign_5: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        !function() {
-            var a;
-            !function(b) {
-                a = 2;
-                console.log(a, b);
-            }(a);
-        }();
-    }
-    expect: {
-        !function() {
-            var a;
-            !function(b) {
-                a = 2,
-                console.log(a, b);
-            }(a);
-        }();
-    }
-    expect_stdout: "2 undefined"
-}
-
-var_assign_6: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        !function() {
-            var a = function(){}(a = 1);
-            console.log(a);
-        }();
-    }
-    expect: {
-        !function() {
-            var a = function(){}(a = 1);
-            console.log(a);
-        }();
-    }
-    expect_stdout: "undefined"
-}
-
-immutable: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        !function() {
-            var a = "test";
-            console.log(a.indexOf("e"));
-        }();
-    }
-    expect: {
-        !function() {
-            console.log("test".indexOf("e"));
-        }();
-    }
-    expect_stdout: "1"
-}
-
 issue_1814_1: {
     options = {
         evaluate: true,
         reduce_vars: true,
-        toplevel: true,
         unused: true,
     }
     input: {
-        var a = 42;
+        const a = 42;
         !function() {
             var b = a;
             !function(a) {
@@ -2203,6 +2030,7 @@ issue_1814_1: {
         }();
     }
     expect: {
+        const a = 42;
         !function() {
             !function(a) {
                 console.log(a++, 42);
@@ -2216,11 +2044,10 @@ issue_1814_2: {
     options = {
         evaluate: true,
         reduce_vars: true,
-        toplevel: true,
         unused: true,
     }
     input: {
-        var a = "32";
+        const a = "32";
         !function() {
             var b = a + 1;
             !function(a) {
@@ -2229,6 +2056,7 @@ issue_1814_2: {
         }();
     }
     expect: {
+        const a = "32";
         !function() {
             !function(a) {
                 console.log(a++, "321");
@@ -2269,173 +2097,6 @@ try_abort: {
     expect_stdout: "1 undefined"
 }
 
-boolean_binary_assign: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        !function() {
-            var a;
-            void 0 && (a = 1);
-            console.log(a);
-        }();
-    }
-    expect: {
-        !function() {
-            var a;
-            void 0;
-            console.log(a);
-        }();
-    }
-    expect_stdout: "undefined"
-}
-
-cond_assign: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        !function() {
-            var a;
-            void 0 ? (a = 1) : 0;
-            console.log(a);
-        }();
-    }
-    expect: {
-        !function() {
-            var a;
-            void 0 ? (a = 1) : 0;
-            console.log(a);
-        }();
-    }
-    expect_stdout: "undefined"
-}
-
-iife_assign: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        !function() {
-            var a = 1, b = 0;
-            !function() {
-                b++;
-                return;
-                a = 2;
-            }();
-            console.log(a);
-        }();
-    }
-    expect: {
-        !function() {
-            var a = 1, b = 0;
-            !function() {
-                b++;
-                return;
-                a = 2;
-            }();
-            console.log(a);
-        }();
-    }
-    expect_stdout: "1"
-}
-
-issue_1850_1: {
-    options = {
-        reduce_vars: true,
-        toplevel: false,
-        unused: true,
-    }
-    input: {
-        function f() {
-            console.log(a, a, a);
-        }
-        var a = 1;
-        f();
-    }
-    expect: {
-        function f() {
-            console.log(a, a, a);
-        }
-        var a = 1;
-        f();
-    }
-    expect_stdout: true
-}
-
-issue_1850_2: {
-    options = {
-        reduce_vars: true,
-        toplevel: "funcs",
-        unused: true,
-    }
-    input: {
-        function f() {
-            console.log(a, a, a);
-        }
-        var a = 1;
-        f();
-    }
-    expect: {
-        var a = 1;
-        (function() {
-            console.log(a, a, a);
-        })();
-    }
-    expect_stdout: true
-}
-
-issue_1850_3: {
-    options = {
-        reduce_vars: true,
-        toplevel: "vars",
-        unused: true,
-    }
-    input: {
-        function f() {
-            console.log(a, a, a);
-        }
-        var a = 1;
-        f();
-    }
-    expect: {
-        function f() {
-            console.log(a, a, a);
-        }
-        var a = 1;
-        f();
-    }
-    expect_stdout: true
-}
-
-issue_1850_4: {
-    options = {
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            console.log(a, a, a);
-        }
-        var a = 1;
-        f();
-    }
-    expect: {
-        var a = 1;
-        (function() {
-            console.log(a, a, a);
-        })();
-    }
-    expect_stdout: true
-}
-
 issue_1865: {
     options = {
         evaluate: true,

test/compress/screw-ie8.js

@@ -1,9 +1,9 @@
 do_screw: {
     options = {
-        ie8: false,
+        screw_ie8: true,
     }
     beautify = {
-        ie8: false,
+        screw_ie8: true,
         ascii_only: true,
     }
     input: {
@@ -14,10 +14,10 @@ do_screw: {
 
 dont_screw: {
     options = {
-        ie8: true,
+        screw_ie8: false,
     }
     beautify = {
-        ie8: true,
+        screw_ie8: false,
         ascii_only: true,
     }
     input: {
@@ -28,7 +28,7 @@ dont_screw: {
 
 do_screw_constants: {
     options = {
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         f(undefined, Infinity);
@@ -38,7 +38,7 @@ do_screw_constants: {
 
 dont_screw_constants: {
     options = {
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         f(undefined, Infinity);
@@ -47,15 +47,9 @@ dont_screw_constants: {
 }
 
 do_screw_try_catch: {
-    options = {
-        ie8: false,
-    }
-    mangle = {
-        ie8: false,
-    }
-    beautify = {
-        ie8: false,
-    }
+    options = { screw_ie8: true };
+    mangle = { screw_ie8: true };
+    beautify = { screw_ie8: true };
     input: {
         good = function(e){
             return function(error){
@@ -81,15 +75,9 @@ do_screw_try_catch: {
 }
 
 dont_screw_try_catch: {
-    options = {
-        ie8: true,
-    }
-    mangle = {
-        ie8: true,
-    }
-    beautify = {
-        ie8: true,
-    }
+    options = { screw_ie8: false };
+    mangle = { screw_ie8: false };
+    beautify = { screw_ie8: false };
     input: {
         bad = function(e){
             return function(error){
@@ -115,15 +103,9 @@ dont_screw_try_catch: {
 }
 
 do_screw_try_catch_undefined: {
-    options = {
-        ie8: false,
-    }
-    mangle = {
-        ie8: false,
-    }
-    beautify = {
-        ie8: false,
-    }
+    options = { screw_ie8: true };
+    mangle = { screw_ie8: true };
+    beautify = { screw_ie8: true };
     input: {
         function a(b){
             try {
@@ -150,15 +132,9 @@ do_screw_try_catch_undefined: {
 }
 
 dont_screw_try_catch_undefined: {
-    options = {
-        ie8: true,
-    }
-    mangle = {
-        ie8: true,
-    }
-    beautify = {
-        ie8: true,
-    }
+    options = { screw_ie8: false };
+    mangle = { screw_ie8: false };
+    beautify = { screw_ie8: false };
     input: {
         function a(b){
             try {
@@ -188,11 +164,11 @@ reduce_vars: {
     options = {
         evaluate: true,
         reduce_vars: true,
-        ie8: true,
+        screw_ie8: false,
         unused: true,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         function f() {
@@ -220,10 +196,10 @@ reduce_vars: {
 
 issue_1586_1: {
     options = {
-        ie8: true,
+        screw_ie8: false,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         function f() {
@@ -239,10 +215,10 @@ issue_1586_1: {
 
 issue_1586_2: {
     options = {
-        ie8: false,
+        screw_ie8: true,
     }
     mangle = {
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         function f() {

test/compress/sequences.js

@@ -460,7 +460,7 @@ issue_1758: {
         console.log(function(c) {
             var undefined = 42;
             return function() {
-                return c--, c--, void c.toString();
+                return c--, c--, c.toString(), void 0;
             }();
         }());
     }
@@ -481,12 +481,12 @@ delete_seq_1: {
         console.log(delete (1, 0 / 0));
     }
     expect: {
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
+        console.log((void 0, !0));
+        console.log((void 0, !0));
+        console.log((1 / 0, !0));
+        console.log((1 / 0, !0));
+        console.log((NaN, !0));
+        console.log((0 / 0, !0));
     }
     expect_stdout: true
 }
@@ -505,12 +505,12 @@ delete_seq_2: {
         console.log(delete (1, 2, 0 / 0));
     }
     expect: {
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
+        console.log((void 0, !0));
+        console.log((void 0, !0));
+        console.log((1 / 0, !0));
+        console.log((1 / 0, !0));
+        console.log((NaN, !0));
+        console.log((0 / 0, !0));
     }
     expect_stdout: true
 }
@@ -530,12 +530,12 @@ delete_seq_3: {
         console.log(delete (1, 2, 0 / 0));
     }
     expect: {
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
+        console.log((void 0, !0));
+        console.log((void 0, !0));
+        console.log((Infinity, !0));
+        console.log((1 / 0, !0));
+        console.log((NaN, !0));
+        console.log((0 / 0, !0));
     }
     expect_stdout: true
 }
@@ -606,107 +606,31 @@ delete_seq_6: {
     }
     expect: {
         var a;
-        console.log(!0);
+        console.log((a, !0));
     }
     expect_stdout: true
 }
 
-side_effects: {
+reassign_const: {
     options = {
+        cascade: true,
         sequences: true,
         side_effects: true,
     }
     input: {
-        0, a(), 1, b(), 2, c(), 3;
+        function f() {
+            const a = 1;
+            a++;
+            return a;
+        }
+        console.log(f());
     }
     expect: {
-        a(), b(), c();
-    }
-}
-
-side_effects_cascade_1: {
-    options = {
-        cascade: true,
-        conditionals: true,
-        sequences: true,
-        side_effects: true,
-    }
-    input: {
-        function f(a, b) {
-            a -= 42;
-            if (a < 0) a = 0;
-            b.a = a;
-        }
-    }
-    expect: {
-        function f(a, b) {
-            (a -= 42) < 0 && (a = 0), b.a = a;
-        }
-    }
-}
-
-side_effects_cascade_2: {
-    options = {
-        cascade: true,
-        side_effects: true,
-    }
-    input: {
-        function f(a, b) {
-            b = a,
-            !a + (b += a) || (b += a),
-            b = a,
-            b;
-        }
-    }
-    expect: {
-        function f(a, b) {
-            b = a,
-            !a + (b += a) || (b += a),
-            b = a;
-        }
-    }
-}
-
-side_effects_cascade_3: {
-    options = {
-        cascade: true,
-        conditionals: true,
-        side_effects: true,
-    }
-    input: {
-        function f(a, b) {
-            "foo" ^ (b += a),
-            b ? false : (b = a) ? -1 : (b -= a) - (b ^= a),
-            a-- || !a,
-            a;
-        }
-    }
-    expect: {
-        function f(a, b) {
-            !(b += a) && ((b = a) || (b -= a, b ^= a)),
-            --a;
-        }
-    }
-}
-
-issue_27: {
-    options = {
-        cascade: true,
-        passes: 2,
-        sequences: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        (function(jQuery) {
-            var $;
-            $ = jQuery;
-            $("body").addClass("foo");
-        })(jQuery);
-    }
-    expect: {
-        (function(jQuery) {
-            jQuery("body").addClass("foo");
-        })(jQuery);
+        function f() {
+            const a = 1;
+            return a++, a;
+        }
+        console.log(f());
     }
+    expect_stdout: true
 }

test/exports.js

@@ -1,13 +0,0 @@
-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/delete.js

@@ -1,14 +0,0 @@
-function f(x) {
-    delete 42;
-    delete (0, x);
-    delete null;
-    delete x;
-}
-
-function g(x) {
-    "use strict";
-    delete 42;
-    delete (0, x);
-    delete null;
-    delete x;
-}

test/input/invalid/function_1.js

@@ -1,6 +0,0 @@
-function f(arguments) {
-}
-
-function g(arguments) {
-    "use strict";
-}

test/input/invalid/function_2.js

@@ -1,6 +0,0 @@
-function arguments() {
-}
-
-function eval() {
-    "use strict";
-}

test/input/invalid/function_3.js

@@ -1,6 +0,0 @@
-!function eval() {
-}();
-
-!function arguments() {
-    "use strict";
-}();

test/input/invalid/try.js

@@ -1,8 +0,0 @@
-function f() {
-    try {} catch (eval) {}
-}
-
-function g() {
-    "use strict";
-    try {} catch (eval) {}
-}

test/input/invalid/var.js

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

test/jetstream.js

@@ -12,7 +12,7 @@ if (typeof phantom == "undefined") {
     });
     var args = process.argv.slice(2);
     if (!args.length) {
-        args.push("-mc");
+        args.push("-mc", "warnings=false");
     }
     args.push("--stats");
     var child_process = require("child_process");

test/mocha/accessorTokens-1492.js

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

test/mocha/arguments.js

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

test/mocha/cli.js

@@ -2,10 +2,6 @@ var assert = require("assert");
 var exec = require("child_process").exec;
 var readFileSync = require("fs").readFileSync;
 
-function read(path) {
-    return readFileSync(path, "utf8");
-}
-
 describe("bin/uglifyjs", function () {
     var uglifyjscmd = '"' + process.argv[0] + '" bin/uglifyjs';
     it("should produce a functional build when using --self", function (done) {
@@ -19,12 +15,12 @@ describe("bin/uglifyjs", function () {
             eval(stdout);
 
             assert.strictEqual(typeof WrappedUglifyJS, 'object');
-            assert.strictEqual(WrappedUglifyJS.minify("foo([true,,2+3]);").code, "foo([!0,,5]);");
+            assert.strictEqual(true, WrappedUglifyJS.parse('foo;') instanceof WrappedUglifyJS.AST_Node);
 
             done();
         });
     });
-    it("Should be able to filter comments correctly with `--comments all`", function (done) {
+    it("Should be able to filter comments correctly with `--comment all`", function (done) {
         var command = uglifyjscmd + ' test/input/comments/filter.js --comments all';
 
         exec(command, function (err, stdout) {
@@ -54,8 +50,8 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
-    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";
+    it("Should append source map to output when using --source-map-inline", function (done) {
+        var command = uglifyjscmd + ' test/input/issue-1323/sample.js --source-map-inline';
 
         exec(command, function (err, stdout) {
             if (err) throw err;
@@ -65,7 +61,7 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
-    it("should not append source map to output when not using --source-map url=inline", function (done) {
+    it("should not append source map to output when not using --source-map-inline", function (done) {
         var command = uglifyjscmd + ' test/input/issue-1323/sample.js';
 
         exec(command, function (err, stdout) {
@@ -141,7 +137,7 @@ describe("bin/uglifyjs", function () {
         exec(command, function (err, stdout) {
             if (err) throw err;
 
-            assert.strictEqual(stdout, read("test/input/issue-1482/default.js"));
+            assert.strictEqual(stdout, readFileSync("test/input/issue-1482/default.js", "utf8"));
             done();
         });
     });
@@ -151,59 +147,55 @@ describe("bin/uglifyjs", function () {
         exec(command, function (err, stdout) {
             if (err) throw err;
 
-            assert.strictEqual(stdout, read("test/input/issue-1482/bracketize.js"));
+            assert.strictEqual(stdout, readFileSync("test/input/issue-1482/bracketize.js", "utf8"));
             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";
+        var command = uglifyjscmd + ' test/input/issue-520/input.js -mc toplevel --in-source-map inline --source-map-inline';
 
         exec(command, function (err, stdout) {
             if (err) throw err;
 
-            assert.strictEqual(stdout, read("test/input/issue-520/output.js"));
+            assert.strictEqual(stdout, readFileSync("test/input/issue-520/output.js", "utf8"));
             done();
         });
     });
     it("Should warn for missing inline source map", function(done) {
-        var command = uglifyjscmd + " test/input/issue-1323/sample.js --source-map content=inline,url=inline";
+        var command = uglifyjscmd + ' test/input/issue-1323/sample.js --in-source-map inline';
 
         exec(command, function (err, stdout, stderr) {
             if (err) throw err;
 
-            assert.strictEqual(stdout, [
-                "var bar=function(){function foo(bar){return bar}return foo}();",
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=",
-                "",
-            ].join("\n"));
+            assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n");
             assert.strictEqual(stderr, "WARN: inline source map not found\n");
             done();
         });
     });
     it("Should fail with multiple input and inline source map", function(done) {
-        var command = uglifyjscmd + " test/input/issue-520/input.js test/input/issue-520/output.js --source-map content=inline,url=inline";
+        var command = uglifyjscmd + ' test/input/issue-520/input.js test/input/issue-520/output.js --in-source-map inline --source-map-inline';
 
         exec(command, function (err, stdout, stderr) {
             assert.ok(err);
-            assert.strictEqual(stderr.split(/\n/)[0], "ERROR: inline source map only works with singular input");
+            assert.strictEqual(stderr, "ERROR: Inline source map only works with singular input\n");
             done();
         });
     });
     it("Should fail with acorn and inline source map", function(done) {
-        var command = uglifyjscmd + " test/input/issue-520/input.js --source-map content=inline,url=inline -p acorn";
+        var command = uglifyjscmd + ' test/input/issue-520/input.js --in-source-map inline --source-map-inline --acorn';
 
         exec(command, function (err, stdout, stderr) {
             assert.ok(err);
-            assert.strictEqual(stderr, "ERROR: inline source map only works with built-in parser\n");
+            assert.strictEqual(stderr, "ERROR: Inline source map only works with built-in parser\n");
             done();
         });
     });
     it("Should fail with SpiderMonkey and inline source map", function(done) {
-        var command = uglifyjscmd + " test/input/issue-520/input.js --source-map content=inline,url=inline -p spidermonkey";
+        var command = uglifyjscmd + ' test/input/issue-520/input.js --in-source-map inline --source-map-inline --spidermonkey';
 
         exec(command, function (err, stdout, stderr) {
             assert.ok(err);
-            assert.strictEqual(stderr, "ERROR: inline source map only works with built-in parser\n");
+            assert.strictEqual(stderr, "ERROR: Inline source map only works with built-in parser\n");
             done();
         });
     });
@@ -216,7 +208,7 @@ describe("bin/uglifyjs", function () {
             assert.strictEqual(lines[0], "Parse error at test/input/invalid/simple.js:1,12");
             assert.strictEqual(lines[1], "function f(a{}");
             assert.strictEqual(lines[2], "            ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token punc «{», expected punc «,»");
+            assert.strictEqual(lines[3], "SyntaxError: Unexpected token punc «{», expected punc «,»");
             done();
         });
     });
@@ -229,7 +221,7 @@ describe("bin/uglifyjs", function () {
             assert.strictEqual(lines[0], "Parse error at test/input/invalid/tab.js:1,12");
             assert.strictEqual(lines[1], "\t\tfoo(\txyz, 0abc);");
             assert.strictEqual(lines[2], "\t\t    \t     ^");
-            assert.strictEqual(lines[3], "ERROR: Invalid syntax: 0abc");
+            assert.strictEqual(lines[3], "SyntaxError: Invalid syntax: 0abc");
             done();
         });
     });
@@ -242,7 +234,7 @@ describe("bin/uglifyjs", function () {
             assert.strictEqual(lines[0], "Parse error at test/input/invalid/eof.js:2,0");
             assert.strictEqual(lines[1], "foo, bar(");
             assert.strictEqual(lines[2], "         ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: eof (undefined)");
+            assert.strictEqual(lines[3], "SyntaxError: Unexpected token: eof (undefined)");
             done();
         });
     });
@@ -255,7 +247,17 @@ describe("bin/uglifyjs", function () {
             assert.strictEqual(lines[0], "Parse error at test/input/invalid/loop-no-body.js:2,0");
             assert.strictEqual(lines[1], "for (var i = 0; i < 1; i++) ");
             assert.strictEqual(lines[2], "                            ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: eof (undefined)");
+            assert.strictEqual(lines[3], "SyntaxError: Unexpected token: eof (undefined)");
+            done();
+        });
+    });
+    it("Should support hyphen as shorthand", function(done) {
+        var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep-fnames=true';
+
+        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();
         });
     });
@@ -269,7 +271,7 @@ describe("bin/uglifyjs", function () {
                 "Parse error at test/input/invalid/assign_1.js:1,18",
                 "console.log(1 || 5--);",
                 "                  ^",
-                "ERROR: Invalid use of -- operator"
+                "SyntaxError: Invalid use of -- operator"
             ].join("\n"));
             done();
         });
@@ -284,7 +286,7 @@ describe("bin/uglifyjs", function () {
                 "Parse error at test/input/invalid/assign_2.js:1,32",
                 "console.log(2 || (Math.random() /= 2));",
                 "                                ^",
-                "ERROR: Invalid assignment"
+                "SyntaxError: Invalid assignment"
             ].join("\n"));
             done();
         });
@@ -299,7 +301,7 @@ describe("bin/uglifyjs", function () {
                 "Parse error at test/input/invalid/assign_3.js:1,17",
                 "console.log(3 || ++this);",
                 "                 ^",
-                "ERROR: Invalid use of ++ operator"
+                "SyntaxError: Invalid use of ++ operator"
             ].join("\n"));
             done();
         });
@@ -314,7 +316,7 @@ describe("bin/uglifyjs", function () {
                 "Parse error at test/input/invalid/assign_4.js:1,0",
                 "++null",
                 "^",
-                "ERROR: Invalid use of ++ operator"
+                "SyntaxError: Invalid use of ++ operator"
             ].join("\n"));
             done();
         });
@@ -329,7 +331,7 @@ describe("bin/uglifyjs", function () {
                 "Parse error at test/input/invalid/dot_1.js:1,2",
                 "a.=",
                 "  ^",
-                "ERROR: Unexpected token: operator (=)"
+                "SyntaxError: Unexpected token: operator (=)"
             ].join("\n"));
             done();
         });
@@ -344,7 +346,7 @@ describe("bin/uglifyjs", function () {
                 "Parse error at test/input/invalid/dot_2.js:1,0",
                 "%.a;",
                 "^",
-                "ERROR: Unexpected token: operator (%)"
+                "SyntaxError: Unexpected token: operator (%)"
             ].join("\n"));
             done();
         });
@@ -359,7 +361,7 @@ describe("bin/uglifyjs", function () {
                 "Parse error at test/input/invalid/dot_3.js:1,2",
                 "a./();",
                 "  ^",
-                "ERROR: Unexpected token: operator (/)"
+                "SyntaxError: Unexpected token: operator (/)"
             ].join("\n"));
             done();
         });
@@ -374,97 +376,7 @@ describe("bin/uglifyjs", function () {
                 "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';
-
-        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';
-
-        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';
-
-        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';
-
-        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';
-
-        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';
-
-        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"
+                "SyntaxError: Unexpected token: operator (%)"
             ].join("\n"));
             done();
         });
@@ -479,7 +391,7 @@ describe("bin/uglifyjs", function () {
                 "Parse error at test/input/invalid/else.js:1,7",
                 "if (0) else 1;",
                 "       ^",
-                "ERROR: Unexpected token: keyword (else)"
+                "SyntaxError: Unexpected token: keyword (else)"
             ].join("\n"));
             done();
         });
@@ -494,45 +406,9 @@ describe("bin/uglifyjs", function () {
                 "Parse error at test/input/invalid/return.js:1,0",
                 "return 42;",
                 "^",
-                "ERROR: 'return' outside of function"
+                "SyntaxError: 'return' outside of function"
             ].join("\n"));
             done();
         });
     });
-    it("Should handle literal string as source map input", function(done) {
-        var command = [
-            uglifyjscmd,
-            "test/input/issue-1236/simple.js",
-            "--source-map",
-            'content="' + read_map() + '",url=inline'
-        ].join(" ");
-
-        exec(command, function (err, stdout) {
-            if (err) throw err;
-
-            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",
-                ""
-            ].join("\n"));
-            done();
-        });
-
-        function read_map() {
-            var map = JSON.parse(read("./test/input/issue-1236/simple.js.map"));
-            delete map.sourcesContent;
-            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("../node");
+var UglifyJS = require('../../');
 var assert = require("assert");
 
 describe("comment filters", function() {
@@ -75,6 +75,7 @@ describe("comment filters", function() {
 
     it("Should handle shebang and preamble correctly", function() {
         var code = UglifyJS.minify("#!/usr/bin/node\nvar x = 10;", {
+            fromString: true,
             output: { preamble: "/* Build */" }
         }).code;
         assert.strictEqual(code, "#!/usr/bin/node\n/* Build */\nvar x=10;");
@@ -82,6 +83,7 @@ describe("comment filters", function() {
 
     it("Should handle preamble without shebang correctly", function() {
         var code = UglifyJS.minify("var x = 10;", {
+            fromString: true,
             output: { preamble: "/* Build */" }
         }).code;
         assert.strictEqual(code, "/* Build */\nvar x=10;");

test/mocha/comment.js

@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../node");
+var uglify = require("../../");
 
 describe("Comment", function() {
     it("Should recognize eol of single line comments", function() {
@@ -20,7 +20,7 @@ describe("Comment", function() {
 
         for (var i = 0; i < tests.length; i++) {
             assert.throws(function() {
-                uglify.parse(tests[i]);
+                uglify.parse(tests[i], {fromString: true})
             }, fail, tests[i]);
         }
     });
@@ -43,7 +43,7 @@ describe("Comment", function() {
 
         for (var i = 0; i < tests.length; i++) {
             assert.throws(function() {
-                uglify.parse(tests[i]);
+                uglify.parse(tests[i], {fromString: true})
             }, fail, tests[i]);
         }
     });

test/mocha/comment_before_constant.js

@@ -6,7 +6,9 @@ describe("comment before constant", function() {
 
     it("Should test comment before constant is retained and output after mangle.", function() {
         var result = Uglify.minify(js, {
+            fromString: true,
             compress: { collapse_vars: false, reduce_vars: false },
+            mangle: {},
             output: { comments: true },
         });
         assert.strictEqual(result.code, 'function f(){/*c1*/var/*c2*/n=/*c3*/!1;return n}');
@@ -14,9 +16,12 @@ describe("comment before constant", function() {
 
     it("Should test code works when comments disabled.", function() {
         var result = Uglify.minify(js, {
+            fromString: true,
             compress: { collapse_vars: false, reduce_vars: false },
+            mangle: {},
             output: { comments: false },
         });
         assert.strictEqual(result.code, 'function f(){var n=!1;return n}');
     });
 });
+

test/mocha/directives.js

@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../node");
+var uglify = require("../../");
 
 describe("Directives", function() {
     it ("Should allow tokenizer to store directives state", function() {
@@ -197,7 +197,7 @@ describe("Directives", function() {
         assert.strictEqual(
             uglify.minify(
                 '"use strict";\'use strict\';"use strict";"use strict";;\'use strict\';console.log(\'use strict\');',
-                {output: {beautify: true, quote_style: 3}, compress: false}
+                {fromString: true, output: {beautify: true, quote_style: 3}, compress: false}
             ).code,
             '"use strict";\n\n\'use strict\';\n\n"use strict";\n\n"use strict";\n\n;\'use strict\';\n\nconsole.log(\'use strict\');'
         );
@@ -225,7 +225,7 @@ describe("Directives", function() {
 
         for (var i = 0; i < tests.length; i++) {
             assert.strictEqual(
-                uglify.minify(tests[i][0], {compress: false, mangle: false}).code,
+                uglify.minify(tests[i][0], {fromString: true, quote_style: 3, compress: false, mangle: false}).code,
                 tests[i][1],
                 tests[i][0]
             );
@@ -234,7 +234,7 @@ describe("Directives", function() {
 
     it("Should add double semicolon when relying on automatic semicolon insertion", function() {
         var code = uglify.minify('"use strict";"use\\x20strict";',
-            {output: {semicolons: false}, compress: false}
+            {fromString: true, output: {semicolons: false}, compress: false}
         ).code;
         assert.strictEqual(code, '"use strict";;"use strict"\n');
     });
@@ -340,7 +340,7 @@ describe("Directives", function() {
         ];
         for (var i = 0; i < tests.length; i++) {
             assert.strictEqual(
-                uglify.minify(tests[i][0], {output:{quote_style: tests[i][1]}, compress: false}).code,
+                uglify.minify(tests[i][0], {fromString: true, output:{quote_style: tests[i][1]}, compress: false}).code,
                 tests[i][2],
                 tests[i][0] + " using mode " + tests[i][1]
             );
@@ -372,7 +372,7 @@ describe("Directives", function() {
 
         for (var i = 0; i < tests.length; i++) {
             assert.strictEqual(
-                uglify.minify(tests[i][0]).code,
+                uglify.minify(tests[i][0], {fromString: true}).code,
                 tests[i][1],
                 tests[i][0]
             );

test/mocha/getter-setter.js

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

test/mocha/glob.js

@@ -1,80 +1,58 @@
+var Uglify = require('../../');
 var assert = require("assert");
-var exec = require("child_process").exec;
 var path = require("path");
-var readFileSync = require("fs").readFileSync;
 
-describe("bin/uglifyjs with input file globs", function() {
-    var uglifyjscmd = '"' + process.argv[0] + '" bin/uglifyjs';
-    it("bin/uglifyjs with one input file extension glob.", function(done) {
-        var command = uglifyjscmd + ' "test/input/issue-1242/foo.*" -cm';
-
-        exec(command, function(err, stdout) {
-            if (err) throw err;
-
-            assert.strictEqual(stdout, 'function foo(o){print("Foo:",2*o)}var print=console.log.bind(console);\n');
-            done();
-        });
+describe("minify() with input file globs", function() {
+    it("minify() with one input file glob string.", function() {
+        var result = Uglify.minify("test/input/issue-1242/foo.*");
+        assert.strictEqual(result.code, 'function foo(o){print("Foo:",2*o)}var print=console.log.bind(console);');
     });
-    it("bin/uglifyjs with one input file name glob.", function(done) {
-        var command = uglifyjscmd + ' "test/input/issue-1242/b*.es5" -cm';
-
-        exec(command, function(err, stdout) {
-            if (err) throw err;
-
-            assert.strictEqual(stdout, 'function bar(n){return 3*n}function baz(n){return n/2}\n');
-            done();
-        });
+    it("minify() with an array of one input file glob.", function() {
+        var result = Uglify.minify([
+            "test/input/issue-1242/b*.es5",
+        ]);
+        assert.strictEqual(result.code, 'function bar(n){return 3*n}function baz(n){return n/2}');
     });
-    it("bin/uglifyjs with multiple input file globs.", function(done) {
-        var command = uglifyjscmd + ' "test/input/issue-1242/???.es5" "test/input/issue-1242/*.js" -mc toplevel';
-
-        exec(command, function(err, stdout) {
-            if (err) throw err;
-
-            assert.strictEqual(stdout, 'var print=console.log.bind(console),a=function(n){return 3*n}(3),b=function(n){return n/2}(12);print("qux",a,b),function(n){print("Foo:",2*n)}(11);\n');
-            done();
+    it("minify() with an array of multiple input file globs.", function() {
+        var result = Uglify.minify([
+            "test/input/issue-1242/???.es5",
+            "test/input/issue-1242/*.js",
+        ], {
+            compress: { toplevel: true }
         });
+        assert.strictEqual(result.code, 'var print=console.log.bind(console),a=function(n){return 3*n}(3),b=function(n){return n/2}(12);print("qux",a,b),function(n){print("Foo:",2*n)}(11);');
     });
-    it("should throw with non-matching glob string", function(done) {
-        var command = uglifyjscmd + ' "test/input/issue-1242/blah.*"';
-
-        exec(command, function(err, stdout, stderr) {
-            assert.ok(err);
-            assert.ok(/^ERROR: ENOENT/.test(stderr));
-            done();
-        });
+    it("should throw with non-matching glob string", function() {
+        var glob = "test/input/issue-1242/blah.*";
+        assert.strictEqual(Uglify.simple_glob(glob).length, 1);
+        assert.strictEqual(Uglify.simple_glob(glob)[0], glob);
+        assert.throws(function() {
+            Uglify.minify(glob);
+        }, "should throw file not found");
     });
-    it('"?" in glob string should not match "/"', function(done) {
-        var command = uglifyjscmd + ' "test/input?issue-1242/foo.*"';
-
-        exec(command, function(err, stdout, stderr) {
-            assert.ok(err);
-            assert.ok(/^ERROR: ENOENT/.test(stderr));
-            done();
-        });
+    it('"?" in glob string should not match "/"', function() {
+        var glob = "test/input?issue-1242/foo.*";
+        assert.strictEqual(Uglify.simple_glob(glob).length, 1);
+        assert.strictEqual(Uglify.simple_glob(glob)[0], glob);
+        assert.throws(function() {
+            Uglify.minify(glob);
+        }, "should throw file not found");
     });
-    it("should handle special characters in glob string", function(done) {
-        var command = uglifyjscmd + ' "test/input/issue-1632/^{*}[???](*)+$.??" -cm';
-
-        exec(command, function(err, stdout) {
-            if (err) throw err;
-
-            assert.strictEqual(stdout, "console.log(x);\n");
-            done();
-        });
+    it("should handle special characters in glob string", function() {
+        var result = Uglify.minify("test/input/issue-1632/^{*}[???](*)+$.??");
+        assert.strictEqual(result.code, "console.log(x);");
     });
-    it("should handle array of glob strings - matching and otherwise", function(done) {
+    it("should handle array of glob strings - matching and otherwise", function() {
         var dir = "test/input/issue-1242";
-        var command = uglifyjscmd + ' "' + [
+        var matches = Uglify.simple_glob([
             path.join(dir, "b*.es5"),
             path.join(dir, "z*.es5"),
-            path.join(dir, "*.js")
-        ].join('" "') + '"';
-
-        exec(command, function(err, stdout, stderr) {
-            assert.ok(err);
-            assert.ok(/^ERROR: ENOENT.*?z\*\.es5/.test(stderr));
-            done();
-        });
+            path.join(dir, "*.js"),
+        ]);
+        assert.strictEqual(matches.length, 4);
+        assert.strictEqual(matches[0], path.join(dir, "bar.es5"));
+        assert.strictEqual(matches[1], path.join(dir, "baz.es5"));
+        assert.strictEqual(matches[2], path.join(dir, "z*.es5"));
+        assert.strictEqual(matches[3], path.join(dir, "qux.js"));
     });
 });

test/mocha/huge-number-of-comments.js

@@ -8,7 +8,12 @@ describe("Huge number of comments.", function() {
         for (i = 1; i <= 5000; ++i) { js += "// " + i + "\n"; }
         for (; i <= 10000; ++i) { js += "/* " + i + " */ /**/"; }
         js += "x; }";
-        var result = Uglify.minify(js, { mangle: false });
+        var result = Uglify.minify(js, {
+            fromString: true,
+            mangle: false,
+            compress: {}
+        });
         assert.strictEqual(result.code, "function lots_of_comments(x){return 7-x}");
     });
 });
+

test/mocha/input-sourcemaps.js

@@ -25,9 +25,9 @@ describe("input sourcemaps", function() {
         transpilemap = sourceMap || getMap();
 
         var result = Uglify.minify(transpiled, {
-            sourceMap: {
-                content: transpilemap
-            }
+            fromString: true,
+            inSourceMap: transpilemap,
+            outSourceMap: true
         });
 
         map = new SourceMapConsumer(result.map);

test/mocha/let.js

@@ -11,7 +11,7 @@ describe("let", function() {
             s += "var v" + i + "=0;";
         }
         s += '}';
-        var result = Uglify.minify(s, {compress: false});
+        var result = Uglify.minify(s, {fromString: true, compress: false});
 
         // Verify that select keywords and reserved keywords not produced
         assert.strictEqual(result.code.indexOf("var let="), -1);

test/mocha/line-endings.js

@@ -1,10 +1,11 @@
-var Uglify = require("../node");
+var Uglify = require('../../');
 var assert = require("assert");
 
 describe("line-endings", function() {
     var options = {
-        compress: false,
+        fromString: true,
         mangle: false,
+        compress: false,
         output: {
             beautify: false,
             comments: /^!/,

test/mocha/minify-file-map.js

@@ -6,41 +6,43 @@ describe("Input file as map", function() {
         var jsMap = {
             '/scripts/foo.js': 'var foo = {"x": 1, y: 2, \'z\': 3};'
         };
-        var result = Uglify.minify(jsMap, {sourceMap: true});
+        var result = Uglify.minify(jsMap, {fromString: true, outSourceMap: true});
 
         var map = JSON.parse(result.map);
         assert.strictEqual(result.code, 'var foo={x:1,y:2,z:3};');
         assert.deepEqual(map.sources, ['/scripts/foo.js']);
         assert.strictEqual(map.file, undefined);
 
-        result = Uglify.minify(jsMap);
-        assert.strictEqual(result.map, undefined);
+        result = Uglify.minify(jsMap, {fromString: true, outFileName: 'out.js'});
+        assert.strictEqual(result.map, null);
 
-        result = Uglify.minify(jsMap, {sourceMap: {filename: 'out.js'}});
+        result = Uglify.minify(jsMap, {fromString: true, outFileName: 'out.js', outSourceMap: true});
         map = JSON.parse(result.map);
         assert.strictEqual(map.file, 'out.js');
     });
 
-    it("Should accept array of strings", function() {
+    it("Should accept array of objects and strings", function() {
         var jsSeq = [
-            'var foo = {"x": 1, y: 2, \'z\': 3};',
+            {'/scripts/foo.js': 'var foo = {"x": 1, y: 2, \'z\': 3};'},
             'var bar = 15;'
         ];
-        var result = Uglify.minify(jsSeq, {sourceMap: true});
+        var result = Uglify.minify(jsSeq, {fromString: true, outSourceMap: true});
 
         var map = JSON.parse(result.map);
         assert.strictEqual(result.code, 'var foo={x:1,y:2,z:3},bar=15;');
-        assert.deepEqual(map.sources, ['0', '1']);
+        assert.strictEqual(map.sources[0], '/scripts/foo.js');
     });
 
     it("Should correctly include source", function() {
-        var jsMap = {
-            '/scripts/foo.js': 'var foo = {"x": 1, y: 2, \'z\': 3};'
-        };
-        var result = Uglify.minify(jsMap, {sourceMap: {includeSources: true}});
+        var jsSeq = [
+            {'/scripts/foo.js': 'var foo = {"x": 1, y: 2, \'z\': 3};'},
+            'var bar = 15;'
+        ];
+        var result = Uglify.minify(jsSeq, {fromString: true, outSourceMap: true, sourceMapIncludeSources: true});
 
         var map = JSON.parse(result.map);
-        assert.strictEqual(result.code, 'var foo={x:1,y:2,z:3};');
-        assert.deepEqual(map.sourcesContent, ['var foo = {"x": 1, y: 2, \'z\': 3};']);
+        assert.strictEqual(result.code, 'var foo={x:1,y:2,z:3},bar=15;');
+        assert.deepEqual(map.sourcesContent, ['var foo = {"x": 1, y: 2, \'z\': 3};', 'var bar = 15;']);
     });
+
 });

test/mocha/minify.js

@@ -2,14 +2,10 @@ var Uglify = require('../../');
 var assert = require("assert");
 var readFileSync = require("fs").readFileSync;
 
-function read(path) {
-    return readFileSync(path, "utf8");
-}
-
 describe("minify", function() {
     it("Should test basic sanity of minify with default options", function() {
         var js = 'function foo(bar) { if (bar) return 3; else return 7; var u = not_called(); }';
-        var result = Uglify.minify(js);
+        var result = Uglify.minify(js, {fromString: true});
         assert.strictEqual(result.code, 'function foo(n){return n?3:7}');
     });
 
@@ -17,7 +13,7 @@ describe("minify", function() {
         it("Should preserve quotes in object literals", function() {
             var js = 'var foo = {"x": 1, y: 2, \'z\': 3};';
             var result = Uglify.minify(js, {
-                output: {
+                fromString: true, output: {
                     keep_quoted_props: true
                 }});
             assert.strictEqual(result.code, 'var foo={"x":1,y:2,"z":3};');
@@ -26,7 +22,7 @@ describe("minify", function() {
         it("Should preserve quote styles when quote_style is 3", function() {
             var js = 'var foo = {"x": 1, y: 2, \'z\': 3};';
             var result = Uglify.minify(js, {
-                output: {
+                fromString: true, output: {
                     keep_quoted_props: true,
                     quote_style: 3
                 }});
@@ -36,7 +32,7 @@ describe("minify", function() {
         it("Should not preserve quotes in object literals when disabled", function() {
             var js = 'var foo = {"x": 1, y: 2, \'z\': 3};';
             var result = Uglify.minify(js, {
-                output: {
+                fromString: true, output: {
                     keep_quoted_props: false,
                     quote_style: 3
                 }});
@@ -48,13 +44,12 @@ describe("minify", function() {
         it("Shouldn't mangle quoted properties", function() {
             var js = 'a["foo"] = "bar"; a.color = "red"; x = {"bar": 10};';
             var result = Uglify.minify(js, {
+                fromString: true,
                 compress: {
                     properties: false
                 },
-                mangle: {
-                    properties: {
-                        keep_quoted: true
-                    }
+                mangleProperties: {
+                    ignore_quoted: true
                 },
                 output: {
                     keep_quoted_props: true,
@@ -68,12 +63,10 @@ describe("minify", function() {
 
     describe("inSourceMap", function() {
         it("Should read the given string filename correctly when sourceMapIncludeSources is enabled (#1236)", function() {
-            var result = Uglify.minify(read("./test/input/issue-1236/simple.js"), {
-                sourceMap: {
-                    content: read("./test/input/issue-1236/simple.js.map"),
-                    filename: "simple.min.js",
-                    includeSources: true
-                }
+            var result = Uglify.minify('./test/input/issue-1236/simple.js', {
+                outSourceMap: "simple.min.js.map",
+                inSourceMap: "./test/input/issue-1236/simple.js.map",
+                sourceMapIncludeSources: true
             });
 
             var map = JSON.parse(result.map);
@@ -84,12 +77,10 @@ describe("minify", function() {
                 'let foo = x => "foo " + x;\nconsole.log(foo("bar"));');
         });
         it("Should process inline source map", function() {
-            var code = Uglify.minify(read("./test/input/issue-520/input.js"), {
+            var code = Uglify.minify("./test/input/issue-520/input.js", {
                 compress: { toplevel: true },
-                sourceMap: {
-                    content: "inline",
-                    url: "inline"
-                }
+                inSourceMap: "inline",
+                sourceMapInline: true
             }).code + "\n";
             assert.strictEqual(code, readFileSync("test/input/issue-520/output.js", "utf8"));
         });
@@ -100,11 +91,9 @@ describe("minify", function() {
                 warnings.push(txt);
             };
             try {
-                var result = Uglify.minify(read("./test/input/issue-1323/sample.js"), {
+                var result = Uglify.minify("./test/input/issue-1323/sample.js", {
+                    inSourceMap: "inline",
                     mangle: false,
-                    sourceMap: {
-                        content: "inline"
-                    }
                 });
                 assert.strictEqual(result.code, "var bar=function(){function foo(bar){return bar}return foo}();");
                 assert.strictEqual(warnings.length, 1);
@@ -114,34 +103,41 @@ describe("minify", function() {
             }
         });
         it("Should fail with multiple input and inline source map", function() {
-            var result = Uglify.minify([
-                read("./test/input/issue-520/input.js"),
-                read("./test/input/issue-520/output.js")
-            ], {
-                sourceMap: {
-                    content: "inline",
-                    url: "inline"
-                }
+            assert.throws(function() {
+                Uglify.minify([
+                    "./test/input/issue-520/input.js",
+                    "./test/input/issue-520/output.js"
+                ], {
+                    inSourceMap: "inline",
+                    sourceMapInline: true
+                });
+            });
+        });
+        it("Should fail with SpiderMonkey and inline source map", function() {
+            assert.throws(function() {
+                Uglify.minify("./test/input/issue-520/input.js", {
+                    inSourceMap: "inline",
+                    sourceMapInline: true,
+                    spidermonkey: true
+                });
             });
-            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");
         });
     });
 
     describe("sourceMapInline", function() {
         it("should append source map to output js when sourceMapInline is enabled", function() {
             var result = Uglify.minify('var a = function(foo) { return foo; };', {
-                sourceMap: {
-                    url: "inline"
-                }
+                fromString: true,
+                sourceMapInline: true
             });
             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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIj8iXSwibmFtZXMiOlsiYSIsImZvbyJdLCJtYXBwaW5ncyI6IkFBQUEsR0FBSUEsR0FBSSxTQUFTQyxHQUFPLE1BQU9BIn0=");
         });
         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 result = Uglify.minify('var a = function(foo) { return foo; };', {
+                fromString: true
+            });
             var code = result.code;
             assert.strictEqual(code, "var a=function(n){return n};");
         });
@@ -150,6 +146,7 @@ describe("minify", function() {
     describe("#__PURE__", function() {
         it("should drop #__PURE__ hint after use", function() {
             var result = Uglify.minify('//@__PURE__ comment1 #__PURE__ comment2\n foo(), bar();', {
+                fromString: true,
                 output: {
                     comments: "all",
                     beautify: false,
@@ -160,6 +157,7 @@ describe("minify", function() {
         });
         it("should not drop #__PURE__ hint if function is retained", function() {
             var result = Uglify.minify("var a = /*#__PURE__*/(function(){ foo(); })();", {
+                fromString: true,
                 output: {
                     comments: "all",
                     beautify: false,
@@ -171,14 +169,27 @@ describe("minify", function() {
     });
 
     describe("JS_Parse_Error", function() {
-        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);
+        it("should throw syntax error", function() {
+            assert.throws(function() {
+                Uglify.minify("function f(a{}", { fromString: true });
+            }, 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;
+            });
         });
     });
+
+    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)}");
+        });
+    })
+
 });

test/mocha/new.js

@@ -34,6 +34,7 @@ describe("New", function() {
         for (var i = 0; i < tests.length; i++) {
             assert.strictEqual(
                 uglify.minify(tests[i], {
+                    fromString: true,
                     output: {beautify: true},
                     compress: false,
                     mangle: false
@@ -75,6 +76,7 @@ describe("New", function() {
         for (var i = 0; i < tests.length; i++) {
             assert.strictEqual(
                 uglify.minify(tests[i], {
+                    fromString: true,
                     output: {beautify: false},
                     compress: false,
                     mangle: false

test/mocha/number-literal.js

@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../node");
+var uglify = require("../../");
 
 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("../node");
+var UglifyJS = require("../../");
 var assert = require("assert");
 
 describe("operator", function() {

test/mocha/release.js

@@ -42,8 +42,8 @@ describe("test/jetstream.js", function() {
         run("npm", ["install", "phantomjs-prebuilt@2.1.14"], done);
     });
     [
-        "-mc",
-        "-mc keep_fargs=false,passes=3,pure_getters,unsafe,unsafe_comps,unsafe_math,unsafe_proto",
+        "-mc warnings=false",
+        "-mc keep_fargs=false,passes=3,pure_getters,unsafe,unsafe_comps,unsafe_math,unsafe_proto,warnings=false",
     ].forEach(function(options) {
         it("Should pass with options " + options, function(done) {
             var args = options.split(/ /);

test/mocha/screw-ie8.js

@@ -13,7 +13,9 @@ describe("screw-ie8", function () {
                     }\
                     console.log('undefined is ' + undefined);\
                     return b === undefined;\
-                };"
+                };", {
+                    fromString: true
+                }
             ).code,
             'function a(o){try{throw"Stuff"}catch(o){console.log("caught: "+o)}return console.log("undefined is "+void 0),void 0===o}'
         );

test/mocha/spidermonkey.js

@@ -1,21 +1,32 @@
 var assert = require("assert");
 var exec = require("child_process").exec;
-var uglify = require("../node");
+var uglify = require("../../");
 
 describe("spidermonkey export/import sanity test", function() {
-    it("should produce a functional build when using --self with spidermonkey", function(done) {
-        this.timeout(30000);
+    it("should produce a functional build when using --self with spidermonkey", function (done) {
+        this.timeout(20000);
 
         var uglifyjs = '"' + process.argv[0] + '" bin/uglifyjs';
-        var command = uglifyjs + " --self -cm --wrap SpiderUglify -o spidermonkey | " +
-            uglifyjs + " -p spidermonkey -cm";
+        var command = uglifyjs + " --self -cm --wrap SpiderUglify --dump-spidermonkey-ast | " +
+            uglifyjs + " --spidermonkey -cm";
 
-        exec(command, function(err, stdout) {
+        exec(command, function (err, stdout) {
             if (err) throw err;
 
             eval(stdout);
             assert.strictEqual(typeof SpiderUglify, "object");
-            assert.strictEqual(SpiderUglify.minify("foo([true,,2+3]);").code, "foo([!0,,5]);");
+
+            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]);");
 
             done();
         });

test/mocha/string-literal.js

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

test/mocha/with.js

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

test/mozilla-ast.js

@@ -6,14 +6,20 @@ var ufuzz = require("./ufuzz");
 var UglifyJS = require("..");
 
 function try_beautify(code) {
-    var beautified = UglifyJS.minify(code, {
-        compress: false,
-        mangle: false,
-        output: {
-            beautify: true,
-            bracketize: true
-        }
-    });
+    var beautified;
+    try {
+        beautified = UglifyJS.minify(code, {
+            fromString: true,
+            compress: false,
+            mangle: false,
+            output: {
+                beautify: true,
+                bracketize: true
+            }
+        });
+    } catch (ex) {
+        beautified = { error: ex };
+    }
     if (beautified.error) {
         console.log("// !!! beautify failed !!!");
         console.log(beautified.error.stack);
@@ -25,10 +31,17 @@ function try_beautify(code) {
 }
 
 function test(original, estree, description) {
-    var transformed = UglifyJS.minify(UglifyJS.AST_Node.from_mozilla_ast(estree), {
-        compress: false,
-        mangle: false
-    });
+    var transformed;
+    try {
+        transformed = UglifyJS.minify(estree, {
+            fromString: true,
+            compress: false,
+            mangle: false,
+            spidermonkey: true
+        });
+    } catch (ex) {
+        transformed = { error: ex };
+    }
     if (transformed.error || original !== transformed.code) {
         console.log("//=============================================================");
         console.log("// !!!!!! Failed... round", round);
@@ -52,13 +65,14 @@ 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
-        }
-    });
+    var uglified = {
+        ast: UglifyJS.parse(code),
+        code: UglifyJS.minify(code, {
+            fromString: true,
+            compress: false,
+            mangle: false
+        }).code
+    };
     test(uglified.code, uglified.ast.to_mozilla_ast(), "AST_Node.to_mozilla_ast()");
     try {
         test(uglified.code, acorn.parse(code), "acorn.parse()");

test/node.js

@@ -1,6 +0,0 @@
-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,6 +1,6 @@
 #! /usr/bin/env node
 
-var U = require("./node");
+var U = require("../tools/node");
 var path = require("path");
 var fs = require("fs");
 var assert = require("assert");

test/sourcemaps.js

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

test/ufuzz.js

@@ -12,7 +12,7 @@
         stream._handle.setBlocking(true);
 });
 
-var UglifyJS = require("./node");
+var UglifyJS = require("..");
 var randomBytes = require("crypto").randomBytes;
 var sandbox = require("./sandbox");
 
@@ -942,21 +942,24 @@ if (require.main !== module) {
 }
 
 function try_beautify(code, result) {
-    var beautified = UglifyJS.minify(code, {
-        compress: false,
-        mangle: false,
-        output: {
-            beautify: true,
-            bracketize: true,
-        },
-    });
-    if (beautified.error) {
+    try {
+        var beautified = UglifyJS.minify(code, {
+            fromString: true,
+            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) {
         console.log("// !!! beautify failed !!!");
-        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(e.stack);
     }
     console.log("//");
     console.log(code);
@@ -992,13 +995,12 @@ function log_suspects(minify_options, component) {
             var o = JSON.parse(JSON.stringify(options));
             o[name] = false;
             m[component] = o;
-            var result = UglifyJS.minify(original_code, m);
-            if (result.error) {
-                console.log("Error testing options." + component + "." + name);
-                console.log(result.error);
-            } else {
-                var r = sandbox.run_code(result.code);
+            try {
+                var r = sandbox.run_code(UglifyJS.minify(original_code, m).code);
                 return sandbox.same_stdout(original_result, r);
+            } catch (e) {
+                console.log("Error testing options." + component + "." + name);
+                console.log(e);
             }
         }
     });
@@ -1053,7 +1055,10 @@ var fallback_options = [ JSON.stringify({
     compress: false,
     mangle: false
 }) ];
-var minify_options = require("./ufuzz.json").map(JSON.stringify);
+var minify_options = require("./ufuzz.json").map(function(options) {
+    options.fromString = true;
+    return JSON.stringify(options);
+});
 var original_code, original_result;
 var uglify_code, uglify_result, ok;
 for (var round = 1; round <= num_iterations; round++) {
@@ -1062,16 +1067,18 @@ for (var round = 1; round <= num_iterations; round++) {
     original_code = createTopLevelCode();
     original_result = sandbox.run_code(original_code);
     (typeof original_result != "string" ? fallback_options : minify_options).forEach(function(options) {
-        uglify_code = UglifyJS.minify(original_code, JSON.parse(options));
-        if (!uglify_code.error) {
-            uglify_code = uglify_code.code;
+        try {
+            uglify_code = UglifyJS.minify(original_code, JSON.parse(options)).code;
+        } catch (e) {
+            uglify_code = e;
+        }
+
+        ok = typeof uglify_code == "string";
+        if (ok) {
             uglify_result = sandbox.run_code(uglify_code);
             ok = sandbox.same_stdout(original_result, uglify_result);
-        } else {
-            uglify_code = uglify_code.error;
-            if (typeof original_result != "string") {
-                ok = uglify_code.name == original_result.name;
-            }
+        } else if (typeof original_result != "string") {
+            ok = uglify_code.name == original_result.name;
         }
         if (verbose || (verbose_interval && !(round % INTERVAL_COUNT)) || !ok) log(options);
         else if (typeof original_result != "string") {

test/ufuzz.json

@@ -11,12 +11,20 @@
         "compress": false
     },
     {
+        "compress": {
+            "warnings": false
+        },
         "mangle": false
     },
-    {},
     {
         "compress": {
-            "toplevel": true
+            "warnings": false
+        }
+    },
+    {
+        "compress": {
+            "toplevel": true,
+            "warnings": false
         },
         "mangle": {
             "toplevel": true
@@ -25,7 +33,8 @@
     {
         "compress": {
             "keep_fargs": false,
-            "passes": 3
+            "passes": 3,
+            "warnings": false
         }
     }
 ]

tools/exports.js

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

tools/node.js

@@ -1,3 +1,10 @@
+// workaround for tty output truncation upon process.exit()
+[process.stdout, process.stderr].forEach(function(stream){
+    if (stream._handle && stream._handle.setBlocking)
+        stream._handle.setBlocking(true);
+});
+
+var path = require("path");
 var fs = require("fs");
 
 var UglifyJS = exports;
@@ -12,25 +19,182 @@ var FILES = UglifyJS.FILES = [
     "../lib/sourcemap.js",
     "../lib/mozilla-ast.js",
     "../lib/propmangle.js",
-    "../lib/minify.js",
     "./exports.js",
 ].map(function(file){
     return require.resolve(file);
 });
 
-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");
-}())(
+new Function("MOZ_SourceMap", "exports", FILES.map(function(file){
+    return fs.readFileSync(file, "utf8");
+}).join("\n\n"))(
     require("source-map"),
     UglifyJS
 );
 
-function describe_ast() {
-    var out = OutputStream({ beautify: true });
+UglifyJS.AST_Node.warn_function = function(txt) {
+    console.error("WARN: %s", txt);
+};
+
+function read_source_map(code) {
+    var match = /\n\/\/# sourceMappingURL=data:application\/json(;.*?)?;base64,(.*)/.exec(code);
+    if (!match) {
+        UglifyJS.AST_Node.warn("inline source map not found");
+        return null;
+    }
+    return JSON.parse(new Buffer(match[2], "base64"));
+}
+
+UglifyJS.minify = function(files, options) {
+    options = UglifyJS.defaults(options, {
+        compress         : {},
+        fromString       : false,
+        inSourceMap      : null,
+        mangle           : {},
+        mangleProperties : false,
+        nameCache        : null,
+        outFileName      : null,
+        output           : null,
+        outSourceMap     : null,
+        parse            : {},
+        sourceMapInline  : false,
+        sourceMapUrl     : null,
+        sourceRoot       : null,
+        spidermonkey     : false,
+        warnings         : false,
+    });
+    UglifyJS.base54.reset();
+
+    var inMap = options.inSourceMap;
+    if (typeof inMap == "string" && inMap != "inline") {
+        inMap = JSON.parse(fs.readFileSync(inMap, "utf8"));
+    }
+
+    // 1. parse
+    var toplevel = null,
+        sourcesContent = {};
+
+    if (options.spidermonkey) {
+        if (inMap == "inline") {
+            throw new Error("inline source map only works with built-in parser");
+        }
+        toplevel = UglifyJS.AST_Node.from_mozilla_ast(files);
+    } else {
+        function addFile(file, fileUrl) {
+            var code = options.fromString
+                ? file
+                : fs.readFileSync(file, "utf8");
+            if (inMap == "inline") {
+                inMap = read_source_map(code);
+            }
+            sourcesContent[fileUrl] = code;
+            toplevel = UglifyJS.parse(code, {
+                filename: fileUrl,
+                toplevel: toplevel,
+                bare_returns: options.parse ? options.parse.bare_returns : undefined
+            });
+        }
+        if (!options.fromString) {
+            files = UglifyJS.simple_glob(files);
+            if (inMap == "inline" && files.length > 1) {
+                throw new Error("inline source map only works with singular input");
+            }
+        }
+        [].concat(files).forEach(function (files, i) {
+            if (typeof files === 'string') {
+                addFile(files, options.fromString ? i : files);
+            } else {
+                for (var fileUrl in files) {
+                    addFile(files[fileUrl], fileUrl);
+                }
+            }
+        });
+    }
+    if (options.wrap) {
+      toplevel = toplevel.wrap_commonjs(options.wrap, options.exportAll);
+    }
+
+    // 2. compress
+    if (options.compress) {
+        var compress = { warnings: options.warnings };
+        UglifyJS.merge(compress, options.compress);
+        toplevel.figure_out_scope(options.mangle);
+        var sq = UglifyJS.Compressor(compress);
+        toplevel = sq.compress(toplevel);
+    }
+
+    // 3. mangle properties
+    if (options.mangleProperties || options.nameCache) {
+        options.mangleProperties.cache = UglifyJS.readNameCache(options.nameCache, "props");
+        toplevel = UglifyJS.mangle_properties(toplevel, options.mangleProperties);
+        UglifyJS.writeNameCache(options.nameCache, "props", options.mangleProperties.cache);
+    }
+
+    // 4. mangle
+    if (options.mangle) {
+        toplevel.figure_out_scope(options.mangle);
+        toplevel.compute_char_frequency(options.mangle);
+        toplevel.mangle_names(options.mangle);
+    }
+
+    // 5. output
+    var output = { max_line_len: 32000 };
+    if (options.outSourceMap || options.sourceMapInline) {
+        output.source_map = UglifyJS.SourceMap({
+            // prefer outFileName, otherwise use outSourceMap without .map suffix
+            file: options.outFileName || (typeof options.outSourceMap === 'string' ? options.outSourceMap.replace(/\.map$/i, '') : null),
+            orig: inMap,
+            root: options.sourceRoot
+        });
+        if (options.sourceMapIncludeSources) {
+            for (var file in sourcesContent) {
+                if (sourcesContent.hasOwnProperty(file)) {
+                    output.source_map.get().setSourceContent(file, sourcesContent[file]);
+                }
+            }
+        }
+
+    }
+    if (options.output) {
+        UglifyJS.merge(output, options.output);
+    }
+    var stream = UglifyJS.OutputStream(output);
+    toplevel.print(stream);
+
+
+    var source_map = output.source_map;
+    if (source_map) {
+        source_map = source_map + "";
+    }
+
+    var mappingUrlPrefix = "\n//# sourceMappingURL=";
+    if (options.sourceMapInline) {
+        stream += mappingUrlPrefix + "data:application/json;charset=utf-8;base64," + new Buffer(source_map).toString("base64");
+    } else if (options.outSourceMap && typeof options.outSourceMap === "string" && options.sourceMapUrl !== false) {
+        stream += mappingUrlPrefix + (typeof options.sourceMapUrl === "string" ? options.sourceMapUrl : options.outSourceMap);
+    }
+
+    return {
+        code : stream + "",
+        map  : source_map
+    };
+};
+
+// UglifyJS.describe_ast = function() {
+//     function doitem(ctor) {
+//         var sub = {};
+//         ctor.SUBCLASSES.forEach(function(ctor){
+//             sub[ctor.TYPE] = doitem(ctor);
+//         });
+//         var ret = {};
+//         if (ctor.SELF_PROPS.length > 0) ret.props = ctor.SELF_PROPS;
+//         if (ctor.SUBCLASSES.length > 0) ret.sub = sub;
+//         return ret;
+//     }
+//     return doitem(UglifyJS.AST_Node).sub;
+// }
+
+UglifyJS.describe_ast = function() {
+    var out = UglifyJS.OutputStream({ beautify: true });
     function doitem(ctor) {
         out.print("AST_" + ctor.TYPE);
         var props = ctor.SELF_PROPS.filter(function(prop){
@@ -60,6 +224,97 @@ function describe_ast() {
             });
         }
     };
-    doitem(AST_Node);
+    doitem(UglifyJS.AST_Node);
     return out + "";
+};
+
+function readReservedFile(filename, reserved) {
+    if (!reserved) {
+        reserved = { vars: [], props: [] };
+    }
+    var data = fs.readFileSync(filename, "utf8");
+    data = JSON.parse(data);
+    if (data.vars) {
+        data.vars.forEach(function(name){
+            UglifyJS.push_uniq(reserved.vars, name);
+        });
+    }
+    if (data.props) {
+        data.props.forEach(function(name){
+            UglifyJS.push_uniq(reserved.props, name);
+        });
+    }
+    return reserved;
 }
+
+UglifyJS.readReservedFile = readReservedFile;
+
+UglifyJS.readDefaultReservedFile = function(reserved) {
+    return readReservedFile(require.resolve("./domprops.json"), reserved);
+};
+
+UglifyJS.readNameCache = function(filename, key) {
+    var cache = null;
+    if (filename) {
+        try {
+            var cache = fs.readFileSync(filename, "utf8");
+            cache = JSON.parse(cache)[key];
+            if (!cache) throw "init";
+            cache.props = UglifyJS.Dictionary.fromObject(cache.props);
+        } catch(ex) {
+            cache = {
+                cname: -1,
+                props: new UglifyJS.Dictionary()
+            };
+        }
+    }
+    return cache;
+};
+
+UglifyJS.writeNameCache = function(filename, key, cache) {
+    if (filename) {
+        var data;
+        try {
+            data = fs.readFileSync(filename, "utf8");
+            data = JSON.parse(data);
+        } catch(ex) {
+            data = {};
+        }
+        data[key] = {
+            cname: cache.cname,
+            props: cache.props.toObject()
+        };
+        fs.writeFileSync(filename, JSON.stringify(data, null, 2), "utf8");
+    }
+};
+
+// A file glob function that only supports "*" and "?" wildcards in the basename.
+// Example: "foo/bar/*baz??.*.js"
+// Argument `glob` may be a string or an array of strings.
+// Returns an array of strings. Garbage in, garbage out.
+UglifyJS.simple_glob = function simple_glob(glob) {
+    if (Array.isArray(glob)) {
+        return [].concat.apply([], glob.map(simple_glob));
+    }
+    if (glob.match(/\*|\?/)) {
+        var dir = path.dirname(glob);
+        try {
+            var entries = fs.readdirSync(dir);
+        } catch (ex) {}
+        if (entries) {
+            var pattern = "^" + path.basename(glob)
+                .replace(/[.+^$[\]\\(){}]/g, "\\$&")
+                .replace(/\*/g, "[^/\\\\]*")
+                .replace(/\?/g, "[^/\\\\]") + "$";
+            var mod = process.platform === "win32" ? "i" : "";
+            var rx = new RegExp(pattern, mod);
+            var results = entries.filter(function(name) {
+                return rx.test(name);
+            }).map(function(name) {
+                return path.join(dir, name);
+            });
+            if (results.length) return results;
+        }
+    }
+    return [ glob ];
+};