Merge branch 'master' into harmony

Also add .gitattributes to checkout lf eol style

.github/ISSUE_TEMPLATE.md

@@ -1,27 +0,0 @@
-**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**
-
-<!--
-    A complete parsable JS program exhibiting the issue with
-    UglifyJS alone - without third party tools or libraries.
-    Ideally the input should be as small as possible.
-    Post a link to a gist if necessary.
--->
-
-**The `uglifyjs` CLI command executed or `minify()` options used.**
-
-**JavaScript output or error produced.**
-
-<!--
-    Note: `uglify-js` only supports ES5. 
-    Those wishing to minify ES6 should use `uglify-es`.
--->

.travis.yml

@@ -1,14 +1,10 @@
 language: node_js
+before_install: "npm install -g npm"
 node_js:
-    - "0.10"
     - "0.12"
+    - "0.10"
     - "4"
     - "6"
-    - "8"
-env:
-    - UGLIFYJS_TEST_ALL=1
 matrix:
   fast_finish: true
 sudo: false
-cache:
-  directories: tmp

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,399 +3,593 @@
 
 "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 async = require("async");
+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-8 quirks. This flag is enabled by default.")
+    .describe("support-ie8", "Support non-standard Internet Explorer 6-8 javascript. Note: may break standards compliant `catch` identifiers.")
+    .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;
-if (process.argv.indexOf("ast") >= 0) program.helpInformation = UglifyJS.describe_ast;
-else if (process.argv.indexOf("options") >= 0) program.helpInformation = function() {
-    var text = [];
-    var options = UglifyJS.default_options();
-    for (var option in options) {
-        text.push("--" + (option == "output" ? "beautify" : option == "sourceMap" ? "source-map" : option) + " options:");
-        text.push(format_object(options[option]));
-        text.push("");
-    }
-    return text.join("\n");
-};
-program.option("-p, --parse <options>", "Specify parser options.", parse_js());
-program.option("-c, --compress [options]", "Enable compressor/specify compressor options.", parse_js());
-program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js());
-program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js());
-program.option("-b, --beautify [options]", "Beautify output/specify output options.", parse_js());
-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("--timings", "Display operations run time on STDERR.")
-program.option("--toplevel", "Compress and/or mangle variables in toplevel scope.");
-program.option("--verbose", "Print diagnostic messages.");
-program.option("--warn", "Print warning messages.");
-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));
-}
-if (!program.output && program.sourceMap && program.sourceMap.url != "inline") {
-    fatal("ERROR: cannot write source map to STDOUT");
-}
-[
-    "compress",
-    "ie8",
-    "mangle",
-    "sourceMap",
-    "toplevel",
-    "wrap"
-].forEach(function(name) {
-    if (name in program) {
-        options[name] = program[name];
-    }
-});
-if (program.beautify) {
-    options.output = typeof program.beautify == "object" ? program.beautify : {};
-    if (!("beautify" in options.output)) {
-        options.output.beautify = true;
-    }
-}
-if (program.comments) {
-    if (typeof options.output != "object") options.output = {};
-    options.output.comments = typeof program.comments == "string" ? program.comments : "some";
-}
-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 (program.keepFnames) {
-    options.keep_fnames = true;
-}
-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 (program.nameCache) {
-    options.nameCache = JSON.parse(read_file(program.nameCache, "{}"));
-}
-if (program.output == "ast") {
-    options.output = {
-        ast: true,
-        code: false
-    };
-}
-if (program.parse) {
-    if (!program.parse.acorn && !program.parse.spidermonkey) {
-        options.parse = program.parse;
-    } else if (program.sourceMap && program.sourceMap.content == "inline") {
-        fatal("ERROR: inline source map only works with built-in parser");
-    }
-}
-var convert_path = function(name) {
-    return name;
-};
-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 (program.verbose) {
-    options.warnings = "verbose";
-} else if (program.warn) {
-    options.warnings = true;
-}
-if (program.self) {
-    if (program.args.length) {
-        print_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();
-} 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();
-}
+    .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.")
 
-function convert_ast(fn) {
-    return UglifyJS.AST_Node.from_mozilla_ast(Object.keys(files).reduce(fn, null));
-}
+    .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.")
 
-function run() {
-    UglifyJS.AST_Node.warn_function = function(msg) {
+    .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.timings) options.timings = true;
-    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);
+}
+
+if (ARGS.version || ARGS.V) {
+    var json = require("../package.json");
+    print(json.name + ' ' + json.version);
+    process.exit(0);
+}
+
+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 (ARGS.reserve_domprops) {
+    RESERVED = UglifyJS.readDefaultReservedFile(RESERVED);
+}
+
+if (ARGS.d) {
+    if (COMPRESS) COMPRESS.global_defs = getOptions("d");
+}
+
+if (ARGS.pure_funcs) {
+    if (COMPRESS) COMPRESS.pure_funcs = ARGS.pure_funcs;
+}
+
+if (ARGS.r) {
+    if (MANGLE) MANGLE.except = ARGS.r.replace(/^\s+|\s+$/g).split(/\s*,+\s*/);
+}
+
+if (RESERVED && MANGLE) {
+    if (!MANGLE.except) MANGLE.except = RESERVED.vars;
+    else MANGLE.except = MANGLE.except.concat(RESERVED.vars);
+}
+
+function readNameCache(key) {
+    return UglifyJS.readNameCache(ARGS.name_cache, key);
+}
+
+function writeNameCache(key, cache) {
+    return UglifyJS.writeNameCache(ARGS.name_cache, key, cache);
+}
+
+function extractRegex(str) {
+  if (/^\/.*\/[a-zA-Z]*$/.test(str)) {
+    var regex_pos = str.lastIndexOf("/");
+    return new RegExp(str.substr(1, regex_pos - 1), str.substr(regex_pos + 1));
+  } else {
+    throw new Error("Invalid regular expression: " + str);
+  }
+}
+
+if (ARGS.quotes === true) {
+    ARGS.quotes = 3;
+}
+
+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,
+    preamble    : ARGS.preamble || null,
+    quote_style : ARGS.quotes != null ? ARGS.quotes : 0
+};
+
+if (ARGS.mangle_props == 2) {
+    OUTPUT_OPTIONS.keep_quoted_props = true;
+    if (COMPRESS && !("properties" in COMPRESS))
+        COMPRESS.properties = false;
+}
+
+if (ARGS.support_ie8 === true && ARGS.screw_ie8 !== true) {
+    screw_ie8 = false;
+}
+
+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 {
+    OUTPUT_OPTIONS.comments = ARGS.comments;
+}
+
+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");
     }
-    var result = UglifyJS.minify(files, options);
-    if (result.error) {
-        var ex = result.error;
-        if (ex.name == "SyntaxError") {
-            print_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) {
-                var limit = 70;
-                if (col > limit) {
-                    line = line.slice(col - limit);
-                    col = limit;
-                }
-                print_error(line.slice(0, 80));
-                print_error(line.slice(0, col).replace(/\S/g, " ") + "^");
-            }
-        }
-        if (ex.defs) {
-            print_error("Supported options:");
-            print_error(format_object(ex.defs));
-        }
-        fatal(ex);
-    } else if (program.output == "ast") {
-        print(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") {
-        print(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 {
-        print(result.code);
+    files = UglifyJS.FILES;
+    if (!ARGS.wrap) ARGS.wrap = "UglifyJS";
+}
+
+var ORIG_MAP = ARGS.in_source_map;
+
+if (ORIG_MAP) {
+    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 ];
     }
-    if (program.nameCache) {
-        fs.writeFileSync(program.nameCache, JSON.stringify(options.nameCache));
-    }
-    if (result.timings) for (var phase in result.timings) {
-        print_error("- " + phase + ": " + result.timings[phase].toFixed(3) + "s");
+    if (ARGS.source_map_root == null) {
+        ARGS.source_map_root = ORIG_MAP.sourceRoot;
     }
 }
 
-function fatal(message) {
-    if (message instanceof Error) message = message.stack.replace(/^\S*?Error:/, "ERROR:")
-    print_error(message);
+if (files.length == 0) {
+    files = [ "-" ];
+}
+
+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 (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 OUTPUT_FILE = ARGS.o;
+var TOPLEVEL = null;
+var P_RELATIVE = ARGS.p && ARGS.p == "relative";
+var SOURCES_CONTENT = {};
+
+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: 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.msg);
+        print_error("Supported options:");
+        print_error(sys.inspect(ex.defs));
+        process.exit(1);
     }
-    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;
+}
+
+async.eachLimit(files, 1, function (file, cb) {
+    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) {
-    return function(value, options) {
-        options = options || {};
-        try {
-            UglifyJS.minify(value, {
-                parse: {
-                    expression: true
-                },
-                compress: false,
-                mangle: false,
-                output: {
-                    ast: true,
-                    code: false
-                }
-            }).ast.walk(new UglifyJS.TreeWalker(function(node) {
-                if (node instanceof UglifyJS.AST_Assign) {
-                    var name = node.left.print_to_string();
-                    var value = node.right;
-                    if (flag) {
-                        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
-                    });
-                }
-            }));
-        } catch(ex) {
-            if (flag) {
-                fatal("Error parsing arguments for '" + flag + "': " + value);
+        if (ARGS.p != null) {
+            if (P_RELATIVE) {
+                file = path.relative(path.dirname(ARGS.source_map), file).replace(/\\/g, '/');
             } else {
-                options[value] = null;
+                var p = parseInt(ARGS.p, 10);
+                if (!isNaN(p)) {
+                    file = file.replace(/^\/+/, "").split(/\/+/).slice(ARGS.p).join("/");
+                }
             }
         }
-        return options;
-    }
-}
-
-function parse_source_map() {
-    var parse = parse_js();
-    return function(value, options) {
-        var hasContent = options && "content" in options;
-        var settings = parse(value, options);
-        if (!hasContent && settings.content && settings.content != "inline") {
-            print_error("INFO: Using input source map: " + settings.content);
-            settings.content = read_file(settings.content, settings.content);
-        }
-        return settings;
-    }
-}
-
-function skip_key(key) {
-    return skip_keys.indexOf(key) >= 0;
-}
-
-function format_object(obj) {
-    var lines = [];
-    var padding = "";
-    Object.keys(obj).map(function(name) {
-        if (padding.length < name.length) padding = Array(name.length + 1).join(" ");
-        return [ name, JSON.stringify(obj[name]) ];
-    }).forEach(function(tokens) {
-        lines.push("  " + tokens[0] + padding.slice(tokens[0].length - 2) + tokens[1]);
+        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);
+                        print_error(ex.message);
+                        print_error(ex.stack);
+                        process.exit(1);
+                    }
+                    throw ex;
+                }
+            };
+        });
+        cb();
     });
-    return lines.join("\n");
+}, function () {
+    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 (SCOPE_IS_NEEDED) {
+        time_it("scope", function(){
+            TOPLEVEL.figure_out_scope({ 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({ screw_ie8: screw_ie8, cache: TL_CACHE });
+            if (MANGLE && !TL_CACHE) {
+                TOPLEVEL.compute_char_frequency(MANGLE);
+            }
+        });
+    }
+
+    if (MANGLE) time_it("mangle", function(){
+        MANGLE.cache = TL_CACHE;
+        TOPLEVEL.mangle_names(MANGLE);
+    });
+
+    writeNameCache("vars", TL_CACHE);
+
+    if (ARGS.source_map_include_sources) {
+        for (var file in SOURCES_CONTENT) {
+            if (SOURCES_CONTENT.hasOwnProperty(file)) {
+                SOURCE_MAP.get().setSourceContent(file, SOURCES_CONTENT[file]);
+            }
+        }
+    }
+
+    if (ARGS.dump_spidermonkey_ast) {
+        print(JSON.stringify(TOPLEVEL.to_mozilla_ast(), null, 2));
+    } else {
+        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)
+            }));
+        }
+    }
+});
+
+/* -----[ 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, { 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({ beautify: false }).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({ beautify: false }).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 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) {
-    process.stderr.write(msg);
-    process.stderr.write("\n");
+    console.error("%s", msg);
 }
 
 function print(txt) {
-    process.stdout.write(txt);
-    process.stdout.write("\n");
+    console.log("%s", txt);
 }

lib/ast.js

@@ -81,9 +81,7 @@ function DEFNODE(type, props, methods, base) {
     ctor.DEFMETHOD = function(name, method) {
         this.prototype[name] = method;
     };
-    if (typeof exports !== "undefined") {
-        exports["AST_" + type] = ctor;
-    }
+    exports["AST_" + type] = ctor;
     return ctor;
 };
 
@@ -91,20 +89,9 @@ var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos
 }, null);
 
 var AST_Node = DEFNODE("Node", "start end", {
-    _clone: function(deep) {
-        if (deep) {
-            var self = this.clone();
-            return self.transform(new TreeTransformer(function(node) {
-                if (node !== self) {
-                    return node.clone(true);
-                }
-            }));
-        }
+    clone: function() {
         return new this.CTOR(this);
     },
-    clone: function(deep) {
-        return this._clone(deep);
-    },
     $documentation: "Base class of all AST nodes",
     $propdoc: {
         start: "[AST_Token] The first token of this node",
@@ -134,10 +121,11 @@ var AST_Debugger = DEFNODE("Debugger", null, {
     $documentation: "Represents a debugger statement",
 }, AST_Statement);
 
-var AST_Directive = DEFNODE("Directive", "value quote", {
+var AST_Directive = DEFNODE("Directive", "value scope quote", {
     $documentation: "Represents a directive, like \"use strict\";",
     $propdoc: {
         value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
+        scope: "[AST_Scope/S] The scope that this directive affects",
         quote: "[string] the original quote character"
     },
 }, AST_Statement);
@@ -155,13 +143,12 @@ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
 }, AST_Statement);
 
 function walk_body(node, visitor) {
-    var body = node.body;
-    if (body instanceof AST_Statement) {
-        body._walk(visitor);
-    }
-    else for (var i = 0, len = body.length; i < len; i++) {
-        body[i]._walk(visitor);
+    if (node.body instanceof AST_Node) {
+        node.body._walk(visitor);
     }
+    else node.body.forEach(function(stat){
+        stat._walk(visitor);
+    });
 };
 
 var AST_Block = DEFNODE("Block", "body", {
@@ -181,13 +168,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);
 
@@ -201,21 +196,6 @@ var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", {
             this.label._walk(visitor);
             this.body._walk(visitor);
         });
-    },
-    clone: function(deep) {
-        var node = this._clone(deep);
-        if (deep) {
-            var label = node.label;
-            var def = this.label;
-            node.walk(new TreeWalker(function(node) {
-                if (node instanceof AST_LoopControl
-                    && node.label && node.label.thedef === def) {
-                    node.label.thedef = label;
-                    label.references.push(node);
-                }
-            }));
-        }
-        return node;
     }
 }, AST_StatementWithBody);
 
@@ -283,6 +263,10 @@ var AST_ForIn = DEFNODE("ForIn", "init name object", {
     }
 }, AST_IterationStatement);
 
+var AST_ForOf = DEFNODE("ForOf", null, {
+    $documentation: "A `for ... of` statement",
+}, AST_ForIn);
+
 var AST_With = DEFNODE("With", "expression", {
     $documentation: "A `with` statement",
     $propdoc: {
@@ -298,9 +282,10 @@ var AST_With = DEFNODE("With", "expression", {
 
 /* -----[ scope and functions ]----- */
 
-var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent_scope enclosed cname", {
+var AST_Scope = DEFNODE("Scope", "directives variables functions uses_with uses_eval parent_scope enclosed cname", {
     $documentation: "Base class for all statements introducing a lexical scope",
     $propdoc: {
+        directives: "[string*/S] an array of directives declared in this scope",
         variables: "[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
         functions: "[Object/S] like `variables`, but only lists function declarations",
         uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
@@ -309,6 +294,13 @@ var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent
         enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
         cname: "[integer/S] current index for mangling variables (used internally by the mangler)",
     },
+    get_defun_scope: function () {
+        var self = this;
+        while (self.is_block_scope() && self.parent_scope) {
+            self = self.parent_scope;
+        }
+        return self;
+    }
 }, AST_Block);
 
 var AST_Toplevel = DEFNODE("Toplevel", "globals", {
@@ -316,33 +308,165 @@ 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;
     }
 }, AST_Scope);
 
-var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments", {
+var AST_Expansion = DEFNODE("Expansion", "expression", {
+    $documentation: "An expandible argument, such as ...rest, a splat, such as [1,2,...all], or an expansion in a variable declaration, such as var [first, ...rest] = list",
+    $propdoc: {
+        expression: "AST_Symbol the thing to be expanded"
+    },
+    _walk: function(visitor) {
+        var self = this;
+        return visitor._visit(this, function(){
+            self.expression.walk(visitor);
+        });
+    }
+});
+
+var AST_ArrowParametersOrSeq = DEFNODE("ArrowParametersOrSeq", "expressions", {
+    $documentation: "A set of arrow function parameters or a sequence expression. This is used because when the parser sees a \"(\" it could be the start of a seq, or the start of a parameter list of an arrow function.",
+    $propdoc: {
+        expressions: "[AST_Expression|AST_Destructuring|AST_Expansion*] array of expressions or argument names or destructurings."
+    },
+    as_params: function (croak) {
+        // We don't want anything which doesn't belong in a destructuring
+        var root = this;
+        return this.expressions.map(function to_fun_args(ex, _, __, default_seen_above) {
+            if (ex instanceof AST_Object) {
+                return new AST_Destructuring({
+                    start: ex.start,
+                    end: ex.end,
+                    is_array: false,
+                    default: default_seen_above,
+                    names: ex.properties.map(to_fun_args)
+                });
+            } else if (ex instanceof AST_ObjectKeyVal) {
+                if (ex.key instanceof AST_SymbolRef) {
+                    ex.key = to_fun_args(ex.key, 0, [ex.key], ex.default);
+                }
+                ex.value = to_fun_args(ex.value, 0, [ex.key], ex.default);
+                return ex;
+            } else if (ex instanceof AST_Hole) {
+                return ex;
+            } else if (ex instanceof AST_Destructuring) {
+                if (ex.names.length == 0)
+                    croak("Invalid destructuring function parameter", ex.start.line, ex.start.col);
+                ex.names = ex.names.map(to_fun_args);
+                return ex;
+            } else if (ex instanceof AST_SymbolRef) {
+                return new AST_SymbolFunarg({
+                    name: ex.name,
+                    default: default_seen_above,
+                    start: ex.start,
+                    end: ex.end
+                });
+            } else if (ex instanceof AST_Expansion) {
+                return ex;
+            } else if (ex instanceof AST_Array) {
+                return new AST_Destructuring({
+                    start: ex.start,
+                    end: ex.end,
+                    is_array: true,
+                    default: default_seen_above,
+                    names: ex.elements.map(to_fun_args)
+                });
+            } else if (ex instanceof AST_Assign) {
+                return to_fun_args(ex.left, undefined, undefined, ex.right);
+            } else {
+                croak("Invalid function parameter", ex.start.line, ex.start.col);
+            }
+        });
+    },
+    as_expr: function (croak) {
+        return AST_Seq.from_array(this.expressions);
+    }
+});
+
+var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator", {
     $documentation: "Base class for functions",
     $propdoc: {
+        is_generator: "[boolean] is generatorFn or not",
         name: "[AST_SymbolDeclaration?] the name of this function",
-        argnames: "[AST_SymbolFunarg*] array of function arguments",
+        argnames: "[AST_SymbolFunarg|AST_Destructuring|AST_Expansion*] array of function arguments, destructurings, or expanding arguments",
         uses_arguments: "[boolean/S] tells whether this function accesses the arguments array"
     },
+    args_as_names: function () {
+        var out = [];
+        for (var i = 0; i < this.argnames.length; i++) {
+            if (this.argnames[i] instanceof AST_Destructuring) {
+                out = out.concat(this.argnames[i].all_symbols());
+            } else {
+                out.push(this.argnames[i]);
+            }
+        }
+        return out;
+    },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
             if (this.name) this.name._walk(visitor);
-            var argnames = this.argnames;
-            for (var i = 0, len = argnames.length; i < len; i++) {
-                argnames[i]._walk(visitor);
-            }
+            this.argnames.forEach(function(arg){
+                arg._walk(visitor);
+            });
             walk_body(this, visitor);
         });
     }
@@ -356,10 +480,79 @@ var AST_Function = DEFNODE("Function", null, {
     $documentation: "A function expression"
 }, AST_Lambda);
 
+var AST_Arrow = DEFNODE("Arrow", null, {
+    $documentation: "An ES6 Arrow function ((a) => b)"
+}, AST_Lambda);
+
 var AST_Defun = DEFNODE("Defun", null, {
     $documentation: "A function definition"
 }, AST_Lambda);
 
+/* -----[ DESTRUCTURING ]----- */
+var AST_Destructuring = DEFNODE("Destructuring", "names is_array default", {
+    $documentation: "A destructuring of several names. Used in destructuring assignment and with destructuring function argument names",
+    $propdoc: {
+        "names": "[AST_Destructuring|AST_Expansion|AST_Hole|AST_ObjectKeyVal|AST_Symbol] Array of properties or elements",
+        "is_array": "[Boolean] Whether the destructuring represents an object or array",
+        "default": "[AST_Node?] Default assign value"
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.names.forEach(function(name){
+                name._walk(visitor);
+            });
+        });
+    },
+    all_symbols: function() {
+        var out = [];
+        this.walk(new TreeWalker(function (node) {
+            if (node instanceof AST_Symbol) {
+                out.push(node);
+            }
+            if (node instanceof AST_Expansion) {
+                out.push(node.expression);
+            }
+        }));
+        return out;
+    }
+});
+
+var AST_PrefixedTemplateString = DEFNODE("PrefixedTemplateString", "template_string prefix", {
+    $documentation: "A templatestring with a prefix, such as String.raw`foobarbaz`",
+    $propdoc: {
+        template_string: "[AST_TemplateString] The template string",
+        prefix: "[AST_SymbolRef|AST_PropAccess] The prefix, which can be a symbol such as `foo` or a dotted expression such as `String.raw`."
+    },
+    _walk: function(visitor) {
+        this.prefix._walk(visitor);
+        this.template_string._walk(visitor);
+    }
+})
+
+var AST_TemplateString = DEFNODE("TemplateString", "segments", {
+    $documentation: "A template string literal",
+    $propdoc: {
+        segments: "[AST_TemplateSegment|AST_Expression]* One or more segments, starting with AST_TemplateSegment. AST_Expression may follow AST_TemplateSegment, but each AST_Expression must be followed by AST_TemplateSegment."
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.segments.forEach(function(seg, i){
+                if (i % 2 !== 0) {
+                    seg._walk(visitor);
+                }
+            });
+        });
+    }
+});
+
+var AST_TemplateSegment = DEFNODE("TemplateSegment", "value raw", {
+    $documentation: "A segment of a template string literal",
+    $propdoc: {
+        value: "Content of the segment",
+        raw: "Raw content of the segment"
+    }
+});
+
 /* -----[ JUMPS ]----- */
 
 var AST_Jump = DEFNODE("Jump", null, {
@@ -493,19 +686,18 @@ 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"
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            var definitions = this.definitions;
-            for (var i = 0, len = definitions.length; i < len; i++) {
-                definitions[i]._walk(visitor);
-            }
+            this.definitions.forEach(function(def){
+                def._walk(visitor);
+            });
         });
     }
 }, AST_Statement);
@@ -514,12 +706,78 @@ var AST_Var = DEFNODE("Var", null, {
     $documentation: "A `var` statement"
 }, AST_Definitions);
 
+var AST_Let = DEFNODE("Let", null, {
+    $documentation: "A `let` statement"
+}, AST_Definitions);
+
+var AST_Const = DEFNODE("Const", null, {
+    $documentation: "A `const` statement"
+}, AST_Definitions);
+
+var AST_NameImport = DEFNODE("NameImport", "foreign_name name", {
+    $documentation: "The part of the import statement that imports names from a module.",
+    $propdoc: {
+        foreign_name: "[AST_SymbolImportForeign] The name being imported (as specified in the module)",
+        name: "[AST_SymbolImport] The name as it becomes available to this module."
+    },
+    _walk: function (visitor) {
+        return visitor._visit(this, function() {
+            this.foreign_name._walk(visitor);
+            this.name._walk(visitor);
+        });
+    }
+})
+
+var AST_Import = DEFNODE("Import", "imported_name imported_names module_name", {
+    $documentation: "An `import` statement",
+    $propdoc: {
+        imported_name: "[AST_SymbolImport] The name of the variable holding the module's default export.",
+        imported_names: "[AST_NameImport*] The names of non-default imported variables",
+        module_name: "[AST_String] String literal describing where this module came from",
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, function() {
+            if (this.imported_name) {
+                this.imported_name._walk(visitor);
+            }
+            if (this.imported_names) {
+                this.imported_names.forEach(function (name_import) {
+                    name_import._walk(visitor);
+                });
+            }
+            this.module_name._walk(visitor);
+        });
+    }
+});
+
+var AST_Export = DEFNODE("Export", "exported_definition exported_value is_default", {
+    $documentation: "An `export` statement",
+    $propdoc: {
+        exported_definition: "[AST_Defun|AST_Definitions|AST_DefClass?] An exported definition",
+        exported_value: "[AST_Node?] An exported value",
+        is_default: "[Boolean] Whether this is the default exported value of this module"
+    },
+    _walk: function (visitor) {
+        visitor._visit(this, function () {
+            if (this.exported_definition) {
+                this.exported_definition._walk(visitor);
+            }
+            if (this.exported_value) {
+                this.exported_value._walk(visitor);
+            }
+        });
+    }
+}, AST_Statement);
+
 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|AST_Destructuring] name of the variable",
         value: "[AST_Node?] initializer, or null of there's no initializer"
     },
+    is_destructuring: function() {
+        return this.name instanceof AST_Destructuring;
+    },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
             this.name._walk(visitor);
@@ -538,11 +796,10 @@ var AST_Call = DEFNODE("Call", "expression args", {
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            var args = this.args;
-            for (var i = 0, len = args.length; i < len; i++) {
-                args[i]._walk(visitor);
-            }
             this.expression._walk(visitor);
+            this.args.forEach(function(arg){
+                arg._walk(visitor);
+            });
         });
     }
 });
@@ -551,16 +808,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);
         });
     }
 });
@@ -613,7 +922,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",
@@ -657,10 +966,9 @@ var AST_Array = DEFNODE("Array", "elements", {
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            var elements = this.elements;
-            for (var i = 0, len = elements.length; i < len; i++) {
-                elements[i]._walk(visitor);
-            }
+            this.elements.forEach(function(el){
+                el._walk(visitor);
+            });
         });
     }
 });
@@ -672,10 +980,9 @@ var AST_Object = DEFNODE("Object", "properties", {
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            var properties = this.properties;
-            for (var i = 0, len = properties.length; i < len; i++) {
-                properties[i]._walk(visitor);
-            }
+            this.properties.forEach(function(prop){
+                prop._walk(visitor);
+            });
         });
     }
 });
@@ -683,38 +990,99 @@ var AST_Object = DEFNODE("Object", "properties", {
 var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
     $documentation: "Base class for literal object properties",
     $propdoc: {
-        key: "[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an AST_SymbolAccessor.",
-        value: "[AST_Node] property value.  For setters and getters this is an AST_Accessor."
+        key: "[string|AST_Node] the property name converted to a string for ObjectKeyVal. For setters, getters and computed property this is an arbitrary AST_Node",
+        value: "[AST_Node] property value. For setters and getters this is an AST_Function.",
+        default: "[AST_Expression] The default for this parameter, only used when nested inside a binding pattern"
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
+            if (this.key instanceof AST_Node)
+                this.key._walk(visitor);
             this.value._walk(visitor);
         });
     }
 });
 
-var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", {
+var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote default", {
     $documentation: "A key: value object property",
     $propdoc: {
-        quote: "[string] the original quote character"
+        quote: "[string] the original quote character",
+        default: "[AST_Expression] The default parameter value, only used when nested inside a binding pattern"
     }
 }, AST_ObjectProperty);
 
-var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
+var AST_ObjectSetter = DEFNODE("ObjectSetter", "quote static", {
+    $propdoc: {
+        quote: "[string|undefined] the original quote character, if any",
+        static: "[boolean] whether this is a static setter (classes only)"
+    },
     $documentation: "An object setter property",
 }, AST_ObjectProperty);
 
-var AST_ObjectGetter = DEFNODE("ObjectGetter", null, {
+var AST_ObjectGetter = DEFNODE("ObjectGetter", "quote static", {
+    $propdoc: {
+        quote: "[string|undefined] the original quote character, if any",
+        static: "[boolean] whether this is a static getter (classes only)"
+    },
     $documentation: "An object getter property",
 }, AST_ObjectProperty);
 
-var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
+var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator", {
+    $propdoc: {
+        quote: "[string|undefined] the original quote character, if any",
+        static: "[boolean] whether this method is static (classes only)",
+        is_generator: "[boolean] is generatorFn or not",
+    },
+    $documentation: "An ES6 concise method inside an object or class"
+}, AST_ObjectProperty);
+
+var AST_Class = DEFNODE("Class", "name extends properties", {
+    $propdoc: {
+        name: "[AST_SymbolClass|AST_SymbolDefClass?] optional class name.",
+        extends: "[AST_Node]? optional parent class",
+        properties: "[AST_ObjectProperty*] array of properties"
+    },
+    $documentation: "An ES6 class",
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            if (this.name) {
+                this.name._walk(visitor);
+            }
+            if (this.extends) {
+                this.extends._walk(visitor);
+            }
+            this.properties.forEach(function(prop){
+                prop._walk(visitor);
+            });
+        });
+    },
+}, AST_Scope);
+
+var AST_DefClass = DEFNODE("DefClass", null, {
+    $documentation: "A class definition",
+}, AST_Class);
+
+var AST_ClassExpression = DEFNODE("ClassExpression", null, {
+    $documentation: "A class expression."
+}, AST_Class);
+
+var AST_Symbol = DEFNODE("Symbol", "scope name thedef default", {
     $propdoc: {
         name: "[string] name of this symbol",
         scope: "[AST_Scope/S] the current scope (not necessarily the definition scope)",
-        thedef: "[SymbolDef/S] the definition of this symbol"
+        thedef: "[SymbolDef/S] the definition of this symbol",
+        default: "[AST_Expression] The default parameter value, only used when nested inside a binding pattern"
     },
     $documentation: "Base class for all symbols",
+    _walk: function (visitor) {
+        return visitor._visit(this, function() {
+            if (this.default) this.default._walk(visitor);
+        });
+    }
+});
+
+var AST_NewTarget = DEFNODE("NewTarget", null, {
+    $documentation: "A reference to new.target"
 });
 
 var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
@@ -722,13 +1090,28 @@ 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)",
+    $propdoc: {
+        init: "[AST_Node*/S] array of initializers for this declaration."
+    },
 }, AST_Symbol);
 
 var AST_SymbolVar = DEFNODE("SymbolVar", null, {
     $documentation: "Symbol defining a variable",
 }, AST_SymbolDeclaration);
 
+var AST_SymbolBlockDeclaration = DEFNODE("SymbolBlockDeclaration", null, {
+    $documentation: "Base class for block-scoped declaration symbols"
+}, AST_SymbolDeclaration);
+
+var AST_SymbolConst = DEFNODE("SymbolConst", null, {
+    $documentation: "A constant declaration"
+}, AST_SymbolBlockDeclaration);
+
+var AST_SymbolLet = DEFNODE("SymbolLet", null, {
+    $documentation: "A block-scoped `let` declaration"
+}, AST_SymbolBlockDeclaration);
+
 var AST_SymbolFunarg = DEFNODE("SymbolFunarg", null, {
     $documentation: "Symbol naming a function argument",
 }, AST_SymbolVar);
@@ -737,13 +1120,33 @@ var AST_SymbolDefun = DEFNODE("SymbolDefun", null, {
     $documentation: "Symbol defining a function",
 }, AST_SymbolDeclaration);
 
+var AST_SymbolMethod = DEFNODE("SymbolMethod", null, {
+    $documentation: "Symbol in an object defining a method",
+}, AST_Symbol);
+
 var AST_SymbolLambda = DEFNODE("SymbolLambda", null, {
     $documentation: "Symbol naming a function expression",
 }, AST_SymbolDeclaration);
 
+var AST_SymbolDefClass = DEFNODE("SymbolDefClass", null, {
+    $documentation: "Symbol naming a class's name in a class declaration. Lexically scoped to its containing scope, and accessible within the class."
+}, AST_SymbolBlockDeclaration);
+
+var AST_SymbolClass = DEFNODE("SymbolClass", null, {
+    $documentation: "Symbol naming a class's name. Lexically scoped to the class."
+}, AST_SymbolDeclaration);
+
 var AST_SymbolCatch = DEFNODE("SymbolCatch", null, {
     $documentation: "Symbol naming the exception in catch",
-}, AST_SymbolDeclaration);
+}, AST_SymbolBlockDeclaration);
+
+var AST_SymbolImport = DEFNODE("SymbolImport", null, {
+    $documentation: "Symbol refering to an imported name",
+}, AST_SymbolBlockDeclaration);
+
+var AST_SymbolImportForeign = DEFNODE("SymbolImportForeign", null, {
+    $documentation: "A symbol imported from a module, but it is defined in the other module, and its real name is irrelevant for this module's purposes",
+}, AST_Symbol);
 
 var AST_Label = DEFNODE("Label", "references", {
     $documentation: "Symbol naming a label (declaration)",
@@ -768,6 +1171,10 @@ var AST_This = DEFNODE("This", null, {
     $documentation: "The `this` symbol",
 }, AST_Symbol);
 
+var AST_Super = DEFNODE("Super", null, {
+    $documentation: "The `super` symbol",
+}, AST_Symbol);
+
 var AST_Constant = DEFNODE("Constant", null, {
     $documentation: "Base class for all constants",
     getValue: function() {
@@ -841,6 +1248,21 @@ var AST_True = DEFNODE("True", null, {
     value: true
 }, AST_Boolean);
 
+/* -----[ Yield ]----- */
+
+var AST_Yield = DEFNODE("Yield", "expression is_star", {
+    $documentation: "A `yield` statement",
+    $propdoc: {
+        expression: "[AST_Node?] the value returned or thrown by this statement; could be null (representing undefined) but only when is_star is set to false",
+        is_star: "[Boolean] Whether this is a yield or yield* statement"
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, this.expression && function(){
+            this.expression._walk(visitor);
+        });
+    }
+});
+
 /* -----[ TreeWalker ]----- */
 
 function TreeWalker(callback) {
@@ -857,22 +1279,26 @@ TreeWalker.prototype = {
         if (!ret && descend) {
             descend.call(node);
         }
-        this.pop();
+        this.pop(node);
         return ret;
     },
     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]) {
-            this.directives[node.value] = node;
+        } else if (node instanceof AST_Directive) {
+            this.directives[node.value] = this.directives[node.value] ? "up" : true;
+        } else if (node instanceof AST_Class) {
+            this.directives = Object.create(this.directives);
+            this.directives["use strict"] = this.directives["use strict"] ? "up" : true;
         }
         this.stack.push(node);
     },
-    pop: function() {
-        if (this.stack.pop() instanceof AST_Lambda) {
+    pop: function(node) {
+        this.stack.pop();
+        if (node instanceof AST_Lambda || node instanceof AST_Class) {
             this.directives = Object.getPrototypeOf(this.directives);
         }
     },
@@ -890,11 +1316,11 @@ TreeWalker.prototype = {
         var dir = this.directives[type];
         if (dir) return dir;
         var node = this.stack[this.stack.length - 1];
-        if (node instanceof AST_Scope) {
+        if (node instanceof AST_Scope && node.body) {
             for (var i = 0; i < node.body.length; ++i) {
                 var st = node.body[i];
                 if (!(st instanceof AST_Directive)) break;
-                if (st.value == type) return st;
+                if (st.value == type) return true;
             }
         }
     },
@@ -916,16 +1342,16 @@ TreeWalker.prototype = {
             self = p;
         }
     },
-    loopcontrol_target: function(node) {
+    loopcontrol_target: function(label) {
         var stack = this.stack;
-        if (node.label) for (var i = stack.length; --i >= 0;) {
+        if (label) for (var i = stack.length; --i >= 0;) {
             var x = stack[i];
-            if (x instanceof AST_LabeledStatement && x.label.name == node.label.name)
+            if (x instanceof AST_LabeledStatement && x.label.name == label.name) {
                 return x.body;
+            }
         } else for (var i = stack.length; --i >= 0;) {
             var x = stack[i];
-            if (x instanceof AST_IterationStatement
-                || node instanceof AST_Break && x instanceof AST_Switch)
+            if (x instanceof AST_Switch || x instanceof AST_IterationStatement)
                 return x;
         }
     }

lib/minify.js

@@ -1,218 +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 init_cache(cache) {
-    if (!cache) return;
-    if (!("cname" in cache)) cache.cname = -1;
-    if (!("props" in cache)) {
-        cache.props = new Dictionary();
-    } else if (!(cache.props instanceof Dictionary)) {
-        cache.props = Dictionary.fromObject(cache.props);
-    }
-}
-
-function to_json(cache) {
-    return {
-        cname: cache.cname,
-        props: cache.props.toObject()
-    };
-}
-
-function minify(files, options) {
-    var warn_function = AST_Node.warn_function;
-    try {
-        options = defaults(options, {
-            compress: {},
-            ie8: false,
-            keep_fnames: false,
-            mangle: {},
-            nameCache: null,
-            output: {},
-            parse: {},
-            sourceMap: false,
-            timings: false,
-            toplevel: false,
-            warnings: false,
-            wrap: false,
-        }, true);
-        var timings = options.timings && {
-            start: Date.now()
-        };
-        set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
-        set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
-        set_shorthand("toplevel", options, [ "compress", "mangle" ]);
-        set_shorthand("warnings", options, [ "compress" ]);
-        var quoted_props;
-        if (options.mangle) {
-            options.mangle = defaults(options.mangle, {
-                cache: options.nameCache && (options.nameCache.vars || {}),
-                eval: false,
-                ie8: false,
-                keep_fnames: false,
-                properties: false,
-                reserved: [],
-                toplevel: false,
-            }, true);
-            if (options.mangle.properties) {
-                if (typeof options.mangle.properties != "object") {
-                    options.mangle.properties = {};
-                }
-                if (options.mangle.properties.keep_quoted) {
-                    quoted_props = options.mangle.properties.reserved;
-                    if (!Array.isArray(quoted_props)) quoted_props = [];
-                    options.mangle.properties.reserved = quoted_props;
-                }
-                if (options.nameCache && !("cache" in options.mangle.properties)) {
-                    options.mangle.properties.cache = options.nameCache.props || {};
-                }
-            }
-            init_cache(options.mangle.cache);
-            init_cache(options.mangle.properties.cache);
-        }
-        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);
-            };
-        }
-        if (timings) timings.parse = Date.now();
-        var toplevel;
-        if (files instanceof AST_Toplevel) {
-            toplevel = files;
-        } else {
-            if (typeof files == "string") {
-                files = [ files ];
-            }
-            options.parse = options.parse || {};
-            options.parse.toplevel = null;
-            for (var name in files) if (HOP(files, name)) {
-                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 (quoted_props) {
-            reserve_quoted_keys(toplevel, quoted_props);
-        }
-        if (options.wrap) {
-            toplevel = toplevel.wrap_commonjs(options.wrap);
-        }
-        if (timings) timings.compress = Date.now();
-        if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
-        if (timings) timings.scope = Date.now();
-        if (options.mangle) toplevel.figure_out_scope(options.mangle);
-        if (timings) timings.mangle = Date.now();
-        if (options.mangle) {
-            base54.reset();
-            toplevel.compute_char_frequency(options.mangle);
-            toplevel.mangle_names(options.mangle);
-        }
-        if (timings) timings.properties = Date.now();
-        if (options.mangle && options.mangle.properties) {
-            toplevel = mangle_properties(toplevel, options.mangle.properties);
-        }
-        if (timings) timings.output = Date.now();
-        var result = {};
-        if (options.output.ast) {
-            result.ast = toplevel;
-        }
-        if (!HOP(options.output, "code") || options.output.code) {
-            if (options.sourceMap) {
-                if (typeof options.sourceMap.content == "string") {
-                    options.sourceMap.content = JSON.parse(options.sourceMap.content);
-                }
-                options.output.source_map = SourceMap({
-                    file: options.sourceMap.filename,
-                    orig: options.sourceMap.content,
-                    root: options.sourceMap.root
-                });
-                if (options.sourceMap.includeSources) {
-                    if (files instanceof AST_Toplevel) {
-                        throw new Error("original source content unavailable");
-                    } else for (var name in files) if (HOP(files, name)) {
-                        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 (options.nameCache && options.mangle) {
-            if (options.mangle.cache) options.nameCache.vars = to_json(options.mangle.cache);
-            if (options.mangle.properties && options.mangle.properties.cache) {
-                options.nameCache.props = to_json(options.mangle.properties.cache);
-            }
-        }
-        if (timings) {
-            timings.end = Date.now();
-            result.timings = {
-                parse: 1e-3 * (timings.compress - timings.parse),
-                compress: 1e-3 * (timings.scope - timings.compress),
-                scope: 1e-3 * (timings.mangle - timings.scope),
-                mangle: 1e-3 * (timings.properties - timings.mangle),
-                properties: 1e-3 * (timings.output - timings.properties),
-                output: 1e-3 * (timings.end - timings.output),
-                total: 1e-3 * (timings.end - timings.start)
-            }
-        }
-        if (warnings.length) {
-            result.warnings = warnings;
-        }
-        return result;
-    } catch (ex) {
-        return { error: ex };
-    } finally {
-        AST_Node.warn_function = warn_function;
-    }
-}

lib/mozilla-ast.js

@@ -111,19 +111,23 @@
         },
         Property: function(M) {
             var key = M.key;
+            var name = key.type == "Identifier" ? key.name : key.value;
             var args = {
                 start    : my_start_token(key),
                 end      : my_end_token(M.value),
-                key      : key.type == "Identifier" ? key.name : key.value,
+                key      : name,
                 value    : from_moz(M.value)
             };
-            if (M.kind == "init") return new AST_ObjectKeyVal(args);
-            args.key = new AST_SymbolAccessor({
-                name: args.key
-            });
-            args.value = new AST_Accessor(args.value);
-            if (M.kind == "get") return new AST_ObjectGetter(args);
-            if (M.kind == "set") return new AST_ObjectSetter(args);
+            switch (M.kind) {
+              case "init":
+                return new AST_ObjectKeyVal(args);
+              case "set":
+                args.value.name = from_moz(key);
+                return new AST_ObjectSetter(args);
+              case "get":
+                args.value.name = from_moz(key);
+                return new AST_ObjectGetter(args);
+            }
         },
         ArrayExpression: function(M) {
             return new AST_Array({
@@ -145,11 +149,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 +168,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 +204,7 @@
         Identifier: function(M) {
             var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
             return new (  p.type == "LabeledStatement" ? AST_Label
-                        : p.type == "VariableDeclarator" && p.id === M ? 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
@@ -256,7 +256,10 @@
     map("CallExpression", AST_Call, "callee>expression, arguments@args");
 
     def_to_moz(AST_Toplevel, function To_Moz_Program(M) {
-        return to_moz_scope("Program", M);
+        return {
+            type: "Program",
+            body: M.body.map(to_moz)
+        };
     });
 
     def_to_moz(AST_Defun, function To_Moz_FunctionDeclaration(M) {
@@ -264,7 +267,7 @@
             type: "FunctionDeclaration",
             id: to_moz(M.name),
             params: M.argnames.map(to_moz),
-            body: to_moz_scope("BlockStatement", M)
+            body: to_moz_block(M)
         }
     });
 
@@ -273,7 +276,7 @@
             type: "FunctionExpression",
             id: to_moz(M.name),
             params: M.argnames.map(to_moz),
-            body: to_moz_scope("BlockStatement", M)
+            body: to_moz_block(M)
         }
     });
 
@@ -324,15 +327,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)
         };
     });
 
@@ -379,10 +382,11 @@
     });
 
     def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
-        var key = {
-            type: "Literal",
-            value: M.key instanceof AST_SymbolAccessor ? M.key.name : M.key
-        };
+        var key = (
+            is_identifier(M.key)
+            ? {type: "Identifier", name: M.key}
+            : {type: "Literal", value: M.key}
+        );
         var kind;
         if (M instanceof AST_ObjectKeyVal) {
             kind = "init";
@@ -543,8 +547,8 @@
         moz_to_me = new Function("U2", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
             exports, my_start_token, my_end_token, from_moz
         );
-        me_to_moz = new Function("to_moz", "to_moz_block", "to_moz_scope", "return(" + me_to_moz + ")")(
-            to_moz, to_moz_block, to_moz_scope
+        me_to_moz = new Function("to_moz", "to_moz_block", "return(" + me_to_moz + ")")(
+            to_moz, to_moz_block
         );
         MOZ_TO_ME[moztype] = moz_to_me;
         def_to_moz(mytype, me_to_moz);
@@ -602,14 +606,4 @@
         };
     };
 
-    function to_moz_scope(type, node) {
-        var body = node.body.map(to_moz);
-        if (node.body[0] instanceof AST_SimpleStatement && node.body[0].body instanceof AST_String) {
-            body.unshift(to_moz(new AST_EmptyStatement(node.body[0])));
-        }
-        return {
-            type: type,
-            body: body
-        };
-    };
 })();

lib/propmangle.js

@@ -43,19 +43,28 @@
 
 "use strict";
 
-function find_builtins(reserved) {
-    // NaN will be included due to Number.NaN
-    [
-        "null",
-        "true",
-        "false",
-        "Infinity",
-        "-Infinity",
-        "undefined",
-    ].forEach(add);
+function find_builtins() {
+
+    // Compatibility fix for some standard defined globals not defined on every js environment
+    var new_globals = ["Symbol", "Map", "Promise", "Proxy", "Reflect", "Set", "WeakMap", "WeakSet"];
+    var objects = {};
+
+    new_globals.forEach(function (new_global) {
+        objects[new_global] = global[new_global] || new Function();
+    });
+
+    var a = [];
     [ Object, Array, Function, Number,
       String, Boolean, Error, Math,
-      Date, RegExp
+      Date, RegExp, objects.Symbol, ArrayBuffer,
+      DataView, decodeURI, decodeURIComponent,
+      encodeURI, encodeURIComponent, eval, EvalError,
+      Float32Array, Float64Array, Int8Array, Int16Array,
+      Int32Array, isFinite, isNaN, JSON, objects.Map, parseFloat,
+      parseInt, objects.Promise, objects.Proxy, RangeError, ReferenceError,
+      objects.Reflect, objects.Set, SyntaxError, TypeError, Uint8Array,
+      Uint8ClampedArray, Uint16Array, Uint32Array, URIError,
+      objects.WeakMap, objects.WeakSet
     ].forEach(function(ctor){
         Object.getOwnPropertyNames(ctor).map(add);
         if (ctor.prototype) {
@@ -63,52 +72,24 @@ function find_builtins(reserved) {
         }
     });
     function add(name) {
-        push_uniq(reserved, name);
+        push_uniq(a, name);
     }
-}
-
-function reserve_quoted_keys(ast, reserved) {
-    function add(name) {
-        push_uniq(reserved, name);
-    }
-
-    ast.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_ObjectKeyVal && node.quote) {
-            add(node.key);
-        } else if (node instanceof AST_Sub) {
-            addStrings(node.property, add);
-        }
-    }));
-}
-
-function addStrings(node, add) {
-    node.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_Sequence) {
-            addStrings(node.expressions[node.expressions.length - 1], add);
-        } else if (node instanceof AST_String) {
-            add(node.value);
-        } else if (node instanceof AST_Conditional) {
-            addStrings(node.consequent, add);
-            addStrings(node.alternative, add);
-        }
-        return true;
-    }));
+    return a;
 }
 
 function mangle_properties(ast, options) {
     options = defaults(options, {
-        builtins: false,
-        cache: null,
-        debug: false,
-        keep_quoted: false,
-        only_cache: false,
-        regex: null,
-        reserved: null,
-    }, true);
+        reserved : null,
+        cache : null,
+        only_cache : false,
+        regex : null,
+        ignore_quoted : false,
+        debug : false
+    });
 
     var reserved = options.reserved;
-    if (!Array.isArray(reserved)) reserved = [];
-    if (!options.builtins) find_builtins(reserved);
+    if (reserved == null)
+        reserved = find_builtins();
 
     var cache = options.cache;
     if (cache == null) {
@@ -119,11 +100,12 @@ function mangle_properties(ast, options) {
     }
 
     var regex = options.regex;
+    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);
@@ -131,11 +113,12 @@ function mangle_properties(ast, options) {
 
     var names_to_mangle = [];
     var unmangleable = [];
+    var ignored = {};
 
     // step 1: find candidates to mangle
     ast.walk(new TreeWalker(function(node){
         if (node instanceof AST_ObjectKeyVal) {
-            add(node.key);
+            add(node.key, ignore_quoted && node.quote);
         }
         else if (node instanceof AST_ObjectProperty) {
             // setter or getter, since KeyVal is handled above
@@ -145,14 +128,18 @@ function mangle_properties(ast, options) {
             add(node.property);
         }
         else if (node instanceof AST_Sub) {
-            addStrings(node.property, add);
+            addStrings(node.property, ignore_quoted);
+        }
+        else if (node instanceof AST_ConciseMethod) {
+            add(node.name.name);
         }
     }));
 
     // step 2: transform the tree, renaming properties
     return ast.transform(new TreeTransformer(function(node){
         if (node instanceof AST_ObjectKeyVal) {
-            node.key = mangle(node.key);
+            if (!(ignore_quoted && node.quote))
+                node.key = mangle(node.key);
         }
         else if (node instanceof AST_ObjectProperty) {
             // setter or getter
@@ -161,9 +148,27 @@ function mangle_properties(ast, options) {
         else if (node instanceof AST_Dot) {
             node.property = mangle(node.property);
         }
-        else if (!options.keep_quoted && node instanceof AST_Sub) {
-            node.property = mangleStrings(node.property);
+        else if (node instanceof AST_Sub) {
+            if (!ignore_quoted)
+                node.property = mangleStrings(node.property);
         }
+        else if (node instanceof AST_ConciseMethod) {
+            if (should_mangle(node.name.name)) {
+                node.name.name = mangle(node.name.name);
+            }
+        }
+        // else if (node instanceof AST_String) {
+        //     if (should_mangle(node.value)) {
+        //         AST_Node.warn(
+        //             "Found \"{prop}\" property candidate for mangling in an arbitrary string [{file}:{line},{col}]", {
+        //                 file : node.start.file,
+        //                 line : node.start.line,
+        //                 col  : node.start.col,
+        //                 prop : node.value
+        //             }
+        //         );
+        //     }
+        // }
     }));
 
     // only function declarations after this line
@@ -174,18 +179,24 @@ function mangle_properties(ast, options) {
         if (options.only_cache) {
             return cache.props.has(name);
         }
-        if (/^-?[0-9]+(\.[0-9]+)?(e[+-][0-9]+)?$/.test(name)) return false;
+        if (/^[0-9.]+$/.test(name)) return false;
         return true;
     }
 
     function should_mangle(name) {
+        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) {
+    function add(name, ignore) {
+        if (ignore) {
+            ignored[name] = true;
+            return;
+        }
+
         if (can_mangle(name))
             push_uniq(names_to_mangle, name);
 
@@ -205,16 +216,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)) {
+                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 '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));
+                } while (!can_mangle(mangled) || (ignore_quoted && mangled in ignored));
             }
 
             cache.props.set(name, mangled);
@@ -222,11 +236,36 @@ function mangle_properties(ast, options) {
         return mangled;
     }
 
+    function addStrings(node, ignore) {
+        var out = {};
+        try {
+            (function walk(node){
+                node.walk(new TreeWalker(function(node){
+                    if (node instanceof AST_Seq) {
+                        walk(node.cdr);
+                        return true;
+                    }
+                    if (node instanceof AST_String) {
+                        add(node.value, ignore);
+                        return true;
+                    }
+                    if (node instanceof AST_Conditional) {
+                        walk(node.consequent);
+                        walk(node.alternative);
+                        return true;
+                    }
+                    throw out;
+                }));
+            })(node);
+        } catch(ex) {
+            if (ex !== out) throw ex;
+        }
+    }
+
     function mangleStrings(node) {
         return node.transform(new TreeTransformer(function(node){
-            if (node instanceof AST_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);
@@ -238,4 +277,5 @@ function mangle_properties(ast, options) {
             return node;
         }));
     }
+
 }

lib/scope.js

@@ -49,8 +49,11 @@ function SymbolDef(scope, index, orig) {
     this.scope = scope;
     this.references = [];
     this.global = false;
+    this.export = false;
     this.mangled_name = null;
+    this.object_destructuring_arg = false;
     this.undeclared = false;
+    this.constant = false;
     this.index = index;
     this.id = SymbolDef.next_id++;
 };
@@ -62,11 +65,17 @@ SymbolDef.prototype = {
         if (!options) options = {};
 
         return (this.global && !options.toplevel)
+            || this.export
+            || this.object_destructuring_arg
             || this.undeclared
             || (!options.eval && (this.scope.uses_eval || this.scope.uses_with))
             || (options.keep_fnames
                 && (this.orig[0] instanceof AST_SymbolLambda
-                    || this.orig[0] instanceof AST_SymbolDefun));
+                    || this.orig[0] instanceof AST_SymbolDefun))
+            || this.orig[0] instanceof AST_SymbolMethod
+            || (options.keep_classnames
+                && (this.orig[0] instanceof AST_SymbolClass
+                    || this.orig[0] instanceof AST_SymbolDefClass));
     },
     mangle: function(options) {
         var cache = options.cache && options.cache.props;
@@ -75,28 +84,20 @@ 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 && this.orig[0] instanceof AST_SymbolLambda)
                 s = s.parent_scope;
-            var def;
-            if (def = this.redefined()) {
-                this.mangled_name = def.mangled_name || def.name;
-            } else
-                this.mangled_name = s.next_mangled(options, this);
+            this.mangled_name = s.next_mangled(options, this);
             if (this.global && cache) {
                 cache.set(this.name, this.mangled_name);
             }
         }
-    },
-    redefined: function() {
-        return this.defun && this.defun.variables.get(this.name);
     }
 };
 
 AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     options = defaults(options, {
-        cache: null,
-        ie8: false,
+        screw_ie8: true,
+        cache: null
     });
 
     // pass 1: setup scope chaining and handle definitions
@@ -104,28 +105,49 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     var scope = self.parent_scope = null;
     var labels = new Dictionary();
     var defun = null;
+    var last_var_had_const_pragma = false;
+    var nesting = 0;
+    var in_destructuring = null;
+    var in_export;
     var tw = new TreeWalker(function(node, descend){
-        if (node instanceof AST_Catch) {
+        if (node.is_block_scope()) {
             var save_scope = scope;
             scope = new AST_Scope(node);
-            scope.init_scope_vars(save_scope);
+            scope.init_scope_vars(nesting);
+            scope.parent_scope = save_scope;
+            if (!(node instanceof AST_Scope)) {
+                scope.uses_with = save_scope.uses_with;
+                scope.uses_eval = save_scope.uses_eval;
+                scope.directives = save_scope.directives;
+            }
             descend();
             scope = save_scope;
             return true;
         }
+        if (node instanceof AST_Destructuring && node.is_array === false) {
+            in_destructuring = node;  // These don't nest
+            descend();
+            in_destructuring = null;
+            return true;
+        }
         if (node instanceof AST_Scope) {
-            node.init_scope_vars(scope);
-            var save_scope = scope;
+            node.init_scope_vars(nesting);
+            var save_scope = node.parent_scope = scope;
             var save_defun = defun;
             var save_labels = labels;
             defun = scope = node;
             labels = new Dictionary();
-            descend();
+            ++nesting; descend(); --nesting;
             scope = save_scope;
             defun = save_defun;
             labels = save_labels;
             return true;        // don't descend again in TreeWalker
         }
+        if (node instanceof AST_Export) {
+            in_export = true;
+            descend();
+            in_export = false;
+        }
         if (node instanceof AST_LabeledStatement) {
             var l = node.label;
             if (labels.has(l.name)) {
@@ -144,12 +166,16 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
         if (node instanceof AST_Symbol) {
             node.scope = scope;
         }
+        if (node instanceof AST_SymbolFunarg) {
+            node.object_destructuring_arg = !!in_destructuring;
+            defun.def_variable(node, in_export);
+        }
         if (node instanceof AST_Label) {
             node.thedef = node;
             node.references = [];
         }
         if (node instanceof AST_SymbolLambda) {
-            defun.def_function(node);
+            defun.def_function(node, in_export);
         }
         else if (node instanceof AST_SymbolDefun) {
             // Careful here, the scope where this should be defined is
@@ -157,21 +183,37 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             // scope when we encounter the AST_Defun node (which is
             // instanceof AST_Scope) but we get to the symbol a bit
             // later.
-            (node.scope = defun.parent_scope).def_function(node);
-        }
-        else if (node instanceof AST_SymbolVar) {
-            defun.def_variable(node);
-            if (defun !== scope) {
-                node.mark_enclosed(options);
-                var def = scope.find_variable(node);
-                if (node.thedef !== def) {
-                    node.thedef = def;
-                    node.reference(options);
-                }
+            var parent_lambda = defun.parent_scope;
+            while (parent_lambda.is_block_scope()) {
+                parent_lambda = parent_lambda.parent_scope;
             }
+            (node.scope = parent_lambda).def_function(node, in_export);
+        }
+        else if (node instanceof AST_SymbolClass) {
+            defun.def_variable(node, in_export);
+        }
+        else if (node instanceof AST_SymbolImport) {
+            scope.def_variable(node, in_export);
+        }
+        else if (node instanceof AST_SymbolDefClass) {
+            // This deals with the name of the class being available
+            // inside the class.
+            (node.scope = defun.parent_scope).def_function(node, in_export);
+        }
+        else if (node instanceof AST_Var) {
+            last_var_had_const_pragma = node.has_const_pragma();
+        }
+        else if (node instanceof AST_SymbolVar
+                 || node instanceof AST_SymbolConst
+                 || node instanceof AST_SymbolLet) {
+            var def = ((node instanceof AST_SymbolBlockDeclaration) ? scope : defun).def_variable(node, in_export);
+            def.constant = node instanceof AST_SymbolConst || last_var_had_const_pragma;
+            def.destructuring = in_destructuring;
+            def.init = tw.parent().value;
         }
         else if (node instanceof AST_SymbolCatch) {
-            scope.def_variable(node).defun = defun;
+            (options.screw_ie8 ? scope : defun)
+                .def_variable(node);
         }
         else if (node instanceof AST_LabelRef) {
             var sym = labels.get(node.name);
@@ -186,117 +228,111 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     self.walk(tw);
 
     // pass 2: find back references and eval
-    self.globals = new Dictionary();
+    var func = null;
+    var cls = null;
+    var globals = self.globals = new Dictionary();
     var tw = new TreeWalker(function(node, descend){
+        if (node instanceof AST_Lambda) {
+            var prev_func = func;
+            func = node;
+            descend();
+            func = prev_func;
+            return true;
+        }
+        if (node instanceof AST_Class) {
+            var prev_cls = cls;
+            cls = node;
+            descend();
+            cls = prev_cls;
+            return true;
+        }
         if (node instanceof AST_LoopControl && node.label) {
             node.label.thedef.references.push(node);
             return true;
         }
         if (node instanceof AST_SymbolRef) {
             var name = node.name;
-            if (name == "eval" && tw.parent() instanceof AST_Call) {
+            var parent = tw.parent();
+            if (name == "eval" && parent instanceof AST_Call) {
                 for (var s = node.scope; s && !s.uses_eval; s = s.parent_scope) {
                     s.uses_eval = true;
                 }
             }
             var sym = node.scope.find_variable(name);
+            if (node.scope instanceof AST_Lambda && name == "arguments") {
+                node.scope.uses_arguments = true;
+            }
             if (!sym) {
-                sym = self.def_global(node);
-            } else if (sym.scope instanceof AST_Lambda && name == "arguments") {
-                sym.scope.uses_arguments = true;
+                var g;
+                if (globals.has(name)) {
+                    g = globals.get(name);
+                } else {
+                    g = new SymbolDef(self, globals.size(), node);
+                    g.undeclared = true;
+                    g.global = true;
+                    globals.set(name, g);
+                }
+                sym = g;
             }
             node.thedef = sym;
-            node.reference(options);
-            return true;
-        }
-        // ensure mangling works if catch reuses a scope variable
-        var def;
-        if (node instanceof AST_SymbolCatch && (def = node.definition().redefined())) {
-            var s = node.scope;
-            while (s) {
-                push_uniq(s.enclosed, def);
-                if (s === def.scope) break;
-                s = s.parent_scope;
+            if (parent instanceof AST_Unary && (parent.operator === '++' || parent.operator === '--')
+             || parent instanceof AST_Assign && parent.left === node) {
+                sym.modified = true;
             }
+            node.reference();
+            return true;
         }
     });
     self.walk(tw);
 
-    // pass 3: fix up any scoping issue with IE8
-    if (options.ie8) {
-        self.walk(new TreeWalker(function(node, descend) {
-            if (node instanceof AST_SymbolCatch) {
-                var name = node.name;
-                var refs = node.thedef.references;
-                var scope = node.thedef.defun;
-                var def = scope.find_variable(name) || self.globals.get(name) || scope.def_variable(node);
-                refs.forEach(function(ref) {
-                    ref.thedef = def;
-                    ref.reference(options);
-                });
-                node.thedef = def;
-                node.reference(options);
-                return true;
-            }
-        }));
-    }
-
     if (options.cache) {
         this.cname = options.cache.cname;
     }
 });
 
-AST_Toplevel.DEFMETHOD("def_global", function(node){
-    var globals = this.globals, name = node.name;
-    if (globals.has(name)) {
-        return globals.get(name);
-    } else {
-        var g = new SymbolDef(this, globals.size(), node);
-        g.undeclared = true;
-        g.global = true;
-        globals.set(name, g);
-        return g;
-    }
+AST_Scope.DEFMETHOD("init_scope_vars", function(nesting){
+    this.variables = new Dictionary(); // map name to AST_SymbolVar (variables defined in this scope; includes functions)
+    this.functions = new Dictionary(); // map name to AST_SymbolDefun (functions defined in this scope)
+    this.uses_with = false;   // will be set to true if this or some nested scope uses the `with` statement
+    this.uses_eval = false;   // will be set to true if this or nested scope uses the global `eval`
+    this.parent_scope = null; // the parent scope
+    this.enclosed = [];       // a list of variables from this or outer scope(s) that are referenced from this or inner scopes
+    this.cname = -1;          // the current index for mangling functions/variables
+    this.nesting = nesting;   // the nesting level of this scope (0 means toplevel)
 });
 
-AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
-    this.variables = new Dictionary();  // map name to AST_SymbolVar (variables defined in this scope; includes functions)
-    this.functions = new Dictionary();  // map name to AST_SymbolDefun (functions defined in this scope)
-    this.uses_with = false;             // will be set to true if this or some nested scope uses the `with` statement
-    this.uses_eval = false;             // will be set to true if this or nested scope uses the global `eval`
-    this.parent_scope = parent_scope;   // the parent scope
-    this.enclosed = [];                 // a list of variables from this or outer scope(s) that are referenced from this or inner scopes
-    this.cname = -1;                    // the current index for mangling functions/variables
+AST_Node.DEFMETHOD("is_block_scope", function(){
+    return false; // Behaviour will be overridden by AST_Block
+});
+
+AST_Block.DEFMETHOD("is_block_scope", function(){
+    return (
+        !(this instanceof AST_Lambda) &&
+        !(this instanceof AST_Toplevel) &&
+        !(this instanceof AST_Class) &&
+        !(this instanceof AST_SwitchBranch)
+    );
 });
 
 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({
-        name: "arguments",
-        start: this.start,
-        end: this.end
-    }));
+
+    var symbol = new AST_VarDef({ name: "arguments", start: this.start, end: this.end });
+    var def = new SymbolDef(this, this.variables.size(), symbol);
+    this.variables.set(symbol.name, def);
 });
 
-AST_Symbol.DEFMETHOD("mark_enclosed", function(options) {
+AST_SymbolRef.DEFMETHOD("reference", function() {
     var def = this.definition();
+    def.references.push(this);
     var s = this.scope;
     while (s) {
         push_uniq(s.enclosed, def);
-        if (options.keep_fnames) {
-            s.functions.each(function(d) {
-                push_uniq(def.scope.enclosed, d);
-            });
-        }
         if (s === def.scope) break;
         s = s.parent_scope;
     }
-});
-
-AST_Symbol.DEFMETHOD("reference", function(options) {
-    this.definition().references.push(this);
-    this.mark_enclosed(options);
+    this.frame = this.scope.nesting - def.scope.nesting;
 });
 
 AST_Scope.DEFMETHOD("find_variable", function(name){
@@ -305,16 +341,20 @@ AST_Scope.DEFMETHOD("find_variable", function(name){
         || (this.parent_scope && this.parent_scope.find_variable(name));
 });
 
-AST_Scope.DEFMETHOD("def_function", function(symbol){
-    this.functions.set(symbol.name, this.def_variable(symbol));
+AST_Scope.DEFMETHOD("def_function", function(symbol, in_export){
+    this.functions.set(symbol.name, this.def_variable(symbol, in_export));
 });
 
-AST_Scope.DEFMETHOD("def_variable", function(symbol){
+AST_Scope.DEFMETHOD("def_variable", function(symbol, in_export){
     var def;
     if (!this.variables.has(symbol.name)) {
         def = new SymbolDef(this, this.variables.size(), symbol);
         this.variables.set(symbol.name, def);
-        def.global = !this.parent_scope;
+        def.object_destructuring_arg = symbol.object_destructuring_arg;
+        if (in_export) {
+            def.export = true;
+        }
+        def.global = !this.parent_scope && !(symbol instanceof AST_SymbolBlockDeclaration);
     } else {
         def = this.variables.get(symbol.name);
         def.orig.push(symbol);
@@ -329,8 +369,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
@@ -361,19 +401,43 @@ AST_Function.DEFMETHOD("next_mangled", function(options, def){
     }
 });
 
+AST_Scope.DEFMETHOD("references", function(sym){
+    if (sym instanceof AST_Symbol) sym = sym.definition();
+    return this.enclosed.indexOf(sym) < 0 ? null : sym;
+});
+
 AST_Symbol.DEFMETHOD("unmangleable", function(options){
     var def = this.definition();
-    return !def || def.unmangleable(options);
+    return def && def.unmangleable(options);
+});
+
+// property accessors are not mangleable
+AST_SymbolAccessor.DEFMETHOD("unmangleable", function(){
+    return true;
 });
 
 // labels are always mangleable
-AST_Label.DEFMETHOD("unmangleable", return_false);
+AST_Label.DEFMETHOD("unmangleable", function(){
+    return false;
+});
 
 AST_Symbol.DEFMETHOD("unreferenced", function(){
     return this.definition().references.length == 0
         && !(this.scope.uses_eval || this.scope.uses_with);
 });
 
+AST_Symbol.DEFMETHOD("undeclared", function(){
+    return this.definition().undeclared;
+});
+
+AST_LabelRef.DEFMETHOD("undeclared", function(){
+    return false;
+});
+
+AST_Label.DEFMETHOD("undeclared", function(){
+    return false;
+});
+
 AST_Symbol.DEFMETHOD("definition", function(){
     return this.thedef;
 });
@@ -382,23 +446,29 @@ AST_Symbol.DEFMETHOD("global", function(){
     return this.definition().global;
 });
 
+AST_Var.DEFMETHOD("has_const_pragma", function() {
+    var comments_before = this.start && this.start.comments_before;
+    var lastComment = comments_before && comments_before[comments_before.length - 1];
+    return lastComment && /@const\b/.test(lastComment.value);
+});
+
 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
-    options = defaults(options, {
+    return defaults(options, {
+        except      : [],
         eval        : false,
-        ie8         : false,
-        keep_fnames : false,
-        reserved    : [],
+        sort        : false, // Ignored. Flag retained for backwards compatibility.
         toplevel    : false,
+        screw_ie8   : true,
+        keep_fnames : false,
+        keep_classnames : false
     });
-    if (!Array.isArray(options.reserved)) options.reserved = [];
-    return options;
 });
 
 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
@@ -409,7 +479,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);
             }
         });
@@ -426,7 +496,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);
                 }
             });
@@ -439,13 +509,19 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
             node.mangled_name = name;
             return true;
         }
-        if (!options.ie8 && node instanceof AST_SymbolCatch) {
+        var mangle_with_block_scope =
+            (options.screw_ie8 && node instanceof AST_SymbolCatch) ||
+            node instanceof AST_SymbolBlockDeclaration;
+        if (mangle_with_block_scope) {
             to_mangle.push(node.definition());
             return;
         }
     });
     this.walk(tw);
-    to_mangle.forEach(function(def){ def.mangle(options) });
+    to_mangle.forEach(function(def){
+        if (def.destructuring && !def.destructuring.is_array) return;
+        def.mangle(options);
+    });
 
     if (options.cache) {
         options.cache.cname = this.cname;
@@ -454,69 +530,111 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
 
 AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
     options = this._default_mangler_options(options);
-    try {
-        AST_Node.prototype.print = function(stream, force_parens) {
-            this._print(stream, force_parens);
-            if (this instanceof AST_Symbol && !this.unmangleable(options)) {
-                base54.consider(this.name, -1);
-            } else if (options.properties) {
-                if (this instanceof AST_Dot) {
-                    base54.consider(this.property, -1);
-                } else if (this instanceof AST_Sub) {
-                    skip_string(this.property);
-                }
-            }
-        };
-        base54.consider(this.print_to_string(), 1);
-    } finally {
-        AST_Node.prototype.print = AST_Node.prototype._print;
-    }
-    base54.sort();
-
-    function skip_string(node) {
-        if (node instanceof AST_String) {
-            base54.consider(node.value, -1);
-        } else if (node instanceof AST_Conditional) {
-            skip_string(node.consequent);
-            skip_string(node.alternative);
-        } else if (node instanceof AST_Sequence) {
-            skip_string(node.expressions[node.expressions.length - 1]);
+    var tw = new TreeWalker(function(node){
+        if (node instanceof AST_Constant)
+            base54.consider(node.print_to_string());
+        else if (node instanceof AST_Return)
+            base54.consider("return");
+        else if (node instanceof AST_Throw)
+            base54.consider("throw");
+        else if (node instanceof AST_Continue)
+            base54.consider("continue");
+        else if (node instanceof AST_Break)
+            base54.consider("break");
+        else if (node instanceof AST_Debugger)
+            base54.consider("debugger");
+        else if (node instanceof AST_Directive)
+            base54.consider(node.value);
+        else if (node instanceof AST_While)
+            base54.consider("while");
+        else if (node instanceof AST_Do)
+            base54.consider("do while");
+        else if (node instanceof AST_If) {
+            base54.consider("if");
+            if (node.alternative) base54.consider("else");
         }
-    }
+        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)
+            base54.consider("for");
+        else if (node instanceof AST_ForIn)
+            base54.consider("for in");
+        else if (node instanceof AST_Switch)
+            base54.consider("switch");
+        else if (node instanceof AST_Case)
+            base54.consider("case");
+        else if (node instanceof AST_Default)
+            base54.consider("default");
+        else if (node instanceof AST_With)
+            base54.consider("with");
+        else if (node instanceof AST_ObjectSetter)
+            base54.consider("set" + (typeof node.key === "string" ? node.key : ""));
+        else if (node instanceof AST_ObjectGetter)
+            base54.consider("get" + (typeof node.key === "string" ? node.key : ""));
+        else if (node instanceof AST_ObjectKeyVal && typeof node.key === "string")
+            base54.consider(node.key);
+        else if (node instanceof AST_ConciseMethod && typeof node.key === "string")
+            base54.consider(node.key);
+        else if (node instanceof AST_New)
+            base54.consider("new");
+        else if (node instanceof AST_This)
+            base54.consider("this");
+        else if (node instanceof AST_Super)
+            base54.consider("super");
+        else if (node instanceof AST_Try)
+            base54.consider("try");
+        else if (node instanceof AST_Catch)
+            base54.consider("catch");
+        else if (node instanceof AST_Finally)
+            base54.consider("finally");
+        else if (node instanceof AST_Yield)
+            base54.consider("yield");
+        else if (node instanceof AST_Symbol && node.unmangleable(options))
+            base54.consider(node.name);
+        else if (node instanceof AST_Unary || node instanceof AST_Binary)
+            base54.consider(node.operator);
+        else if (node instanceof AST_Dot)
+            base54.consider(node.property);
+    });
+    this.walk(tw);
+    base54.sort();
 });
 
 var base54 = (function() {
-    var leading = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_".split("");
-    var digits = "0123456789".split("");
+    var string = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789";
     var chars, frequency;
     function reset() {
         frequency = Object.create(null);
-        leading.forEach(function(ch) {
-            frequency[ch] = 0;
-        });
-        digits.forEach(function(ch) {
-            frequency[ch] = 0;
-        });
+        chars = string.split("").map(function(ch){ return ch.charCodeAt(0) });
+        chars.forEach(function(ch){ frequency[ch] = 0 });
     }
-    base54.consider = function(str, delta) {
+    base54.consider = function(str){
         for (var i = str.length; --i >= 0;) {
-            frequency[str[i]] += delta;
+            var code = str.charCodeAt(i);
+            if (code in frequency) ++frequency[code];
         }
     };
-    function compare(a, b) {
-        return frequency[b] - frequency[a];
-    }
     base54.sort = function() {
-        chars = mergeSort(leading, compare).concat(mergeSort(digits, compare));
+        chars = mergeSort(chars, function(a, b){
+            if (is_digit(a) && !is_digit(b)) return 1;
+            if (is_digit(b) && !is_digit(a)) return -1;
+            return frequency[b] - frequency[a];
+        });
     };
     base54.reset = reset;
     reset();
+    base54.get = function(){ return chars };
+    base54.freq = function(){ return frequency };
     function base54(num) {
         var ret = "", base = 54;
         num++;
         do {
             num--;
-            ret += chars[num % base];
+            ret += String.fromCharCode(chars[num % base]);
             num = Math.floor(num / base);
             base = 64;
         } while (num > 0);
@@ -524,3 +642,89 @@ var base54 = (function() {
     };
     return base54;
 })();
+
+AST_Toplevel.DEFMETHOD("scope_warnings", function(options){
+    options = defaults(options, {
+        undeclared       : false, // this makes a lot of noise
+        unreferenced     : true,
+        assign_to_global : true,
+        func_arguments   : true,
+        nested_defuns    : true,
+        eval             : 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

@@ -70,7 +70,7 @@ TreeTransformer.prototype = new TreeWalker;
                     if (y !== undefined) x = y;
                 }
             }
-            tw.pop();
+            tw.pop(this);
             return x;
         });
     };
@@ -163,10 +163,18 @@ TreeTransformer.prototype = new TreeWalker;
         if (self.value) self.value = self.value.transform(tw);
     });
 
+    _(AST_Destructuring, function(self, tw) {
+        self.names = do_list(self.names, tw);
+    });
+
     _(AST_Lambda, function(self, tw){
         if (self.name) self.name = self.name.transform(tw);
         self.argnames = do_list(self.argnames, tw);
-        self.body = do_list(self.body, tw);
+        if (self.body instanceof AST_Node) {
+            self.body = self.body.transform(tw);
+        } else {
+            self.body = do_list(self.body, tw);
+        }
     });
 
     _(AST_Call, function(self, tw){
@@ -174,8 +182,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){
@@ -187,6 +196,10 @@ TreeTransformer.prototype = new TreeWalker;
         self.property = self.property.transform(tw);
     });
 
+    _(AST_Yield, function(self, tw){
+        if (self.expression) self.expression = self.expression.transform(tw);
+    });
+
     _(AST_Unary, function(self, tw){
         self.expression = self.expression.transform(tw);
     });
@@ -211,7 +224,32 @@ TreeTransformer.prototype = new TreeWalker;
     });
 
     _(AST_ObjectProperty, function(self, tw){
+        if (self.key instanceof AST_Node) {
+            self.key = self.key.transform(tw);
+        }
         self.value = self.value.transform(tw);
     });
 
+    _(AST_Class, function(self, tw){
+        if (self.name) self.name = self.name.transform(tw);
+        if (self.extends) self.extends = self.extends.transform(tw);
+        self.properties = do_list(self.properties, tw);
+    });
+
+    _(AST_Expansion, function(self, tw){
+        self.expression = self.expression.transform(tw);
+    });
+
+    _(AST_TemplateString, function(self, tw) {
+        for (var i = 0; i < self.segments.length; i++) {
+            if (!(self.segments[i] instanceof AST_TemplateSegment)) {
+                self.segments[i] = self.segments[i].transform(tw);
+            }
+        }
+    });
+
+    _(AST_PrefixedTemplateString, function(self, tw) {
+        self.template_string = self.template_string.transform(tw);
+    });
+
 })();

lib/utils.js

@@ -43,6 +43,13 @@
 
 "use strict";
 
+function array_to_hash(a) {
+    var ret = Object.create(null);
+    for (var i = 0; i < a.length; ++i)
+        ret[a[i]] = true;
+    return ret;
+};
+
 function slice(a, start) {
     return Array.prototype.slice.call(a, start || 0);
 };
@@ -71,28 +78,13 @@ function repeat_string(str, i) {
     return d;
 };
 
-function configure_error_stack(fn) {
-    Object.defineProperty(fn.prototype, "stack", {
-        get: function() {
-            var err = new Error(this.message);
-            err.name = this.name;
-            try {
-                throw err;
-            } catch(e) {
-                return e.stack;
-            }
-        }
-    });
-}
-
 function DefaultsError(msg, defs) {
-    this.message = msg;
+    Error.call(this, msg);
+    this.msg = msg;
     this.defs = defs;
 };
 DefaultsError.prototype = Object.create(Error.prototype);
 DefaultsError.prototype.constructor = DefaultsError;
-DefaultsError.prototype.name = "DefaultsError";
-configure_error_stack(DefaultsError);
 
 DefaultsError.croak = function(msg, defs) {
     throw new DefaultsError(msg, defs);
@@ -119,11 +111,9 @@ function merge(obj, ext) {
     return count;
 };
 
-function noop() {}
+function noop() {};
 function return_false() { return false; }
 function return_true() { return true; }
-function return_this() { return this; }
-function return_null() { return null; }
 
 var MAP = (function(){
     function MAP(a, f, backwards) {
@@ -180,7 +170,7 @@ function push_uniq(array, el) {
 
 function string_template(text, props) {
     return text.replace(/\{(.+?)\}/g, function(str, p){
-        return props && props[p];
+        return props[p];
     });
 };
 
@@ -330,26 +320,3 @@ Dictionary.fromObject = function(obj) {
 function HOP(obj, prop) {
     return Object.prototype.hasOwnProperty.call(obj, prop);
 }
-
-// return true if the node at the top of the stack (that means the
-// innermost node in the current output) is lexically the first in
-// a statement.
-function first_in_statement(stack) {
-    var node = stack.parent(-1);
-    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) ||
-            (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 ) ||
-            (p instanceof AST_Conditional   && p.condition === node  ) ||
-            (p instanceof AST_Binary        && p.left === node       ) ||
-            (p instanceof AST_UnaryPostfix  && p.expression === node ))
-        {
-            node = p;
-        } else {
-            return false;
-        }
-    }
-}

npm-shrinkwrap.json

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

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.1.9",
+  "version": "2.7.5",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -29,16 +29,26 @@
     "LICENSE"
   ],
   "dependencies": {
-    "commander": "~2.11.0",
-    "source-map": "~0.6.1"
+    "async": "~0.2.6",
+    "source-map": "~0.5.1",
+    "uglify-to-browserify": "~1.0.0",
+    "yargs": "~3.10.0"
   },
   "devDependencies": {
-    "acorn": "~5.1.1",
-    "mocha": "~3.5.1",
-    "semver": "~5.4.1"
+    "acorn": "~0.6.0",
+    "escodegen": "~1.3.3",
+    "esfuzz": "~0.3.1",
+    "estraverse": "~1.5.1",
+    "mocha": "~2.3.4"
+  },
+  "browserify": {
+    "transform": [
+      "uglify-to-browserify"
+    ]
   },
   "scripts": {
+    "shrinkwrap": "rm ./npm-shrinkwrap.json; rm -rf ./node_modules; npm i && npm shrinkwrap && npm outdated",
     "test": "node test/run-tests.js"
   },
-  "keywords": ["uglify", "uglify-js", "minify", "minifier", "es5"]
+  "keywords": ["uglify", "uglify-js", "minify", "minifier"]
 }

test/benchmark.js

@@ -1,84 +0,0 @@
-#! /usr/bin/env node
-// -*- js -*-
-
-"use strict";
-
-var createHash = require("crypto").createHash;
-var fetch = require("./fetch");
-var fork = require("child_process").fork;
-var zlib = require("zlib");
-var args = process.argv.slice(2);
-if (!args.length) {
-    args.push("-mc");
-}
-args.push("--timings");
-var urls = [
-    "https://code.jquery.com/jquery-3.2.1.js",
-    "https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.6.4/angular.js",
-    "https://cdnjs.cloudflare.com/ajax/libs/mathjs/3.9.0/math.js",
-    "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.js",
-    "https://unpkg.com/react@15.3.2/dist/react.js",
-    "http://builds.emberjs.com/tags/v2.11.0/ember.prod.js",
-    "https://cdn.jsdelivr.net/lodash/4.17.4/lodash.js",
-    "https://cdnjs.cloudflare.com/ajax/libs/d3/4.5.0/d3.js",
-];
-var results = {};
-var remaining = 2 * urls.length;
-function done() {
-    if (!--remaining) {
-        var failures = [];
-        urls.forEach(function(url) {
-            var info = results[url];
-            console.log();
-            console.log(url);
-            console.log(info.log);
-            console.log("Original:", info.input, "bytes");
-            console.log("Uglified:", info.output, "bytes");
-            console.log("GZipped: ", info.gzip, "bytes");
-            console.log("SHA1 sum:", info.sha1);
-            if (info.code) {
-                failures.push(url);
-            }
-        });
-        if (failures.length) {
-            console.error("Benchmark failed:");
-            failures.forEach(function(url) {
-                console.error(url);
-            });
-            process.exit(1);
-        }
-    }
-}
-urls.forEach(function(url) {
-    results[url] = {
-        input: 0,
-        output: 0,
-        gzip: 0,
-        log: ""
-    };
-    fetch(url, function(err, res) {
-        if (err) throw err;
-        var uglifyjs = fork("bin/uglifyjs", args, { silent: true });
-        res.on("data", function(data) {
-            results[url].input += data.length;
-        }).pipe(uglifyjs.stdin);
-        uglifyjs.stdout.on("data", function(data) {
-            results[url].output += data.length;
-        }).pipe(zlib.createGzip({
-            level: zlib.Z_BEST_COMPRESSION
-        })).on("data", function(data) {
-            results[url].gzip += data.length;
-        }).pipe(createHash("sha1")).on("data", function(data) {
-            results[url].sha1 = data.toString("hex");
-            done();
-        });
-        uglifyjs.stderr.setEncoding("utf8");
-        uglifyjs.stderr.on("data", function(data) {
-            results[url].log += data;
-        });
-        uglifyjs.on("exit", function(code) {
-            results[url].code = code;
-            done();
-        });
-    });
-});

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/arrays.js

@@ -1,3 +1,5 @@
+// NOTE trailing comma doesn't contribute to length of an array
+// That also means the array changes length if previous element is a hole too and got cut off
 holes_and_undefined: {
     input: {
         w = [1,,];
@@ -21,19 +23,10 @@ constant_join: {
     input: {
         var a = [ "foo", "bar", "baz" ].join("");
         var a1 = [ "foo", "bar", "baz" ].join();
-        var a2 = [ "foo", "bar", "baz" ].join(null);
-        var a3 = [ "foo", "bar", "baz" ].join(void 0);
-        var a4 = [ "foo", , "baz" ].join();
-        var a5 = [ "foo", null, "baz" ].join();
-        var a6 = [ "foo", void 0, "baz" ].join();
         var b = [ "foo", 1, 2, 3, "bar" ].join("");
         var c = [ boo(), "foo", 1, 2, 3, "bar", bar() ].join("");
         var c1 = [ boo(), bar(), "foo", 1, 2, 3, "bar", bar() ].join("");
         var c2 = [ 1, 2, "foo", "bar", baz() ].join("");
-        var c3 = [ boo() + bar() + "foo", 1, 2, 3, "bar", bar() + "foo" ].join("");
-        var c4 = [ 1, 2, null, undefined, "foo", "bar", baz() ].join("");
-        var c5 = [ boo() + bar() + "foo", 1, 2, 3, "bar", bar() + "foo" ].join();
-        var c6 = [ 1, 2, null, undefined, "foo", "bar", baz() ].join();
         var d = [ "foo", 1 + 2 + "bar", "baz" ].join("-");
         var e = [].join(foo + bar);
         var f = [].join("");
@@ -42,19 +35,10 @@ constant_join: {
     expect: {
         var a = "foobarbaz";
         var a1 = "foo,bar,baz";
-        var a2 = "foonullbarnullbaz";
-        var a3 = "foo,bar,baz";
-        var a4 = "foo,,baz";
-        var a5 = "foo,,baz";
-        var a6 = "foo,,baz";
         var b = "foo123bar";
         var c = boo() + "foo123bar" + bar();
         var c1 = "" + boo() + bar() + "foo123bar" + bar();
         var c2 = "12foobar" + baz();
-        var c3 = boo() + bar() + "foo123bar" + bar() + "foo";
-        var c4 = "12foobar" + baz();
-        var c5 = [ boo() + bar() + "foo", 1, 2, 3, "bar", bar() + "foo" ].join();
-        var c6 = [ "1,2,,,foo,bar", baz() ].join();
         var d = "foo-3bar-baz";
         var e = [].join(foo + bar);
         var f = "";
@@ -91,151 +75,75 @@ constant_join_2: {
     }
 }
 
-constant_join_3: {
-    options = {
-        unsafe: true,
-        evaluate: true,
-    };
+spread_with_variable_as_last_element: {
     input: {
-        var a = [ null ].join();
-        var b = [ , ].join();
-        var c = [ , 1, , 3 ].join();
-        var d = [ foo ].join();
-        var e = [ foo, null, undefined, bar ].join("-");
-        var f = [ foo, bar ].join("");
-        var g = [ null, "foo", null, bar + "baz" ].join("");
-        var h = [ null, "foo", null, bar + "baz" ].join("-");
-        var i = [ "foo" + bar, null, baz + "moo" ].join("");
-        var j = [ foo + "bar", baz ].join("");
-        var k = [ foo, "bar" + baz ].join("");
-        var l = [ foo, bar + "baz" ].join("");
+        var values = [4, 5, 6];
+        var a = [1, 2, 3, ...values];
     }
     expect: {
-        var a = "";
-        var b = "";
-        var c = ",1,,3";
-        var d = "" + foo;
-        var e = [ foo, "-", bar ].join("-");
-        var f = "" + foo + bar;
-        var g = "foo" + bar + "baz";
-        var h = [ "-foo-", bar + "baz" ].join("-");
-        var i = "foo" + bar + baz + "moo";
-        var j = foo + "bar" + baz;
-        var k = foo + "bar" + baz;
-        var l = foo + (bar + "baz");
+        var values = [4, 5, 6];
+        var a = [1, 2, 3, ...values];
     }
 }
 
-for_loop: {
-    options = {
-        evaluate: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        unsafe: true,
-        unused: true,
-    };
+spread_with_variable_in_middle: {
     input: {
-        function f0() {
-            var a = [1, 2, 3];
-            var b = 0;
-            for (var i = 0; i < a.length; i++)
-                b += a[i];
-            return b;
-        }
-        function f1() {
-            var a = [1, 2, 3];
-            var b = 0;
-            for (var i = 0, len = a.length; i < len; i++)
-                b += a[i];
-            return b;
-        }
-        function f2() {
-            var a = [1, 2, 3];
-            for (var i = 0; i < a.length; i++)
-                a[i]++;
-            return a[2];
-        }
-        console.log(f0(), f1(), f2());
+        var values = [4, 5, 6];
+        var a = [1, 2, 3, ...values, 7,,,];
     }
     expect: {
-        function f0() {
-            var a = [1, 2, 3];
-            var b = 0;
-            for (var i = 0; i < 3; i++)
-                b += a[i];
-            return b;
-        }
-        function f1() {
-            var a = [1, 2, 3];
-            var b = 0;
-            for (var i = 0; i < 3; i++)
-                b += a[i];
-            return b;
-        }
-        function f2() {
-            var a = [1, 2, 3];
-            for (var i = 0; i < a.length; i++)
-                a[i]++;
-            return a[2];
-        }
-        console.log(f0(), f1(), f2());
+        var values = [4, 5, 6];
+        var a = [1, 2, 3, ...values, 7,,,];
     }
-    expect_stdout: "6 6 4"
 }
 
-index: {
-    options = {
-        evaluate: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unsafe: true,
-        unused: true,
-    }
+spread_with_variable_at_front: {
     input: {
-        var a = [ 1, 2 ];
-        console.log(a[0], a[1]);
+        var values = [1, 2, 3];
+        var a = [...values, 4, 5, 6];
     }
     expect: {
-        console.log(1, 2);
+        var values = [1, 2, 3];
+        var a = [...values, 4, 5, 6];
     }
-    expect_stdout: "1 2"
 }
 
-length: {
-    options = {
-        evaluate: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unsafe: true,
-        unused: true,
-    }
+spread_with_variable_at_front_after_elisions: {
     input: {
-        var a = [ 1, 2 ];
-        console.log(a.length);
+        var values = [1, 2, 3];
+        var a = [,,,...values, 4, 5, 6];
     }
     expect: {
-        console.log(2);
+        var values = [1, 2, 3];
+        var a = [,,,...values, 4, 5, 6];
     }
-    expect_stdout: "2"
 }
 
-index_length: {
-    options = {
-        evaluate: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unsafe: true,
-        unused: true,
-    }
+spread_with_array_at_end: {
     input: {
-        var a = [ 1, 2 ];
-        console.log(a[0], a.length);
+        var a = [1, 2, ...[4, 5, 6]];
     }
     expect: {
-        console.log(1, 2);
+        var a = [1, 2, ...[4, 5, 6]];
     }
-    expect_stdout: "1 2"
 }
+
+spread_with_logical_expression_at_end: {
+    options = { evaluate: true }
+    input: {
+        var a = [1, 2, 3, ...[2+2]]
+    }
+    expect: {
+        var a = [1, 2, 3, ...[4]]
+    }
+}
+
+spread_with_logical_expression_at_middle: {
+    options = { evaluate: true }
+    input: {
+        var a = [1, 1, ...[1+1, 1+2, 2+3], 8]
+    }
+    expect: {
+        var a = [1, 1, ...[2, 3, 5], 8]
+    }
+}

test/compress/arrow.js

@@ -0,0 +1,128 @@
+arrow_functions_without_body: {
+    input: {
+        var a1 = () => 42;
+        var a2 = (p) => p;
+        var a3 = p => p;
+        var a4 = (...p) => p;
+        var a5 = (b, c) => b + c;
+        var a6 = (b, ...c) => b + c[0];
+        var a7 = (...b) => b.join();
+    }
+    expect: {
+        var a1 = () => 42;
+        var a2 = (p) => p;
+        var a3 = p => p;
+        var a4 = (...p) => p;
+        var a5 = (b, c) => b + c;
+        var a6 = (b, ...c) => b + c[0];
+        var a7 = (...b) => b.join();
+    }
+}
+
+arrow_functions_with_body: {
+    input: {
+        var a1 = () => {
+            var a = 42 * Math.random();
+            return a;
+        };
+        var a2 = (p) => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a3 = p => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a4 = (...p) => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a5 = (b, c) => {
+            var result = b * c + b / c;
+            return result
+        };
+        var a6 = (b, ...c) => {
+            var result = b;
+            for (var i = 0; i < c.length; i++)
+                result += c[i];
+            return result
+        };
+        var a7 = (...b) => {
+            b.join();
+        }
+    }
+    expect: {
+        var a1 = () => {
+            var a = 42 * Math.random();
+            return a;
+        };
+        var a2 = (p) => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a3 = p => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a4 = (...p) => {
+            var a = Math.random() * p;
+            return a;
+        };
+        var a5 = (b, c) => {
+            var result = b * c + b / c;
+            return result
+        };
+        var a6 = (b, ...c) => {
+            var result = b;
+            for (var i = 0; i < c.length; i++)
+                result += c[i];
+            return result
+        };
+        var a7 = (...b) => {
+            b.join();
+        };
+    }
+}
+
+arrow_function_with_single_parameter_with_default: {
+    input: {
+        var foo = (a = 0) => doSomething(a);
+    }
+    expect_exact: "var foo=(a=0)=>doSomething(a);"
+}
+
+arrow_binding_pattern: {
+    input: {
+        var foo = ([]) => "foo";
+        var bar = ({}) => "bar";
+        var with_default = (foo = "default") => foo;
+        var object_with_default = ({foo = "default", bar: baz = "default"}) => foo;
+        var array_after_spread = (...[foo]) => foo;
+        var array_after_spread = (...{foo}) => foo;
+        var computed = ({ [compute()]: x }) => {};
+        var array_hole = ([, , ...x] = [1, 2]) => {};
+        var object_trailing_elision = ({foo,}) => {};
+        var spread_empty_array = (...[]) => "foo";
+        var spread_empty_object = (...{}) => "foo";
+    }
+    expect: {
+        var foo = ([]) => "foo";
+        var bar = ({}) => "bar";
+        var with_default = (foo = "default") => foo;
+        var object_with_default = ({foo = "default", bar: baz = "default"}) => foo;
+        var array_after_spread = (...[foo]) => foo;
+        var array_after_spread = (...{foo}) => foo;
+        var computed = ({ [compute()]: x }) => {};
+        var array_hole = ([, , ...x] = [1, 2]) => {};
+        var object_trailing_elision = ({foo,}) => {};
+        var spread_empty_array = (...[]) => "foo";
+        var spread_empty_object = (...{}) => "foo";
+    }
+}
+
+arrow_binding_pattern_strict: {
+    input: {
+        var foo = ([,]) => "foo";
+    }
+    expect_exact: 'var foo=([,])=>"foo";'
+}

test/compress/ascii.js

@@ -2,7 +2,7 @@ ascii_only_true: {
     options = {}
     beautify = {
         ascii_only : true,
-        ie8        : false,
+        screw_ie8  : true,
         beautify   : false,
     }
     input: {
@@ -13,14 +13,14 @@ ascii_only_true: {
                    "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
         }
     }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\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\'}'
+    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\'}'
 }
 
 ascii_only_false: {
     options = {}
     beautify = {
         ascii_only : false,
-        ie8        : false,
+        screw_ie8  : true,
         beautify   : false,
     }
     input: {
@@ -31,5 +31,6 @@ ascii_only_false: {
                    "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
         }
     }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\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\'}'
+    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/asm.js

@@ -104,65 +104,3 @@ asm_mixed: {
     }
 }
 
-asm_toplevel: {
-    options = {}
-    input: {
-        "use asm";
-        0.0;
-        function f() {
-            0.0;
-            (function(){
-                0.0;
-            });
-        }
-        0.0;
-    }
-    expect_exact: '"use asm";0.0;function f(){0.0;(function(){0.0})}0.0;'
-}
-
-asm_function_expression: {
-    options = {}
-    input: {
-        0.0;
-        var a = function() {
-            "use asm";
-            0.0;
-        }
-        function f() {
-            0.0;
-            return function(){
-                "use asm";
-                0.0;
-            }
-            0.0;
-        }
-        0.0;
-    }
-    expect_exact: '0;var a=function(){"use asm";0.0};function f(){0;return function(){"use asm";0.0};0}0;'
-}
-
-asm_nested_functions: {
-    options = {}
-    input: {
-        0.0;
-        function a() {
-            "use asm";
-            0.0;
-        }
-        0.0;
-        function b() {
-            0.0;
-            function c(){
-                "use asm";
-                0.0;
-            }
-            0.0;
-            function d(){
-                0.0;
-            }
-            0.0;
-        }
-        0.0;
-    }
-    expect_exact: '0;function a(){"use asm";0.0}0;function b(){0;function c(){"use asm";0.0}0;function d(){0}0}0;'
-}

test/compress/block-scope.js

@@ -0,0 +1,174 @@
+
+let_statement: {
+    input: {
+        let x = 6;
+    }
+    expect_exact: "let x=6;"
+}
+
+do_not_hoist_let: {
+    options = {
+        hoist_vars: true,
+    };
+    input: {
+        function x() {
+            if (FOO) {
+                let let1;
+                let let2;
+                var var1;
+                var var2;
+            }
+        }
+    }
+    expect: {
+        function x() {
+            var var1, var2;
+            if (FOO) {
+                let let1;
+                let let2;
+            }
+        }
+    }
+}
+
+do_not_remove_anon_blocks_if_they_have_decls: {
+    input: {
+        function x() {
+            {
+                let x;
+            }
+            {
+                var x;
+            }
+            {
+                const y;
+                class Zee {};
+            }
+        }
+        {
+            let y;
+        }
+        {
+            var y;
+        }
+    }
+    expect: {
+        function x(){
+            {
+                let x
+            }
+            var x;
+            {
+                const y;
+                class Zee {}
+            }
+        }
+        {
+            let y
+        }
+        var y;
+    }
+}
+
+remove_unused_in_global_block: {
+    options = {
+        unused: true,
+    }
+    input: {
+        {
+            let x;
+            const y;
+            class Zee {};
+            var w;
+        }
+        let ex;
+        const why;
+        class Zed {};
+        var wut;
+        console.log(x, y, Zee);
+    }
+    expect: {
+        var w;
+        var wut;
+        console.log(x, y, Zee);
+    }
+}
+
+regression_block_scope_resolves: {
+    mangle = { };
+    options = {
+        dead_code: false
+    };
+    input: {
+        (function () {
+            if(1) {
+                let x;
+                const y;
+                class Zee {};
+            }
+            if(1) {
+                let ex;
+                const why;
+                class Zi {};
+            }
+            console.log(x, y, Zee, ex, why, Zi);
+        }());
+    }
+    expect: {
+        (function () {
+            if (1) {
+                let o;
+                const n;
+                class c {};
+            }
+            if (1) {
+                let o;
+                const n;
+                class c {};
+            }
+            console.log(x, y, Zee, ex, why, Zi);
+        }());
+    }
+}
+
+switch_block_scope_mangler: {
+    mangle = {}
+    input: {
+        var fn = function(code) {
+            switch (code) {
+                case 1:
+                    let apple = code + 1;
+                    let dog = code + 4;
+                    console.log(apple, dog);
+                    break;
+                case 2:
+                    let banana = code + 2;
+                    console.log(banana);
+                    break;
+                default:
+                    let cat = code + 3;
+                    console.log(cat);
+            }
+        };
+    }
+    expect: {
+        var fn = function(o) {
+            switch (o) {
+              case 1:
+                let e = o + 1
+                let c = o + 4;
+                console.log(e, c);
+                break;
+
+              case 2:
+                let l = o + 2;
+                console.log(l);
+                break;
+
+              default:
+                let a = o + 3;
+                console.log(a);
+            }
+        };
+    }
+}

test/compress/comparing.js

@@ -73,42 +73,4 @@ dont_change_in_or_instanceof_expressions: {
         1 instanceof 1;
         null instanceof null;
     }
-}
-
-self_comparison_1: {
-    options = {
-        comparisons: true,
-    }
-    input: {
-        a === a;
-        a !== b;
-        b.c === a.c;
-        b.c !== b.c;
-    }
-    expect: {
-        a == a;
-        a !== b;
-        b.c === a.c;
-        b.c != b.c;
-    }
-}
-
-self_comparison_2: {
-    options = {
-        comparisons: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-    }
-    input: {
-        function f() {}
-        var o = {};
-        console.log(f != f, o === o);
-    }
-    expect: {
-        function f() {}
-        var o = {};
-        console.log(false, true);
-    }
-    expect_stdout: "false true"
-}
+}

test/compress/concat-strings.js

@@ -21,203 +21,6 @@ concat_1: {
         var c = 1 + x() + 2 + "boo";
         var d = 1 + x() + 2 + 3 + "boo";
         var e = 1 + x() + 2 + "X3boo";
-        var f = "\x00360\x008\0";
+        var f = "\x00360\08\0";
     }
 }
-
-concat_2: {
-    options = {};
-    input: {
-        console.log(
-            1 + (2 + 3),
-            1 + (2 + "3"),
-            1 + ("2" + 3),
-            1 + ("2" + "3"),
-            "1" + (2 + 3),
-            "1" + (2 + "3"),
-            "1" + ("2" + 3),
-            "1" + ("2" + "3")
-        );
-    }
-    expect: {
-        console.log(
-            1 + (2 + 3),
-            1 + (2 + "3"),
-            1 + "2" + 3,
-            1 + "2" + "3",
-            "1" + (2 + 3),
-            "1" + 2 + "3",
-            "1" + "2" + 3,
-            "1" + "2" + "3"
-        );
-    }
-    expect_stdout: true
-}
-
-concat_3: {
-    options = {};
-    input: {
-        console.log(
-            1 + 2 + (3 + 4 + 5),
-            1 + 2 + (3 + 4 + "5"),
-            1 + 2 + (3 + "4" + 5),
-            1 + 2 + (3 + "4" + "5"),
-            1 + 2 + ("3" + 4 + 5),
-            1 + 2 + ("3" + 4 + "5"),
-            1 + 2 + ("3" + "4" + 5),
-            1 + 2 + ("3" + "4" + "5")
-        );
-    }
-    expect: {
-        console.log(
-            1 + 2 + (3 + 4 + 5),
-            1 + 2 + (3 + 4 + "5"),
-            1 + 2 + (3 + "4") + 5,
-            1 + 2 + (3 + "4") + "5",
-            1 + 2 + "3" + 4 + 5,
-            1 + 2 + "3" + 4 + "5",
-            1 + 2 + "3" + "4" + 5,
-            1 + 2 + "3" + "4" + "5"
-        );
-    }
-    expect_stdout: true
-}
-
-concat_4: {
-    options = {};
-    input: {
-        console.log(
-            1 + "2" + (3 + 4 + 5),
-            1 + "2" + (3 + 4 + "5"),
-            1 + "2" + (3 + "4" + 5),
-            1 + "2" + (3 + "4" + "5"),
-            1 + "2" + ("3" + 4 + 5),
-            1 + "2" + ("3" + 4 + "5"),
-            1 + "2" + ("3" + "4" + 5),
-            1 + "2" + ("3" + "4" + "5")
-        );
-    }
-    expect: {
-        console.log(
-            1 + "2" + (3 + 4 + 5),
-            1 + "2" + (3 + 4) + "5",
-            1 + "2" + 3 + "4" + 5,
-            1 + "2" + 3 + "4" + "5",
-            1 + "2" + "3" + 4 + 5,
-            1 + "2" + "3" + 4 + "5",
-            1 + "2" + "3" + "4" + 5,
-            1 + "2" + "3" + "4" + "5"
-        );
-    }
-    expect_stdout: true
-}
-
-concat_5: {
-    options = {};
-    input: {
-        console.log(
-            "1" + 2 + (3 + 4 + 5),
-            "1" + 2 + (3 + 4 + "5"),
-            "1" + 2 + (3 + "4" + 5),
-            "1" + 2 + (3 + "4" + "5"),
-            "1" + 2 + ("3" + 4 + 5),
-            "1" + 2 + ("3" + 4 + "5"),
-            "1" + 2 + ("3" + "4" + 5),
-            "1" + 2 + ("3" + "4" + "5")
-        );
-    }
-    expect: {
-        console.log(
-            "1" + 2 + (3 + 4 + 5),
-            "1" + 2 + (3 + 4) + "5",
-            "1" + 2 + 3 + "4" + 5,
-            "1" + 2 + 3 + "4" + "5",
-            "1" + 2 + "3" + 4 + 5,
-            "1" + 2 + "3" + 4 + "5",
-            "1" + 2 + "3" + "4" + 5,
-            "1" + 2 + "3" + "4" + "5"
-        );
-    }
-    expect_stdout: true
-}
-
-concat_6: {
-    options = {};
-    input: {
-        console.log(
-            "1" + "2" + (3 + 4 + 5),
-            "1" + "2" + (3 + 4 + "5"),
-            "1" + "2" + (3 + "4" + 5),
-            "1" + "2" + (3 + "4" + "5"),
-            "1" + "2" + ("3" + 4 + 5),
-            "1" + "2" + ("3" + 4 + "5"),
-            "1" + "2" + ("3" + "4" + 5),
-            "1" + "2" + ("3" + "4" + "5")
-        );
-    }
-    expect: {
-        console.log(
-            "1" + "2" + (3 + 4 + 5),
-            "1" + "2" + (3 + 4) + "5",
-            "1" + "2" + 3 + "4" + 5,
-            "1" + "2" + 3 + "4" + "5",
-            "1" + "2" + "3" + 4 + 5,
-            "1" + "2" + "3" + 4 + "5",
-            "1" + "2" + "3" + "4" + 5,
-            "1" + "2" + "3" + "4" + "5"
-        );
-    }
-    expect_stdout: true
-}
-
-concat_7: {
-    input: {
-        console.log(
-            "" + 1,
-            "" + "1",
-            "" + 1 + 2,
-            "" + 1 + "2",
-            "" + "1" + 2,
-            "" + "1" + "2",
-            "" + (x += "foo")
-        );
-    }
-    expect: {
-        console.log(
-            "" + 1,
-            "1",
-            "" + 1 + 2,
-            1 + "2",
-            "1" + 2,
-            "1" + "2",
-            x += "foo"
-        );
-    }
-    expect_stdout: true
-}
-
-concat_8: {
-    input: {
-        console.log(
-            1 + "",
-            "1" + "",
-            1 + 2 + "",
-            1 + "2" + "",
-            "1" + 2 + "",
-            "1" + "2" + "",
-            (x += "foo") + ""
-        );
-    }
-    expect: {
-        console.log(
-            1 + "",
-            "1",
-            1 + 2 + "",
-            1 + "2",
-            "1" + 2,
-            "1" + "2",
-            x += "foo"
-        );
-    }
-    expect_stdout: true
-}

test/compress/conditionals.js

@@ -50,8 +50,7 @@ ifs_3_should_warn: {
         conditionals : true,
         dead_code    : true,
         evaluate     : true,
-        booleans     : true,
-        side_effects : true,
+        booleans     : true
     };
     input: {
         var x, y;
@@ -136,28 +135,16 @@ ifs_6: {
         comparisons: true
     };
     input: {
-        var x, y;
+        var x;
         if (!foo && !bar && !baz && !boo) {
             x = 10;
         } else {
             x = 20;
         }
-        if (y) {
-            x[foo] = 10;
-        } else {
-            x[foo] = 20;
-        }
-        if (foo) {
-            x[bar] = 10;
-        } else {
-            x[bar] = 20;
-        }
     }
     expect: {
-        var x, y;
+        var x;
         x = foo || bar || baz || boo ? 20 : 10;
-        x[foo] = y ? 10 : 20;
-        foo ? x[bar] = 10 : x[bar] = 20;
     }
 }
 
@@ -172,16 +159,10 @@ cond_1: {
         } else {
             do_something(y);
         }
-        if (some_condition()) {
-            side_effects(x);
-        } else {
-            side_effects(y);
-        }
     }
     expect: {
         var do_something;
         do_something(some_condition() ? x : y);
-        some_condition() ? side_effects(x) : side_effects(y);
     }
 }
 
@@ -232,16 +213,10 @@ cond_4: {
         } else {
             do_something();
         }
-        if (some_condition()) {
-            side_effects();
-        } else {
-            side_effects();
-        }
     }
     expect: {
         var do_something;
         some_condition(), do_something();
-        some_condition(), side_effects();
     }
 }
 
@@ -275,8 +250,7 @@ cond_5: {
 cond_7: {
     options = {
         conditionals: true,
-        evaluate    : true,
-        side_effects: true,
+        evaluate    : true
     };
     input: {
         var x, y, z, a, b;
@@ -661,6 +635,166 @@ ternary_boolean_alternative: {
     }
 }
 
+conditional_and: {
+    options = {
+        conditionals: true,
+        evaluate    : true
+    };
+    input: {
+        var a;
+        // compress these
+
+        a = true     && condition;
+        a = 1        && console.log("a");
+        a = 2 * 3    && 2 * condition;
+        a = 5 == 5   && condition + 3;
+        a = "string" && 4 - condition;
+        a = 5 + ""   && condition / 5;
+        a = -4.5     && 6 << condition;
+        a = 6        && 7;
+
+        a = false     && condition;
+        a = NaN       && console.log("b");
+        a = 0         && console.log("c");
+        a = undefined && 2 * condition;
+        a = null      && condition + 3;
+        a = 2 * 3 - 6 && 4 - condition;
+        a = 10 == 7   && condition / 5;
+        a = !"string" && 6 % condition;
+        a = 0         && 7;
+
+        // don't compress these
+
+        a = condition        && true;
+        a = console.log("a") && 2;
+        a = 4 - condition    && "string";
+        a = 6 << condition   && -4.5;
+
+        a = condition        && false;
+        a = console.log("b") && NaN;
+        a = console.log("c") && 0;
+        a = 2 * condition    && undefined;
+        a = condition + 3    && null;
+
+    }
+    expect: {
+        var a;
+
+        a = condition;
+        a = console.log("a");
+        a = 2 * condition;
+        a = condition + 3;
+        a = 4 - condition;
+        a = condition / 5;
+        a = 6 << condition;
+        a = 7;
+
+        a = false;
+        a = NaN;
+        a = 0;
+        a = void 0;
+        a = null;
+        a = 0;
+        a = false;
+        a = false;
+        a = 0;
+
+        a = condition        && true;
+        a = console.log("a") && 2;
+        a = 4 - condition    && "string";
+        a = 6 << condition   && -4.5;
+
+        a = condition        && false;
+        a = console.log("b") && NaN;
+        a = console.log("c") && 0;
+        a = 2 * condition    && void 0;
+        a = condition + 3    && null;
+    }
+}
+
+conditional_or: {
+    options = {
+        conditionals: true,
+        evaluate    : true
+    };
+    input: {
+        var a;
+        // compress these
+
+        a = true     || condition;
+        a = 1        || console.log("a");
+        a = 2 * 3    || 2 * condition;
+        a = 5 == 5   || condition + 3;
+        a = "string" || 4 - condition;
+        a = 5 + ""   || condition / 5;
+        a = -4.5     || 6 << condition;
+        a = 6        || 7;
+
+        a = false     || condition;
+        a = 0         || console.log("b");
+        a = NaN       || console.log("c");
+        a = undefined || 2 * condition;
+        a = null      || condition + 3;
+        a = 2 * 3 - 6 || 4 - condition;
+        a = 10 == 7   || condition / 5;
+        a = !"string" || 6 % condition;
+        a = null      || 7;
+
+        a = console.log(undefined && condition || null);
+        a = console.log(undefined || condition && null);
+
+        // don't compress these
+
+        a = condition        || true;
+        a = console.log("a") || 2;
+        a = 4 - condition    || "string";
+        a = 6 << condition   || -4.5;
+
+        a = condition        || false;
+        a = console.log("b") || NaN;
+        a = console.log("c") || 0;
+        a = 2 * condition    || undefined;
+        a = condition + 3    || null;
+
+    }
+    expect: {
+        var a;
+
+        a = true;
+        a = 1;
+        a = 6;
+        a = true;
+        a = "string";
+        a = "5";
+        a = -4.5;
+        a = 6;
+
+        a = condition;
+        a = console.log("b");
+        a = console.log("c");
+        a = 2 * condition;
+        a = condition + 3;
+        a = 4 - condition;
+        a = condition / 5;
+        a = 6 % condition;
+        a = 7;
+
+        a = console.log(null);
+        a = console.log(condition && null);
+
+        a = condition        || true;
+        a = console.log("a") || 2;
+        a = 4 - condition    || "string";
+        a = 6 << condition   || -4.5;
+
+        a = condition        || false;
+        a = console.log("b") || NaN;
+        a = console.log("c") || 0;
+        a = 2 * condition    || void 0;
+        a = condition + 3    || null;
+    }
+}
+
 trivial_boolean_ternary_expressions : {
     options = {
         conditionals: true,
@@ -740,7 +874,6 @@ issue_1154: {
         conditionals: true,
         evaluate    : true,
         booleans    : true,
-        side_effects: true,
     };
     input: {
         function f1(x) { return x ? -1 : -1; }
@@ -769,249 +902,7 @@ issue_1154: {
         function g2() { return g(), 2; }
         function g3() { return g(), -4; }
         function g4() { return g(), !1; }
-        function g5() { return void g(); }
+        function g5() { return g(), void 0; }
         function g6() { return g(), "number"; }
     }
 }
-
-no_evaluate: {
-    options = {
-        conditionals: true,
-        evaluate    : false,
-        side_effects: true,
-    }
-    input: {
-        function f(b) {
-            a = b ? !0 : !0;
-            a = b ? ~1 : ~1;
-            a = b ? -2 : -2;
-            a = b ? +3 : +3;
-        }
-    }
-    expect: {
-        function f(b) {
-            a = !0;
-            a = ~1;
-            a = -2;
-            a = +3;
-        }
-    }
-}
-
-equality_conditionals_false: {
-    options = {
-        conditionals: false,
-        sequences: true,
-    }
-    input: {
-        function f(a, b, c) {
-            console.log(
-                a == (b ? a : a),
-                a == (b ? a : c),
-                a != (b ? a : a),
-                a != (b ? a : c),
-                a === (b ? a : a),
-                a === (b ? a : c),
-                a !== (b ? a : a),
-                a !== (b ? a : c)
-            );
-        }
-        f(0, 0, 0);
-        f(0, true, 0);
-        f(1, 2, 3);
-        f(1, null, 3);
-        f(NaN);
-        f(NaN, "foo");
-    }
-    expect: {
-        function f(a, b, c) {
-            console.log(
-                a == (b ? a : a),
-                a == (b ? a : c),
-                a != (b ? a : a),
-                a != (b ? a : c),
-                a === (b ? a : a),
-                a === (b ? a : c),
-                a !== (b ? a : a),
-                a !== (b ? a : c)
-            );
-        }
-        f(0, 0, 0),
-        f(0, true, 0),
-        f(1, 2, 3),
-        f(1, null, 3),
-        f(NaN),
-        f(NaN, "foo");
-    }
-    expect_stdout: true
-}
-
-equality_conditionals_true: {
-    options = {
-        conditionals: true,
-        sequences: true,
-    }
-    input: {
-        function f(a, b, c) {
-            console.log(
-                a == (b ? a : a),
-                a == (b ? a : c),
-                a != (b ? a : a),
-                a != (b ? a : c),
-                a === (b ? a : a),
-                a === (b ? a : c),
-                a !== (b ? a : a),
-                a !== (b ? a : c)
-            );
-        }
-        f(0, 0, 0);
-        f(0, true, 0);
-        f(1, 2, 3);
-        f(1, null, 3);
-        f(NaN);
-        f(NaN, "foo");
-    }
-    expect: {
-        function f(a, b, c) {
-            console.log(
-                (b, a == a),
-                a == (b ? a : c),
-                (b, a != a),
-                a != (b ? a : c),
-                (b, a === a),
-                a === (b ? a : c),
-                (b, a !== a),
-                a !== (b ? a : c)
-            );
-        }
-        f(0, 0, 0),
-        f(0, true, 0),
-        f(1, 2, 3),
-        f(1, null, 3),
-        f(NaN),
-        f(NaN, "foo");
-    }
-    expect_stdout: true
-}
-
-issue_1645_1: {
-    options = {
-        conditionals: true,
-    }
-    input: {
-        var a = 100, b = 10;
-        (b = a) ? a++ + (b += a) ? b += a : b += a : b ^= a;
-        console.log(a, b);
-    }
-    expect: {
-        var a = 100, b = 10;
-        (b = a) ? (a++ + (b += a), b += a) : b ^= a;
-        console.log(a,b);
-    }
-    expect_stdout: true
-}
-
-issue_1645_2: {
-    options = {
-        conditionals: true,
-    }
-    input: {
-        var a = 0;
-        function f() {
-            return a++;
-        }
-        f() ? a += 2 : a += 4;
-        console.log(a);
-    }
-    expect: {
-        var a = 0;
-        function f(){
-            return a++;
-        }
-        f() ? a += 2 : a += 4;
-        console.log(a);
-    }
-    expect_stdout: true
-}
-
-condition_symbol_matches_consequent: {
-    options = {
-        conditionals: true,
-    }
-    input: {
-        function foo(x, y) {
-            return x ? x : y;
-        }
-        function bar() {
-            return g ? g : h;
-        }
-        var g = 4;
-        var h = 5;
-        console.log(foo(3, null), foo(0, 7), foo(true, false), bar());
-    }
-    expect: {
-        function foo(x, y) {
-            return x || y;
-        }
-        function bar() {
-            return g || h;
-        }
-        var g = 4;
-        var h = 5;
-        console.log(foo(3, null), foo(0, 7), foo(true, false), bar());
-    }
-    expect_stdout: "3 7 true 4"
-}
-
-delete_conditional_1: {
-    options = {
-        booleans: true,
-        conditionals: true,
-        evaluate: true,
-        side_effects: true,
-    }
-    input: {
-        console.log(delete (1 ? undefined : x));
-        console.log(delete (1 ? void 0 : x));
-        console.log(delete (1 ? Infinity : x));
-        console.log(delete (1 ? 1 / 0 : x));
-        console.log(delete (1 ? NaN : x));
-        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);
-    }
-    expect_stdout: true
-}
-
-delete_conditional_2: {
-    options = {
-        booleans: true,
-        conditionals: true,
-        evaluate: true,
-        keep_infinity: true,
-        side_effects: true,
-    }
-    input: {
-        console.log(delete (0 ? x : undefined));
-        console.log(delete (0 ? x : void 0));
-        console.log(delete (0 ? x : Infinity));
-        console.log(delete (0 ? x : 1 / 0));
-        console.log(delete (0 ? x : NaN));
-        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);
-    }
-    expect_stdout: true
-}

test/compress/dead-code.js

@@ -31,7 +31,7 @@ dead_code_2_should_warn: {
         function f() {
             g();
             x = 10;
-            throw new Error("foo");
+            throw "foo";
             // completely discarding the `if` would introduce some
             // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
             // we copy any declarations to the upper scope.
@@ -46,60 +46,16 @@ dead_code_2_should_warn: {
                 })();
             }
         }
-        f();
     }
     expect: {
         function f() {
             g();
             x = 10;
-            throw new Error("foo");
+            throw "foo";
             var x;
             function g(){};
         }
-        f();
     }
-    expect_stdout: true
-    node_version: "<=4"
-}
-
-dead_code_2_should_warn_strict: {
-    options = {
-        dead_code: true
-    };
-    input: {
-        "use strict";
-        function f() {
-            g();
-            x = 10;
-            throw new Error("foo");
-            // completely discarding the `if` would introduce some
-            // bugs.  UglifyJS v1 doesn't deal with this issue; in v2
-            // we copy any declarations to the upper scope.
-            if (x) {
-                y();
-                var x;
-                function g(){};
-                // but nested declarations should not be kept.
-                (function(){
-                    var q;
-                    function y(){};
-                })();
-            }
-        }
-        f();
-    }
-    expect: {
-        "use strict";
-        function f() {
-            g();
-            x = 10;
-            throw new Error("foo");
-            var x;
-        }
-        f();
-    }
-    expect_stdout: true
-    node_version: ">=4"
 }
 
 dead_code_constant_boolean_should_warn_more: {
@@ -108,8 +64,7 @@ dead_code_constant_boolean_should_warn_more: {
         loops        : true,
         booleans     : true,
         conditionals : true,
-        evaluate     : true,
-        side_effects : true,
+        evaluate     : true
     };
     input: {
         while (!((foo && bar) || (x + "0"))) {
@@ -122,7 +77,6 @@ dead_code_constant_boolean_should_warn_more: {
             foo();
             var moo;
         }
-        bar();
     }
     expect: {
         var foo;
@@ -131,287 +85,144 @@ dead_code_constant_boolean_should_warn_more: {
         // as for the for, it should keep:
         var x = 10, y;
         var moo;
-        bar();
     }
-    expect_stdout: true
-    node_version: "<=4"
 }
 
-dead_code_constant_boolean_should_warn_more_strict: {
+dead_code_block_decls_die: {
+    options = {
+        dead_code    : true,
+        conditionals : true,
+        booleans     : true,
+        evaluate     : true
+    };
+    input: {
+        if (0) {
+            let foo = 6;
+            const bar = 12;
+            class Baz {};
+            var qux;
+        }
+        console.log(foo, bar, Baz);
+    }
+    expect: {
+        var qux;
+        console.log(foo, bar, Baz);
+    }
+}
+
+dead_code_const_declaration: {
     options = {
         dead_code    : true,
         loops        : true,
         booleans     : true,
         conditionals : true,
-        evaluate     : true,
-        side_effects : true,
+        evaluate     : true
     };
     input: {
-        "use strict";
-        while (!((foo && bar) || (x + "0"))) {
+        var unused;
+        const CONST_FOO = false;
+        if (CONST_FOO) {
             console.log("unreachable");
-            var foo;
+            var moo;
             function bar() {}
         }
-        for (var x = 10, y; x && (y || x) && (!typeof x); ++x) {
-            asdf();
-            foo();
-            var moo;
-        }
-        bar();
     }
     expect: {
-        "use strict";
-        var foo;
-        // nothing for the while
-        // as for the for, it should keep:
-        var x = 10, y;
+        var unused;
+        const CONST_FOO = !1;
         var moo;
-        bar();
+        function bar() {}
     }
-    expect_stdout: true
-    node_version: ">=4"
 }
 
-try_catch_finally: {
+dead_code_const_annotation: {
     options = {
-        conditionals: true,
-        dead_code: true,
-        evaluate: true,
-    }
+        dead_code    : true,
+        loops        : true,
+        booleans     : true,
+        conditionals : true,
+        evaluate     : true
+    };
     input: {
-        var a = 1;
-        !function() {
-            try {
-                if (false) throw x;
-            } catch (a) {
-                var a = 2;
-                console.log("FAIL");
-            } finally {
-                a = 3;
-                console.log("PASS");
+        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() {}
+    }
+}
+
+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');
+    }
+}
+
+dead_code_const_annotation_complex_scope: {
+    options = {
+        dead_code    : true,
+        loops        : true,
+        booleans     : true,
+        conditionals : true,
+        evaluate     : 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');
             }
-        }();
-        try {
-            console.log(a);
-        } finally {
         }
     }
     expect: {
-        var a = 1;
-        !function() {
-            var a;
-            a = 3;
-            console.log("PASS");
-        }();
-        try {
-            console.log(a);
-        } finally {
-        }
-    }
-    expect_stdout: [
-        "PASS",
-        "1",
-    ]
-}
-
-accessor: {
-    options = {
-        side_effects: true,
-    }
-    input: {
-        ({
-            get a() {},
-            set a(v){
-                this.b = 2;
-            },
-            b: 1
-        });
-    }
-    expect: {}
-}
-
-issue_2233_1: {
-    options = {
-        pure_getters: "strict",
-        side_effects: true,
-        unsafe: true,
-    }
-    input: {
-        Array.isArray;
-        Boolean;
-        console.log;
-        Date;
-        decodeURI;
-        decodeURIComponent;
-        encodeURI;
-        encodeURIComponent;
-        Error.name;
-        escape;
-        eval;
-        EvalError;
-        Function.length;
-        isFinite;
-        isNaN;
-        JSON;
-        Math.random;
-        Number.isNaN;
-        parseFloat;
-        parseInt;
-        RegExp;
-        Object.defineProperty;
-        String.fromCharCode;
-        RangeError;
-        ReferenceError;
-        SyntaxError;
-        TypeError;
-        unescape;
-        URIError;
-    }
-    expect: {}
-    expect_stdout: true
-}
-
-global_timeout_and_interval_symbols: {
-    options = {
-        pure_getters: "strict",
-        side_effects: true,
-        unsafe: true,
-    }
-    input: {
-        // These global symbols do not exist in the test sandbox
-        // and must be tested separately.
-        clearInterval;
-        clearTimeout;
-        setInterval;
-        setTimeout;
-    }
-    expect: {}
-}
-
-issue_2233_2: {
-    options = {
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        unsafe: true,
-        unused: true,
-    }
-    input: {
-        var RegExp;
-        Array.isArray;
-        RegExp;
-        UndeclaredGlobal;
-        function foo() {
-            var Number;
-            AnotherUndeclaredGlobal;
-            Math.sin;
-            Number.isNaN;
-        }
-    }
-    expect: {
-        var RegExp;
-        UndeclaredGlobal;
-        function foo() {
-            var Number;
-            AnotherUndeclaredGlobal;
-            Number.isNaN;
-        }
+        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';
+        'good' === pork && console.log('reached, not const');
     }
 }
-
-issue_2233_3: {
-    options = {
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        toplevel: true,
-        unsafe: true,
-        unused: true,
-    }
-    input: {
-        var RegExp;
-        Array.isArray;
-        RegExp;
-        UndeclaredGlobal;
-        function foo() {
-            var Number;
-            AnotherUndeclaredGlobal;
-            Math.sin;
-            Number.isNaN;
-        }
-    }
-    expect: {
-        UndeclaredGlobal;
-    }
-}
-
-global_fns: {
-    options = {
-        side_effects: true,
-        unsafe: true,
-    }
-    input: {
-        Boolean(1, 2);
-        decodeURI(1, 2);
-        decodeURIComponent(1, 2);
-        Date(1, 2);
-        encodeURI(1, 2);
-        encodeURIComponent(1, 2);
-        Error(1, 2);
-        escape(1, 2);
-        EvalError(1, 2);
-        isFinite(1, 2);
-        isNaN(1, 2);
-        Number(1, 2);
-        Object(1, 2);
-        parseFloat(1, 2);
-        parseInt(1, 2);
-        RangeError(1, 2);
-        ReferenceError(1, 2);
-        String(1, 2);
-        SyntaxError(1, 2);
-        TypeError(1, 2);
-        unescape(1, 2);
-        URIError(1, 2);
-        try {
-            Function(1, 2);
-        } catch (e) {
-            console.log(e.name);
-        }
-        try {
-            RegExp(1, 2);
-        } catch (e) {
-            console.log(e.name);
-        }
-        try {
-            Array(NaN);
-        } catch (e) {
-            console.log(e.name);
-        }
-    }
-    expect: {
-        try {
-            Function(1, 2);
-        } catch (e) {
-            console.log(e.name);
-        }
-        try {
-            RegExp(1, 2);
-        } catch (e) {
-            console.log(e.name);
-        }
-        try {
-            Array(NaN);
-        } catch (e) {
-            console.log(e.name);
-        }
-    }
-    expect_stdout: [
-        "SyntaxError",
-        "SyntaxError",
-        "RangeError",
-    ]
-}

test/compress/destructuring.js

@@ -0,0 +1,106 @@
+destructuring_arrays: {
+    input: {
+        {const [aa, bb] = cc;}
+        {const [aa, [bb, cc]] = dd;}
+        {let [aa, bb] = cc;}
+        {let [aa, [bb, cc]] = dd;}
+        var [aa, bb] = cc;
+        var [aa, [bb, cc]] = dd;
+        var [,[,,,,,],,,zz,] = xx; // Trailing comma
+        var [,,zzz,,] = xxx; // Trailing comma after hole
+    }
+    expect: {
+        {const [aa, bb] = cc;}
+        {const [aa, [bb, cc]] = dd;}
+        {let [aa, bb] = cc;}
+        {let [aa, [bb, cc]] = dd;}
+        var [aa, bb] = cc;
+        var [aa, [bb, cc]] = dd;
+        var [,[,,,,,],,,zz] = xx;
+        var [,,zzz,,] = xxx;
+    }
+}
+
+destructuring_arrays_holes: {
+    input: {
+        var [,,,,] = a;
+        var [,,b,] = c;
+        var [d,,]  = e;
+    }
+    expect_exact: "var[,,,,]=a;var[,,b]=c;var[d,,]=e;"
+}
+
+destructuring_objects: {
+    input: {
+        {const {aa, bb} = {aa:1, bb:2};}
+        {const {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        {let {aa, bb} = {aa:1, bb:2};}
+        {let {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        var {aa, bb} = {aa:1, bb:2};
+        var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
+    }
+    expect: {
+        {const {aa, bb} = {aa:1, bb:2};}
+        {const {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        {let {aa, bb} = {aa:1, bb:2};}
+        {let {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
+        var {aa, bb} = {aa:1, bb:2};
+        var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
+    }
+}
+
+destructuring_objects_trailing_elision: {
+    input: {
+        var {cc,} = foo;
+    }
+    expect_exact: "var{cc}=foo;"
+}
+
+nested_destructuring_objects: {
+    input: {
+        const [{a},b] = c;
+        let [{a},b] = c;
+        var [{a},b] = c;
+    }
+    expect_exact: 'const[{a},b]=c;let[{a},b]=c;var[{a},b]=c;';
+}
+
+destructuring_constdef_in_loops: {
+    input: {
+        for (const [x,y] in pairs);
+        for (const [a] = 0;;);
+        for (const {c} of cees);
+    }
+    expect_exact: "for(const[x,y]in pairs);for(const[a]=0;;);for(const{c}of cees);"
+}
+
+destructuring_letdef_in_loops: {
+    input: {
+        for (let [x,y] in pairs);
+        for (let [a] = 0;;);
+        for (let {c} of cees);
+    }
+    expect_exact: "for(let[x,y]in pairs);for(let[a]=0;;);for(let{c}of cees);"
+}
+
+destructuring_vardef_in_loops: {
+    input: {
+        for (var [x,y] in pairs);
+        for (var [a] = 0;;);
+        for (var {c} of cees);
+    }
+    expect_exact: "for(var[x,y]in pairs);for(var[a]=0;;);for(var{c}of cees);"
+}
+
+destructuring_expressions: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        ({a, b});
+        [{a}];
+        f({x});
+    }
+    expect_exact: "({a,b});[{a}];f({x});"
+}
+

test/compress/directives.js

@@ -0,0 +1,10 @@
+class_directives_compression: {
+    input: {
+        class foo {
+            foo() {
+                "use strict";
+            }
+        }
+    }
+    expect_exact: "class foo{foo(){}}"
+}

test/compress/drop-console.js

@@ -1,24 +1,24 @@
-drop_console_1: {
-    options = {};
-    input: {
-        console.log('foo');
-        console.log.apply(console, arguments);
-    }
-    expect: {
-        console.log('foo');
-        console.log.apply(console, arguments);
-    }
-}
-
-drop_console_2: {
-    options = { drop_console: true };
-    input: {
-        console.log('foo');
-        console.log.apply(console, arguments);
-    }
-    expect: {
-        // with regular compression these will be stripped out as well
-        void 0;
-        void 0;
-    }
-}
+drop_console_1: {
+    options = {};
+    input: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+    expect: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+}
+
+drop_console_1: {
+    options = { drop_console: true };
+    input: {
+        console.log('foo');
+        console.log.apply(console, arguments);
+    }
+    expect: {
+        // with regular compression these will be stripped out as well
+        void 0;
+        void 0;
+    }
+}

test/compress/expansions.js

@@ -0,0 +1,28 @@
+
+expand_arguments: {
+    input: {
+        func(a, ...rest);
+        func(...all);
+    }
+    expect_exact: "func(a,...rest);func(...all);"
+}
+
+expand_expression_arguments: {
+    input: {
+        f(...a.b);
+        f(...a.b());
+        f(...(a));
+        f(...(a.b));
+        f(...a[i]);
+    }
+    expect_exact: "f(...a.b);f(...a.b());f(...a);f(...a.b);f(...a[i]);"
+}
+
+expand_parameters: {
+    input: {
+        (function (a, ...b){});
+        (function (...args){});
+    }
+    expect_exact: "(function(a,...b){});(function(...args){});"
+}
+

test/compress/expression.js

@@ -0,0 +1,52 @@
+pow: {
+    input: {
+        var a = 2 ** 7;
+        var b = 3;
+        b **= 2;
+    }
+    expect: {
+        var a = 2 ** 7;
+        var b = 3;
+        b **= 2;
+    }
+}
+
+pow_with_number_constants: {
+    input: {
+        var a = 5 ** NaN;
+        var b = 42 ** +0;
+        var c = 42 ** -0;
+        var d = NaN ** 1;
+        var e = 2 ** Infinity;
+        var f = 2 ** -Infinity;
+    }
+    expect: {
+        var a = 5 ** NaN;
+        var b = 42 ** +0;
+        var c = 42 ** -0;
+        var d = NaN ** 1;
+        var e = 2 ** (1/0);
+        var f = 2 ** -(1/0);
+    }
+}
+
+pow_with_parentheses: {
+    input: {
+        var g = (-7) ** (0.5);
+        var h = 2324334 ** 34343443;
+        var i = (-2324334) ** 34343443;
+        var j = 2 ** (-3);
+        var k = 2.0 ** -3;
+        var l = 2.0 ** (5 - 7);
+    }
+    expect_exact: "var g=(-7)**.5;var h=2324334**34343443;var i=(-2324334)**34343443;var j=2**-3;var k=2**-3;var l=2**(5-7);"
+}
+
+pow_with_unary_between_brackets: {
+    input: {
+        var a = (-(+5)) ** 3;
+    }
+    expect: {
+        var a = (-+5)**3;
+    }
+}

test/compress/functions.js

@@ -1,556 +0,0 @@
-non_ascii_function_identifier_name: {
-    input: {
-        function fooλ(δλ) {}
-        function λ(δλ) {}
-        (function λ(δλ) {})()
-    }
-    expect_exact: "function fooλ(δλ){}function λ(δλ){}(function λ(δλ){})();"
-}
-
-iifes_returning_constants_keep_fargs_true: {
-    options = {
-        keep_fargs    : true,
-        side_effects  : true,
-        evaluate      : true,
-        unused        : true,
-        dead_code     : true,
-        conditionals  : true,
-        comparisons   : true,
-        booleans      : true,
-        if_return     : true,
-        join_vars     : true,
-        reduce_funcs  : true,
-        reduce_vars   : true,
-        cascade       : true,
-        inline        : true,
-    }
-    input: {
-        (function(){ return -1.23; }());
-        console.log( function foo(){ return "okay"; }() );
-        console.log( function foo(x, y, z){ return 123; }() );
-        console.log( function(x, y, z){ return z; }() );
-        console.log( function(x, y, z){ if (x) return y; return z; }(1, 2, 3) );
-        console.log( function(x, y){ return x * y; }(2, 3) );
-        console.log( function(x, y){ return x * y; }(2, 3, a(), b()) );
-    }
-    expect: {
-        console.log("okay");
-        console.log(123);
-        console.log(void 0);
-        console.log(2);
-        console.log(6);
-        console.log((a(), b(), 6));
-    }
-    expect_stdout: true
-}
-
-iifes_returning_constants_keep_fargs_false: {
-    options = {
-        keep_fargs    : false,
-        side_effects  : true,
-        evaluate      : true,
-        unused        : true,
-        dead_code     : true,
-        conditionals  : true,
-        comparisons   : true,
-        booleans      : true,
-        if_return     : true,
-        join_vars     : true,
-        reduce_funcs  : true,
-        reduce_vars   : true,
-        cascade       : true,
-        inline        : true,
-    }
-    input: {
-        (function(){ return -1.23; }());
-        console.log( function foo(){ return "okay"; }() );
-        console.log( function foo(x, y, z){ return 123; }() );
-        console.log( function(x, y, z){ return z; }() );
-        console.log( function(x, y, z){ if (x) return y; return z; }(1, 2, 3) );
-        console.log( function(x, y){ return x * y; }(2, 3) );
-        console.log( function(x, y){ return x * y; }(2, 3, a(), b()) );
-    }
-    expect: {
-        console.log("okay");
-        console.log(123);
-        console.log(void 0);
-        console.log(2);
-        console.log(6);
-        console.log((a(), b(), 6));
-    }
-    expect_stdout: true
-}
-
-issue_485_crashing_1530: {
-    options = {
-        conditionals: true,
-        dead_code: true,
-        evaluate: true,
-        inline: true,
-    }
-    input: {
-        (function(a) {
-            if (true) return;
-            var b = 42;
-        })(this);
-    }
-    expect: {
-        this, void 0;
-    }
-}
-
-issue_1841_1: {
-    options = {
-        keep_fargs: false,
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        var b = 10;
-        !function(arg) {
-            for (var key in "hi")
-                var n = arg.baz, n = [ b = 42 ];
-        }(--b);
-        console.log(b);
-    }
-    expect: {
-        var b = 10;
-        !function() {
-            for (var key in "hi")
-                b = 42;
-        }(--b);
-        console.log(b);
-    }
-    expect_exact: "42"
-}
-
-issue_1841_2: {
-    options = {
-        keep_fargs: false,
-        pure_getters: false,
-        reduce_funcs: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        var b = 10;
-        !function(arg) {
-            for (var key in "hi")
-                var n = arg.baz, n = [ b = 42 ];
-        }(--b);
-        console.log(b);
-    }
-    expect: {
-        var b = 10;
-        !function(arg) {
-            for (var key in "hi")
-                arg.baz, b = 42;
-        }(--b);
-        console.log(b);
-    }
-    expect_exact: "42"
-}
-
-function_returning_constant_literal: {
-    options = {
-        inline: true,
-        passes: 2,
-        properties: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        toplevel: 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"
-}
-
-hoist_funs: {
-    options = {
-        hoist_funs: true,
-    }
-    input: {
-        console.log(1, typeof f, typeof g);
-        if (console.log(2, typeof f, typeof g))
-            console.log(3, typeof f, typeof g);
-        else {
-            console.log(4, typeof f, typeof g);
-            function f() {}
-            console.log(5, typeof f, typeof g);
-        }
-        function g() {}
-        console.log(6, typeof f, typeof g);
-    }
-    expect: {
-        function f() {}
-        function g() {}
-        console.log(1, typeof f, typeof g);
-        if (console.log(2, typeof f, typeof g))
-            console.log(3, typeof f, typeof g);
-        else {
-            console.log(4, typeof f, typeof g);
-            console.log(5, typeof f, typeof g);
-        }
-        console.log(6, typeof f, typeof g);
-    }
-    expect_stdout: [
-        "1 'function' 'function'",
-        "2 'function' 'function'",
-        "4 'function' 'function'",
-        "5 'function' 'function'",
-        "6 'function' 'function'",
-    ]
-    node_version: "<=4"
-}
-
-hoist_funs_strict: {
-    options = {
-        hoist_funs: true,
-    }
-    input: {
-        "use strict";
-        console.log(1, typeof f, typeof g);
-        if (console.log(2, typeof f, typeof g))
-            console.log(3, typeof f, typeof g);
-        else {
-            console.log(4, typeof f, typeof g);
-            function f() {}
-            console.log(5, typeof f, typeof g);
-        }
-        function g() {}
-        console.log(6, typeof f, typeof g);
-    }
-    expect: {
-        "use strict";
-        function g() {}
-        console.log(1, typeof f, typeof g);
-        if (console.log(2, typeof f, typeof g))
-            console.log(3, typeof f, typeof g);
-        else {
-            console.log(4, typeof f, typeof g);
-            function f() {}
-            console.log(5, typeof f, typeof g);
-        }
-        console.log(6, typeof f, typeof g);
-    }
-    expect_stdout: [
-        "1 'undefined' 'function'",
-        "2 'undefined' 'function'",
-        "4 'function' 'function'",
-        "5 'function' 'function'",
-        "6 'undefined' 'function'",
-    ]
-    node_version: ">=4"
-}
-
-issue_203: {
-    options = {
-        keep_fargs: false,
-        side_effects: true,
-        unsafe_Func: true,
-        unused: true,
-    }
-    input: {
-        var m = {};
-        var fn = Function("require", "module", "exports", "module.exports = 42;");
-        fn(null, m, m.exports);
-        console.log(m.exports);
-    }
-    expect: {
-        var m = {};
-        var fn = Function("n,o", "o.exports=42");
-        fn(null, m, m.exports);
-        console.log(m.exports);
-    }
-    expect_stdout: "42"
-}
-
-no_webkit: {
-    beautify = {
-        webkit: false,
-    }
-    input: {
-        console.log(function() {
-            1 + 1;
-        }.a = 1);
-    }
-    expect_exact: "console.log(function(){1+1}.a=1);"
-    expect_stdout: "1"
-}
-
-webkit: {
-    beautify = {
-        webkit: true,
-    }
-    input: {
-        console.log(function() {
-            1 + 1;
-        }.a = 1);
-    }
-    expect_exact: "console.log((function(){1+1}).a=1);"
-    expect_stdout: "1"
-}
-
-issue_2084: {
-    options = {
-        collapse_vars: true,
-        conditionals: true,
-        evaluate: true,
-        inline: true,
-        passes: 2,
-        reduce_funcs: true,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        var c = 0;
-        !function() {
-            !function(c) {
-                c = 1 + c;
-                var c = 0;
-                function f14(a_1) {
-                    if (c = 1 + c, 0 !== 23..toString())
-                        c = 1 + c, a_1 && (a_1[0] = 0);
-                }
-                f14();
-            }(-1);
-        }();
-        console.log(c);
-    }
-    expect: {
-        var c = 0;
-        !function(c) {
-            c = 1 + c,
-            c = 1 + (c = 0),
-            0 !== 23..toString() && (c = 1 + c);
-        }(-1),
-        console.log(c);
-    }
-    expect_stdout: "0"
-}
-
-issue_2097: {
-    options = {
-        negate_iife: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            try {
-                throw 0;
-            } catch (e) {
-                console.log(arguments[0]);
-            }
-        }
-        f(1);
-    }
-    expect: {
-        !function() {
-            try {
-                throw 0;
-            } catch (e) {
-                console.log(arguments[0]);
-            }
-        }(1);
-    }
-    expect_stdout: "1"
-}
-
-issue_2101: {
-    options = {
-        inline: true,
-    }
-    input: {
-        a = {};
-        console.log(function() {
-            return function() {
-                return this.a;
-            }();
-        }() === function() {
-            return a;
-        }());
-    }
-    expect: {
-        a = {};
-        console.log(function() {
-            return this.a;
-        }() === a);
-    }
-    expect_stdout: "true"
-}
-
-inner_ref: {
-    options = {
-        inline: true,
-        unused: true,
-    }
-    input: {
-        console.log(function(a) {
-            return function() {
-                return a;
-            }();
-        }(1), function(a) {
-            return function(a) {
-                return a;
-            }();
-        }(2));
-    }
-    expect: {
-        console.log(function(a) {
-            return a;
-        }(1), function(a) {
-            return a;
-        }());
-    }
-    expect_stdout: "1 undefined"
-}
-
-issue_2107: {
-    options = {
-        cascade: true,
-        collapse_vars: true,
-        inline: true,
-        sequences: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        var c = 0;
-        !function() {
-            c++;
-        }(c++ + new function() {
-            this.a = 0;
-            var a = (c = c + 1) + (c = 1 + c);
-            return c++ + a;
-        }());
-        console.log(c);
-    }
-    expect: {
-        var c = 0;
-        c++, new function() {
-            this.a = 0, c = 1 + (c += 1), c++;
-        }(), c++, console.log(c);
-    }
-    expect_stdout: "5"
-}
-
-issue_2114_1: {
-    options = {
-        collapse_vars: true,
-        if_return: true,
-        inline: true,
-        keep_fargs: false,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        var c = 0;
-        !function(a) {
-            a = 0;
-        }([ {
-            0: c = c + 1,
-            length: c = 1 + c
-        }, typeof void function a() {
-            var b = function f1(a) {
-            }(b && (b.b += (c = c + 1, 0)));
-        }() ]);
-        console.log(c);
-    }
-    expect: {
-        var c = 0;
-        c = 1 + (c += 1), function() {
-            var b = void (b && (b.b += (c += 1, 0)));
-        }();
-        console.log(c);
-    }
-    expect_stdout: "2"
-}
-
-issue_2114_2: {
-    options = {
-        collapse_vars: true,
-        if_return: true,
-        inline: true,
-        keep_fargs: false,
-        passes: 2,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        var c = 0;
-        !function(a) {
-            a = 0;
-        }([ {
-            0: c = c + 1,
-            length: c = 1 + c
-        }, typeof void function a() {
-            var b = function f1(a) {
-            }(b && (b.b += (c = c + 1, 0)));
-        }() ]);
-        console.log(c);
-    }
-    expect: {
-        var c = 0;
-        c = 1 + (c += 1), function() {
-            var b = void (b && (b.b += (c += 1, 0)));
-        }();
-        console.log(c);
-    }
-    expect_stdout: "2"
-}
-
-issue_2428: {
-    options = {
-        collapse_vars: true,
-        inline: true,
-        passes: 3,
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        toplevel: true,
-        unsafe: true,
-        unused: true,
-    }
-    input: {
-        function bar(k) {
-            console.log(k);
-        }
-        function foo(x) {
-            return bar(x);
-        }
-        function baz(a) {
-            foo(a);
-        }
-        baz(42);
-        baz("PASS");
-    }
-    expect: {
-        function baz(a) {
-            console.log(a);
-        }
-        baz(42);
-        baz("PASS");
-    }
-    expect_stdout: [
-        "42",
-        "PASS",
-    ]
-}

test/compress/global_defs.js

@@ -1,198 +0,0 @@
-must_replace: {
-    options = {
-        global_defs: {
-            D: "foo bar",
-        }
-    }
-    input: {
-        console.log(D);
-    }
-    expect: {
-        console.log("foo bar");
-    }
-}
-
-keyword: {
-    options = {
-        global_defs: {
-            undefined: 0,
-            NaN: 1,
-            Infinity: 2,
-        },
-    }
-    input: {
-        console.log(undefined, NaN, Infinity);
-    }
-    expect: {
-        console.log(0, 1, 2);
-    }
-}
-
-object: {
-    options = {
-        evaluate: true,
-        global_defs: {
-            CONFIG: {
-                DEBUG: [ 0 ],
-                VALUE: 42,
-            },
-        },
-        side_effects: true,
-        unsafe: true,
-    }
-    input: {
-        function f(CONFIG) {
-            // CONFIG not global - do not replace
-            return CONFIG.VALUE;
-        }
-        function g() {
-            var CONFIG = { VALUE: 1 };
-            // CONFIG not global - do not replace
-            return CONFIG.VALUE;
-        }
-        function h() {
-            return CONFIG.VALUE;
-        }
-        if (CONFIG.DEBUG[0])
-            console.debug("foo");
-    }
-    expect: {
-        function f(CONFIG) {
-            return CONFIG.VALUE;
-        }
-        function g() {
-            var CONFIG = { VALUE: 1 };
-            return CONFIG.VALUE;
-        }
-        function h() {
-            return 42;
-        }
-        if (0)
-            console.debug("foo");
-    }
-}
-
-expanded: {
-    options = {
-        global_defs: {
-            "CONFIG.DEBUG": [ 0 ],
-            "CONFIG.VALUE": 42,
-        },
-    }
-    input: {
-        function f(CONFIG) {
-            // CONFIG not global - do not replace
-            return CONFIG.VALUE;
-        }
-        function g() {
-            var CONFIG = { VALUE: 1 };
-            // CONFIG not global - do not replace
-            return CONFIG.VALUE;
-        }
-        function h() {
-            return CONFIG.VALUE;
-        }
-        if (CONFIG.DEBUG[0])
-            console.debug("foo");
-    }
-    expect: {
-        function f(CONFIG) {
-            return CONFIG.VALUE;
-        }
-        function g() {
-            var CONFIG = { VALUE: 1 };
-            return CONFIG.VALUE;
-        }
-        function h() {
-            return 42;
-        }
-        if ([0][0])
-            console.debug("foo");
-    }
-}
-
-mixed: {
-    options = {
-        evaluate: true,
-        global_defs: {
-            "CONFIG.VALUE": 42,
-            "FOO.BAR": "moo",
-        },
-        properties: true,
-    }
-    input: {
-        var FOO = { BAR: 0 };
-        console.log(FOO.BAR);
-        console.log(++CONFIG.DEBUG);
-        console.log(++CONFIG.VALUE);
-        console.log(++CONFIG["VAL" + "UE"]);
-        console.log(++DEBUG[CONFIG.VALUE]);
-        CONFIG.VALUE.FOO = "bar";
-        console.log(CONFIG);
-    }
-    expect: {
-        var FOO = { BAR: 0 };
-        console.log("moo");
-        console.log(++CONFIG.DEBUG);
-        console.log(++CONFIG.VALUE);
-        console.log(++CONFIG.VALUE);
-        console.log(++DEBUG[42]);
-        CONFIG.VALUE.FOO = "bar";
-        console.log(CONFIG);
-    }
-    expect_warnings: [
-        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:127,22]',
-        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:128,22]',
-        'WARN: global_defs CONFIG.VALUE redefined [test/compress/global_defs.js:130,8]',
-    ]
-}
-
-issue_1801: {
-    options = {
-        booleans: true,
-        global_defs: {
-            "CONFIG.FOO.BAR": true,
-        },
-    }
-    input: {
-        console.log(CONFIG.FOO.BAR);
-    }
-    expect: {
-        console.log(!0);
-    }
-}
-
-issue_1986: {
-    options = {
-        global_defs: {
-            "@alert": "console.log",
-        },
-    }
-    input: {
-        alert(42);
-    }
-    expect: {
-        console.log(42);
-    }
-}
-
-issue_2167: {
-    options = {
-        conditionals: true,
-        dead_code: true,
-        evaluate: true,
-        global_defs: {
-            "@isDevMode": "function(){}",
-        },
-        side_effects: true,
-    }
-    input: {
-        if (isDevMode()) {
-            greetOverlord();
-        }
-        doWork();
-    }
-    expect: {
-        doWork();
-    }
-}

test/compress/harmony.js

@@ -0,0 +1,288 @@
+arrow_function_parens: {
+    input: {
+        something && (() => {});
+    }
+    expect_exact: "something&&(()=>{});"
+}
+arrow_function_parens_2: {
+    input: {
+        (() => null)();
+    }
+    expect_exact: "(()=>null)();"
+}
+
+typeof_arrow_functions: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var foo = typeof (x) => null;
+    }
+    expect_exact: "var foo=\"function\";"
+}
+
+classes: {
+    input: {
+        class SomeClass {
+            constructor() {
+            };
+            foo() {};
+        };
+        class NoSemi {
+            constructor(...args) {
+            }
+            foo() {}
+        };
+        class ChildClass extends SomeClass {};
+        var asExpression = class AsExpression {};
+        var nameless = class {};
+    }
+    expect_exact: "class SomeClass{constructor(){}foo(){}}class NoSemi{constructor(...args){}foo(){}}class ChildClass extends SomeClass{}var asExpression=class AsExpression{};var nameless=class{};"
+}
+
+class_statics: {
+    input: {
+        x = class {
+            static staticMethod() {}
+            static get foo() {}
+            static set bar() {}
+            static() { /* "static" can be a method name! */ }
+            get() { /* "get" can be a method name! */ }
+            set() { /* "set" can be a method name! */ }
+        }
+    }
+    expect_exact: "x=class{static staticMethod(){}static get foo(){}static set bar(){}static(){}get(){}set(){}};"
+}
+
+class_name_can_be_mangled: {
+    mangle = { };
+    input: {
+        function x() {
+            class Foo {
+            }
+            var class1 = Foo
+            var class2 = class Bar {}
+        }
+    }
+    expect: {
+        function x() {
+            class a { }
+            var n = a
+            var r = class a {}
+        }
+    }
+}
+
+class_name_can_be_preserved: {
+    mangle = {
+        keep_classnames: true
+    }
+    input: {
+        function x() {
+            (class Baz { });
+            class Foo {};
+        }
+    }
+    expect: {
+        function x() {
+            (class Baz { });
+            class Foo {};
+        }
+    }
+}
+
+classes_can_have_generators: {
+    input: {
+        class Foo {
+            *bar() {}
+            static *baz() {}
+        }
+    }
+    expect: {
+        class Foo {
+            *bar() {}
+            static *baz() {}
+        }
+    }
+}
+
+classes_can_have_computed_generators: {
+    input: {
+        class C4 {
+            *['constructor']() {}
+        }
+    }
+    expect: {
+        class C4 {
+            *['constructor']() {}
+        }
+    }
+}
+
+classes_can_have_computed_static: {
+    input: {
+        class C4 {
+            static ['constructor']() {}
+        }
+    }
+    expect: {
+        class C4 {
+            static ['constructor']() {}
+        }
+    }
+}
+
+class_methods_and_getters_with_keep_quoted_props_enabled: {
+    beautify = {
+        quote_style: 3,
+        keep_quoted_props: true,
+    }
+    input: {
+        class clss {
+            a() {}
+            "b"() {}
+            get c() { return "c"}
+            get "d"() { return "d"}
+            set e(a) { doSomething(a); }
+            set 'f'(a) { doSomething(b); }
+            static g() {}
+            static "h"() {}
+        }
+    }
+    expect_exact: 'class clss{a(){}"b"(){}get c(){return"c"}get"d"(){return"d"}set e(a){doSomething(a)}set\'f\'(a){doSomething(b)}static g(){}static"h"(){}}'
+}
+
+new_target: {
+    input: {
+        new.target;
+        new.target.name;
+    }
+    expect_exact: "new.target;new.target.name;"
+}
+
+number_literals: {
+    input: {
+        0b1001;
+        0B1001;
+        0o11;
+        0O11;
+    }
+
+    expect: {
+        9;
+        9;
+        9;
+        9;
+    }
+}
+
+import_statement: {
+    input: {
+        import "mod-name";
+        import Foo from "bar";
+        import { Bar, Baz } from 'lel';
+        import Bar, { Foo } from 'lel';
+        import { Bar as kex, Baz as food } from 'lel';
+    }
+    expect_exact: "import\"mod-name\";import Foo from\"bar\";import{Bar,Baz}from\"lel\";import Bar,{Foo}from\"lel\";import{Bar as kex,Baz as food}from\"lel\";"
+}
+
+export_statement: {
+    input: {
+        export default 1;
+        export var foo = 4;
+        export let foo = 6;
+        export const foo = 6;
+        export function foo() {};
+        export class foo { };
+    }
+    expect_exact: "export default 1;export var foo=4;export let foo=6;export const foo=6;export function foo(){};export class foo{};"
+}
+
+import_statement_mangling: {
+    mangle = { };
+    input: {
+        import Foo from "foo";
+        import Bar, {Food} from "lel";
+        import {What as Whatever} from "lel";
+        Foo();
+        Bar();
+        Food();
+        Whatever();
+    }
+    expect: {
+        import l from "foo";
+        import e, {Food as o} from "lel";
+        import {What as f} from "lel";
+        l();
+        e();
+        o();
+        f();
+    }
+}
+
+export_statement_mangling: {
+    mangle = { };
+    input: {
+        export var foo = 6;
+        export function bar() { }
+        export class Baz { }
+        bar(foo, Baz)
+    }
+    expect: {
+        export var foo = 6;
+        export function bar() { }
+        export class Baz { }
+        bar(foo, Baz)
+    }
+}
+
+// https://github.com/mishoo/UglifyJS2/issues/1021
+regression_for_of_const: {
+    input: {
+        for (const x of y) {}
+        for (const x in y) {}
+    }
+    expect: {
+        for (const x of y);for (const x in y);
+    }
+}
+
+// Fabio: My patches accidentally caused a crash whenever
+// there's an extraneous set of parens around an object.
+regression_cannot_destructure: {
+    input: {
+        var x = ({ x : 3 });
+        x(({ x: 3 }));
+    }
+    expect_exact: "var x={x:3};x({x:3});";
+}
+
+regression_cannot_use_of: {
+    input: {
+        function of() {
+        }
+        var of = "is a valid variable name";
+        of = { of: "is ok" };
+        x.of;
+        of: foo()
+    }
+    expect: {
+        function of(){}
+        var of="is a valid variable name";
+        of={of:"is ok"};
+        x.of;
+        foo();  /* Label statement missing? No prob. */
+    }
+}
+
+fat_arrow_as_param: {
+    input: {
+        foo(x => x);
+        foo(x => x, y => y);
+
+        foo(x => (x, x));
+        foo(x => (x, x), y => (y, y));
+    }
+    expect_exact: "foo(x=>x);foo(x=>x,y=>y);foo(x=>(x,x));foo(x=>(x,x),y=>(y,y));"
+}

test/compress/hoist.js

@@ -0,0 +1,85 @@
+
+hoist_vars: {
+    options = {
+        hoist_vars: true
+    }
+    input: {
+        function a() {
+            bar();
+            var var1;
+            var var2;
+        }
+        function b(anArg) {
+            bar();
+            var var1;
+            var anArg;
+        }
+    }
+    expect: {
+        function a() {
+            var var1, var2;  // Vars go up and are joined
+            bar();
+        }
+        function b(anArg) {
+            var var1;
+            bar();
+            // But vars named like arguments go away!
+        }
+    }
+}
+
+hoist_funs: {
+    options = {
+        hoist_funs: true
+    }
+    input: {
+        function a() {
+            bar();
+            function foo() {}
+        }
+    }
+    expect: {
+        function a() {
+            function foo() {}  // Funs go up
+            bar();
+        }
+    }
+}
+
+hoist_no_destructurings: {
+    options = {
+        hoist_vars: true,
+        hoist_funs: true
+    }
+    input: {
+        function a([anArg]) {
+            bar();
+            var var1;
+            var anArg;  // Because anArg is already declared, this goes away!
+        }
+    }
+    expect: {
+        function a([anArg]) {
+            var var1;
+            bar();
+        }
+    }
+}
+
+dont_hoist_var_destructurings: {
+    options = {
+        hoist_vars: true,
+        hoist_funs: true
+    }
+    input: {
+        function x() {
+            // If foo is null or undefined, this should be an exception
+            var {x,y} = foo;
+        }
+    }
+    expect: {
+        function x() {
+            var {x,y} = foo;
+        }
+    }
+}

test/compress/hoist_props.js

@@ -1,413 +0,0 @@
-issue_2377_1: {
-    options = {
-        evaluate: true,
-        inline: true,
-        hoist_props: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var obj = {
-            foo: 1,
-            bar: 2,
-            square: function(x) {
-                return x * x;
-            },
-            cube: function(x) {
-                return x * x * x;
-            },
-        };
-        console.log(obj.foo, obj.cube(3));
-    }
-    expect: {
-        var obj_foo = 1, obj_cube = function(x) {
-            return x * x * x;
-        };
-        console.log(obj_foo, obj_cube(3));
-    }
-    expect_stdout: "1 27"
-}
-
-issue_2377_2: {
-    options = {
-        evaluate: true,
-        inline: true,
-        hoist_props: true,
-        passes: 2,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var obj = {
-            foo: 1,
-            bar: 2,
-            square: function(x) {
-                return x * x;
-            },
-            cube: function(x) {
-                return x * x * x;
-            },
-        };
-        console.log(obj.foo, obj.cube(3));
-    }
-    expect: {
-        console.log(1, function(x) {
-            return x * x * x;
-        }(3));
-    }
-    expect_stdout: "1 27"
-}
-
-issue_2377_3: {
-    options = {
-        evaluate: true,
-        inline: true,
-        hoist_props: true,
-        passes: 3,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var obj = {
-            foo: 1,
-            bar: 2,
-            square: function(x) {
-                return x * x;
-            },
-            cube: function(x) {
-                return x * x * x;
-            },
-        };
-        console.log(obj.foo, obj.cube(3));
-    }
-    expect: {
-        console.log(1, 27);
-    }
-    expect_stdout: "1 27"
-}
-
-direct_access_1: {
-    options = {
-        hoist_props: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a = 0;
-        var obj = {
-            a: 1,
-            b: 2,
-        };
-        for (var k in obj) a++;
-        console.log(a, obj.a);
-    }
-    expect: {
-        var a = 0;
-        var obj = {
-            a: 1,
-            b: 2,
-        };
-        for (var k in obj) a++;
-        console.log(a, obj.a);
-    }
-    expect_stdout: "2 1"
-}
-
-direct_access_2: {
-    options = {
-        hoist_props: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var o = { a: 1 };
-        var f = function(k) {
-            if (o[k]) return "PASS";
-        };
-        console.log(f("a"));
-    }
-    expect: {
-        var o = { a: 1 };
-        console.log(function(k) {
-            if (o[k]) return "PASS";
-        }("a"));
-    }
-    expect_stdout: "PASS"
-}
-
-direct_access_3: {
-    options = {
-        hoist_props: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var o = { a: 1 };
-        o.b;
-        console.log(o.a);
-    }
-    expect: {
-        var o = { a: 1 };
-        o.b;
-        console.log(o.a);
-    }
-    expect_stdout: "1"
-}
-
-single_use: {
-    options = {
-        hoist_props: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var obj = {
-            bar: function() {
-                return 42;
-            },
-        };
-        console.log(obj.bar());
-    }
-    expect: {
-        console.log({
-            bar: function() {
-                return 42;
-            },
-        }.bar());
-    }
-}
-
-name_collision_1: {
-    options = {
-        hoist_props: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-    }
-    input: {
-        var obj_foo = 1;
-        var obj_bar = 2;
-        function f() {
-            var obj = {
-                foo: 3,
-                bar: 4,
-                "b-r": 5,
-                "b+r": 6,
-                "b!r": 7,
-            };
-            console.log(obj_foo, obj.foo, obj.bar, obj["b-r"], obj["b+r"], obj["b!r"]);
-        }
-        f();
-    }
-    expect: {
-        var obj_foo = 1;
-        var obj_bar = 2;
-        function f() {
-            var obj_foo$0 = 3,
-                obj_bar = 4,
-                obj_b_r = 5,
-                obj_b_r$0 = 6,
-                obj_b_r$1 = 7;
-            console.log(obj_foo, obj_foo$0, obj_bar, obj_b_r, obj_b_r$0, obj_b_r$1);
-        }
-        f();
-    }
-    expect_stdout: "1 3 4 5 6 7"
-}
-
-name_collision_2: {
-    options = {
-        hoist_props: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-    }
-    input: {
-        var o = {
-            p: 1,
-            0: function(x) {
-                return x;
-            },
-            1: function(x) {
-                return x + 1;
-            }
-        }, o__$0 = 2, o__$1 = 3;
-        console.log(o.p === o.p, o[0](4), o[1](5), o__$0, o__$1);
-    }
-    expect: {
-        var o_p = 1,
-            o__ = function(x) {
-                return x;
-            },
-            o__$2 = function(x) {
-                return x + 1;
-            },
-            o__$0 = 2,
-            o__$1 = 3;
-        console.log(o_p === o_p, o__(4), o__$2(5), o__$0, o__$1);
-    }
-    expect_stdout: "true 4 6 2 3"
-}
-
-name_collision_3: {
-    options = {
-        hoist_props: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-    }
-    input: {
-        var o = {
-            p: 1,
-            0: function(x) {
-                return x;
-            },
-            1: function(x) {
-                return x + 1;
-            }
-        }, o__$0 = 2, o__$1 = 3;
-        console.log(o.p === o.p, o[0](4), o[1](5));
-    }
-    expect: {
-        var o_p = 1,
-            o__ = function(x) {
-                return x;
-            },
-            o__$2 = function(x) {
-                return x + 1;
-            },
-            o__$0 = 2,
-            o__$1 = 3;
-        console.log(o_p === o_p, o__(4), o__$2(5));
-    }
-    expect_stdout: "true 4 6"
-}
-
-contains_this_1: {
-    options = {
-        evaluate: true,
-        hoist_props: true,
-        inline: true,
-        passes: 2,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var o = {
-            u: function() {
-                return this === this;
-            },
-            p: 1
-        };
-        console.log(o.p, o.p);
-    }
-    expect: {
-        console.log(1, 1);
-    }
-    expect_stdout: "1 1"
-}
-
-contains_this_2: {
-    options = {
-        evaluate: true,
-        hoist_props: true,
-        inline: true,
-        passes: 2,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var o = {
-            u: function() {
-                return this === this;
-            },
-            p: 1
-        };
-        console.log(o.p, o.p, o.u);
-    }
-    expect: {
-        console.log(1, 1, function() {
-            return this === this;
-        });
-    }
-    expect_stdout: true
-}
-
-contains_this_3: {
-    options = {
-        evaluate: true,
-        hoist_props: true,
-        inline: true,
-        passes: 2,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var o = {
-            u: function() {
-                return this === this;
-            },
-            p: 1
-        };
-        console.log(o.p, o.p, o.u());
-    }
-    expect: {
-        var o = {
-            u: function() {
-                return this === this;
-            },
-            p: 1
-        };
-        console.log(o.p, o.p, o.u());
-    }
-    expect_stdout: "1 1 true"
-}
-
-new_this: {
-    options = {
-        evaluate: true,
-        hoist_props: true,
-        inline: true,
-        passes: 2,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var o = {
-            a: 1,
-            b: 2,
-            f: function(a) {
-                this.b = a;
-            }
-        };
-        console.log(new o.f(o.a).b, o.b);
-    }
-    expect: {
-        console.log(new function(a) {
-            this.b = a;
-        }(1).b, 2);
-    }
-    expect_stdout: "1 2"
-}

test/compress/hoist_vars.js

@@ -1,111 +0,0 @@
-statements: {
-    options = {
-        hoist_funs: false,
-        hoist_vars: true,
-    }
-    input: {
-        function f() {
-            var a = 1;
-            var b = 2;
-            var c = 3;
-            function g() {}
-            return g(a, b, c);
-        }
-    }
-    expect: {
-        function f() {
-            var a = 1, b = 2, c = 3;
-            function g() {}
-            return g(a, b, c);
-        }
-    }
-}
-
-statements_funs: {
-    options = {
-        hoist_funs: true,
-        hoist_vars: true,
-    }
-    input: {
-        function f() {
-            var a = 1;
-            var b = 2;
-            var c = 3;
-            function g() {}
-            return g(a, b, c);
-        }
-    }
-    expect: {
-        function f() {
-            function g() {}
-            var a = 1, b = 2, c = 3;
-            return g(a, b, c);
-        }
-    }
-}
-
-sequences: {
-    options = {
-        hoist_funs: false,
-        hoist_vars: true,
-    }
-    input: {
-        function f() {
-            var a = 1, b = 2;
-            function g() {}
-            var c = 3;
-            return g(a, b, c);
-        }
-    }
-    expect: {
-        function f() {
-            var c, a = 1, b = 2;
-            function g() {}
-            c = 3;
-            return g(a, b, c);
-        }
-    }
-}
-
-sequences_funs: {
-    options = {
-        hoist_funs: true,
-        hoist_vars: true,
-    }
-    input: {
-        function f() {
-            var a = 1, b = 2;
-            function g() {}
-            var c = 3;
-            return g(a, b, c);
-        }
-    }
-    expect: {
-        function f() {
-            function g() {}
-            var a = 1, b = 2, c = 3;
-            return g(a, b, c);
-        }
-    }
-}
-
-issue_2295: {
-    options = {
-        collapse_vars: true,
-        hoist_vars: true,
-    }
-    input: {
-        function foo(o) {
-            var a = o.a;
-            if (a) return a;
-            var a = 1;
-        }
-    }
-    expect: {
-        function foo(o) {
-            var a = o.a;
-            if (a) return a;
-            a = 1;
-        }
-    }
-}

test/compress/html_comments.js

@@ -47,9 +47,34 @@ html_comment_in_greater_than_or_equal: {
     expect_exact: "function f(a,b){return a-- >=b}";
 }
 
+html_comment_in_right_shift_assign: {
+    input: {
+        // Note: illegal javascript
+        function f(a, b) { return a-- >>= b; }
+    }
+    expect_exact: "function f(a,b){return a-- >>=b}";
+}
+
+html_comment_in_zero_fill_right_shift_assign: {
+    input: {
+        // Note: illegal javascript
+        function f(a, b) { return a-- >>>= b; }
+    }
+    expect_exact: "function f(a,b){return a-- >>>=b}";
+}
+
 html_comment_in_string_literal: {
     input: {
         function f() { return "<!--HTML-->comment in<!--string literal-->"; }
     }
     expect_exact: 'function f(){return"\\x3c!--HTML--\\x3ecomment in\\x3c!--string literal--\\x3e"}';
 }
+
+html_comment_after_multiline_comment: {
+    input: {
+        var foo; /*
+*/-->   var bar;
+        var foobar;
+    }
+    expect_exact: "var foo;var foobar;"
+}

test/compress/if_return.js

@@ -170,51 +170,8 @@ if_return_7: {
         }
     }
     expect: {
-        function f(x){if(x)return!0;foo(),bar()}
-    }
-}
-
-if_return_8: {
-    options = {
-        if_return:     true,
-        sequences:     true,
-        conditionals:  true,
-        side_effects : true,
-    }
-    input: {
-        function f(e) {
-            if (2 == e) return foo();
-            if (3 == e) return bar();
-            if (4 == e) return baz();
-            fail(e);
-        }
-
-        function g(e) {
-            if (a(e)) return foo();
-            if (b(e)) return bar();
-            if (c(e)) return baz();
-            fail(e);
-        }
-
-        function h(e) {
-            if (a(e)) return foo();
-            else if (b(e)) return bar();
-            else if (c(e)) return baz();
-            else fail(e);
-        }
-
-        function i(e) {
-            if (a(e)) return foo();
-            else if (b(e)) return bar();
-            else if (c(e)) return baz();
-            fail(e);
-        }
-    }
-    expect: {
-        function f(e){return 2==e?foo():3==e?bar():4==e?baz():void fail(e)}
-        function g(e){return a(e)?foo():b(e)?bar():c(e)?baz():void fail(e)}
-        function h(e){return a(e)?foo():b(e)?bar():c(e)?baz():void fail(e)}
-        function i(e){return a(e)?foo():b(e)?bar():c(e)?baz():void fail(e)}
+        // suboptimal
+        function f(x){return!!x||(foo(),void bar())}
     }
 }
 
@@ -248,81 +205,3 @@ issue_1089: {
         }
     }
 }
-
-issue_1437: {
-    options = {
-        if_return    : true,
-        sequences    : true,
-        conditionals : false
-    }
-    input: {
-        function x() {
-            if (a())
-                return b();
-            if (c())
-                return d();
-            else
-                e();
-            f();
-        }
-    }
-    expect: {
-        function x() {
-            if (a())
-                return b();
-            if (c())
-                return d();
-            else
-                e()
-            f();
-        }
-    }
-}
-
-issue_1437_conditionals: {
-    options = {
-        conditionals : true,
-        if_return    : true,
-        sequences    : true
-    }
-    input: {
-        function x() {
-            if (a())
-                return b();
-            if (c())
-                return d();
-            else
-                e();
-            f();
-        }
-    }
-    expect: {
-        function x() {
-            return a() ? b() : c() ? d() : (e(), f(), void 0);
-        }
-    }
-}
-
-issue_512: {
-    options = {
-        conditionals: true,
-        if_return: true,
-        sequences: true,
-        side_effects: true,
-    }
-    input: {
-        function a() {
-            if (b()) {
-                c();
-                return;
-            }
-            throw e;
-        }
-    }
-    expect: {
-        function a() {
-            if (!b()) throw e;
-            c();
-        }
-    }
-}

test/compress/issue-1001.js

@@ -0,0 +1,8 @@
+parenthesis_strings_in_parenthesis: {
+    input: {
+        var foo = ('(');
+        a(')');
+
+    }
+    expect_exact: 'var foo="(";a(")");'
+}

test/compress/issue-1034.js

@@ -39,7 +39,7 @@ non_hoisted_function_after_return_2a: {
         hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
         evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
         if_return: true, join_vars: true, cascade: true, side_effects: true,
-        collapse_vars: false, passes: 2, warnings: "verbose"
+        collapse_vars: false, passes: 2
     }
     input: {
         function foo(x) {
@@ -71,13 +71,11 @@ non_hoisted_function_after_return_2a: {
         "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:51,16]",
         "WARN: Dropping unused variable a [test/compress/issue-1034.js:48,20]",
         "WARN: Dropping unused function nope [test/compress/issue-1034.js:55,21]",
-        "WARN: pass 0: last_count: Infinity, count: 37",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:53,12]",
         "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:53,12]",
         "WARN: Dropping unreachable code [test/compress/issue-1034.js:56,12]",
         "WARN: Dropping unused variable b [test/compress/issue-1034.js:51,20]",
-        "WARN: Dropping unused variable c [test/compress/issue-1034.js:53,16]",
-        "WARN: pass 1: last_count: 37, count: 18",
+        "WARN: Dropping unused variable c [test/compress/issue-1034.js:53,16]"
     ]
 }
 
@@ -111,146 +109,13 @@ non_hoisted_function_after_return_2b: {
     }
     expect_warnings: [
         // duplicate warnings no longer emitted
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:97,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:97,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:99,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:99,12]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:103,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:95,16]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:95,16]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:97,12]",
+        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:97,12]",
+        "WARN: Dropping unreachable code [test/compress/issue-1034.js:101,12]",
+        "WARN: Dropping unused variable b [test/compress/issue-1034.js:95,20]",
+        "WARN: Dropping unused variable c [test/compress/issue-1034.js:97,16]"
     ]
 }
 
-non_hoisted_function_after_return_strict: {
-    options = {
-        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
-        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true
-    }
-    input: {
-        "use strict";
-        function foo(x) {
-            if (x) {
-                return bar();
-                not_called1();
-            } else {
-                return baz();
-                not_called2();
-            }
-            function bar() { return 7; }
-            return not_reached;
-            function UnusedFunction() {}
-            function baz() { return 8; }
-        }
-        console.log(foo(0), foo(1));
-    }
-    expect: {
-        "use strict";
-        function foo(x) {
-            return x ? bar() : baz();
-            function bar() { return 7 }
-            function baz() { return 8 }
-        }
-        console.log(foo(0), foo(1));
-    }
-    expect_stdout: "8 7"
-    expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:133,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:136,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:139,12]",
-        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:140,21]",
-    ]
-}
-
-non_hoisted_function_after_return_2a_strict: {
-    options = {
-        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
-        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true,
-        collapse_vars: false, passes: 2, warnings: "verbose"
-    }
-    input: {
-        "use strict";
-        function foo(x) {
-            if (x) {
-                return bar(1);
-                var a = not_called(1);
-            } else {
-                return bar(2);
-                var b = not_called(2);
-            }
-            var c = bar(3);
-            function bar(x) { return 7 - x; }
-            function nope() {}
-            return b || c;
-        }
-        console.log(foo(0), foo(1));
-    }
-    expect: {
-        "use strict";
-        function foo(x) {
-            return bar(x ? 1 : 2);
-            function bar(x) {
-                return 7 - x;
-            }
-        }
-        console.log(foo(0), foo(1));
-    }
-    expect_stdout: "5 6"
-    expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:175,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:175,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:178,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:178,16]",
-        "WARN: Dropping unused variable a [test/compress/issue-1034.js:175,20]",
-        "WARN: Dropping unused function nope [test/compress/issue-1034.js:182,21]",
-        "WARN: pass 0: last_count: Infinity, count: 48",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:180,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:180,12]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:183,12]",
-        "WARN: Dropping unused variable b [test/compress/issue-1034.js:178,20]",
-        "WARN: Dropping unused variable c [test/compress/issue-1034.js:180,16]",
-        "WARN: pass 1: last_count: 48, count: 29",
-    ]
-}
-
-non_hoisted_function_after_return_2b_strict: {
-    options = {
-        hoist_funs: false, dead_code: true, conditionals: true, comparisons: true,
-        evaluate: true, booleans: true, loops: true, unused: true, keep_fargs: true,
-        if_return: true, join_vars: true, cascade: true, side_effects: true,
-        collapse_vars: false
-    }
-    input: {
-        "use strict";
-        function foo(x) {
-            if (x) {
-                return bar(1);
-            } else {
-                return bar(2);
-                var b;
-            }
-            var c = bar(3);
-            function bar(x) {
-                return 7 - x;
-            }
-            return b || c;
-        }
-        console.log(foo(0), foo(1));
-    }
-    expect: {
-        "use strict";
-        function foo(x) {
-            return bar(x ? 1 : 2);
-            function bar(x) { return 7 - x; }
-        }
-        console.log(foo(0), foo(1));
-    }
-    expect_stdout: "5 6"
-    expect_warnings: [
-        // duplicate warnings no longer emitted
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:229,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:229,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:231,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:231,12]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:235,12]",
-    ]
-}

test/compress/issue-1041.js

@@ -1,8 +1,19 @@
+const_declaration: {
+    options = {
+        evaluate: true
+    };
+
+    input: {
+        const goog = goog || {};
+    }
+    expect: {
+        const goog = goog || {};
+    }
+}
+
 const_pragma: {
     options = {
-        evaluate: true,
-        reduce_funcs: true,
-        reduce_vars: true,
+        evaluate: true
     };
 
     input: {
@@ -16,9 +27,7 @@ const_pragma: {
 // for completeness' sake
 not_const: {
     options = {
-        evaluate: true,
-        reduce_funcs: true,
-        reduce_vars: true,
+        evaluate: true
     };
 
     input: {

test/compress/issue-1043.js

@@ -0,0 +1,30 @@
+issue_1043: {
+    options = {
+        side_effects: true
+    };
+
+    input: {
+        function* range(start = 0, end = null, step = 1) {
+            if (end == null) {
+                end = start;
+                start = 0;
+            }
+
+            for (let i = start; i < end; i += step) {
+                yield i;
+            }
+        }
+    }
+
+    expect: {
+        function* range(start = 0, end = null, step = 1) {
+            if (null == end) {
+                end = start;
+                start = 0;
+            }
+
+            for (let i = start; i < end; i += step)
+                yield i;
+        }
+    }
+}

test/compress/issue-1044.js

@@ -0,0 +1,9 @@
+issue_1044: {
+    options = { evaluate: true, conditionals: true };
+    input: {
+        const mixed = Base ? class extends Base {} : class {}
+    }
+    expect: {
+        const mixed = Base ? class extends Base {} : class {}
+    }
+}

test/compress/issue-105.js

@@ -0,0 +1,25 @@
+typeof_eq_undefined: {
+    options = {
+        comparisons: true
+    };
+    input: { a = typeof b.c != "undefined" }
+    expect: { a = "undefined" != typeof b.c }
+}
+
+typeof_eq_undefined_unsafe: {
+    options = {
+        comparisons: true,
+        unsafe: true
+    };
+    input: { a = typeof b.c != "undefined" }
+    expect: { a = void 0 !== b.c }
+}
+
+typeof_eq_undefined_unsafe2: {
+    options = {
+        comparisons: true,
+        unsafe: true
+    };
+    input: { a = "undefined" != typeof b.c }
+    expect: { a = void 0 !== b.c }
+}

test/compress/issue-1052.js

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

test/compress/issue-1105.js

@@ -193,15 +193,13 @@ assorted_Infinity_NaN_undefined_in_with_scope: {
         cascade:       true,
         side_effects:  true,
         sequences:     false,
-        keep_infinity: false,
     }
     input: {
-        var f = console.log;
         var o = {
             undefined : 3,
             NaN       : 4,
             Infinity  : 5,
-        };
+        }
         if (o) {
             f(undefined, void 0);
             f(NaN, 0/0);
@@ -218,88 +216,25 @@ assorted_Infinity_NaN_undefined_in_with_scope: {
         }
     }
     expect: {
-        var f = console.log, o = {
+        var o = {
             undefined : 3,
             NaN       : 4,
             Infinity  : 5
-        };
+        }
         if (o) {
             f(void 0, void 0);
             f(NaN, NaN);
             f(1/0, 1/0);
-            f(-1/0, -1/0);
+            f(-(1/0), -(1/0));
             f(NaN, NaN);
         }
         with (o) {
             f(undefined, void 0);
             f(NaN, 0/0);
             f(Infinity, 1/0);
-            f(-Infinity, -1/0);
+            f(-Infinity, -(1/0));
             f(9 + undefined, 9 + void 0);
         }
     }
-    expect_stdout: true
 }
 
-assorted_Infinity_NaN_undefined_in_with_scope_keep_infinity: {
-    options = {
-        unused:        true,
-        evaluate:      true,
-        dead_code:     true,
-        conditionals:  true,
-        comparisons:   true,
-        booleans:      true,
-        hoist_funs:    true,
-        keep_fargs:    true,
-        if_return:     true,
-        join_vars:     true,
-        cascade:       true,
-        side_effects:  true,
-        sequences:     false,
-        keep_infinity: true,
-    }
-    input: {
-        var f = console.log;
-        var o = {
-            undefined : 3,
-            NaN       : 4,
-            Infinity  : 5,
-        };
-        if (o) {
-            f(undefined, void 0);
-            f(NaN, 0/0);
-            f(Infinity, 1/0);
-            f(-Infinity, -(1/0));
-            f(2 + 7 + undefined, 2 + 7 + void 0);
-        }
-        with (o) {
-            f(undefined, void 0);
-            f(NaN, 0/0);
-            f(Infinity, 1/0);
-            f(-Infinity, -(1/0));
-            f(2 + 7 + undefined, 2 + 7 + void 0);
-        }
-    }
-    expect: {
-        var f = console.log, o = {
-            undefined : 3,
-            NaN       : 4,
-            Infinity  : 5
-        };
-        if (o) {
-            f(void 0, void 0);
-            f(NaN, NaN);
-            f(Infinity, 1/0);
-            f(-Infinity, -1/0);
-            f(NaN, NaN);
-        }
-        with (o) {
-            f(undefined, void 0);
-            f(NaN, 0/0);
-            f(Infinity, 1/0);
-            f(-Infinity, -1/0);
-            f(9 + undefined, 9 + void 0);
-        }
-    }
-    expect_stdout: true
-}

test/compress/issue-1202.js

@@ -49,3 +49,4 @@ mangle_keep_fnames_true: {
         }
     }
 }
+

test/compress/issue-1212.js

@@ -0,0 +1,76 @@
+issue_1212_debug_false: {
+    options = {
+        global_defs   : { DEBUG: false },
+        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: {
+        class foo {
+            bar() {
+                if (DEBUG)
+                    console.log("DEV");
+                else
+                    console.log("PROD");
+            }
+        }
+        new foo().bar();
+    }
+    expect: {
+        class foo{
+            bar() { console.log("PROD") }
+        }
+        (new foo).bar();
+    }
+}
+
+issue_1212_debug_true: {
+    options = {
+        global_defs   : { DEBUG: 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: {
+        class foo {
+            bar() {
+                if (DEBUG)
+                    console.log("DEV");
+                else
+                    console.log("PROD");
+            }
+        }
+        new foo().bar();
+    }
+    expect: {
+        class foo{
+            bar() { console.log("DEV") }
+        }
+        (new foo).bar();
+    }
+}
+

test/compress/issue-1261.js

@@ -1,185 +0,0 @@
-pure_function_calls: {
-    options = {
-        evaluate     : true,
-        conditionals : true,
-        comparisons  : true,
-        side_effects : true,
-        booleans     : true,
-        unused       : true,
-        if_return    : true,
-        join_vars    : true,
-        cascade      : true,
-        negate_iife  : true,
-    }
-    input: {
-        // pure top-level IIFE will be dropped
-        // @__PURE__ - comment
-        (function() {
-            console.log("iife0");
-        })();
-
-        // pure top-level IIFE assigned to unreferenced var will not be dropped
-        var iife1 = /*@__PURE__*/(function() {
-            console.log("iife1");
-            function iife1() {}
-            return iife1;
-        })();
-
-        (function(){
-            // pure IIFE in function scope assigned to unreferenced var will be dropped
-            var iife2 = /*#__PURE__*/(function() {
-                console.log("iife2");
-                function iife2() {}
-                return iife2;
-            })();
-        })();
-
-        // comment #__PURE__ comment
-        bar(), baz(), quux();
-        a.b(), /* @__PURE__ */ c.d.e(), f.g();
-    }
-    expect: {
-        var iife1 = function() {
-            console.log("iife1");
-            function iife1() {}
-            return iife1;
-        }();
-
-        baz(), quux();
-        a.b(), f.g();
-    }
-    expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:17,8]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:17,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:30,37]",
-        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:30,16]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:28,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:38,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:39,31]",
-    ]
-}
-
-pure_function_calls_toplevel: {
-    options = {
-        evaluate     : true,
-        conditionals : true,
-        comparisons  : true,
-        side_effects : true,
-        booleans     : true,
-        unused       : true,
-        if_return    : true,
-        join_vars    : true,
-        cascade      : true,
-        negate_iife  : true,
-        toplevel     : true,
-    }
-    input: {
-        // pure top-level IIFE will be dropped
-        // @__PURE__ - comment
-        (function() {
-            console.log("iife0");
-        })();
-
-        // pure top-level IIFE assigned to unreferenced var will be dropped
-        var iife1 = /*@__PURE__*/(function() {
-            console.log("iife1");
-            function iife1() {}
-            return iife1;
-        })();
-
-        (function(){
-            // pure IIFE in function scope assigned to unreferenced var will be dropped
-            var iife2 = /*#__PURE__*/(function() {
-                console.log("iife2");
-                function iife2() {}
-                return iife2;
-            })();
-        })();
-
-        // pure top-level calls will be dropped regardless of the leading comments position
-        var MyClass = /*#__PURE__*//*@class*/(function(){
-            function MyClass() {}
-            MyClass.prototype.method = function() {};
-            return MyClass;
-        })();
-
-        // comment #__PURE__ comment
-        bar(), baz(), quux();
-        a.b(), /* @__PURE__ */ c.d.e(), f.g();
-    }
-    expect: {
-        baz(), quux();
-        a.b(), f.g();
-    }
-    expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:79,8]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:79,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:92,37]",
-        "WARN: Dropping unused variable iife2 [test/compress/issue-1261.js:92,16]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:90,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:107,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:108,31]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:84,33]",
-        "WARN: Dropping unused variable iife1 [test/compress/issue-1261.js:84,12]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:100,45]",
-        "WARN: Dropping unused variable MyClass [test/compress/issue-1261.js:100,12]",
-    ]
-}
-
-should_warn: {
-    options = {
-        booleans: true,
-        conditionals: true,
-        evaluate: true,
-        side_effects: true,
-    }
-    input: {
-        /* @__PURE__ */(function(){x})(), void/* @__PURE__ */(function(){y})();
-        /* @__PURE__ */(function(){x})() || true ? foo() : bar();
-        true || /* @__PURE__ */(function(){y})() ? foo() : bar();
-        /* @__PURE__ */(function(){x})() && false ? foo() : bar();
-        false && /* @__PURE__ */(function(){y})() ? foo() : bar();
-        /* @__PURE__ */(function(){x})() + "foo" ? bar() : baz();
-        "foo" + /* @__PURE__ */(function(){y})() ? bar() : baz();
-        /* @__PURE__ */(function(){x})() ? foo() : foo();
-        [/* @__PURE__ */(function(){x})()] ? foo() : bar();
-        !{ foo: /* @__PURE__ */(function(){x})() } ? bar() : baz();
-    }
-    expect: {
-        foo();
-        foo();
-        bar();
-        bar();
-        bar();
-        bar();
-        foo();
-        foo();
-        baz();
-    }
-    expect_warnings: [
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:137,61]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:137,23]",
-        "WARN: Dropping side-effect-free statement [test/compress/issue-1261.js:137,23]",
-        "WARN: Boolean || always true [test/compress/issue-1261.js:138,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:138,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:138,23]",
-        "WARN: Condition left of || always true [test/compress/issue-1261.js:139,8]",
-        "WARN: Condition always true [test/compress/issue-1261.js:139,8]",
-        "WARN: Boolean && always false [test/compress/issue-1261.js:140,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:140,23]",
-        "WARN: Condition always false [test/compress/issue-1261.js:140,23]",
-        "WARN: Condition left of && always false [test/compress/issue-1261.js:141,8]",
-        "WARN: Condition always false [test/compress/issue-1261.js:141,8]",
-        "WARN: + in boolean context always true [test/compress/issue-1261.js:142,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:142,23]",
-        "WARN: Condition always true [test/compress/issue-1261.js:142,23]",
-        "WARN: + in boolean context always true [test/compress/issue-1261.js:143,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:143,31]",
-        "WARN: Condition always true [test/compress/issue-1261.js:143,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:144,23]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:145,24]",
-        "WARN: Condition always true [test/compress/issue-1261.js:145,8]",
-        "WARN: Dropping __PURE__ call [test/compress/issue-1261.js:146,31]",
-        "WARN: Condition always false [test/compress/issue-1261.js:146,8]",
-    ]
-}

test/compress/issue-1275.js

@@ -35,7 +35,7 @@ string_plus_optimization: {
                 throw "nope";
             }
             try {
-                console.log((throwing_function(), "yes"));
+                console.log('0' + throwing_function() ? "yes" : "no");
             } catch (ex) {
                 console.log(ex);
             }
@@ -46,5 +46,4 @@ string_plus_optimization: {
         }
         foo();
     }
-    expect_stdout: true
 }

test/compress/issue-1321.js

@@ -1,8 +1,6 @@
 issue_1321_no_debug: {
-    mangle = {
-        properties: {
-            keep_quoted: true,
-        },
+    mangle_props = {
+        ignore_quoted: true
     }
     input: {
         var x = {};
@@ -12,19 +10,16 @@ issue_1321_no_debug: {
     }
     expect: {
         var x = {};
-        x.x = 1;
-        x["a"] = 2 * x.x;
-        console.log(x.x, x["a"]);
+        x.b = 1;
+        x["a"] = 2 * x.b;
+        console.log(x.b, x["a"]);
     }
-    expect_stdout: true
 }
 
 issue_1321_debug: {
-    mangle = {
-        properties: {
-            debug: "",
-            keep_quoted: true,
-        },
+    mangle_props = {
+        ignore_quoted: true,
+        debug: ""
     }
     input: {
         var x = {};
@@ -34,18 +29,15 @@ issue_1321_debug: {
     }
     expect: {
         var x = {};
-        x.x = 1;
-        x["_$foo$_"] = 2 * x.x;
-        console.log(x.x, x["_$foo$_"]);
+        x.a = 1;
+        x["_$foo$_"] = 2 * x.a;
+        console.log(x.a, x["_$foo$_"]);
     }
-    expect_stdout: true
 }
 
 issue_1321_with_quoted: {
-    mangle = {
-        properties: {
-            keep_quoted: false,
-        },
+    mangle_props = {
+        ignore_quoted: false
     }
     input: {
         var x = {};
@@ -55,9 +47,8 @@ issue_1321_with_quoted: {
     }
     expect: {
         var x = {};
-        x.x = 1;
-        x["o"] = 2 * x.x;
-        console.log(x.x, x["o"]);
+        x.a = 1;
+        x["b"] = 2 * x.a;
+        console.log(x.a, x["b"]);
     }
-    expect_stdout: true
 }

test/compress/issue-1431.js

@@ -1,151 +0,0 @@
-level_zero: {
-    options = {
-        keep_fnames: true
-    }
-    mangle = {
-        keep_fnames: true
-    }
-    input: {
-        function f(x) {
-            function n(a) {
-                return a * a;
-            }
-            return function() {
-                return x;
-            };
-        }
-    }
-    expect: {
-        function f(r) {
-            function n(n) {
-                return n * n;
-            }
-            return function() {
-                return r;
-            };
-        }
-    }
-}
-
-level_one: {
-    options = {
-        keep_fnames: true
-    }
-    mangle = {
-        keep_fnames: true
-    }
-    input: {
-        function f(x) {
-            return function() {
-                function n(a) {
-                    return a * a;
-                }
-                return x(n);
-            };
-        }
-    }
-    expect: {
-        function f(r) {
-            return function() {
-                function n(n) {
-                    return n * n;
-                }
-                return r(n);
-            };
-        }
-    }
-}
-
-level_two: {
-    options = {
-        keep_fnames: true
-    }
-    mangle = {
-        keep_fnames: true
-    }
-    input: {
-        function f(x) {
-            return function() {
-                function r(a) {
-                    return a * a;
-                }
-                return function() {
-                    function n(a) {
-                        return a * a;
-                    }
-                    return x(n);
-                };
-            };
-        }
-    }
-    expect: {
-        function f(t) {
-            return function() {
-                function r(n) {
-                    return n * n;
-                }
-                return function() {
-                    function n(n) {
-                        return n * n;
-                    }
-                    return t(n);
-                };
-            };
-        }
-    }
-}
-
-level_three: {
-    options = {
-        keep_fnames: true
-    }
-    mangle = {
-        keep_fnames: true
-    }
-    input: {
-        function f(x) {
-            return function() {
-                function r(a) {
-                    return a * a;
-                }
-                return [
-                    function() {
-                        function t(a) {
-                            return a * a;
-                        }
-                        return t;
-                    },
-                    function() {
-                        function n(a) {
-                            return a * a;
-                        }
-                        return x(n);
-                    }
-                ];
-            };
-        }
-    }
-    expect: {
-        function f(t) {
-            return function() {
-                function r(n) {
-                    return n * n;
-                }
-                return [
-                    function() {
-                        function t(n) {
-                            return n * n;
-                        }
-                        return t;
-                    },
-                    function() {
-                        function n(n) {
-                            return n * n;
-                        }
-                        return t(n);
-                    }
-                ];
-            };
-        }
-    }
-}

test/compress/issue-1443.js

@@ -1,61 +0,0 @@
-// tests assume that variable `undefined` not redefined and has `void 0` as value
-
-unsafe_undefined: {
-    options = {
-        conditionals: true,
-        if_return: true,
-        unsafe: true
-    }
-    mangle = {}
-    input: {
-        function f(undefined) {
-            return function() {
-                if (a)
-                    return b;
-                if (c)
-                    return d;
-            };
-        }
-    }
-    expect: {
-        function f(n) {
-            return function() {
-                return a ? b : c ? d : n;
-            };
-        }
-    }
-}
-
-keep_fnames: {
-    options = {
-        conditionals: true,
-        if_return: true,
-        unsafe: true
-    }
-    mangle = {
-        keep_fnames: true
-    }
-    input: {
-        function f(undefined) {
-            return function() {
-                function n(a) {
-                    return a * a;
-                }
-                if (a)
-                    return b;
-                if (c)
-                    return d;
-            };
-        }
-    }
-    expect: {
-        function f(r) {
-            return function() {
-                function n(n) {
-                    return n * n;
-                }
-                return a ? b : c ? d : r;
-            };
-        }
-    }
-}

test/compress/issue-1446.js

@@ -1,75 +0,0 @@
-typeof_eq_undefined: {
-    options = {
-        comparisons: true,
-        typeofs: true,
-    }
-    input: {
-        var a = typeof b != "undefined";
-        b = typeof a != "undefined";
-        var c = typeof d.e !== "undefined";
-        var f = "undefined" === typeof g;
-        g = "undefined" === typeof f;
-        var h = "undefined" == typeof i.j;
-    }
-    expect: {
-        var a = "undefined" != typeof b;
-        b = void 0 !== a;
-        var c = void 0 !== d.e;
-        var f = "undefined" == typeof g;
-        g = void 0 === f;
-        var h = void 0 === i.j;
-    }
-}
-
-typeof_eq_undefined_ie8: {
-    options = {
-        comparisons: true,
-        ie8: true,
-        typeofs: true,
-    }
-    input: {
-        var a = typeof b != "undefined";
-        b = typeof a != "undefined";
-        var c = typeof d.e !== "undefined";
-        var f = "undefined" === typeof g;
-        g = "undefined" === typeof f;
-        var h = "undefined" == typeof i.j;
-    }
-    expect: {
-        var a = "undefined" != typeof b;
-        b = void 0 !== a;
-        var c = "undefined" != typeof d.e;
-        var f = "undefined" == typeof g;
-        g = void 0 === f;
-        var h = "undefined" == typeof i.j;
-    }
-}
-
-undefined_redefined: {
-    options = {
-        comparisons: true,
-        typeofs: true,
-    }
-    input: {
-        function f(undefined) {
-            var n = 1;
-            return typeof n == "undefined";
-        }
-    }
-    expect_exact: "function f(undefined){var n=1;return void 0===n}"
-}
-
-undefined_redefined_mangle: {
-    options = {
-        comparisons: true,
-        typeofs: true,
-    }
-    mangle = {}
-    input: {
-        function f(undefined) {
-            var n = 1;
-            return typeof n == "undefined";
-        }
-    }
-    expect_exact: "function f(n){var r=1;return void 0===r}"
-}

test/compress/issue-1447.js

@@ -1,46 +0,0 @@
-else_with_empty_block: {
-    options = {}
-    input: {
-        if (x)
-            yes();
-        else {
-        }
-    }
-    expect_exact: "if(x)yes();"
-}
-
-else_with_empty_statement: {
-    options = {}
-    input: {
-        if (x)
-            yes();
-        else
-            ;
-    }
-    expect_exact: "if(x)yes();"
-}
-
-conditional_false_stray_else_in_loop: {
-    options = {
-        evaluate     : true,
-        comparisons  : true,
-        booleans     : true,
-        unused       : true,
-        loops        : true,
-        side_effects : true,
-        dead_code    : true,
-        hoist_vars   : true,
-        join_vars    : true,
-        if_return    : true,
-        cascade      : true,
-        conditionals : false,
-    }
-    input: {
-        for (var i = 1; i <= 4; ++i) {
-            if (i <= 2) continue;
-            console.log(i);
-        }
-    }
-    expect_exact: "for(var i=1;i<=4;++i)if(!(i<=2))console.log(i);"
-    expect_stdout: true
-}

test/compress/issue-1569.js

@@ -1,19 +0,0 @@
-inner_reference: {
-    options = {
-        side_effects: true,
-    }
-    input: {
-        !function f(a) {
-            return a && f(a - 1) + a;
-        }(42);
-        !function g(a) {
-            return a;
-        }(42);
-    }
-    expect: {
-        !function f(a) {
-            return a && f(a - 1) + a;
-        }(42);
-        !void 0;
-    }
-}

test/compress/issue-1588.js

@@ -1,87 +0,0 @@
-screw_ie8: {
-    options = {
-        ie8: false,
-    }
-    mangle = {
-        ie8: false,
-    }
-    input: {
-        try { throw "foo"; } catch (x) { console.log(x); }
-    }
-    expect_exact: 'try{throw"foo"}catch(o){console.log(o)}'
-    expect_stdout: [
-        "foo"
-    ]
-}
-
-support_ie8: {
-    options = {
-        ie8: true,
-    }
-    mangle = {
-        ie8: true,
-    }
-    input: {
-        try { throw "foo"; } catch (x) { console.log(x); }
-    }
-    expect_exact: 'try{throw"foo"}catch(x){console.log(x)}'
-    expect_stdout: "foo"
-}
-
-safe_undefined: {
-    options = {
-        conditionals: true,
-        if_return: true,
-        unsafe: false,
-    }
-    mangle = {}
-    input: {
-        var a, c;
-        console.log(function(undefined) {
-            return function() {
-                if (a)
-                    return b;
-                if (c)
-                    return d;
-            };
-        }(1)());
-    }
-    expect: {
-        var a, c;
-        console.log(function(n) {
-            return function() {
-                return a ? b : c ? d : void 0;
-            };
-        }(1)());
-    }
-    expect_stdout: true
-}
-
-unsafe_undefined: {
-    options = {
-        conditionals: true,
-        if_return: true,
-        unsafe: true,
-    }
-    mangle = {}
-    input: {
-        var a, c;
-        console.log(function(undefined) {
-            return function() {
-                if (a)
-                    return b;
-                if (c)
-                    return d;
-            };
-        }()());
-    }
-    expect: {
-        var a, c;
-        console.log(function(n) {
-            return function() {
-                return a ? b : c ? d : n;
-            };
-        }()());
-    }
-    expect_stdout: true
-}

test/compress/issue-1609.js

@@ -1,54 +0,0 @@
-chained_evaluation_1: {
-    options = {
-        collapse_vars: true,
-        evaluate: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        (function() {
-            var a = 1;
-            (function() {
-                var b = a, c;
-                c = f(b);
-                c.bar = b;
-            })();
-        })();
-    }
-    expect: {
-        (function() {
-            (function() {
-                f(1).bar = 1;
-            })();
-        })();
-    }
-}
-
-chained_evaluation_2: {
-    options = {
-        collapse_vars: true,
-        evaluate: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        (function() {
-            var a = "long piece of string";
-            (function() {
-                var b = a, c;
-                c = f(b);
-                c.bar = b;
-            })();
-        })();
-    }
-    expect: {
-        (function() {
-            (function() {
-                var b = "long piece of string";
-                f(b).bar = b;
-            })();
-        })();
-    }
-}

test/compress/issue-1639.js

@@ -1,88 +0,0 @@
-
-issue_1639_1: {
-    options = {
-        booleans: true,
-        cascade: true,
-        conditionals: true,
-        evaluate: true,
-        join_vars: true,
-        loops: true,
-        sequences: true,
-        side_effects: true,
-    }
-    input: {
-        var a = 100, b = 10;
-
-        var L1 = 5;
-        while (--L1 > 0) {
-            if ((--b), false) {
-                if (b) {
-                    var ignore = 0;
-                }
-            }
-        }
-
-        console.log(a, b);
-    }
-    expect: {
-        for (var a = 100, b = 10, L1 = 5; --L1 > 0;)
-            if (--b, !1) var ignore = 0;
-        console.log(a, b);
-    }
-    expect_stdout: true
-}
-
-issue_1639_2: {
-    options = {
-        booleans: true,
-        cascade: true,
-        conditionals: true,
-        evaluate: true,
-        join_vars: true,
-        sequences: true,
-        side_effects: true,
-    }
-    input: {
-        var a = 100, b = 10;
-
-        function f19() {
-            if (++a, false)
-                if (a)
-                    if (++a);
-        }
-        f19();
-
-        console.log(a, b);
-    }
-    expect: {
-        var a = 100, b = 10;
-        function f19() {
-            ++a, 1;
-        }
-        f19(),
-        console.log(a, b);
-    }
-    expect_stdout: true
-}
-
-issue_1639_3: {
-    options = {
-        booleans: true,
-        cascade: true,
-        conditionals: true,
-        evaluate: true,
-        sequences: true,
-        side_effects: true,
-    }
-    input: {
-        var a = 100, b = 10;
-        a++ && false && a ? 0 : 0;
-        console.log(a, b);
-    }
-    expect: {
-        var a = 100, b = 10;
-        a++,
-        console.log(a, b);
-    }
-    expect_stdout: true
-}

test/compress/issue-1656.js

@@ -1,46 +0,0 @@
-f7: {
-    options = {
-        booleans: true,
-        cascade: true,
-        collapse_vars: true,
-        comparisons: true,
-        conditionals: true,
-        dead_code: true,
-        drop_debugger: true,
-        evaluate: true,
-        hoist_funs: true,
-        if_return: true,
-        join_vars: true,
-        loops: true,
-        negate_iife: true,
-        passes: 3,
-        properties: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-        toplevel: true,
-        unused: true,
-    }
-    beautify = {
-        beautify: true,
-    }
-    input: {
-        var a = 100, b = 10;
-        function f22464() {
-            var brake146670 = 5;
-            while (((b = a) ? !a : ~a ? null : b += a) && --brake146670 > 0) {
-            }
-        }
-        f22464();
-        console.log(a, b);
-    }
-    expect_exact: [
-        "var b = 10;",
-        "",
-        "!function() {",
-        "    for (;b = 100, !1; ) ;",
-        "}(), console.log(100, b);",
-    ]
-    expect_stdout: true
-}

test/compress/issue-1673.js

@@ -1,166 +0,0 @@
-side_effects_catch: {
-    options = {
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            function g() {
-                try {
-                    throw 0;
-                } catch (e) {
-                    console.log("PASS");
-                }
-            }
-            g();
-        }
-        f();
-    }
-    expect: {
-        function f() {
-            (function() {
-                try {
-                    throw 0;
-                } catch (e) {
-                    console.log("PASS");
-                }
-            })();
-        }
-        f();
-    }
-    expect_stdout: "PASS"
-}
-
-side_effects_else: {
-    options = {
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        function f(x) {
-            function g() {
-                if (x);
-                else console.log("PASS");
-            }
-            g();
-        }
-        f(0);
-    }
-    expect: {
-        function f(x) {
-            (function() {
-                if (x);
-                else console.log("PASS");
-            })();
-        }
-        f(0);
-    }
-    expect_stdout: "PASS"
-}
-
-side_effects_finally: {
-    options = {
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            function g() {
-                try {
-                    x();
-                } catch (e) {
-                } finally {
-                    console.log("PASS");
-                }
-            }
-            g();
-        }
-        f();
-    }
-    expect: {
-        function f() {
-            (function() {
-                try {
-                    x();
-                } catch (e) {
-                } finally {
-                    console.log("PASS");
-                }
-            })();
-        }
-        f();
-    }
-    expect_stdout: "PASS"
-}
-
-side_effects_label: {
-    options = {
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        function f(x) {
-            function g() {
-                L: {
-                    console.log("PASS");
-                    break L;
-                }
-            }
-            g();
-        }
-        f(0);
-    }
-    expect: {
-        function f(x) {
-            (function() {
-                L: {
-                    console.log("PASS");
-                    break L;
-                }
-            })();
-        }
-        f(0);
-    }
-    expect_stdout: "PASS"
-}
-
-side_effects_switch: {
-    options = {
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            function g() {
-                switch (0) {
-                  default:
-                  case console.log("PASS"):
-                }
-            }
-            g();
-        }
-        f();
-    }
-    expect: {
-        function f() {
-            (function() {
-                switch (0) {
-                  default:
-                  case console.log("PASS"):
-                }
-            })();
-        }
-        f();
-    }
-    expect_stdout: "PASS"
-}

test/compress/issue-1704.js

@@ -1,347 +0,0 @@
-mangle_catch: {
-    options = {
-        ie8: false,
-        toplevel: false,
-    }
-    mangle = {
-        ie8: false,
-        toplevel: false,
-    }
-    input: {
-        var a = "FAIL";
-        try {
-            throw 1;
-        } catch (args) {
-            a = "PASS";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var a="FAIL";try{throw 1}catch(o){a="PASS"}console.log(a);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_ie8: {
-    options = {
-        ie8: true,
-        toplevel: false,
-    }
-    mangle = {
-        ie8: true,
-        toplevel: false,
-    }
-    input: {
-        var a = "FAIL";
-        try {
-            throw 1;
-        } catch (args) {
-            a = "PASS";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var a="FAIL";try{throw 1}catch(args){a="PASS"}console.log(a);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_var: {
-    options = {
-        ie8: false,
-        toplevel: false,
-    }
-    mangle = {
-        ie8: false,
-        toplevel: false,
-    }
-    input: {
-        var a = "FAIL";
-        try {
-            throw 1;
-        } catch (args) {
-            var a = "PASS";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var a="FAIL";try{throw 1}catch(o){var a="PASS"}console.log(a);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_var_ie8: {
-    options = {
-        ie8: true,
-        toplevel: false,
-    }
-    mangle = {
-        ie8: true,
-        toplevel: false,
-    }
-    input: {
-        var a = "FAIL";
-        try {
-            throw 1;
-        } catch (args) {
-            var a = "PASS";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var a="FAIL";try{throw 1}catch(args){var a="PASS"}console.log(a);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_toplevel: {
-    options = {
-        ie8: false,
-        toplevel: true,
-    }
-    mangle = {
-        ie8: false,
-        toplevel: true,
-    }
-    input: {
-        var a = "FAIL";
-        try {
-            throw 1;
-        } catch (args) {
-            a = "PASS";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var o="FAIL";try{throw 1}catch(c){o="PASS"}console.log(o);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_ie8_toplevel: {
-    options = {
-        ie8: true,
-        toplevel: true,
-    }
-    mangle = {
-        ie8: true,
-        toplevel: true,
-    }
-    input: {
-        var a = "FAIL";
-        try {
-            throw 1;
-        } catch (args) {
-            a = "PASS";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var o="FAIL";try{throw 1}catch(c){o="PASS"}console.log(o);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_var_toplevel: {
-    options = {
-        ie8: false,
-        toplevel: true,
-    }
-    mangle = {
-        ie8: false,
-        toplevel: true,
-    }
-    input: {
-        var a = "FAIL";
-        try {
-            throw 1;
-        } catch (args) {
-            var a = "PASS";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var o="FAIL";try{throw 1}catch(r){var o="PASS"}console.log(o);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_var_ie8_toplevel: {
-    options = {
-        ie8: true,
-        toplevel: true,
-    }
-    mangle = {
-        ie8: true,
-        toplevel: true,
-    }
-    input: {
-        var a = "FAIL";
-        try {
-            throw 1;
-        } catch (args) {
-            var a = "PASS";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var o="FAIL";try{throw 1}catch(r){var o="PASS"}console.log(o);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_redef_1: {
-    options = {
-        ie8: false,
-        toplevel: false,
-    }
-    mangle = {
-        ie8: false,
-        toplevel: false,
-    }
-    input: {
-        var a = "PASS";
-        try {
-            throw "FAIL1";
-        } catch (a) {
-            var a = "FAIL2";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var a="PASS";try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_redef_1_ie8: {
-    options = {
-        ie8: true,
-        toplevel: false,
-    }
-    mangle = {
-        ie8: true,
-        toplevel: false,
-    }
-    input: {
-        var a = "PASS";
-        try {
-            throw "FAIL1";
-        } catch (a) {
-            var a = "FAIL2";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var a="PASS";try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_redef_1_toplevel: {
-    options = {
-        ie8: false,
-        toplevel: true,
-    }
-    mangle = {
-        ie8: false,
-        toplevel: true,
-    }
-    input: {
-        var a = "PASS";
-        try {
-            throw "FAIL1";
-        } catch (a) {
-            var a = "FAIL2";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var o="PASS";try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_redef_1_ie8_toplevel: {
-    options = {
-        ie8: true,
-        toplevel: true,
-    }
-    mangle = {
-        ie8: true,
-        toplevel: true,
-    }
-    input: {
-        var a = "PASS";
-        try {
-            throw "FAIL1";
-        } catch (a) {
-            var a = "FAIL2";
-        }
-        console.log(a);
-    }
-    expect_exact: 'var o="PASS";try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
-    expect_stdout: "PASS"
-}
-
-mangle_catch_redef_2: {
-    options = {
-        ie8: false,
-        toplevel: false,
-    }
-    mangle = {
-        ie8: false,
-        toplevel: false,
-    }
-    input: {
-        try {
-            throw "FAIL1";
-        } catch (a) {
-            var a = "FAIL2";
-        }
-        console.log(a);
-    }
-    expect_exact: 'try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
-    expect_stdout: "undefined"
-}
-
-mangle_catch_redef_2_ie8: {
-    options = {
-        ie8: true,
-        toplevel: false,
-    }
-    mangle = {
-        ie8: true,
-        toplevel: false,
-    }
-    input: {
-        try {
-            throw "FAIL1";
-        } catch (a) {
-            var a = "FAIL2";
-        }
-        console.log(a);
-    }
-    expect_exact: 'try{throw"FAIL1"}catch(a){var a="FAIL2"}console.log(a);'
-    expect_stdout: "undefined"
-}
-
-mangle_catch_redef_2_toplevel: {
-    options = {
-        ie8: false,
-        toplevel: true,
-    }
-    mangle = {
-        ie8: false,
-        toplevel: true,
-    }
-    input: {
-        try {
-            throw "FAIL1";
-        } catch (a) {
-            var a = "FAIL2";
-        }
-        console.log(a);
-    }
-    expect_exact: 'try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
-    expect_stdout: "undefined"
-}
-
-mangle_catch_redef_2_ie8_toplevel: {
-    options = {
-        ie8: true,
-        toplevel: true,
-    }
-    mangle = {
-        ie8: true,
-        toplevel: true,
-    }
-    input: {
-        try {
-            throw "FAIL1";
-        } catch (a) {
-            var a = "FAIL2";
-        }
-        console.log(a);
-    }
-    expect_exact: 'try{throw"FAIL1"}catch(o){var o="FAIL2"}console.log(o);'
-    expect_stdout: "undefined"
-}

test/compress/issue-1733.js

@@ -1,97 +0,0 @@
-function_iife_catch: {
-    mangle = {
-        ie8: false,
-    }
-    input: {
-        function f(n) {
-            !function() {
-                try {
-                    throw 0;
-                } catch (n) {
-                    var a = 1;
-                    console.log(n, a);
-                }
-            }();
-        }
-        f();
-    }
-    expect_exact: "function f(o){!function(){try{throw 0}catch(c){var o=1;console.log(c,o)}}()}f();"
-    expect_stdout: "0 1"
-}
-
-function_iife_catch_ie8: {
-    mangle = {
-        ie8: true,
-    }
-    input: {
-        function f(n) {
-            !function() {
-                try {
-                    throw 0;
-                } catch (n) {
-                    var a = 1;
-                    console.log(n, a);
-                }
-            }();
-        }
-        f();
-    }
-    expect_exact: "function f(o){!function(){try{throw 0}catch(o){var c=1;console.log(o,c)}}()}f();"
-    expect_stdout: "0 1"
-}
-
-function_catch_catch: {
-    mangle = {
-        ie8: false,
-    }
-    input: {
-        var o = 0;
-        function f() {
-            try {
-                throw 1;
-            } catch (c) {
-                try {
-                    throw 2;
-                } catch (o) {
-                    var o = 3;
-                    console.log(o);
-                }
-            }
-            console.log(o);
-        }
-        f();
-    }
-    expect_exact: "var o=0;function f(){try{throw 1}catch(c){try{throw 2}catch(o){var o=3;console.log(o)}}console.log(o)}f();"
-    expect_stdout: [
-        "3",
-        "undefined",
-    ]
-}
-
-function_catch_catch_ie8: {
-    mangle = {
-        ie8: true,
-    }
-    input: {
-        var o = 0;
-        function f() {
-            try {
-                throw 1;
-            } catch (c) {
-                try {
-                    throw 2;
-                } catch (o) {
-                    var o = 3;
-                    console.log(o);
-                }
-            }
-            console.log(o);
-        }
-        f();
-    }
-    expect_exact: "var o=0;function f(){try{throw 1}catch(c){try{throw 2}catch(o){var o=3;console.log(o)}}console.log(o)}f();"
-    expect_stdout: [
-        "3",
-        "undefined",
-    ]
-}

test/compress/issue-1750.js

@@ -1,54 +0,0 @@
-case_1: {
-    options = {
-        dead_code: true,
-        evaluate: true,
-        switches: true,
-    }
-    input: {
-        var a = 0, b = 1;
-        switch (true) {
-          case a, true:
-          default:
-            b = 2;
-          case true:
-        }
-        console.log(a, b);
-    }
-    expect: {
-        var a = 0, b = 1;
-        switch (true) {
-          case a, true:
-            b = 2;
-        }
-        console.log(a, b);
-    }
-    expect_stdout: "0 2"
-}
-
-case_2: {
-    options = {
-        dead_code: true,
-        evaluate: true,
-        switches: true,
-    }
-    input: {
-        var a = 0, b = 1;
-        switch (0) {
-          default:
-            b = 2;
-          case a:
-            a = 3;
-          case 0:
-        }
-        console.log(a, b);
-    }
-    expect: {
-        var a = 0, b = 1;
-        switch (0) {
-          case a:
-            a = 3;
-        }
-        console.log(a, b);
-    }
-    expect_stdout: "3 1"
-}

test/compress/issue-1770.js

@@ -1,245 +0,0 @@
-mangle_props: {
-    mangle = {
-        properties: true,
-    }
-    input: {
-        var obj = {
-            undefined: 1,
-            NaN: 2,
-            Infinity: 3,
-            "-Infinity": 4,
-            null: 5,
-        };
-        console.log(
-            obj[void 0],
-            obj[undefined],
-            obj["undefined"],
-            obj[0/0],
-            obj[NaN],
-            obj["NaN"],
-            obj[1/0],
-            obj[Infinity],
-            obj["Infinity"],
-            obj[-1/0],
-            obj[-Infinity],
-            obj["-Infinity"],
-            obj[null],
-            obj["null"]
-        );
-    }
-    expect: {
-        var obj = {
-            undefined: 1,
-            NaN: 2,
-            Infinity: 3,
-            "-Infinity": 4,
-            null: 5,
-        };
-        console.log(
-            obj[void 0],
-            obj[void 0],
-            obj["undefined"],
-            obj[0/0],
-            obj[NaN],
-            obj["NaN"],
-            obj[1/0],
-            obj[1/0],
-            obj["Infinity"],
-            obj[-1/0],
-            obj[-1/0],
-            obj["-Infinity"],
-            obj[null],
-            obj["null"]
-        );
-    }
-    expect_stdout: "1 1 1 2 2 2 3 3 3 4 4 4 5 5"
-}
-
-numeric_literal: {
-    mangle = {
-        properties: true,
-    }
-    beautify = {
-        beautify: true,
-    }
-    input: {
-        var obj = {
-            0: 0,
-            "-0": 1,
-            42: 2,
-            "42": 3,
-            0x25: 4,
-            "0x25": 5,
-            1E42: 6,
-            "1E42": 7,
-            "1e+42": 8,
-        };
-        console.log(obj[-0], obj[-""], obj["-0"]);
-        console.log(obj[42], obj["42"]);
-        console.log(obj[0x25], obj["0x25"], obj[37], obj["37"]);
-        console.log(obj[1E42], obj["1E42"], obj["1e+42"]);
-    }
-    expect_exact: [
-        'var obj = {',
-        '    0: 0,',
-        '    "-0": 1,',
-        '    42: 2,',
-        '    "42": 3,',
-        '    37: 4,',
-        '    o: 5,',
-        '    1e42: 6,',
-        '    b: 7,',
-        '    "1e+42": 8',
-        '};',
-        '',
-        'console.log(obj[-0], obj[-""], obj["-0"]);',
-        '',
-        'console.log(obj[42], obj["42"]);',
-        '',
-        'console.log(obj[37], obj["o"], obj[37], obj["37"]);',
-        '',
-        'console.log(obj[1e42], obj["b"], obj["1e+42"]);',
-    ]
-    expect_stdout: [
-        "0 0 1",
-        "3 3",
-        "4 5 4 4",
-        "8 7 8",
-    ]
-}
-
-identifier: {
-    mangle = {
-        properties: true,
-    }
-    input: {
-        var obj = {
-            abstract: 1,
-            boolean: 2,
-            byte: 3,
-            char: 4,
-            class: 5,
-            double: 6,
-            enum: 7,
-            export: 8,
-            extends: 9,
-            final: 10,
-            float: 11,
-            goto: 12,
-            implements: 13,
-            import: 14,
-            int: 15,
-            interface: 16,
-            let: 17,
-            long: 18,
-            native: 19,
-            package: 20,
-            private: 21,
-            protected: 22,
-            public: 23,
-            short: 24,
-            static: 25,
-            super: 26,
-            synchronized: 27,
-            this: 28,
-            throws: 29,
-            transient: 30,
-            volatile: 31,
-            yield: 32,
-            false: 33,
-            null: 34,
-            true: 35,
-            break: 36,
-            case: 37,
-            catch: 38,
-            const: 39,
-            continue: 40,
-            debugger: 41,
-            default: 42,
-            delete: 43,
-            do: 44,
-            else: 45,
-            finally: 46,
-            for: 47,
-            function: 48,
-            if: 49,
-            in: 50,
-            instanceof: 51,
-            new: 52,
-            return: 53,
-            switch: 54,
-            throw: 55,
-            try: 56,
-            typeof: 57,
-            var: 58,
-            void: 59,
-            while: 60,
-            with: 61,
-        };
-    }
-    expect: {
-        var obj = {
-            e: 1,
-            t: 2,
-            n: 3,
-            a: 4,
-            i: 5,
-            o: 6,
-            r: 7,
-            l: 8,
-            s: 9,
-            c: 10,
-            f: 11,
-            u: 12,
-            d: 13,
-            h: 14,
-            p: 15,
-            b: 16,
-            v: 17,
-            w: 18,
-            y: 19,
-            g: 20,
-            m: 21,
-            k: 22,
-            x: 23,
-            j: 24,
-            z: 25,
-            q: 26,
-            A: 27,
-            B: 28,
-            C: 29,
-            D: 30,
-            F: 31,
-            G: 32,
-            false: 33,
-            null: 34,
-            true: 35,
-            H: 36,
-            I: 37,
-            J: 38,
-            K: 39,
-            L: 40,
-            M: 41,
-            N: 42,
-            O: 43,
-            P: 44,
-            Q: 45,
-            R: 46,
-            S: 47,
-            T: 48,
-            U: 49,
-            V: 50,
-            W: 51,
-            X: 52,
-            Y: 53,
-            Z: 54,
-            $: 55,
-            _: 56,
-            ee: 57,
-            te: 58,
-            ne: 59,
-            ae: 60,
-            ie: 61,
-        };
-    }
-}

test/compress/issue-1787.js

@@ -1,17 +0,0 @@
-unary_prefix: {
-    options = {
-        evaluate: true,
-        inline: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        console.log(function() {
-            var x = -(2 / 3);
-            return x;
-        }());
-    }
-    expect_exact: "console.log(-2/3);"
-    expect_stdout: true
-}

test/compress/issue-1833.js

@@ -1,138 +0,0 @@
-iife_for: {
-    options = {
-        negate_iife: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            function g() {
-                L: for (;;) break L;
-            }
-            g();
-        }
-        f();
-    }
-    expect: {
-        !function() {
-            !function() {
-                L: for (;;) break L;
-            }();
-        }();
-    }
-}
-
-iife_for_in: {
-    options = {
-        negate_iife: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            function g() {
-                L: for (var a in x) break L;
-            }
-            g();
-        }
-        f();
-    }
-    expect: {
-        !function() {
-            !function() {
-                L: for (var a in x) break L;
-            }();
-        }();
-    }
-}
-
-iife_do: {
-    options = {
-        negate_iife: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            function g() {
-                L: do {
-                    break L;
-                } while (1);
-            }
-            g();
-        }
-        f();
-    }
-    expect: {
-        !function() {
-            !function() {
-                L: do {
-                    break L;
-                } while (1);
-            }();
-        }();
-    }
-}
-
-iife_while: {
-    options = {
-        negate_iife: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            function g() {
-                L: while (1) break L;
-            }
-            g();
-        }
-        f();
-    }
-    expect: {
-        !function() {
-            !function() {
-                L: while (1) break L;
-            }();
-        }();
-    }
-}
-
-label_do: {
-    options = {
-        evaluate: true,
-        loops: true,
-    }
-    input: {
-        L: do {
-            continue L;
-        } while (0);
-    }
-    expect: {
-        L: do {
-            continue L;
-        } while (0);
-    }
-}
-
-label_while: {
-    options = {
-        evaluate: true,
-        dead_code: true,
-        loops: true,
-    }
-    input: {
-        function f() {
-            L: while (0) continue L;
-        }
-    }
-    expect_exact: "function f(){L:;}"
-}

test/compress/issue-1943.js

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

test/compress/issue-203.js

@@ -0,0 +1,30 @@
+
+compress_new_function: {
+    options = {
+        unsafe: true
+    }
+    input: {
+        new Function("aa, bb", 'return aa;');
+    }
+    expect: {
+        Function("a", "b", "return a");
+    }
+}
+
+compress_new_function_with_destruct: {
+    options = {
+        unsafe: true
+    }
+    input: {
+        new Function("aa, [bb]", 'return aa;');
+        new Function("aa, {bb}", 'return aa;');
+        new Function("[[aa]], [{bb}]", 'return aa;');
+    }
+    expect: {
+        Function("a", "[b]", "return a");
+        Function("a", "{bb}", "return a");
+        Function("[[a]]", "[{bb}]", 'return a');
+    }
+}
+
+

test/compress/issue-208.js

@@ -1,70 +1,11 @@
 do_not_update_lhs: {
-    options = {
-        global_defs: { DEBUG: 0 }
-    }
-    input: {
-        DEBUG++;
-        DEBUG += 1;
-        DEBUG = 1;
-    }
-    expect: {
-        DEBUG++;
-        DEBUG += 1;
-        DEBUG = 1;
-    }
+    options = { global_defs: { DEBUG: false } };
+    input: { DEBUG = false; }
+    expect: { DEBUG = false; }
 }
 
 do_update_rhs: {
-    options = {
-        global_defs: { DEBUG: 0 }
-    }
-    input: {
-        MY_DEBUG = DEBUG;
-        MY_DEBUG += DEBUG;
-    }
-    expect: {
-        MY_DEBUG = 0;
-        MY_DEBUG += 0;
-    }
-}
-
-mixed: {
-    options = {
-        evaluate: true,
-        global_defs: {
-            DEBUG: 0,
-            ENV: 1,
-            FOO: 2,
-        }
-    }
-    input: {
-        var ENV = 3;
-        var FOO = 4;
-        f(ENV * 10);
-        --FOO;
-        DEBUG = 1;
-        DEBUG++;
-        DEBUG += 1;
-        f(DEBUG);
-        x = DEBUG;
-    }
-    expect: {
-        var ENV = 3;
-        var FOO = 4;
-        f(10);
-        --FOO;
-        DEBUG = 1;
-        DEBUG++;
-        DEBUG += 1;
-        f(0);
-        x = 0;
-    }
-    expect_warnings: [
-        'WARN: global_defs ENV redefined [test/compress/issue-208.js:41,12]',
-        'WARN: global_defs FOO redefined [test/compress/issue-208.js:42,12]',
-        'WARN: global_defs FOO redefined [test/compress/issue-208.js:44,10]',
-        'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:45,8]',
-        'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:46,8]',
-        'WARN: global_defs DEBUG redefined [test/compress/issue-208.js:47,8]',
-    ]
+    options = { global_defs: { DEBUG: false } };
+    input: { MY_DEBUG = DEBUG; }
+    expect: { MY_DEBUG = false; }
 }

test/compress/issue-281.js

@@ -1,498 +0,0 @@
-collapse_vars_constants: {
-    options = {
-        collapse_vars: true,
-        evaluate: true,
-        inline: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        function f1(x) {
-            var a = 4, b = x.prop, c = 5, d = sideeffect1(), e = sideeffect2();
-            return b + (function() { return d - a * e - c; })();
-        }
-        function f2(x) {
-            var a = 4, b = x.prop, c = 5, not_used = sideeffect1(), e = sideeffect2();
-            return b + (function() { return -a * e - c; })();
-        }
-    }
-    expect: {
-        function f1(x) {
-            var b = x.prop, d = sideeffect1(), e = sideeffect2();
-            return b + (d - 4 * e - 5);
-        }
-        function f2(x) {
-            var b = x.prop;
-            sideeffect1();
-            return b + (-4 * sideeffect2() - 5);
-        }
-    }
-}
-
-modified: {
-    options = {
-        collapse_vars: true,
-        inline: true,
-        unused: true,
-    }
-    input: {
-        function f5(b) {
-            var a = function() {
-                return b;
-            }();
-            return b++ + a;
-        }
-        console.log(f5(1));
-    }
-    expect: {
-        function f5(b) {
-            var a = b;
-            return b++ + a;
-        }
-        console.log(f5(1));
-    }
-    expect_stdout: "2"
-}
-
-ref_scope: {
-    options = {
-        collapse_vars: true,
-        inline: 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 a + b;
-        }());
-    }
-    expect_stdout: true
-}
-
-safe_undefined: {
-    options = {
-        conditionals: true,
-        if_return: true,
-        inline: true,
-        unsafe: false,
-        unused: true,
-    }
-    mangle = {}
-    input: {
-        var a, c;
-        console.log(function(undefined) {
-            return function() {
-                if (a)
-                    return b;
-                if (c)
-                    return d;
-            };
-        }(1)());
-    }
-    expect: {
-        var a, c;
-        console.log(a ? b : c ? d : void 0);
-    }
-    expect_stdout: true
-}
-
-negate_iife_3: {
-    options = {
-        conditionals: true,
-        expression: true,
-        inline: true,
-        negate_iife: true,
-    }
-    input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-    }
-    expect: {
-        t ? console.log(true) : console.log(false);
-    }
-}
-
-negate_iife_3_off: {
-    options = {
-        conditionals: true,
-        expression: true,
-        inline: true,
-        negate_iife: false,
-    }
-    input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-    }
-    expect: {
-        t ? console.log(true) : console.log(false);
-    }
-}
-
-negate_iife_4: {
-    options = {
-        conditionals: true,
-        expression: true,
-        inline: true,
-        negate_iife: true,
-        sequences: true,
-    }
-    input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-        (function(){
-            console.log("something");
-        })();
-    }
-    expect: {
-        t ? console.log(true) : console.log(false), void console.log("something");
-    }
-}
-
-negate_iife_5: {
-    options = {
-        conditionals: true,
-        expression: true,
-        inline: true,
-        negate_iife: true,
-        sequences: true,
-    }
-    input: {
-        if ((function(){ return t })()) {
-            foo(true);
-        } else {
-            bar(false);
-        }
-        (function(){
-            console.log("something");
-        })();
-    }
-    expect: {
-        t ? foo(true) : bar(false), void console.log("something");
-    }
-}
-
-negate_iife_5_off: {
-    options = {
-        conditionals: true,
-        expression: true,
-        inline: true,
-        negate_iife: false,
-        sequences: true,
-    };
-    input: {
-        if ((function(){ return t })()) {
-            foo(true);
-        } else {
-            bar(false);
-        }
-        (function(){
-            console.log("something");
-        })();
-    }
-    expect: {
-        t ? foo(true) : bar(false), void console.log("something");
-    }
-}
-
-issue_1254_negate_iife_true: {
-    options = {
-        expression: true,
-        inline: true,
-        negate_iife: true,
-    }
-    input: {
-        (function() {
-            return function() {
-                console.log('test')
-            };
-        })()();
-    }
-    expect_exact: 'void console.log("test");'
-    expect_stdout: true
-}
-
-issue_1254_negate_iife_nested: {
-    options = {
-        expression: true,
-        inline: true,
-        negate_iife: true,
-    }
-    input: {
-        (function() {
-            return function() {
-                console.log('test')
-            };
-        })()()()()();
-    }
-    expect_exact: '(void console.log("test"))()()();'
-}
-
-negate_iife_issue_1073: {
-    options = {
-        conditionals: true,
-        evaluate: true,
-        inline: true,
-        negate_iife: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        sequences: true,
-        unused: true,
-    };
-    input: {
-        new (function(a) {
-            return function Foo() {
-                this.x = a;
-                console.log(this);
-            };
-        }(7))();
-    }
-    expect: {
-        new function() {
-            this.x = 7,
-            console.log(this);
-        }();
-    }
-    expect_stdout: true
-}
-
-issue_1288_side_effects: {
-    options = {
-        conditionals: true,
-        evaluate: true,
-        inline: true,
-        negate_iife: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        unused: true,
-    };
-    input: {
-        if (w) ;
-        else {
-            (function f() {})();
-        }
-        if (!x) {
-            (function() {
-                x = {};
-            })();
-        }
-        if (y)
-            (function() {})();
-        else
-            (function(z) {
-                return z;
-            })(0);
-    }
-    expect: {
-        w;
-        x || (x = {});
-        y;
-    }
-}
-
-inner_var_for_in_1: {
-    options = {
-        evaluate: true,
-        inline: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-    }
-    input: {
-        function f() {
-            var a = 1, b = 2;
-            for (b in (function() {
-                return x(a, b, c);
-            })()) {
-                var c = 3, d = 4;
-                x(a, b, c, d);
-            }
-            x(a, b, c, d);
-        }
-    }
-    expect: {
-        function f() {
-            var a = 1, b = 2;
-            for (b in x(1, b, c)) {
-                var c = 3, d = 4;
-                x(1, b, c, d);
-            }
-            x(1, b, c, d);
-        }
-    }
-}
-
-issue_1595_3: {
-    options = {
-        evaluate: true,
-        inline: true,
-        passes: 2,
-        reduce_funcs: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        (function f(a) {
-            return g(a + 1);
-        })(2);
-    }
-    expect: {
-        g(3);
-    }
-}
-
-issue_1758: {
-    options = {
-        inline: true,
-        sequences: true,
-        side_effects: true,
-    }
-    input: {
-        console.log(function(c) {
-            var undefined = 42;
-            return function() {
-                c--;
-                c--, c.toString();
-                return;
-            }();
-        }());
-    }
-    expect: {
-        console.log(function(c) {
-            var undefined = 42;
-            return c--, c--, void c.toString();
-        }());
-    }
-    expect_stdout: "undefined"
-}
-wrap_iife: {
-    options = {
-        inline: true,
-        negate_iife: false,
-    }
-    beautify = {
-        wrap_iife: true,
-    }
-    input: {
-        (function() {
-            return function() {
-                console.log('test')
-            };
-        })()();
-    }
-    expect_exact: 'void console.log("test");'
-}
-
-wrap_iife_in_expression: {
-    options = {
-        inline: true,
-        negate_iife: false,
-    }
-    beautify = {
-        wrap_iife: true,
-    }
-    input: {
-        foo = (function () {
-            return bar();
-        })();
-    }
-    expect_exact: 'foo=bar();'
-}
-
-wrap_iife_in_return_call: {
-    options = {
-        inline: true,
-        negate_iife: false,
-    }
-    beautify = {
-        wrap_iife: true,
-    }
-    input: {
-        (function() {
-            return (function() {
-                console.log('test')
-            })();
-        })()();
-    }
-    expect_exact: '(void console.log("test"))();'
-}
-
-pure_annotation_1: {
-    options = {
-        inline: true,
-        side_effects: true,
-    }
-    input: {
-        /*@__PURE__*/(function() {
-            console.log("hello");
-        }());
-    }
-    expect_exact: ""
-}
-
-pure_annotation_2: {
-    options = {
-        collapse_vars: true,
-        inline: true,
-        side_effects: true,
-    }
-    input: {
-        /*@__PURE__*/(function(n) {
-            console.log("hello", n);
-        }(42));
-    }
-    expect_exact: ""
-}
-
-drop_fargs: {
-    options = {
-        cascade: true,
-        inline: true,
-        keep_fargs: false,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        var a = 1;
-        !function(a_1) {
-            a++;
-        }(a++ + (a && a.var));
-        console.log(a);
-    }
-    expect: {
-        var a = 1;
-        ++a && a.var, a++;
-        console.log(a);
-    }
-    expect_stdout: "3"
-}
-
-keep_fargs: {
-    options = {
-        cascade: true,
-        inline: true,
-        keep_fargs: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        var a = 1;
-        !function(a_1) {
-            a++;
-        }(a++ + (a && a.var));
-        console.log(a);
-    }
-    expect: {
-        var a = 1;
-        ++a && a.var, a++;
-        console.log(a);
-    }
-    expect_stdout: "3"
-}

test/compress/issue-368.js

@@ -1,55 +0,0 @@
-collapse: {
-    options = {
-        cascade: true,
-        sequences: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        function f1() {
-            var a;
-            a = typeof b === 'function' ? b() : b;
-            return a !== undefined && c();
-        }
-        function f2(b) {
-            var a;
-            b = c();
-            a = typeof b === 'function' ? b() : b;
-            return 'stirng' == typeof a && d();
-        }
-        function f3(c) {
-            var a;
-            a = b(a / 2);
-            if (a < 0) {
-                a++;
-                ++c;
-                return c / 2;
-            }
-        }
-        function f4(c) {
-            var a;
-            a = b(a / 2);
-            if (a < 0) {
-                a++;
-                c++;
-                return c / 2;
-            }
-        }
-    }
-    expect: {
-        function f1() {
-            return void 0 !== ('function' === typeof b ? b() : b) && c();
-        }
-        function f2(b) {
-            return b = c(), 'stirng' == typeof ('function' === typeof b ? b() : b) && d();
-        }
-        function f3(c) {
-            var a;
-            if ((a = b(a / 2)) < 0) return a++, ++c / 2;
-        }
-        function f4(c) {
-            var a;
-            if ((a = b(a / 2)) < 0) return a++, ++c / 2;
-        }
-    }
-}

test/compress/issue-597.js

@@ -6,7 +6,7 @@ NaN_and_Infinity_must_have_parens: {
     }
     expect: {
         (1/0).toString();
-        NaN.toString();
+        NaN.toString();         // transformation to 0/0 dropped
     }
 }
 
@@ -23,135 +23,3 @@ NaN_and_Infinity_should_not_be_replaced_when_they_are_redefined: {
         NaN.toString();
     }
 }
-
-NaN_and_Infinity_must_have_parens_evaluate: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        (123456789 / 0).toString();
-        (+"foo").toString();
-    }
-    expect: {
-        (1/0).toString();
-        NaN.toString();
-    }
-}
-
-NaN_and_Infinity_should_not_be_replaced_when_they_are_redefined_evaluate: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        var Infinity, NaN;
-        (123456789 / 0).toString();
-        (+"foo").toString();
-    }
-    expect: {
-        var Infinity, NaN;
-        (1/0).toString();
-        (0/0).toString();
-    }
-}
-
-beautify_off_1: {
-    options = {
-        evaluate: true,
-    }
-    beautify = {
-        beautify: false,
-    }
-    input: {
-        var NaN;
-        console.log(
-            null,
-            undefined,
-            Infinity,
-            NaN,
-            Infinity * undefined,
-            Infinity.toString(),
-            NaN.toString(),
-            (Infinity * undefined).toString()
-        );
-    }
-    expect_exact: "var NaN;console.log(null,void 0,1/0,NaN,0/0,(1/0).toString(),NaN.toString(),(0/0).toString());"
-    expect_stdout: true
-}
-
-beautify_off_2: {
-    options = {
-        evaluate: true,
-    }
-    beautify = {
-        beautify: false,
-    }
-    input: {
-        console.log(
-            null.toString(),
-            undefined.toString()
-        );
-    }
-    expect_exact: "console.log(null.toString(),(void 0).toString());"
-}
-
-beautify_on_1: {
-    options = {
-        evaluate: true,
-    }
-    beautify = {
-        beautify: true,
-    }
-    input: {
-        var NaN;
-        console.log(
-            null,
-            undefined,
-            Infinity,
-            NaN,
-            Infinity * undefined,
-            Infinity.toString(),
-            NaN.toString(),
-            (Infinity * undefined).toString()
-        );
-    }
-    expect_exact: [
-        "var NaN;",
-        "",
-        "console.log(null, void 0, 1 / 0, NaN, 0 / 0, (1 / 0).toString(), NaN.toString(), (0 / 0).toString());",
-    ]
-    expect_stdout: true
-}
-
-beautify_on_2: {
-    options = {
-        evaluate: true,
-    }
-    beautify = {
-        beautify: true,
-    }
-    input: {
-        console.log(
-            null.toString(),
-            undefined.toString()
-        );
-    }
-    expect_exact: "console.log(null.toString(), (void 0).toString());"
-}
-
-issue_1724: {
-    input: {
-        var a = 0;
-        ++a % Infinity | Infinity ? a++ : 0;
-        console.log(a);
-    }
-    expect_exact: "var a=0;++a%(1/0)|1/0?a++:0;console.log(a);"
-    expect_stdout: "2"
-}
-
-issue_1725: {
-    input: {
-        ([].length === 0) % Infinity ? console.log("PASS") : console.log("FAIL");
-    }
-    expect_exact: '(0===[].length)%(1/0)?console.log("PASS"):console.log("FAIL");'
-    expect_stdout: "PASS"
-}

test/compress/issue-640.js

@@ -1,320 +0,0 @@
-cond_5: {
-    options = {
-        conditionals: true,
-        expression: true,
-    }
-    input: {
-        if (some_condition()) {
-            if (some_other_condition()) {
-                do_something();
-            } else {
-                alternate();
-            }
-        } else {
-            alternate();
-        }
-
-        if (some_condition()) {
-            if (some_other_condition()) {
-                do_something();
-            }
-        }
-    }
-    expect: {
-        some_condition() && some_other_condition() ? do_something() : alternate();
-        if (some_condition() && some_other_condition()) do_something();
-    }
-}
-
-dead_code_const_annotation_regex: {
-    options = {
-        booleans     : true,
-        conditionals : true,
-        dead_code    : true,
-        evaluate     : true,
-        expression   : true,
-        loops        : 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;
-        if (CONST_FOO_ANN) console.log('reachable');
-    }
-    expect_stdout: true
-}
-
-drop_console_2: {
-    options = {
-        drop_console: true,
-        expression: true,
-    }
-    input: {
-        console.log('foo');
-        console.log.apply(console, arguments);
-    }
-    expect: {
-        // with regular compression these will be stripped out as well
-        void 0;
-        void 0;
-    }
-}
-
-drop_value: {
-    options = {
-        expression: true,
-        side_effects: true,
-    }
-    input: {
-        (1, [2, foo()], 3, {a:1, b:bar()});
-    }
-    expect: {
-        foo(), {a:1, b:bar()};
-    }
-}
-
-wrongly_optimized: {
-    options = {
-        conditionals: true,
-        booleans: true,
-        evaluate: true,
-        expression: true,
-    }
-    input: {
-        function func() {
-            foo();
-        }
-        if (func() || true) {
-            bar();
-        }
-    }
-    expect: {
-        function func() {
-            foo();
-        }
-        // TODO: optimize to `func(), bar()`
-        if (func(), !0) bar();
-    }
-}
-
-negate_iife_1: {
-    options = {
-        expression: true,
-        negate_iife: true,
-    }
-    input: {
-        (function(){ stuff() })();
-    }
-    expect: {
-        (function(){ stuff() })();
-    }
-}
-
-negate_iife_3: {
-    options = {
-        conditionals: true,
-        expression: true,
-        negate_iife: true,
-    }
-    input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-    }
-    expect: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-    }
-}
-
-negate_iife_3_off: {
-    options = {
-        conditionals: true,
-        expression: true,
-        negate_iife: false,
-    }
-    input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-    }
-    expect: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-    }
-}
-
-negate_iife_4: {
-    options = {
-        conditionals: true,
-        expression: true,
-        negate_iife: true,
-        sequences: true,
-    }
-    input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-        (function(){
-            console.log("something");
-        })();
-    }
-    expect: {
-        !function(){ return t }() ? console.log(false) : console.log(true), function(){
-            console.log("something");
-        }();
-    }
-}
-
-negate_iife_5: {
-    options = {
-        conditionals: true,
-        expression: true,
-        negate_iife: true,
-        sequences: true,
-    }
-    input: {
-        if ((function(){ return t })()) {
-            foo(true);
-        } else {
-            bar(false);
-        }
-        (function(){
-            console.log("something");
-        })();
-    }
-    expect: {
-        !function(){ return t }() ? bar(false) : foo(true), function(){
-            console.log("something");
-        }();
-    }
-}
-
-negate_iife_5_off: {
-    options = {
-        conditionals: true,
-        expression: true,
-        negate_iife: false,
-        sequences: true,
-    };
-    input: {
-        if ((function(){ return t })()) {
-            foo(true);
-        } else {
-            bar(false);
-        }
-        (function(){
-            console.log("something");
-        })();
-    }
-    expect: {
-        !function(){ return t }() ? bar(false) : foo(true), function(){
-            console.log("something");
-        }();
-    }
-}
-
-issue_1254_negate_iife_true: {
-    options = {
-        expression: true,
-        negate_iife: true,
-    }
-    input: {
-        (function() {
-            return function() {
-                console.log('test')
-            };
-        })()();
-    }
-    expect_exact: '(function(){return function(){console.log("test")}})()();'
-    expect_stdout: true
-}
-
-issue_1254_negate_iife_nested: {
-    options = {
-        expression: true,
-        negate_iife: true,
-    }
-    input: {
-        (function() {
-            return function() {
-                console.log('test')
-            };
-        })()()()()();
-    }
-    expect_exact: '(function(){return function(){console.log("test")}})()()()()();'
-    expect_stdout: true
-}
-
-conditional: {
-    options = {
-        expression: true,
-        pure_funcs: [ "pure" ],
-        side_effects: true,
-    }
-    input: {
-        pure(1 | a() ? 2 & b() : 7 ^ c());
-        pure(1 | a() ? 2 & b() : 5);
-        pure(1 | a() ? 4 : 7 ^ c());
-        pure(1 | a() ? 4 : 5);
-        pure(3 ? 2 & b() : 7 ^ c());
-        pure(3 ? 2 & b() : 5);
-        pure(3 ? 4 : 7 ^ c());
-        pure(3 ? 4 : 5);
-    }
-    expect: {
-        1 | a() ? b() : c();
-        1 | a() && b();
-        1 | a() || c();
-        a();
-        3 ? b() : c();
-        3 && b();
-        3 || c();
-        pure(3 ? 4 : 5);
-    }
-}
-
-limit_1: {
-    options = {
-        expression: true,
-        sequences: 3,
-    }
-    input: {
-        a;
-        b;
-        c;
-        d;
-        e;
-        f;
-        g;
-        h;
-        i;
-        j;
-        k;
-    }
-    expect: {
-        // Turned into a single return statement
-        // so it can no longer be split into lines
-        a,b,c,d,e,f,g,h,i,j,k;
-    }
-}
-
-iife: {
-    options = {
-        expression: true,
-        sequences: true,
-    }
-    input: {
-        x = 42;
-        (function a() {})();
-        !function b() {}();
-        ~function c() {}();
-        +function d() {}();
-        -function e() {}();
-        void function f() {}();
-        typeof function g() {}();
-    }
-    expect: {
-        x = 42, function a() {}(), function b() {}(), function c() {}(),
-        function d() {}(), function e() {}(), function f() {}(), typeof function g() {}();
-    }
-}

test/compress/issue-747.js

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

test/compress/issue-892.js

@@ -29,5 +29,4 @@ dont_mangle_arguments: {
         })(5,6,7);
     }
     expect_exact: "(function(){var arguments=arguments,o=9;console.log(o,arguments)})(5,6,7);"
-    expect_stdout: true
 }

test/compress/issue-926.js

@@ -0,0 +1,9 @@
+template_strings: {
+    input: {
+        foo(
+            `<span>${contents}</span>`,
+            `<a href="${url}">${text}</a>`
+        );
+    }
+    expect_exact: "foo(`<span>${contents}</span>`,`<a href=\"${url}\">${text}</a>`);"
+}

test/compress/issue-973.js

@@ -50,8 +50,6 @@ this_binding_conditionals: {
 this_binding_collapse_vars: {
     options = {
         collapse_vars: true,
-        toplevel: true,
-        unused: true,
     };
     input: {
         var c = a; c();

test/compress/issue-976.js

@@ -42,7 +42,6 @@ eval_collapse_vars: {
             eval("console.log(a);");
         })(eval);
     }
-    expect_stdout: true
 }
 
 eval_unused: {

test/compress/issue-979.js

@@ -82,7 +82,7 @@ issue979_test_negated_is_best: {
             1!=a||2!=b||foo();
         }
         function f7() {
-            if(1!=a&&2!=b)return bar();foo()
+            return 1!=a&&2!=b?bar():void foo();
         }
     }
 }

test/compress/join-vars.js

@@ -0,0 +1,40 @@
+only_vars: {
+    options = { join_vars: true };
+    input: {
+        let netmaskBinary = '';
+        for (let i = 0; i < netmaskBits; ++i) {
+            netmaskBinary += '1';
+        }
+    }
+    expect: {
+        let netmaskBinary = '';
+        for (let i = 0; i < netmaskBits; ++i) netmaskBinary += '1';
+    }
+}
+
+issue_1079_with_vars: {
+    options = { join_vars: true };
+    input: {
+        var netmaskBinary = '';
+        for (var i = 0; i < netmaskBits; ++i) {
+            netmaskBinary += '1';
+        }
+    }
+    expect: {
+        for (var netmaskBinary = '', i = 0; i < netmaskBits; ++i) netmaskBinary += '1';
+    }
+}
+
+issue_1079_with_mixed: {
+    options = { join_vars: true };
+    input: {
+        var netmaskBinary = '';
+        for (let i = 0; i < netmaskBits; ++i) {
+            netmaskBinary += '1';
+        }
+    }
+    expect: {
+        var netmaskBinary = ''
+        for (let i = 0; i < netmaskBits; ++i) netmaskBinary += '1';
+    }
+}

test/compress/labels.js

@@ -9,7 +9,6 @@ labels_1: {
     expect: {
         foo || console.log("bar");
     }
-    expect_stdout: true
 }
 
 labels_2: {
@@ -41,7 +40,6 @@ labels_3: {
         for (var i = 0; i < 5; ++i)
             i < 3 || console.log(i);
     }
-    expect_stdout: true
 }
 
 labels_4: {
@@ -56,7 +54,6 @@ labels_4: {
         for (var i = 0; i < 5; ++i)
             i < 3 || console.log(i);
     }
-    expect_stdout: true
 }
 
 labels_5: {

test/compress/loops.js

@@ -146,307 +146,44 @@ parse_do_while_without_semicolon: {
     }
 }
 
-evaluate: {
-    options = {
-        loops: true,
-        dead_code: true,
-        evaluate: true,
-    };
-    input: {
-        while (true) {
-            a();
-        }
-        while (false) {
-            b();
-        }
-        do {
-            c();
-        } while (true);
-        do {
-            d();
-        } while (false);
-    }
-    expect: {
-        for(;;)
-            a();
-        for(;;)
-            c();
-        d();
-    }
-}
 
-issue_1532: {
-    options = {
-        evaluate: true,
-        loops: true,
-    }
-    input: {
-        function f(x, y) {
-            do {
-                if (x) break;
-                foo();
-            } while (false);
-        }
-    }
-    expect: {
-        function f(x, y) {
-            do {
-                if (x) break;
-                foo();
-            } while (false);
-        }
-    }
-}
-
-issue_186: {
-    beautify = {
-        beautify: false,
-        ie8: false,
-    }
-    input: {
-        var x = 3;
-        if (foo())
-            do
-                do
-                    alert(x);
-                while (--x);
-            while (x);
-        else
-            bar();
-    }
-    expect_exact: 'var x=3;if(foo())do{do{alert(x)}while(--x)}while(x);else bar();'
-}
-
-issue_186_ie8: {
-    beautify = {
-        beautify: false,
-        ie8: true,
-    }
-    input: {
-        var x = 3;
-        if (foo())
-            do
-                do
-                    alert(x);
-                while (--x);
-            while (x);
-        else
-            bar();
-    }
-    expect_exact: 'var x=3;if(foo()){do{do{alert(x)}while(--x)}while(x)}else bar();'
-}
-
-issue_186_beautify: {
-    beautify = {
-        beautify: true,
-        ie8: false,
-    }
-    input: {
-        var x = 3;
-        if (foo())
-            do
-                do
-                    alert(x);
-                while (--x);
-            while (x);
-        else
-            bar();
-    }
-    expect_exact: [
-        'var x = 3;',
-        '',
-        'if (foo()) do {',
-        '    do {',
-        '        alert(x);',
-        '    } while (--x);',
-        '} while (x); else bar();',
-    ]
-}
-
-issue_186_beautify_ie8: {
-    beautify = {
-        beautify: true,
-        ie8: true,
-    }
-    input: {
-        var x = 3;
-        if (foo())
-            do
-                do
-                    alert(x);
-                while (--x);
-            while (x);
-        else
-            bar();
-    }
-    expect_exact: [
-        'var x = 3;',
-        '',
-        'if (foo()) {',
-        '    do {',
-        '        do {',
-        '            alert(x);',
-        '        } while (--x);',
-        '    } while (x);',
-        '} else bar();',
-    ]
-}
-
-issue_186_bracketize: {
-    beautify = {
-        beautify: false,
-        bracketize: true,
-        ie8: false,
-    }
-    input: {
-        var x = 3;
-        if (foo())
-            do
-                do
-                    alert(x);
-                while (--x);
-            while (x);
-        else
-            bar();
-    }
-    expect_exact: 'var x=3;if(foo()){do{do{alert(x)}while(--x)}while(x)}else{bar()}'
-}
-
-issue_186_bracketize_ie8: {
-    beautify = {
-        beautify: false,
-        bracketize: true,
-        ie8: true,
-    }
-    input: {
-        var x = 3;
-        if (foo())
-            do
-                do
-                    alert(x);
-                while (--x);
-            while (x);
-        else
-            bar();
-    }
-    expect_exact: 'var x=3;if(foo()){do{do{alert(x)}while(--x)}while(x)}else{bar()}'
-}
-
-issue_186_beautify_bracketize: {
-    beautify = {
-        beautify: true,
-        bracketize: true,
-        ie8: false,
-    }
-    input: {
-        var x = 3;
-        if (foo())
-            do
-                do
-                    alert(x);
-                while (--x);
-            while (x);
-        else
-            bar();
-    }
-    expect_exact: [
-        'var x = 3;',
-        '',
-        'if (foo()) {',
-        '    do {',
-        '        do {',
-        '            alert(x);',
-        '        } while (--x);',
-        '    } while (x);',
-        '} else {',
-        '    bar();',
-        '}',
-    ]
-}
-
-issue_186_beautify_bracketize_ie8: {
-    beautify = {
-        beautify: true,
-        bracketize: true,
-        ie8: true,
-    }
-    input: {
-        var x = 3;
-        if (foo())
-            do
-                do
-                    alert(x);
-                while (--x);
-            while (x);
-        else
-            bar();
-    }
-    expect_exact: [
-        'var x = 3;',
-        '',
-        'if (foo()) {',
-        '    do {',
-        '        do {',
-        '            alert(x);',
-        '        } while (--x);',
-        '    } while (x);',
-        '} else {',
-        '    bar();',
-        '}',
-    ]
-}
-
-issue_1648: {
+keep_collapse_const_in_own_block_scope: {
     options = {
         join_vars: true,
-        loops: true,
-        passes: 2,
-        sequences: true,
-        unused: true,
+        loops: true
     }
     input: {
-        function f() {
-            x();
-            var b = 1;
-            while (1);
-        }
-    }
-    expect_exact: "function f(){for(x();1;);}"
-}
-
-do_switch: {
-    options = {
-        evaluate: true,
-        loops: true,
-    }
-    input: {
-        do {
-            switch (a) {
-              case b:
-                continue;
-            }
-        } while (false);
+        var i=2;
+        const c=5;
+        while(i--)
+            console.log(i);
+        console.log(c);
     }
     expect: {
-        do {
-            switch (a) {
-              case b:
-                continue;
-            }
-        } while (false);
+        var i=2;
+        const c=5;
+        for(;i--;)
+            console.log(i);
+        console.log(c);
     }
 }
 
-in_parenthesis_1: {
-    input: {
-        for (("foo" in {});0;);
+keep_collapse_const_in_own_block_scope_2: {
+    options = {
+        join_vars: true,
+        loops: true
     }
-    expect_exact: 'for(("foo"in{});0;);'
-}
-
-in_parenthesis_2: {
     input: {
-        for ((function(){ "foo" in {}; });0;);
+        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_exact: 'for(function(){"foo"in{}};0;);'
 }

test/compress/max_line_len.js

@@ -1,39 +0,0 @@
-too_short: {
-    beautify = {
-        max_line_len: 10,
-    }
-    input: {
-        function f(a) {
-            return { c: 42, d: a(), e: "foo"};
-        }
-    }
-    expect_exact: [
-        'function f(a){',
-        'return{',
-        'c:42,',
-        'd:a(),',
-        'e:"foo"}}',
-    ]
-    expect_warnings: [
-        "WARN: Output exceeds 10 characters"
-    ]
-}
-
-just_enough: {
-    beautify = {
-        max_line_len: 14,
-    }
-    input: {
-        function f(a) {
-            return { c: 42, d: a(), e: "foo"};
-        }
-    }
-    expect_exact: [
-        'function f(a){',
-        'return{c:42,',
-        'd:a(),e:"foo"}',
-        '}',
-    ]
-    expect_warnings: [
-    ]
-}

test/compress/negate-iife.js

@@ -10,173 +10,56 @@ negate_iife_1: {
     }
 }
 
-negate_iife_1_off: {
-    options = {
-        negate_iife: false,
-    };
-    input: {
-        (function(){ stuff() })();
-    }
-    expect_exact: '(function(){stuff()})();'
-}
-
 negate_iife_2: {
     options = {
-        inline: true,
-        negate_iife: true,
+        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: {
-    options = {
-        inline: true,
-        negate_iife: true,
-        side_effects: true,
-    }
-    input: {
-        (function(){ return {} })().x = 10;
-    }
-    expect_exact: "({}).x=10;"
 }
 
 negate_iife_3: {
     options = {
         negate_iife: true,
-        conditionals: true
     };
-    input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-    }
-    expect: {
-        !function(){ return t }() ? console.log(false) : console.log(true);
-    }
-}
-
-negate_iife_3_evaluate: {
-    options = {
-        conditionals: true,
-        evaluate: true,
-        inline: true,
-        negate_iife: true,
-    }
     input: {
         (function(){ return true })() ? console.log(true) : console.log(false);
     }
     expect: {
-        console.log(true);
+        !function(){ return true }() ? console.log(false) : console.log(true);
     }
-    expect_stdout: true
 }
 
-negate_iife_3_side_effects: {
+negate_iife_3: {
     options = {
-        conditionals: true,
         negate_iife: true,
-        side_effects: true,
-    }
-    input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-    }
-    expect: {
-        !function(){ return t }() ? console.log(false) : console.log(true);
-    }
-}
-
-negate_iife_3_off: {
-    options = {
-        negate_iife: false,
-        conditionals: true,
+        sequences: true
     };
-    input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-    }
-    expect: {
-        !function(){ return t }() ? console.log(false) : console.log(true);
-    }
-}
-
-negate_iife_3_off_evaluate: {
-    options = {
-        conditionals: true,
-        evaluate: true,
-        inline: true,
-        negate_iife: false,
-    }
     input: {
         (function(){ return true })() ? console.log(true) : console.log(false);
+        (function(){
+            console.log("something");
+        })();
     }
     expect: {
-        console.log(true);
+        !function(){ return true }() ? console.log(false) : console.log(true), function(){
+            console.log("something");
+        }();
     }
-    expect_stdout: true
 }
 
 negate_iife_4: {
-    options = {
-        negate_iife: true,
-        conditionals: true,
-        sequences: true
-    };
-    input: {
-        (function(){ return t })() ? console.log(true) : console.log(false);
-        (function(){
-            console.log("something");
-        })();
-    }
-    expect: {
-        !function(){ return t }() ? console.log(false) : console.log(true), function(){
-            console.log("something");
-        }();
-    }
-}
-
-sequence_off: {
-    options = {
-        negate_iife: false,
-        conditionals: true,
-        sequences: true,
-        passes: 2,
-    };
-    input: {
-        function f() {
-            (function(){ return t })() ? console.log(true) : console.log(false);
-            (function(){
-                console.log("something");
-            })();
-        }
-        function g() {
-            (function(){
-                console.log("something");
-            })();
-            (function(){ return t })() ? console.log(true) : console.log(false);
-        }
-    }
-    expect: {
-        function f() {
-            !function(){ return t }() ? console.log(false) : console.log(true), function(){
-                console.log("something");
-            }();
-        }
-        function g() {
-            (function(){
-                console.log("something");
-            })(), function(){ return t }() ? console.log(true) : console.log(false);
-        }
-    }
-}
-
-negate_iife_5: {
     options = {
         negate_iife: true,
         sequences: true,
         conditionals: true,
     };
     input: {
-        if ((function(){ return t })()) {
+        if ((function(){ return true })()) {
             foo(true);
         } else {
             bar(false);
@@ -186,30 +69,7 @@ negate_iife_5: {
         })();
     }
     expect: {
-        !function(){ return t }() ? bar(false) : foo(true), function(){
-            console.log("something");
-        }();
-    }
-}
-
-negate_iife_5_off: {
-    options = {
-        negate_iife: false,
-        sequences: true,
-        conditionals: true,
-    };
-    input: {
-        if ((function(){ return t })()) {
-            foo(true);
-        } else {
-            bar(false);
-        }
-        (function(){
-            console.log("something");
-        })();
-    }
-    expect: {
-        !function(){ return t }() ? bar(false) : foo(true), function(){
+        !function(){ return true }() ? bar(false) : foo(true), function(){
             console.log("something");
         }();
     }
@@ -245,40 +105,6 @@ negate_iife_nested: {
             }(7);
         }).f();
     }
-    expect_stdout: true
-}
-
-negate_iife_nested_off: {
-    options = {
-        negate_iife: false,
-        sequences: true,
-        conditionals: true,
-    };
-    input: {
-        function Foo(f) {
-            this.f = f;
-        }
-        new Foo(function() {
-            (function(x) {
-                (function(y) {
-                    console.log(y);
-                })(x);
-            })(7);
-        }).f();
-    }
-    expect: {
-        function Foo(f) {
-            this.f = f;
-        }
-        new Foo(function() {
-            (function(x) {
-                (function(y) {
-                    console.log(y);
-                })(x);
-            })(7);
-        }).f();
-    }
-    expect_stdout: true
 }
 
 negate_iife_issue_1073: {
@@ -303,7 +129,6 @@ negate_iife_issue_1073: {
             };
         }(7))();
     }
-    expect_stdout: true
 }
 
 issue_1254_negate_iife_false: {
@@ -318,7 +143,6 @@ issue_1254_negate_iife_false: {
         })()();
     }
     expect_exact: '(function(){return function(){console.log("test")}})()();'
-    expect_stdout: true
 }
 
 issue_1254_negate_iife_true: {
@@ -333,7 +157,6 @@ issue_1254_negate_iife_true: {
         })()();
     }
     expect_exact: '!function(){return function(){console.log("test")}}()();'
-    expect_stdout: true
 }
 
 issue_1254_negate_iife_nested: {
@@ -348,71 +171,4 @@ issue_1254_negate_iife_nested: {
         })()()()()();
     }
     expect_exact: '!function(){return function(){console.log("test")}}()()()()();'
-    expect_stdout: true
-}
-
-issue_1288: {
-    options = {
-        conditionals: true,
-        negate_iife: true,
-        side_effects: false,
-    };
-    input: {
-        if (w) ;
-        else {
-            (function f() {})();
-        }
-        if (!x) {
-            (function() {
-                x = {};
-            })();
-        }
-        if (y)
-            (function() {})();
-        else
-            (function(z) {
-                return z;
-            })(0);
-    }
-    expect: {
-        w || !function f() {}();
-        x || !function() {
-            x = {};
-        }();
-        y ? !function() {}() : !function(z) {
-            return z;
-        }(0);
-    }
-}
-
-issue_1288_side_effects: {
-    options = {
-        conditionals: true,
-        negate_iife: true,
-        side_effects: true,
-    }
-    input: {
-        if (w) ;
-        else {
-            (function f() {})();
-        }
-        if (!x) {
-            (function() {
-                x = {};
-            })();
-        }
-        if (y)
-            (function() {})();
-        else
-            (function(z) {
-                return z;
-            })(0);
-    }
-    expect: {
-        w;
-        x || function() {
-            x = {};
-        }();
-        y;
-    }
 }

test/compress/new.js

@@ -82,19 +82,3 @@ new_with_unary_prefix: {
     }
     expect_exact: 'var bar=(+new Date).toString(32);';
 }
-
-dot_parenthesis_1: {
-    input: {
-        console.log(new (Math.random().constructor) instanceof Number);
-    }
-    expect_exact: "console.log(new(Math.random().constructor)instanceof Number);"
-    expect_stdout: "true"
-}
-
-dot_parenthesis_2: {
-    input: {
-        console.log(typeof new function(){Math.random()}.constructor);
-    }
-    expect_exact: "console.log(typeof new function(){Math.random()}.constructor);"
-    expect_stdout: "function"
-}

test/compress/node_version.js

@@ -1,38 +0,0 @@
-eval_let_6: {
-    input: {
-        eval("let a;");
-        console.log();
-    }
-    expect: {
-        eval("let a;");
-        console.log();
-    }
-    expect_stdout: ""
-    node_version: ">=6"
-}
-
-eval_let_4: {
-    input: {
-        eval("let a;");
-        console.log();
-    }
-    expect: {
-        eval("let a;");
-        console.log();
-    }
-    expect_stdout: SyntaxError("Block-scoped declarations (let, const, function, class) not yet supported outside strict mode")
-    node_version: "4"
-}
-
-eval_let_0: {
-    input: {
-        eval("let a;");
-        console.log();
-    }
-    expect: {
-        eval("let a;");
-        console.log();
-    }
-    expect_stdout: SyntaxError("Unexpected identifier")
-    node_version: "<=0.12"
-}

test/compress/numbers.js

@@ -17,188 +17,3 @@ hex_numbers_in_parentheses_for_prototype_functions: {
     }
     expect_exact: "-2;(-2).toFixed(0);2;2..toFixed(0);.2;.2.toFixed(0);2e-8;2e-8.toFixed(0);0xde0b6b3a7640080;(0xde0b6b3a7640080).toFixed(0);"
 }
-
-comparisons: {
-    options = {
-        comparisons: true,
-    }
-    input: {
-        console.log(
-            ~x === 42,
-            x % n === 42
-        );
-    }
-    expect: {
-        console.log(
-            42 == ~x,
-            x % n == 42
-        );
-    }
-}
-
-evaluate_1: {
-    options = {
-        evaluate: true,
-        unsafe_math: false,
-    }
-    input: {
-        console.log(
-            x + 1 + 2,
-            x * 1 * 2,
-            +x + 1 + 2,
-            1 + x + 2 + 3,
-            1 | x | 2 | 3,
-            1 + x-- + 2 + 3,
-            1 + (x*y + 2) + 3,
-            1 + (2 + x + 3),
-            1 + (2 + ~x + 3),
-            -y + (2 + ~x + 3),
-            1 & (2 & x & 3),
-            1 + (2 + (x |= 0) + 3)
-        );
-    }
-    expect: {
-        console.log(
-            x + 1 + 2,
-            1 * x * 2,
-            +x + 1 + 2,
-            1 + x + 2 + 3,
-            3 | x,
-            1 + x-- + 2 + 3,
-            x*y + 2 + 1 + 3,
-            1 + (2 + x + 3),
-            2 + ~x + 3 + 1,
-            -y + (2 + ~x + 3),
-            0 & x,
-            2 + (x |= 0) + 3 + 1
-        );
-    }
-}
-
-evaluate_2: {
-    options = {
-        evaluate: true,
-        unsafe_math: true,
-    }
-    input: {
-        console.log(
-            x + 1 + 2,
-            x * 1 * 2,
-            +x + 1 + 2,
-            1 + x + 2 + 3,
-            1 | x | 2 | 3,
-            1 + x-- + 2 + 3,
-            1 + (x*y + 2) + 3,
-            1 + (2 + x + 3),
-            1 & (2 & x & 3),
-            1 + (2 + (x |= 0) + 3)
-        );
-    }
-    expect: {
-        console.log(
-            x + 1 + 2,
-            2 * x,
-            3 + +x,
-            1 + x + 2 + 3,
-            3 | x,
-            6 + x--,
-            6 + x*y,
-            1 + (2 + x + 3),
-            0 & x,
-            6 + (x |= 0)
-        );
-    }
-}
-
-evaluate_3: {
-    options = {
-        evaluate: true,
-        unsafe: true,
-        unsafe_math: true,
-    }
-    input: {
-        console.log(1 + Number(x) + 2);
-    }
-    expect: {
-        console.log(3 + +x);
-    }
-}
-
-evaluate_4: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        console.log(
-            1+ +a,
-            +a+1,
-            1+-a,
-            -a+1,
-            +a+ +b,
-            +a+-b,
-            -a+ +b,
-            -a+-b
-        );
-    }
-    expect: {
-        console.log(
-            +a+1,
-            +a+1,
-            1-a,
-            1-a,
-            +a+ +b,
-            +a-b,
-            -a+ +b,
-            -a-b
-        );
-    }
-}
-
-issue_1710: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        var x = {};
-        console.log((x += 1) + -x);
-    }
-    expect: {
-        var x = {};
-        console.log((x += 1) + -x);
-    }
-    expect_stdout: true
-}
-
-unary_binary_parenthesis: {
-    input: {
-        var v = [ 0, 1, NaN, Infinity, null, undefined, true, false, "", "foo", /foo/ ];
-        v.forEach(function(x) {
-            v.forEach(function(y) {
-                console.log(
-                    +(x*y),
-                    +(x/y),
-                    +(x%y),
-                    -(x*y),
-                    -(x/y),
-                    -(x%y)
-                );
-            });
-        });
-    }
-    expect: {
-        var v = [ 0, 1, NaN, 1/0, null, void 0, true, false, "", "foo", /foo/ ];
-        v.forEach(function(x) {
-            v.forEach(function(y) {
-                console.log(
-                    +x*y,
-                    +x/y,
-                    +x%y,
-                    -x*y,
-                    -x/y,
-                    -x%y
-                );
-            });
-        });
-    }
-    expect_stdout: true
-}

test/compress/object.js

@@ -0,0 +1,504 @@
+getter_setter: {
+    input: {
+        var get = "bar";
+        var a = {
+            get,
+            set: "foo",
+            get bar() {
+                return this.get;
+            },
+            get 5() {
+                return "five";
+            },
+            get 0xf55() {
+                return "f five five";
+            },
+            get "five"() {
+                return 5;
+            },
+            set one(value) {
+                this._one = value;
+            },
+            set 9(value) {
+                this._nine = value;
+            },
+            set 0b1010(value) {
+                this._ten = value;
+            },
+            set "eleven"(value) {
+                this._eleven = value;
+            }
+        };
+        var b = {
+            get() { return "gift"; },
+            set: function(code) { return "Storing code " + code; }
+        };
+        var c = {
+            ["get"]: "foo",
+            ["set"]: "bar"
+        };
+        var d = {
+            get: "foo",
+            set: "bar"
+        };
+    }
+    expect: {
+        var get = "bar";
+        var a = {
+            get,
+            set: "foo",
+            get bar() {
+                return this.get;
+            },
+            get 5() {
+                return "five";
+            },
+            get 0xf55() {
+                return "f five five";
+            },
+            get "five"() {
+                return 5;
+            },
+            set one(value) {
+                this._one = value;
+            },
+            set 9(value) {
+                this._nine = value;
+            },
+            set 0b1010(value) {
+                this._ten = value;
+            },
+            set "eleven"(value) {
+                this._eleven = value;
+            }
+        };
+        var b = {
+            get() { return "gift"; },
+            set: function(code) { return "Storing code " + code; }
+        };
+        var c = {
+            ["get"]: "foo",
+            ["set"]: "bar"
+        };
+        var d = {
+            get: "foo",
+            set: "bar"
+        };
+    }
+}
+
+getter_setter_mangler: {
+    mangle = {}
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        function f(get,set) {
+            return {
+                get,
+                set,
+                get g(){},
+                set s(n){},
+                c,
+                a:1,
+                m(){}
+            };
+        }
+    }
+    expect_exact: "function f(n,t){return{get:n,set:t,get g(){},set s(n){},c,a:1,m(){}}}"
+}
+
+use_shorthand_opportunity: {
+    beautify = {
+        ecma: 6
+    }
+    input: {
+        var foo = 123;
+        var obj = {foo: foo};
+    }
+    expect_exact: "var foo=123;var obj={foo};"
+}
+
+computed_property_names: {
+    input: {
+        obj({ ["x" + "x"]: 6 });
+    }
+    expect_exact: 'obj({["x"+"x"]:6});'
+}
+
+computed_property_names_evaluated_1: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        obj({
+            [1 + 1]: 2,
+            ["x" + "x"]: 6
+        });
+    }
+    expect_exact: 'obj({[2]:2,["xx"]:6});'
+}
+
+computed_property_names_evaluated_2: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var foo = something();
+
+        var obj = {
+            [foo]() {
+                return "blah";
+            }
+        }
+    }
+    expect_exact: 'var foo=something();var obj={[foo](){return"blah"}};'
+}
+
+shorthand_properties: {
+    mangle = true;
+    input: (function() {
+        var prop = 1;
+        const value = {prop};
+        return value;
+    })();
+    expect: (function() {
+        var n = 1;
+        const r = {prop:n};
+        return r;
+    })();
+}
+
+concise_methods: {
+    input: {
+        x = {
+            foo(a, b) {
+                return x;
+            }
+        }
+        y = {
+            foo([{a}]) {
+                return a;
+            },
+            bar(){}
+        }
+    }
+    expect_exact: "x={foo(a,b){return x}};y={foo([{a}]){return a},bar(){}};"
+}
+
+concise_methods_with_computed_property: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var foo = {
+            [Symbol.iterator]() {
+                return { /* stuff */ }
+            },
+            [1 + 2]() {
+                return 3;
+            },
+            ["1" + "4"]() {
+                return 14;
+            }
+        }
+    }
+    expect: {
+        var foo = {
+            [Symbol.iterator]() {
+                return { /* stuff */ }
+            },
+            [3]() {
+                return 3;
+            },
+            ["14"]() {
+                return 14;
+            }
+        }
+    }
+}
+
+concise_methods_with_computed_property2: {
+    options = {
+        evaluate: true
+    }
+    input: {
+        var foo = {
+            [[1]](){
+                return "success";
+            }
+        };
+        doSomething(foo[[1]]());
+    }
+    expect_exact: {
+        'var foo={[[1]](){return"success"}};doSomething(foo[[1]]());'
+    }
+}
+
+concise_methods_with_various_property_names: {
+    input: {
+        var get = "bar";
+        var a = {
+            bar() {
+                return this.get;
+            },
+            5() {
+                return "five";
+            },
+            0xf55() {
+                return "f five five";
+            },
+            "five"() {
+                return 5;
+            },
+            0b1010(value) {
+                this._ten = value;
+            }
+        };
+    }
+    expect: {
+        var get = "bar";
+        var a = {
+            bar() {
+                return this.get;
+            },
+            5() {
+                return "five";
+            },
+            0xf55() {
+                return "f five five";
+            },
+            "five"() {
+                return 5;
+            },
+            0b1010(value) {
+                this._ten = value;
+            }
+        };
+    }
+}
+
+concise_methods_and_mangle_props: {
+    mangle_props = {
+        regex: /_/
+    };
+    input: {
+        function x() {
+            obj = {
+                _foo() { return 1; }
+            }
+        }
+    }
+    expect: {
+        function x() {
+            obj = {
+                a() { return 1; }
+            }
+        }
+    }
+}
+
+concise_generators: {
+    input: {
+        x = {
+            *foo(a, b) {
+                return x;
+            }
+        }
+        y = {
+            *foo([{a}]) {
+                yield a;
+            },
+            bar(){}
+        }
+    }
+    expect_exact: "x={*foo(a,b){return x}};y={*foo([{a}]){yield a},bar(){}};"
+}
+
+concise_methods_and_keyword_names: {
+    input: {
+        x = {
+            catch() {},
+            throw() {}
+        }
+    }
+    expect: {
+        x={catch(){},throw(){}};
+    }
+}
+
+getter_setter_with_computed_value: {
+    input: {
+        class C {
+            get ['a']() {
+                return 'A';
+            }
+            set ['a'](value) {
+                do_something(a);
+            }
+        }
+        var x = {
+            get [a.b]() {
+                return 42;
+            }
+        };
+        class MyArray extends Array {
+            get [Symbol.species]() {
+                return Array;
+            }
+        }
+    }
+    expect_exact: 'class C{get["a"](){return"A"}set["a"](value){do_something(a)}}var x={get[a.b](){return 42}};class MyArray extends Array{get[Symbol.species](){return Array}}'
+}
+
+property_with_operator_value: {
+    input: {
+        var foo = {
+            "*": 1,
+            get "*"() {
+                return 2;
+            },
+            *"*"() {
+                return 3;
+            },
+            "%": 1,
+            get "%"() {
+                return 2;
+            },
+            *"%"() {
+                return 3;
+            }
+        }
+        class bar {
+            get "*"() {
+                return 1
+            }
+            *"*"() {
+                return 2;
+            }
+            get "%"() {
+                return 1
+            }
+            *"%"() {
+                return 2;
+            }
+        }
+    }
+    expect_exact: 'var foo={"*":1,get"*"(){return 2},*"*"(){return 3},"%":1,get"%"(){return 2},*"%"(){return 3}};class bar{get"*"(){return 1}*"*"(){return 2}get"%"(){return 1}*"%"(){return 2}}'
+}
+
+property_with_unprintable: {
+    input: {
+        var foo = {
+            "\x00\x01": "foo",
+            get "\x00\x01"() {
+                return "bar";
+            },
+            set "\x00\x01"(foo) {
+                save(foo);
+            },
+            *"\x00\x01"() {
+                return "foobar";
+            }
+        }
+        class bar {
+            get "\x00\x01"() {
+                return "bar"
+            }
+            set "\x00\x01"(foo) {
+                save(foo);
+            }
+            *"\x00\x01"() {
+                return "foobar";
+            }
+        }
+    }
+    expect_exact: 'var foo={"\\0\x01":"foo",get"\\0\x01"(){return"bar"},set"\\0\x01"(foo){save(foo)},*"\\0\x01"(){return"foobar"}};class bar{get"\\0\x01"(){return"bar"}set"\\0\x01"(foo){save(foo)}*"\\0\x01"(){return"foobar"}}'
+}
+
+property_with_unprintable_ascii_only: {
+    beautify = {
+        ascii_only: true,
+    }
+    input: {
+        var foo = {
+            "\x00\x01": "foo",
+            get "\x00\x01"() {
+                return "bar";
+            },
+            set "\x00\x01"(foo) {
+                save(foo);
+            },
+            *"\x00\x01"() {
+                return "foobar";
+            }
+        }
+        class bar {
+            get "\x00\x01"() {
+                return "bar"
+            }
+            set "\x00\x01"(foo) {
+                save(foo);
+            }
+            *"\x00\x01"() {
+                return "foobar";
+            }
+        }
+    }
+    expect_exact: 'var foo={"\\0\\x01":"foo",get"\\0\\x01"(){return"bar"},set"\\0\\x01"(foo){save(foo)},*"\\0\\x01"(){return"foobar"}};class bar{get"\\0\\x01"(){return"bar"}set"\\0\\x01"(foo){save(foo)}*"\\0\\x01"(){return"foobar"}}'
+}
+
+property_with_unprintable_ascii_only_static: {
+    beautify = {
+        ascii_only: true
+    }
+    input: {
+        class foo {
+            static get "\x02\x03"() {
+                return "bar";
+            }
+            static set "\x04\x05"(foo) {
+                save(foo);
+            }
+        }
+    }
+    expect_exact: 'class foo{static get"\\x02\\x03"(){return"bar"}static set"\\x04\\x05"(foo){save(foo)}}'
+}
+
+methods_and_getters_with_keep_quoted_props_enabled: {
+    beautify = {
+        quote_style: 3,
+        keep_quoted_props: true,
+    }
+    input: {
+        var obj = {
+            a() {},
+            "b"() {},
+            get c() { return "c"},
+            get "d"() { return "d"},
+            set e(a) { doSomething(a); },
+            set f(a) { doSomething(b); }
+        }
+    }
+    expect_exact: 'var obj={a(){},"b"(){},get c(){return"c"},get"d"(){return"d"},set e(a){doSomething(a)},set f(a){doSomething(b)}};'
+}
+
+allow_assignments_to_property_values: {
+    input: {
+        var foo = {123: foo = 123} = {foo: "456"};
+    }
+    expect: {
+        var foo = {123: foo = 123} = {foo: "456"};
+    }
+}
+
+variable_as_computed_property: {
+    input: {
+        function getLine(header) {
+            return {
+                [header]: {}
+            };
+        }
+    }
+    expect_exact: "function getLine(header){return{[header]:{}}}"
+}

test/compress/parameters.js

@@ -0,0 +1,159 @@
+arrow_functions: {
+    input: {
+        (a) => b;  // 1 args
+        (a, b) => c;  // n args
+        () => b;  // 0 args
+        (a) => (b) => c;  // func returns func returns func
+        (a) => ((b) => c);  // So these parens are dropped
+        () => (b,c) => d;  // func returns func returns func
+        a=>{return b;}
+        a => 'lel';  // Dropping the parens
+    }
+    expect_exact: "a=>b;(a,b)=>c;()=>b;a=>b=>c;a=>b=>c;()=>(b,c)=>d;a=>{return b};a=>\"lel\";"
+}
+
+regression_arrow_functions_and_hoist: {
+    options = {
+        hoist_vars: true,
+        hoist_funs: true
+    }
+    input: {
+        (a) => b;
+    }
+    expect_exact: "a=>b;"
+}
+
+regression_assign_arrow_functions: {
+    input: {
+        oninstall = e => false;
+        oninstall = () => false;
+    }
+    expect: {
+        oninstall=e=>false;
+        oninstall=()=>false;
+    }
+}
+
+destructuring_arguments_1: {
+    input: {
+        (function ( a ) { });
+        (function ( [ a ] ) { });
+        (function ( [ a, b ] ) { });
+        (function ( [ [ a ] ] ) { });
+        (function ( [ [ a, b ] ] ) { });
+        (function ( [ a, [ b ] ] ) { });
+        (function ( [ [ b ], a ] ) { });
+
+        (function ( { a } ) { });
+        (function ( { a, b } ) { });
+
+        (function ( [ { a } ] ) { });
+        (function ( [ { a, b } ] ) { });
+        (function ( [ a, { b } ] ) { });
+        (function ( [ { b }, a ] ) { });
+
+        ( [ a ] ) => { };
+        ( [ a, b ] ) => { };
+
+        ( { a } ) => { };
+        ( { a, b, c, d, e } ) => { };
+
+        ( [ a ] ) => b;
+        ( [ a, b ] ) => c;
+
+        ( { a } ) => b;
+        ( { a, b } ) => c;
+    }
+    expect: {
+        (function(a){});
+        (function([a]){});
+        (function([a,b]){});
+        (function([[a]]){});
+        (function([[a,b]]){});
+        (function([a,[b]]){});
+        (function([[b],a]){});
+
+        (function({a}){});
+        (function({a,b}){});
+
+        (function([{a}]){});
+        (function([{a,b}]){});
+        (function([a,{b}]){});
+        (function([{b},a]){});
+
+        ([a])=>{};
+        ([a,b])=>{};
+
+        ({a})=>{};
+        ({a,b,c,d,e})=>{};
+
+        ([a])=>b;
+        ([a,b])=>c;
+
+        ({a})=>b;
+        ({a,b})=>c;
+    }
+}
+
+destructuring_arguments_2: {
+    input: {
+        (function([]) {});
+        (function({}) {});
+        (function([,,,,,]) {});
+        (function ([a, {b: c}]) {});
+        (function ([...args]) {});
+        (function ({x,}) {});
+        class a { *method({ [thrower()]: x } = {}) {}};
+        (function(a, b, c, d, [{e: [...f]}]){})(1, 2, 3, 4, [{e: [1, 2, 3]}]);
+    }
+    expect: {
+        (function([]) {});
+        (function({}) {});
+        (function([,,,,,]) {});
+        (function ([a, {b: c}]) {});
+        (function ([...args]) {});
+        (function ({x,}) {});
+        class a { *method({ [thrower()]: x } = {}) {}};
+        (function(a, b, c, d, [{e: [...f]}]){})(1, 2, 3, 4, [{e: [1, 2, 3]}]);
+    }
+}
+
+destructuring_arguments_3: {
+    input: {
+        function fn3({x: {y: {z: {} = 42}}}) {}
+        const { cover = (function () {}), xCover = (0, function() {})  } = {};
+        let { cover = (function () {}), xCover = (0, function() {})  } = {};
+        var { cover = (function () {}), xCover = (0, function() {})  } = {};
+    }
+    expect_exact: "function fn3({x:{y:{z:{}=42}}}){}const{cover=function(){},xCover=(0,function(){})}={};let{cover=function(){},xCover=(0,function(){})}={};var{cover=function(){},xCover=(0,function(){})}={};"
+}
+
+default_arguments: {
+    input: {
+        function x(a = 6) { }
+        function x(a = (6 + 5)) { }
+        function x({ foo } = {}, [ bar ] = [ 1 ]) { }
+    }
+    expect_exact: "function x(a=6){}function x(a=6+5){}function x({foo}={},[bar]=[1]){}"
+}
+
+default_values_in_destructurings: {
+    input: {
+        function x({a=(4), b}) {}
+        function x([b, c=(12)]) {}
+        var { x = (6), y } = x;
+        var [ x, y = (6) ] = x;
+    }
+    expect_exact: "function x({a=4,b}){}function x([b,c=12]){}var{x=6,y}=x;var[x,y=6]=x;"
+}
+
+accept_duplicated_parameters_in_non_strict_without_spread_or_default_assignment: {
+    input: {
+        function a(b, b){}
+        function b({c: test, c: test}){}
+    }
+    expect: {
+        function a(b, b){}
+        function b({c: test, c: test}){}
+    }
+}

test/compress/properties.js

@@ -1,8 +1,7 @@
 keep_properties: {
     options = {
-        evaluate: true,
-        properties: false,
-    }
+        properties: false
+    };
     input: {
         a["foo"] = "bar";
     }
@@ -13,12 +12,9 @@ keep_properties: {
 
 dot_properties: {
     options = {
-        evaluate: true,
         properties: true,
-    }
-    beautify = {
-        ie8: true,
-    }
+        screw_ie8: false
+    };
     input: {
         a["foo"] = "bar";
         a["if"] = "if";
@@ -39,12 +35,9 @@ dot_properties: {
 
 dot_properties_es5: {
     options = {
-        evaluate: true,
         properties: true,
-    }
-    beautify = {
-        ie8: false,
-    }
+        screw_ie8: true
+    };
     input: {
         a["foo"] = "bar";
         a["if"] = "if";
@@ -61,61 +54,12 @@ dot_properties_es5: {
     }
 }
 
-sub_properties: {
+evaluate_length: {
     options = {
-        evaluate: true,
-        properties: true,
-    }
-    input: {
-        a[0] = 0;
-        a["0"] = 1;
-        a[3.14] = 2;
-        a["3" + ".14"] = 3;
-        a["i" + "f"] = 4;
-        a["foo" + " bar"] = 5;
-        a[0 / 0] = 6;
-        a[null] = 7;
-        a[undefined] = 8;
-    }
-    expect: {
-        a[0] = 0;
-        a[0] = 1;
-        a[3.14] = 2;
-        a[3.14] = 3;
-        a.if = 4;
-        a["foo bar"] = 5;
-        a.NaN = 6;
-        a.null = 7;
-        a[void 0] = 8;
-    }
-}
-
-evaluate_array_length: {
-    options = {
-        evaluate: true,
         properties: true,
         unsafe: true,
-    }
-    input: {
-        a = [1, 2, 3].length;
-        a = [1, 2, 3].join()["len" + "gth"];
-        a = [1, 2, b].length;
-        a = [1, 2, 3].join(b).length;
-    }
-    expect: {
-        a = 3;
-        a = 5;
-        a = [1, 2, b].length;
-        a = [1, 2, 3].join(b).length;
-    }
-}
-
-evaluate_string_length: {
-    options = {
-        evaluate: true,
-        properties: true,
-        unsafe: true,
-    }
+        evaluate: true
+    };
     input: {
         a = "foo".length;
         a = ("foo" + "bar")["len" + "gth"];
@@ -131,11 +75,9 @@ evaluate_string_length: {
 }
 
 mangle_properties: {
-    mangle = {
-        properties: {
-            keep_quoted: false,
-        },
-    }
+    mangle_props = {
+        ignore_quoted: false
+    };
     input: {
         a["foo"] = "bar";
         a.color = "red";
@@ -146,21 +88,19 @@ mangle_properties: {
     expect: {
         a["a"] = "bar";
         a.b = "red";
-        x = {o: 10};
-        a.r(x.o, a.a);
-        a['r']({b: "blue", a: "baz"});
+        x = {c: 10};
+        a.d(x.c, a.a);
+        a['d']({b: "blue", a: "baz"});
     }
 }
 
 mangle_unquoted_properties: {
     options = {
-        evaluate: true,
-        properties: false,
+        properties: false
     }
-    mangle = {
-        properties: {
-            keep_quoted: true,
-        },
+    mangle_props = {
+        ignore_quoted: true,
+        reserved: []
     }
     beautify = {
         beautify: false,
@@ -189,26 +129,24 @@ mangle_unquoted_properties: {
         function f1() {
             a["foo"] = "bar";
             a.color = "red";
-            a.r = 2;
-            x = {"bar": 10, b: 7};
-            a.b = 9;
+            a.b = 2;
+            x = {"bar": 10, c: 7};
+            a.c = 9;
         }
         function f2() {
             a.foo = "bar";
             a['color'] = "red";
-            x = {bar: 10, b: 7};
-            a.b = 9;
-            a.r = 3;
+            x = {bar: 10, c: 7};
+            a.c = 9;
+            a.b = 3;
         }
     }
 }
 
 mangle_debug: {
-    mangle = {
-        properties: {
-            debug: "",
-        },
-    }
+    mangle_props = {
+        debug: ""
+    };
     input: {
         a.foo = "bar";
         x = { baz: "ban" };
@@ -220,11 +158,9 @@ mangle_debug: {
 }
 
 mangle_debug_true: {
-    mangle = {
-        properties: {
-            debug: true,
-        },
-    }
+    mangle_props = {
+        debug: true
+    };
     input: {
         a.foo = "bar";
         x = { baz: "ban" };
@@ -236,11 +172,9 @@ mangle_debug_true: {
 }
 
 mangle_debug_suffix: {
-    mangle = {
-        properties: {
-            debug: "XYZ",
-        },
-    }
+    mangle_props = {
+        debug: "XYZ"
+    };
     input: {
         a.foo = "bar";
         x = { baz: "ban" };
@@ -251,17 +185,14 @@ mangle_debug_suffix: {
     }
 }
 
-mangle_debug_suffix_keep_quoted: {
+mangle_debug_suffix_ignore_quoted: {
     options = {
-        evaluate: true,
-        properties: false,
+        properties: false
     }
-    mangle = {
-        properties: {
-            debug: "XYZ",
-            keep_quoted: true,
-            reserved: [],
-        },
+    mangle_props = {
+        ignore_quoted: true,
+        debug: "XYZ",
+        reserved: []
     }
     beautify = {
         beautify: false,
@@ -560,471 +491,3 @@ first_256_hex_chars_as_properties: {
         };
     }
 }
-
-native_prototype: {
-    options = {
-        unsafe_proto: true,
-    }
-    input: {
-        Array.prototype.splice.apply(a, [1, 2, b, c]);
-        Object.prototype.hasOwnProperty.call(d, "foo");
-        String.prototype.indexOf.call(e, "bar");
-    }
-    expect: {
-        [].splice.apply(a, [1, 2, b, c]);
-        ({}).hasOwnProperty.call(d, "foo");
-        "".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"
-}
-
-issue_2208_1: {
-    options = {
-        inline: true,
-        properties: true,
-        side_effects: true,
-    }
-    input: {
-        console.log({
-            p: function() {
-                return 42;
-            }
-        }.p());
-    }
-    expect: {
-        console.log(42);
-    }
-    expect_stdout: "42"
-}
-
-issue_2208_2: {
-    options = {
-        inline: true,
-        properties: true,
-        side_effects: true,
-    }
-    input: {
-        console.log({
-            a: 42,
-            p: function() {
-                return this.a;
-            }
-        }.p());
-    }
-    expect: {
-        console.log({
-            a: 42,
-            p: function() {
-                return this.a;
-            }
-        }.p());
-    }
-    expect_stdout: "42"
-}
-
-issue_2208_3: {
-    options = {
-        inline: true,
-        properties: true,
-        side_effects: true,
-    }
-    input: {
-        a = 42;
-        console.log({
-            p: function() {
-                return function() {
-                    return this.a;
-                }();
-            }
-        }.p());
-    }
-    expect: {
-        a = 42;
-        console.log(function() {
-            return this.a;
-        }());
-    }
-    expect_stdout: "42"
-}
-
-issue_2208_4: {
-    options = {
-        inline: true,
-        properties: true,
-        side_effects: true,
-    }
-    input: {
-        function foo() {}
-        console.log({
-            a: foo(),
-            p: function() {
-                return 42;
-            }
-        }.p());
-    }
-    expect: {
-        function foo() {}
-        console.log((foo(), function() {
-            return 42;
-        })());
-    }
-    expect_stdout: "42"
-}
-
-issue_2208_5: {
-    options = {
-        inline: true,
-        properties: true,
-        side_effects: true,
-    }
-    input: {
-        console.log({
-            p: "FAIL",
-            p: function() {
-                return 42;
-            }
-        }.p());
-    }
-    expect: {
-        console.log(42);
-    }
-    expect_stdout: "42"
-}
-
-issue_2256: {
-    options = {
-        side_effects: true,
-    }
-    mangle = {
-        properties: {
-            keep_quoted: true,
-        },
-    }
-    input: {
-        ({ "keep": 1 });
-        g.keep = g.change;
-    }
-    expect: {
-        g.keep = g.g;
-    }
-}
-
-lhs_prop_1: {
-    options = {
-        evaluate: true,
-        properties: true,
-    }
-    input: {
-        console.log(++{
-            a: 1
-        }.a);
-    }
-    expect: {
-        console.log(++{
-            a: 1
-        }.a);
-    }
-    expect_stdout: "2"
-}
-
-lhs_prop_2: {
-    options = {
-        evaluate: true,
-        inline: true,
-        properties: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        [1][0] = 42;
-        (function(a) {
-            a.b = "g";
-        })("abc");
-        (function(a) {
-            a[2] = "g";
-        })("def");
-        (function(a) {
-            a[""] = "g";
-        })("ghi");
-    }
-    expect: {
-        [1][0] = 42;
-        "abc".b = "g";
-        "def"[2] = "g";
-        "ghi"[""] = "g";
-    }
-}
-
-literal_duplicate_key_side_effects: {
-    options = {
-        properties: true,
-        side_effects: true,
-    }
-    input: {
-        console.log({
-            a: "FAIL",
-            a: console.log ? "PASS" : "FAIL"
-        }.a);
-    }
-    expect: {
-        console.log(console.log ? "PASS" : "FAIL");
-    }
-    expect_stdout: "PASS"
-}
-
-prop_side_effects_1: {
-    options = {
-        evaluate: true,
-        inline: true,
-        properties: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var C = 1;
-        console.log(C);
-        var obj = {
-            bar: function() {
-                return C + C;
-            }
-        };
-        console.log(obj.bar());
-    }
-    expect: {
-        console.log(1);
-        var obj = {
-            bar: function() {
-                return 2;
-            }
-        };
-        console.log(obj.bar());
-    }
-    expect_stdout: [
-        "1",
-        "2",
-    ]
-}
-
-prop_side_effects_2: {
-    options = {
-        evaluate: true,
-        inline: true,
-        passes: 2,
-        properties: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var C = 1;
-        console.log(C);
-        var obj = {
-            "": function() {
-                return C + C;
-            }
-        };
-        console.log(obj[""]());
-    }
-    expect: {
-        console.log(1);
-        console.log(2);
-    }
-    expect_stdout: [
-        "1",
-        "2",
-    ]
-}
-
-accessor_1: {
-    options = {
-        properties: true,
-    }
-    input: {
-        console.log({
-            a: "FAIL",
-            get a() {
-                return "PASS";
-            }
-        }.a);
-    }
-    expect: {
-        console.log({
-            a: "FAIL",
-            get a() {
-                return "PASS";
-            }
-        }.a);
-    }
-    expect_stdout: "PASS"
-    node_version: ">=4"
-}
-
-accessor_2: {
-    options = {
-        properties: true,
-    }
-    input: {
-        console.log({
-            get a() {
-                return "PASS";
-            },
-            set a(v) {},
-            a: "FAIL"
-        }.a);
-    }
-    expect: {
-        console.log({
-            get a() {
-                return "PASS";
-            },
-            set a(v) {},
-            a: "FAIL"
-        }.a);
-    }
-    expect_stdout: true
-}
-
-array_hole: {
-    options = {
-        properties: true,
-        side_effects: true,
-    }
-    input: {
-        console.log(
-            [ 1, 2, , 3][1],
-            [ 1, 2, , 3][2],
-            [ 1, 2, , 3][3]
-        );
-    }
-    expect: {
-        console.log(2, void 0, 3);
-    }
-    expect_stdout: "2 undefined 3"
-}
-
-new_this: {
-    options = {
-        properties: true,
-        side_effects: true,
-    }
-    input: {
-        new {
-            f: function(a) {
-                this.a = a;
-            }
-        }.f(42);
-    }
-    expect: {
-        new function(a) {
-            this.a = a;
-        }(42);
-    }
-}

test/compress/pure_funcs.js

@@ -1,295 +0,0 @@
-array: {
-    options = {
-        pure_funcs: [ "Math.floor" ],
-        side_effects: true,
-    }
-    input: {
-        var a;
-        function f(b) {
-            Math.floor(a / b);
-            Math.floor(c / b);
-        }
-    }
-    expect: {
-        var a;
-        function f(b) {
-            c;
-        }
-    }
-}
-
-func: {
-    options = {
-        pure_funcs: function(node) {
-            return !~node.args[0].print_to_string().indexOf("a");
-        },
-        side_effects: true,
-    }
-    input: {
-        function f(a, b) {
-            Math.floor(a / b);
-            Math.floor(c / b);
-        }
-    }
-    expect: {
-        function f(a, b) {
-            Math.floor(c / b);
-        }
-    }
-}
-
-side_effects: {
-    options = {
-        pure_funcs: [ "console.log" ],
-        side_effects: true,
-    }
-    input: {
-        function f(a, b) {
-            console.log(a());
-            console.log(b);
-        }
-    }
-    expect: {
-        function f(a, b) {
-            a();
-        }
-    }
-}
-
-unused: {
-    options = {
-        pure_funcs: [ "pure" ],
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        function foo() {
-            var u = pure(1);
-            var x = pure(2);
-            var y = pure(x);
-            var z = pure(pure(side_effects()));
-            return pure(3);
-        }
-    }
-    expect: {
-        function foo() {
-            side_effects();
-            return pure(3);
-        }
-    }
-}
-
-babel: {
-    options = {
-        pure_funcs: [ "_classCallCheck" ],
-        side_effects: true,
-        unused: true,
-    }
-    input: {
-        function _classCallCheck(instance, Constructor) {
-            if (!(instance instanceof Constructor))
-                throw new TypeError("Cannot call a class as a function");
-        }
-        var Foo = function Foo() {
-            _classCallCheck(this, Foo);
-        };
-    }
-    expect: {
-        function _classCallCheck(instance, Constructor) {
-            if (!(instance instanceof Constructor))
-                throw new TypeError("Cannot call a class as a function");
-        }
-        var Foo = function() {
-        };
-    }
-}
-
-conditional: {
-    options = {
-        pure_funcs: [ "pure" ],
-        side_effects: true,
-    }
-    input: {
-        pure(1 | a() ? 2 & b() : 7 ^ c());
-        pure(1 | a() ? 2 & b() : 5);
-        pure(1 | a() ? 4 : 7 ^ c());
-        pure(1 | a() ? 4 : 5);
-        pure(3 ? 2 & b() : 7 ^ c());
-        pure(3 ? 2 & b() : 5);
-        pure(3 ? 4 : 7 ^ c());
-        pure(3 ? 4 : 5);
-    }
-    expect: {
-        1 | a() ? b() : c();
-        1 | a() && b();
-        1 | a() || c();
-        a();
-        3 ? b() : c();
-        3 && b();
-        3 || c();
-    }
-}
-
-relational: {
-    options = {
-        pure_funcs: [ "foo" ],
-        side_effects :true,
-    }
-    input: {
-        foo() in foo();
-        foo() instanceof bar();
-        foo() < "bar";
-        bar() > foo();
-        bar() != bar();
-        bar() !== "bar";
-        "bar" == foo();
-        "bar" === bar();
-        "bar" >= "bar";
-    }
-    expect: {
-        bar();
-        bar();
-        bar(), bar();
-        bar();
-        bar();
-    }
-}
-
-arithmetic: {
-    options = {
-        pure_funcs: [ "foo" ],
-        side_effects :true,
-    }
-    input: {
-        foo() + foo();
-        foo() - bar();
-        foo() * "bar";
-        bar() / foo();
-        bar() & bar();
-        bar() | "bar";
-        "bar" >> foo();
-        "bar" << bar();
-        "bar" >>> "bar";
-    }
-    expect: {
-        bar();
-        bar();
-        bar(), bar();
-        bar();
-        bar();
-    }
-}
-
-boolean_and: {
-    options = {
-        pure_funcs: [ "foo" ],
-        side_effects :true,
-    }
-    input: {
-        foo() && foo();
-        foo() && bar();
-        foo() && "bar";
-        bar() && foo();
-        bar() && bar();
-        bar() && "bar";
-        "bar" && foo();
-        "bar" && bar();
-        "bar" && "bar";
-    }
-    expect: {
-        foo() && bar();
-        bar();
-        bar() && bar();
-        bar();
-        "bar" && bar();
-    }
-}
-
-boolean_or: {
-    options = {
-        pure_funcs: [ "foo" ],
-        side_effects :true,
-    }
-    input: {
-        foo() || foo();
-        foo() || bar();
-        foo() || "bar";
-        bar() || foo();
-        bar() || bar();
-        bar() || "bar";
-        "bar" || foo();
-        "bar" || bar();
-        "bar" || "bar";
-    }
-    expect: {
-        foo() || bar();
-        bar();
-        bar() || bar();
-        bar();
-        "bar" || bar();
-    }
-}
-
-assign: {
-    options = {
-        pure_funcs: [ "foo" ],
-        side_effects :true,
-    }
-    input: {
-        var a;
-        function f(b) {
-            a = foo();
-            b *= 4 + foo();
-            c >>= 0 | foo();
-        }
-    }
-    expect: {
-        var a;
-        function f(b) {
-            a = foo();
-            b *= 4 + foo();
-            c >>= 0 | foo();
-        }
-    }
-}
-
-unary: {
-    options = {
-        pure_funcs: [ "foo" ],
-        side_effects :true,
-    }
-    input: {
-        typeof foo();
-        typeof bar();
-        typeof "bar";
-        void foo();
-        void bar();
-        void "bar";
-        delete a[foo()];
-        delete a[bar()];
-        delete a["bar"];
-        a[foo()]++;
-        a[bar()]++;
-        a["bar"]++;
-        --a[foo()];
-        --a[bar()];
-        --a["bar"];
-        ~foo();
-        ~bar();
-        ~"bar";
-    }
-    expect: {
-        bar();
-        bar();
-        delete a[foo()];
-        delete a[bar()];
-        delete a["bar"];
-        a[foo()]++;
-        a[bar()]++;
-        a["bar"]++;
-        --a[foo()];
-        --a[bar()];
-        --a["bar"];
-        bar();
-    }
-}

test/compress/pure_getters.js

@@ -1,613 +0,0 @@
-strict: {
-    options = {
-        pure_getters: "strict",
-        reduce_funcs: false,
-        reduce_vars: false,
-        side_effects: true,
-        toplevel: true,
-    }
-    input: {
-        var a, b = null, c = {};
-        a.prop;
-        b.prop;
-        c.prop;
-        d.prop;
-        null.prop;
-        (void 0).prop;
-        undefined.prop;
-    }
-    expect: {
-        var a, b = null, c = {};
-        a.prop;
-        b.prop;
-        c.prop;
-        d.prop;
-        null.prop;
-        (void 0).prop;
-        (void 0).prop;
-    }
-}
-
-strict_reduce_vars: {
-    options = {
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        toplevel: true,
-    }
-    input: {
-        var a, b = null, c = {};
-        a.prop;
-        b.prop;
-        c.prop;
-        d.prop;
-        null.prop;
-        (void 0).prop;
-        undefined.prop;
-    }
-    expect: {
-        var a, b = null, c = {};
-        a.prop;
-        b.prop;
-        d.prop;
-        null.prop;
-        (void 0).prop;
-        (void 0).prop;
-    }
-}
-
-unsafe: {
-    options = {
-        pure_getters: true,
-        reduce_funcs: false,
-        reduce_vars: false,
-        side_effects: true,
-        toplevel: true,
-    }
-    input: {
-        var a, b = null, c = {};
-        a.prop;
-        b.prop;
-        c.prop;
-        d.prop;
-        null.prop;
-        (void 0).prop;
-        undefined.prop;
-    }
-    expect: {
-        var a, b = null, c = {};
-        d;
-        null.prop;
-        (void 0).prop;
-        (void 0).prop;
-    }
-}
-
-unsafe_reduce_vars: {
-    options = {
-        pure_getters: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        side_effects: true,
-        toplevel: true,
-    }
-    input: {
-        var a, b = null, c = {};
-        a.prop;
-        b.prop;
-        c.prop;
-        d.prop;
-        null.prop;
-        (void 0).prop;
-        undefined.prop;
-    }
-    expect: {
-        var a, b = null, c = {};
-        d;
-        null.prop;
-        (void 0).prop;
-        (void 0).prop;
-    }
-}
-
-chained: {
-    options = {
-        pure_getters: "strict",
-        side_effects: true,
-    }
-    input: {
-        a.b.c;
-    }
-    expect: {
-        a.b.c;
-    }
-}
-
-impure_getter_1: {
-    options = {
-        pure_getters: "strict",
-        side_effects: true,
-    }
-    input: {
-        ({
-            get a() {
-                console.log(1);
-            },
-            b: 1
-        }).a;
-        ({
-            get a() {
-                console.log(1);
-            },
-            b: 1
-        }).b;
-    }
-    expect: {
-        ({
-            get a() {
-                console.log(1);
-            },
-            b: 1
-        }).a;
-        ({
-            get a() {
-                console.log(1);
-            },
-            b: 1
-        }).b;
-    }
-    expect_stdout: "1"
-}
-
-impure_getter_2: {
-    options = {
-        pure_getters: true,
-        side_effects: true,
-    }
-    input: {
-        // will produce incorrect output because getter is not pure
-        ({
-            get a() {
-                console.log(1);
-            },
-            b: 1
-        }).a;
-        ({
-            get a() {
-                console.log(1);
-            },
-            b: 1
-        }).b;
-    }
-    expect: {}
-}
-
-issue_2110_1: {
-    options = {
-        cascade: true,
-        pure_getters: "strict",
-        sequences: true,
-        side_effects: true,
-        reduce_funcs: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            function f() {}
-            function g() {
-                return this;
-            }
-            f.g = g;
-            return f.g();
-        }
-        console.log(typeof f());
-    }
-    expect: {
-        function f() {
-            function f() {}
-            return f.g = function() {
-                return this;
-            }, f.g();
-        }
-        console.log(typeof f());
-    }
-    expect_stdout: "function"
-}
-
-issue_2110_2: {
-    options = {
-        collapse_vars: true,
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            function f() {}
-            function g() {
-                return this;
-            }
-            f.g = g;
-            return f.g();
-        }
-        console.log(typeof f());
-    }
-    expect: {
-        function f() {
-            function f() {}
-            f.g = function() {
-                return this;
-            };
-            return f.g();
-        }
-        console.log(typeof f());
-    }
-    expect_stdout: "function"
-}
-
-set_immutable_1: {
-    options = {
-        collapse_vars: true,
-        evaluate: true,
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a = 1;
-        a.foo += "";
-        if (a.foo) console.log("FAIL");
-        else console.log("PASS");
-    }
-    expect: {
-        1..foo += "";
-        if (1..foo) console.log("FAIL");
-        else console.log("PASS");
-    }
-    expect_stdout: "PASS"
-}
-
-set_immutable_2: {
-    options = {
-        cascade: true,
-        conditionals: true,
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-        toplevel: true,
-    }
-    input: {
-        var a = 1;
-        a.foo += "";
-        if (a.foo) console.log("FAIL");
-        else console.log("PASS");
-    }
-    expect: {
-        var a = 1;
-        a.foo += "", a.foo ? console.log("FAIL") : console.log("PASS");
-    }
-    expect_stdout: "PASS"
-}
-
-set_immutable_3: {
-    options = {
-        collapse_vars: true,
-        evaluate: true,
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        "use strict";
-        var a = 1;
-        a.foo += "";
-        if (a.foo) console.log("FAIL");
-        else console.log("PASS");
-    }
-    expect: {
-        "use strict";
-        1..foo += "";
-        if (1..foo) console.log("FAIL");
-        else console.log("PASS");
-    }
-    expect_stdout: true
-}
-
-set_immutable_4: {
-    options = {
-        cascade: true,
-        conditionals: true,
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-        toplevel: true,
-    }
-    input: {
-        "use strict";
-        var a = 1;
-        a.foo += "";
-        if (a.foo) console.log("FAIL");
-        else console.log("PASS");
-    }
-    expect: {
-        "use strict";
-        var a = 1;
-        a.foo += "", a.foo ? console.log("FAIL") : console.log("PASS");
-    }
-    expect_stdout: true
-}
-
-set_mutable_1: {
-    options = {
-        collapse_vars: true,
-        evaluate: true,
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        unused: true,
-    }
-    input: {
-        !function a() {
-            a.foo += "";
-            if (a.foo) console.log("PASS");
-            else console.log("FAIL");
-        }();
-    }
-    expect: {
-        !function a() {
-            if (a.foo += "") console.log("PASS");
-            else console.log("FAIL");
-        }();
-    }
-    expect_stdout: "PASS"
-}
-
-set_mutable_2: {
-    options = {
-        cascade: true,
-        conditionals: true,
-        pure_getters: "strict",
-        reduce_funcs: true,
-        reduce_vars: true,
-        sequences: true,
-        side_effects: true,
-    }
-    input: {
-        !function a() {
-            a.foo += "";
-            if (a.foo) console.log("PASS");
-            else console.log("FAIL");
-        }();
-    }
-    expect: {
-        !function a() {
-            (a.foo += "") ? console.log("PASS") : console.log("FAIL");
-        }();
-    }
-    expect_stdout: "PASS"
-}
-
-issue_2313_1: {
-    options = {
-        cascade: true,
-        conditionals: true,
-        pure_getters: "strict",
-        sequences: true,
-        side_effects: true,
-    }
-    input: {
-        function x() {
-            console.log(1);
-            return {
-                y: function() {
-                    console.log(2);
-                    return {
-                        z: 0
-                    };
-                }
-            };
-        }
-        x().y().z++;
-        if (x().y().z) {
-            console.log(3);
-        }
-    }
-    expect: {
-        function x() {
-            return console.log(1), {
-                y: function() {
-                    return console.log(2), {
-                        z: 0
-                    };
-                }
-            };
-        }
-        x().y().z++,
-        x().y().z && console.log(3);
-    }
-    expect_stdout: [
-        "1",
-        "2",
-        "1",
-        "2",
-    ]
-}
-
-issue_2313_2: {
-    options = {
-        cascade: true,
-        conditionals: true,
-        pure_getters: true,
-        sequences: true,
-        side_effects: true,
-    }
-    input: {
-        function x() {
-            console.log(1);
-            return {
-                y: function() {
-                    console.log(2);
-                    return {
-                        z: 0
-                    };
-                }
-            };
-        }
-        x().y().z++;
-        if (x().y().z) {
-            console.log(3);
-        }
-    }
-    expect: {
-        function x() {
-            return console.log(1), {
-                y: function() {
-                    return console.log(2), {
-                        z: 0
-                    };
-                }
-            };
-        }
-        x().y().z++,
-        x().y().z && console.log(3);
-    }
-    expect_stdout: [
-        "1",
-        "2",
-        "1",
-        "2",
-    ]
-}
-
-issue_2313_3: {
-    options = {
-        collapse_vars: true,
-        conditionals: true,
-        pure_getters: "strict",
-    }
-    input: {
-        function x() {
-            console.log(1);
-            return {
-                y: function() {
-                    console.log(2);
-                    return {
-                        z: 0
-                    };
-                }
-            };
-        }
-        x().y().z++;
-        if (x().y().z) {
-            console.log(3);
-        }
-    }
-    expect: {
-        function x() {
-            console.log(1);
-            return {
-                y: function() {
-                    console.log(2);
-                    return {
-                        z: 0
-                    };
-                }
-            };
-        }
-        x().y().z++;
-        x().y().z && console.log(3);
-    }
-    expect_stdout: [
-        "1",
-        "2",
-        "1",
-        "2",
-    ]
-}
-
-issue_2313_4: {
-    options = {
-        collapse_vars: true,
-        conditionals: true,
-        pure_getters: true,
-    }
-    input: {
-        function x() {
-            console.log(1);
-            return {
-                y: function() {
-                    console.log(2);
-                    return {
-                        z: 0
-                    };
-                }
-            };
-        }
-        x().y().z++;
-        if (x().y().z) {
-            console.log(3);
-        }
-    }
-    expect: {
-        function x() {
-            console.log(1);
-            return {
-                y: function() {
-                    console.log(2);
-                    return {
-                        z: 0
-                    };
-                }
-            };
-        }
-        x().y().z++;
-        x().y().z && console.log(3);
-    }
-    expect_stdout: [
-        "1",
-        "2",
-        "1",
-        "2",
-    ]
-}
-
-issue_2313_5: {
-    options = {
-        pure_getters: "strict",
-        side_effects: true,
-    }
-    input: {
-        x().y++;
-        x().y;
-    }
-    expect: {
-        x().y++;
-        x().y;
-    }
-}
-
-issue_2313_6: {
-    options = {
-        pure_getters: true,
-        side_effects: true,
-    }
-    input: {
-        x().y++;
-        x().y;
-    }
-    expect: {
-        x().y++;
-        x();
-    }
-}