v2.8.25

- fix `estree` conversion of getter/setter
- fix non-directive literal in `to_mozilla_ast()`
- revamp `test/mozilla-ast.js`
  - reuse `test/ufuzz.js` for code generation
  - use `acorn.parse()` for creating `estree`
- extend `test/ufuzz.js` for `acorn` workaround
  - catch variable redefinition
  - non-trivial literal as directive
  - adjust options for tolerance

Miscellaneous
- optional semi-colon when parsing directives

fixes #1914
closes #1915

.github/ISSUE_TEMPLATE.md

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

.travis.yml

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

bin/extract-props.js

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

bin/uglifyjs

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

lib/ast.js

@@ -157,7 +157,7 @@ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
 
 function walk_body(node, visitor) {
     var body = node.body;
-    if (body instanceof AST_Node) {
+    if (body instanceof AST_Statement) {
         body._walk(visitor);
     }
     else for (var i = 0, len = body.length; i < len; i++) {
@@ -182,13 +182,21 @@ var AST_BlockStatement = DEFNODE("BlockStatement", null, {
 }, AST_Block);
 
 var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
-    $documentation: "The empty statement (empty block or simply a semicolon)"
+    $documentation: "The empty statement (empty block or simply a semicolon)",
+    _walk: function(visitor) {
+        return visitor._visit(this);
+    }
 }, AST_Statement);
 
 var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", {
     $documentation: "Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`",
     $propdoc: {
         body: "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"
+    },
+    _walk: function(visitor) {
+        return visitor._visit(this, function(){
+            this.body._walk(visitor);
+        });
     }
 }, AST_Statement);
 
@@ -284,10 +292,6 @@ 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: {
@@ -315,13 +319,6 @@ var AST_Scope = DEFNODE("Scope", "directives variables functions uses_with uses_
         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", {
@@ -329,124 +326,75 @@ 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_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) {
-            var insert_default = function(ex, default_value) {
-                if (default_value) {
-                    return new AST_DefaultAssign({
-                        start: ex.start,
-                        left: ex,
-                        operator: "=",
-                        right: default_value,
-                        end: default_value.end
-                    });
-                }
-                return ex;
-            }
-            if (ex instanceof AST_Object) {
-                return insert_default(new AST_Destructuring({
-                    start: ex.start,
-                    end: ex.end,
-                    is_array: false,
-                    names: ex.properties.map(to_fun_args)
-                }), default_seen_above);
-            } else if (ex instanceof AST_ObjectKeyVal) {
-                if (ex.key instanceof AST_SymbolRef) {
-                    ex.key = to_fun_args(ex.key, 0, [ex.key]);
-                }
-                ex.value = to_fun_args(ex.value, 0, [ex.key]);
-                return insert_default(ex, default_seen_above);
-            } else if (ex instanceof AST_Hole) {
-                return ex;
-            } else if (ex instanceof AST_Destructuring) {
-                ex.names = ex.names.map(to_fun_args);
-                return insert_default(ex, default_seen_above);
-            } else if (ex instanceof AST_SymbolRef) {
-                return insert_default(new AST_SymbolFunarg({
-                    name: ex.name,
-                    start: ex.start,
-                    end: ex.end
-                }), default_seen_above);
-            } else if (ex instanceof AST_Expansion) {
-                ex.expression = to_fun_args(ex.expression);
-                return insert_default(ex, default_seen_above);
-            } else if (ex instanceof AST_Array) {
-                return insert_default(new AST_Destructuring({
-                    start: ex.start,
-                    end: ex.end,
-                    is_array: true,
-                    names: ex.elements.map(to_fun_args)
-                }), default_seen_above);
-            } else if (ex instanceof AST_Assign) {
-                return insert_default(to_fun_args(ex.left, undefined, undefined, ex.right), default_seen_above);
-            } else if (ex instanceof AST_DefaultAssign) {
-                ex.left = to_fun_args(ex.left, 0, [ex.left]);
-                return ex;
-            } else {
-                croak("Invalid function parameter", ex.start.line, ex.start.col);
-            }
-        });
-    },
-    as_expr: function() {
-        var exprs = this.expressions;
-        return exprs.length == 1 ? exprs[0] : new AST_Sequence({
-            expressions: exprs
-        });
-    }
-});
-
-var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator", {
+var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments", {
     $documentation: "Base class for functions",
     $propdoc: {
-        is_generator: "[boolean] is generatorFn or not",
         name: "[AST_SymbolDeclaration?] the name of this function",
-        argnames: "[AST_SymbolFunarg|AST_Destructuring|AST_Expansion|AST_DefaultAssign*] array of function arguments, destructurings, or expanding arguments",
+        argnames: "[AST_SymbolFunarg*] array of function 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);
@@ -467,78 +415,10 @@ 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", {
-    $documentation: "A destructuring of several names. Used in destructuring assignment and with destructuring function argument names",
-    $propdoc: {
-        "names": "[AST_Node*] Array of properties or elements",
-        "is_array": "[Boolean] Whether the destructuring represents an object or array"
-    },
-    _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, {
@@ -658,7 +538,7 @@ var AST_Try = DEFNODE("Try", "bcatch bfinally", {
 var AST_Catch = DEFNODE("Catch", "argname", {
     $documentation: "A `catch` node; only makes sense as part of a `try` statement",
     $propdoc: {
-        argname: "[AST_SymbolCatch|AST_Destructuring|AST_Expansion|AST_DefaultAssign] symbol for the exception"
+        argname: "[AST_SymbolCatch] symbol for the exception"
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
@@ -693,75 +573,14 @@ 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 exported_names module_name", {
-    $documentation: "An `export` statement",
-    $propdoc: {
-        exported_definition: "[AST_Defun|AST_Definitions|AST_DefClass?] An exported definition",
-        exported_value: "[AST_Node?] An exported value",
-        exported_names: "[AST_NameImport*?] List of exported names",
-        module_name: "[AST_String?] Name of the file to load exports from",
-        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|AST_SymbolConst|AST_Destructuring] name of the variable",
+        name: "[AST_SymbolVar|AST_SymbolConst] name of the variable",
         value: "[AST_Node?] initializer, or null of there's no initializer"
     },
     _walk: function(visitor) {
@@ -782,11 +601,11 @@ var AST_Call = DEFNODE("Call", "expression args", {
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
+            this.expression._walk(visitor);
             var args = this.args;
             for (var i = 0, len = args.length; i < len; i++) {
                 args[i]._walk(visitor);
             }
-            this.expression._walk(visitor);
         });
     }
 });
@@ -795,16 +614,68 @@ var AST_New = DEFNODE("New", null, {
     $documentation: "An object instantiation.  Derives from a function call since it has exactly the same properties"
 }, AST_Call);
 
-var AST_Sequence = DEFNODE("Sequence", "expressions", {
-    $documentation: "A sequence expression (comma-separated expressions)",
+var AST_Seq = DEFNODE("Seq", "car cdr", {
+    $documentation: "A sequence expression (two comma-separated expressions)",
     $propdoc: {
-        expressions: "[AST_Node*] array of expressions (at least two)"
+        car: "[AST_Node] first element in sequence",
+        cdr: "[AST_Node] second element in sequence"
+    },
+    $cons: function(x, y) {
+        var seq = new AST_Seq(x);
+        seq.car = x;
+        seq.cdr = y;
+        return seq;
+    },
+    $from_array: function(array) {
+        if (array.length == 0) return null;
+        if (array.length == 1) return array[0].clone();
+        var list = null;
+        for (var i = array.length; --i >= 0;) {
+            list = AST_Seq.cons(array[i], list);
+        }
+        var p = list;
+        while (p) {
+            if (p.cdr && !p.cdr.cdr) {
+                p.cdr = p.cdr.car;
+                break;
+            }
+            p = p.cdr;
+        }
+        return list;
+    },
+    to_array: function() {
+        var p = this, a = [];
+        while (p) {
+            a.push(p.car);
+            if (p.cdr && !(p.cdr instanceof AST_Seq)) {
+                a.push(p.cdr);
+                break;
+            }
+            p = p.cdr;
+        }
+        return a;
+    },
+    add: function(node) {
+        var p = this;
+        while (p) {
+            if (!(p.cdr instanceof AST_Seq)) {
+                var cell = AST_Seq.cons(p.cdr, node);
+                return p.cdr = cell;
+            }
+            p = p.cdr;
+        }
+    },
+    len: function() {
+        if (this.cdr instanceof AST_Seq) {
+            return this.cdr.len() + 1;
+        } else {
+            return 2;
+        }
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            this.expressions.forEach(function(node) {
-                node._walk(visitor);
-            });
+            this.car._walk(visitor);
+            if (this.cdr) this.cdr._walk(visitor);
         });
     }
 });
@@ -857,7 +728,7 @@ var AST_UnaryPostfix = DEFNODE("UnaryPostfix", null, {
     $documentation: "Unary postfix expression, i.e. `i++`"
 }, AST_Unary);
 
-var AST_Binary = DEFNODE("Binary", "operator left right", {
+var AST_Binary = DEFNODE("Binary", "left operator right", {
     $documentation: "Binary expression, i.e. `a + b`",
     $propdoc: {
         left: "[AST_Node] left-hand side expression",
@@ -892,10 +763,6 @@ var AST_Assign = DEFNODE("Assign", null, {
     $documentation: "An assignment expression — `a = b + 5`",
 }, AST_Binary);
 
-var AST_DefaultAssign = DEFNODE("DefaultAssign", null, {
-    $documentation: "A default assignment expression like in `(a = 3) => a`"
-}, AST_Binary);
-
 /* -----[ LITERALS ]----- */
 
 var AST_Array = DEFNODE("Array", "elements", {
@@ -931,13 +798,11 @@ var AST_Object = DEFNODE("Object", "properties", {
 var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
     $documentation: "Base class for literal object properties",
     $propdoc: {
-        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",
+        key: "[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an AST_SymbolAccessor.",
         value: "[AST_Node] property value.  For setters and getters this is an AST_Accessor."
     },
     _walk: function(visitor) {
         return visitor._visit(this, function(){
-            if (this.key instanceof AST_Node)
-                this.key._walk(visitor);
             this.value._walk(visitor);
         });
     }
@@ -950,73 +815,26 @@ var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", {
     }
 }, AST_ObjectProperty);
 
-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)"
-    },
+var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
     $documentation: "An object setter property",
 }, AST_ObjectProperty);
 
-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)"
-    },
+var AST_ObjectGetter = DEFNODE("ObjectGetter", null, {
     $documentation: "An object getter property",
 }, AST_ObjectProperty);
 
-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", {
     $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"
     },
-    $documentation: "Base class for all symbols"
+    $documentation: "Base class for all symbols",
 });
 
-var AST_NewTarget = DEFNODE("NewTarget", null, {
-    $documentation: "A reference to new.target"
-});
+var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
+    $documentation: "The name of a property accessor (setter/getter function)"
+}, AST_Symbol);
 
 var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
     $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
@@ -1026,17 +844,9 @@ 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);
+}, AST_SymbolDeclaration);
 
 var AST_SymbolFunarg = DEFNODE("SymbolFunarg", null, {
     $documentation: "Symbol naming a function argument",
@@ -1046,33 +856,13 @@ 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_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);
+}, AST_SymbolDeclaration);
 
 var AST_Label = DEFNODE("Label", "references", {
     $documentation: "Symbol naming a label (declaration)",
@@ -1097,10 +887,6 @@ 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() {
@@ -1174,21 +960,6 @@ 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) {
@@ -1211,22 +982,17 @@ TreeWalker.prototype = {
     parent: function(n) {
         return this.stack[this.stack.length - 2 - (n || 0)];
     },
-    push: function(node) {
+    push: function (node) {
         if (node instanceof AST_Lambda) {
             this.directives = Object.create(this.directives);
         } else if (node instanceof AST_Directive && !this.directives[node.value]) {
             this.directives[node.value] = node;
-        } else if (node instanceof AST_Class) {
-            this.directives = Object.create(this.directives);
-            if (!this.directives["use strict"]) {
-                this.directives["use strict"] = node;
-            }
         }
         this.stack.push(node);
     },
     pop: function(node) {
         this.stack.pop();
-        if (node instanceof AST_Lambda || node instanceof AST_Class) {
+        if (node instanceof AST_Lambda) {
             this.directives = Object.getPrototypeOf(this.directives);
         }
     },
@@ -1244,7 +1010,7 @@ TreeWalker.prototype = {
         var dir = this.directives[type];
         if (dir) return dir;
         var node = this.stack[this.stack.length - 1];
-        if (node instanceof AST_Scope && node.body) {
+        if (node instanceof AST_Scope) {
             for (var i = 0; i < node.body.length; ++i) {
                 var st = node.body[i];
                 if (!(st instanceof AST_Directive)) break;

lib/minify.js

@@ -1,156 +0,0 @@
-"use strict";
-
-var to_ascii = typeof atob == "undefined" ? function(b64) {
-    return new Buffer(b64, "base64").toString();
-} : atob;
-var to_base64 = typeof btoa == "undefined" ? function(str) {
-    return new Buffer(str).toString("base64");
-} : btoa;
-
-function read_source_map(code) {
-    var match = /\n\/\/# sourceMappingURL=data:application\/json(;.*?)?;base64,(.*)/.exec(code);
-    if (!match) {
-        AST_Node.warn("inline source map not found");
-        return null;
-    }
-    return to_ascii(match[2]);
-}
-
-function set_shorthand(name, options, keys) {
-    if (options[name]) {
-        keys.forEach(function(key) {
-            if (options[key]) {
-                if (typeof options[key] != "object") options[key] = {};
-                if (!(name in options[key])) options[key][name] = options[name];
-            }
-        });
-    }
-}
-
-function minify(files, options) {
-    var warn_function = AST_Node.warn_function;
-    try {
-        if (typeof files == "string") {
-            files = [ files ];
-        }
-        options = defaults(options, {
-            compress: {},
-            ie8: false,
-            keep_fnames: false,
-            mangle: {},
-            output: {},
-            parse: {},
-            sourceMap: false,
-            toplevel: false,
-            warnings: false,
-            wrap: false,
-        }, true);
-        set_shorthand("ie8", options, [ "compress", "mangle", "output" ]);
-        set_shorthand("keep_fnames", options, [ "compress", "mangle" ]);
-        set_shorthand("toplevel", options, [ "compress", "mangle" ]);
-        set_shorthand("warnings", options, [ "compress" ]);
-        if (options.mangle) {
-            options.mangle = defaults(options.mangle, {
-                cache: null,
-                eval: false,
-                ie8: false,
-                keep_classnames: false,
-                keep_fnames: false,
-                properties: false,
-                reserved: [],
-                safari10: false,
-                toplevel: false,
-            }, true);
-        }
-        if (options.sourceMap) {
-            options.sourceMap = defaults(options.sourceMap, {
-                content: null,
-                filename: null,
-                includeSources: false,
-                root: null,
-                url: null,
-            }, true);
-        }
-        var warnings = [];
-        if (options.warnings && !AST_Node.warn_function) {
-            AST_Node.warn_function = function(warning) {
-                warnings.push(warning);
-            };
-        }
-        var toplevel;
-        if (files instanceof AST_Toplevel) {
-            toplevel = files;
-        } else {
-            options.parse = options.parse || {};
-            options.parse.toplevel = null;
-            for (var name in files) {
-                options.parse.filename = name;
-                options.parse.toplevel = parse(files[name], options.parse);
-                if (options.sourceMap && options.sourceMap.content == "inline") {
-                    if (Object.keys(files).length > 1)
-                        throw new Error("inline source map only works with singular input");
-                    options.sourceMap.content = read_source_map(files[name]);
-                }
-            }
-            toplevel = options.parse.toplevel;
-        }
-        if (options.wrap) {
-            toplevel = toplevel.wrap_commonjs(options.wrap);
-        }
-        if (options.compress) {
-            toplevel.figure_out_scope(options.mangle);
-            toplevel = new Compressor(options.compress).compress(toplevel);
-        }
-        if (options.mangle) {
-            toplevel.figure_out_scope(options.mangle);
-            base54.reset();
-            toplevel.compute_char_frequency(options.mangle);
-            toplevel.mangle_names(options.mangle);
-            if (options.mangle.properties) {
-                toplevel = mangle_properties(toplevel, options.mangle.properties);
-            }
-        }
-        var result = {};
-        if (options.output.ast) {
-            result.ast = toplevel;
-        }
-        if (!HOP(options.output, "code") || options.output.code) {
-            if (options.sourceMap) {
-                if (typeof options.sourceMap.content == "string") {
-                    options.sourceMap.content = JSON.parse(options.sourceMap.content);
-                }
-                options.output.source_map = SourceMap({
-                    file: options.sourceMap.filename,
-                    orig: options.sourceMap.content,
-                    root: options.sourceMap.root
-                });
-                if (options.sourceMap.includeSources) {
-                    for (var name in files) {
-                        options.output.source_map.get().setSourceContent(name, files[name]);
-                    }
-                }
-            }
-            delete options.output.ast;
-            delete options.output.code;
-            var stream = OutputStream(options.output);
-            toplevel.print(stream);
-            result.code = stream.get();
-            if (options.sourceMap) {
-                result.map = options.output.source_map.toString();
-                if (options.sourceMap.url == "inline") {
-                    result.code += "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64," + to_base64(result.map);
-                } else if (options.sourceMap.url) {
-                    result.code += "\n//# sourceMappingURL=" + options.sourceMap.url;
-                }
-            }
-        }
-        if (warnings.length) {
-            result.warnings = warnings;
-        }
-        return result;
-    } catch (ex) {
-        return { error: ex };
-    } finally {
-        AST_Node.warn_function = warn_function;
-    }
-}

lib/mozilla-ast.js

@@ -118,7 +118,7 @@
                 value    : from_moz(M.value)
             };
             if (M.kind == "init") return new AST_ObjectKeyVal(args);
-            args.key = new AST_SymbolMethod({
+            args.key = new AST_SymbolAccessor({
                 name: args.key
             });
             args.value = new AST_Accessor(args.value);
@@ -145,11 +145,7 @@
             });
         },
         SequenceExpression: function(M) {
-            return new AST_Sequence({
-                start      : my_start_token(M),
-                end        : my_end_token(M),
-                expressions: M.expressions.map(from_moz)
-            });
+            return AST_Seq.from_array(M.expressions.map(from_moz));
         },
         MemberExpression: function(M) {
             return new (M.computed ? AST_Sub : AST_Dot)({
@@ -329,10 +325,10 @@
         };
     });
 
-    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)
         };
     });
 
@@ -381,7 +377,7 @@
     def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
         var key = {
             type: "Literal",
-            value: M.key instanceof AST_SymbolMethod ? M.key.name : M.key
+            value: M.key instanceof AST_SymbolAccessor ? M.key.name : M.key
         };
         var kind;
         if (M instanceof AST_ObjectKeyVal) {

lib/output.js

@@ -54,12 +54,9 @@ function OutputStream(options) {
 
     options = defaults(options, {
         ascii_only       : false,
-        ascii_identifiers: undefined,
         beautify         : false,
         bracketize       : false,
         comments         : false,
-        ecma             : 5,
-        ie8              : false,
         indent_level     : 4,
         indent_start     : 0,
         inline_script    : true,
@@ -69,20 +66,16 @@ function OutputStream(options) {
         preserve_line    : false,
         quote_keys       : false,
         quote_style      : 0,
+        screw_ie8        : true,
         semicolons       : true,
         shebang          : true,
-        shorthand        : undefined,
         source_map       : null,
+        space_colon      : true,
+        unescape_regexps : false,
         width            : 80,
         wrap_iife        : false,
     }, true);
 
-    if (typeof options.ascii_identifiers === 'undefined')
-        options.ascii_identifiers = options.ascii_only;
-
-    if (options.shorthand === undefined)
-        options.shorthand = options.ecma > 5;
-
     // Convert comment option to RegExp if neccessary and set up comments filter
     var comment_filter = return_false; // Default case, throw all comments away
     if (options.comments) {
@@ -118,19 +111,9 @@ function OutputStream(options) {
     var OUTPUT = "";
 
     function to_ascii(str, identifier) {
-        return str.replace(/[\ud800-\udbff][\udc00-\udfff]|[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
-            var code = get_full_char_code(ch, 0).toString(16);
-
-            if ((identifier && code.length === 1 && options.ecma >= 6) || code.length > 4) {
-                if (options.ecma < 6) {
-                    if (identifier) {
-                        return ch; // no \u{} support
-                    }
-                    return "\\u" + ch.charCodeAt(0).toString(16) + "\\u"
-                        + ch.charCodeAt(1).toString(16);
-                }
-                return "\\u{" + code + "}";
-            } else if (code.length <= 2 && !identifier) {
+        return str.replace(/[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
+            var code = ch.charCodeAt(0).toString(16);
+            if (code.length <= 2 && !identifier) {
                 while (code.length < 2) code = "0" + code;
                 return "\\x" + code;
             } else {
@@ -153,12 +136,12 @@ function OutputStream(options) {
               case "\t": return "\\t";
               case "\b": return "\\b";
               case "\f": return "\\f";
-              case "\x0B": return options.ie8 ? "\\x0B" : "\\v";
+              case "\x0B": return options.screw_ie8 ? "\\v" : "\\x0B";
               case "\u2028": return "\\u2028";
               case "\u2029": return "\\u2029";
               case "\ufeff": return "\\ufeff";
               case "\0":
-                  return /[0-7]/.test(get_full_char(str, i+1)) ? "\\x00" : "\\0";
+                  return /[0-7]/.test(str.charAt(i+1)) ? "\\x00" : "\\0";
             }
             return s;
         });
@@ -168,11 +151,7 @@ function OutputStream(options) {
         function quote_double() {
             return '"' + str.replace(/\x22/g, '\\"') + '"';
         }
-        function quote_template() {
-            return '`' + str.replace(/`/g, '\\`') + '`';
-        }
         if (options.ascii_only) str = to_ascii(str);
-        if (quote === "`") return quote_template();
         switch (options.quote_style) {
           case 1:
             return quote_single();
@@ -197,7 +176,7 @@ function OutputStream(options) {
 
     function make_name(name) {
         name = name.toString();
-        if (options.ascii_identifiers)
+        if (options.ascii_only)
             name = to_ascii(name, true);
         return name;
     };
@@ -234,8 +213,8 @@ function OutputStream(options) {
 
     function print(str) {
         str = String(str);
-        var ch = get_full_char(str, 0);
-        var prev = get_full_char(last, last.length - 1);
+        var ch = str.charAt(0);
+        var prev = last.charAt(last.length - 1);
         if (might_need_semicolon) {
             might_need_semicolon = false;
 
@@ -299,10 +278,6 @@ function OutputStream(options) {
         last = str;
     };
 
-    var star = function(){
-        print("*");
-    }
-
     var space = options.beautify ? function() {
         print(" ");
     } : function() {
@@ -382,7 +357,7 @@ function OutputStream(options) {
 
     function colon() {
         print(":");
-        space();
+        if (options.space_colon) space();
     };
 
     var add_mapping = options.source_map ? function(token, name) {
@@ -422,7 +397,6 @@ function OutputStream(options) {
         should_break    : function() { return options.width && this.current_width() >= options.width },
         newline         : newline,
         print           : print,
-        star            : star,
         space           : space,
         comma           : comma,
         colon           : colon,
@@ -442,10 +416,6 @@ function OutputStream(options) {
             }
             print(encoded);
         },
-        print_template_string_chars: function(str) {
-            var encoded = encode_string(str, '`').replace(/\${/g, "\\${");
-            return print(encoded.substr(1, encoded.length - 2));
-        },
         encode_string   : encode_string,
         next_indent     : next_indent,
         with_indent     : with_indent,
@@ -606,11 +576,6 @@ function OutputStream(options) {
         return false;
     });
 
-    PARENS(AST_Arrow, function(output){
-        var p = output.parent();
-        return p instanceof AST_PropAccess && p.expression === this;
-    });
-
     // same goes for an object literal, because otherwise it would be
     // interpreted as a block of code.
     PARENS(AST_Object, function(output){
@@ -620,28 +585,20 @@ function OutputStream(options) {
     PARENS(AST_Unary, function(output){
         var p = output.parent();
         return p instanceof AST_PropAccess && p.expression === this
-            || p instanceof AST_Call && p.expression === this
-            || p instanceof AST_Binary
-                && p.operator === "**"
-                && this instanceof AST_UnaryPrefix
-                && p.left === this
-                && this.operator !== "++"
-                && this.operator !== "--";
+            || p instanceof AST_Call && p.expression === this;
     });
 
-    PARENS(AST_Sequence, function(output){
+    PARENS(AST_Seq, function(output){
         var p = output.parent();
-        return p instanceof AST_Call                          // (foo, bar)() or foo(1, (2, 3), 4)
-            || p instanceof AST_Unary                         // !(foo, bar, baz)
-            || p instanceof AST_Binary                        // 1 + (2, 3) + 4 ==> 8
-            || p instanceof AST_VarDef                        // var a = (1, 2), b = a + a; ==> b == 4
-            || p instanceof AST_PropAccess                    // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
-            || p instanceof AST_Array                         // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
-            || p instanceof AST_ObjectProperty                // { foo: (1, 2) }.foo ==> 2
-            || p instanceof AST_Conditional                   /* (false, true) ? (a = 10, b = 20) : (c = 30)
-                                                               * ==> 20 (side effect, set a := 10 and b := 20) */
-            || p instanceof AST_Arrow                         // x => (x, x)
-            || p instanceof AST_DefaultAssign                 // x => (x = (0, function(){}))
+        return p instanceof AST_Call             // (foo, bar)() or foo(1, (2, 3), 4)
+            || p instanceof AST_Unary            // !(foo, bar, baz)
+            || p instanceof AST_Binary           // 1 + (2, 3) + 4 ==> 8
+            || p instanceof AST_VarDef           // var a = (1, 2), b = a + a; ==> b == 4
+            || p instanceof AST_PropAccess       // (1, {foo:2}).foo or (1, {foo:2})["foo"] ==> 2
+            || p instanceof AST_Array            // [ 1, (2, 3), 4 ] ==> [ 1, 3, 4 ]
+            || p instanceof AST_ObjectProperty   // { foo: (1, 2) }.foo ==> 2
+            || p instanceof AST_Conditional      /* (false, true) ? (a = 10, b = 20) : (c = 30)
+                                                  * ==> 20 (side effect, set a := 10 and b := 20) */
         ;
     });
 
@@ -668,24 +625,6 @@ function OutputStream(options) {
         }
     });
 
-    PARENS(AST_Yield, function(output){
-        var p = output.parent();
-        // (yield 1) + (yield 2)
-        // a = yield 3
-        if (p instanceof AST_Binary && p.operator !== "=")
-            return true;
-        // (yield 1) ? yield 2 : yield 3
-        if (p instanceof AST_Conditional && p.condition === this)
-            return true;
-        // -(yield 4)
-        if (p instanceof AST_Unary)
-            return true;
-        // (yield x).foo
-        // (yield x)['foo']
-        if (p instanceof AST_PropAccess && p.expression === this)
-            return true;
-    });
-
     PARENS(AST_PropAccess, function(output){
         var p = output.parent();
         if (p instanceof AST_New && p.expression === this) {
@@ -738,7 +677,7 @@ function OutputStream(options) {
         }
     });
 
-    PARENS([ AST_Assign, AST_Conditional ], function(output){
+    PARENS([ AST_Assign, AST_Conditional ], function (output){
         var p = output.parent();
         // !(a = false) → true
         if (p instanceof AST_Unary)
@@ -755,9 +694,6 @@ function OutputStream(options) {
         // (a = foo)["prop"] —or— (a = foo).prop
         if (p instanceof AST_PropAccess && p.expression === this)
             return true;
-        // ({a, b} = {a: 1, b: 2}), a destructuring assignment
-        if (this instanceof AST_Assign && this.left instanceof AST_Destructuring && this.left.is_array === false)
-            return true;
     });
 
     /* -----[ PRINTERS ]----- */
@@ -766,28 +702,6 @@ function OutputStream(options) {
         output.print_string(self.value, self.quote);
         output.semicolon();
     });
-
-    DEFPRINT(AST_Expansion, function (self, output) {
-        output.print('...');
-        self.expression.print(output);
-    });
-
-    DEFPRINT(AST_Destructuring, function (self, output) {
-        output.print(self.is_array ? "[" : "{");
-        var first = true;
-        var len = self.names.length;
-        self.names.forEach(function (name, i) {
-            if (first) first = false; else { output.comma(); output.space(); }
-            name.print(output);
-            // If the final element is a hole, we need to make sure it
-            // doesn't look like a trailing comma, by inserting an actual
-            // trailing comma.
-            if (i === len - 1 && name instanceof AST_Hole)
-              output.comma();
-        })
-        output.print(self.is_array ? "]" : "}");
-    });
-
     DEFPRINT(AST_Debugger, function(self, output){
         output.print("debugger");
         output.semicolon();
@@ -912,11 +826,7 @@ function OutputStream(options) {
         output.with_parens(function(){
             self.init.print(output);
             output.space();
-            if (self instanceof AST_ForOf) {
-                output.print("of");
-            } else {
-                output.print("in");
-            }
+            output.print("in");
             output.space();
             self.object.print(output);
         });
@@ -938,19 +848,10 @@ function OutputStream(options) {
         var self = this;
         if (!nokeyword) {
             output.print("function");
-            if (this.is_generator) {
-                output.star();
-            }
-            if (self.name) {
-                output.space();
-            }
         }
-        if (self.name instanceof AST_Symbol) {
+        if (self.name) {
+            output.space();
             self.name.print(output);
-        } else if (nokeyword && self.name instanceof AST_Node) {
-            output.with_square(function() {
-                self.name.print(output); // Computed method name
-            });
         }
         output.with_parens(function(){
             self.argnames.forEach(function(arg, i){
@@ -965,56 +866,6 @@ function OutputStream(options) {
         self._do_print(output);
     });
 
-    DEFPRINT(AST_PrefixedTemplateString, function(self, output) {
-        self.prefix.print(output);
-        self.template_string.print(output);
-    });
-    DEFPRINT(AST_TemplateString, function(self, output) {
-        var is_tagged = output.parent() instanceof AST_PrefixedTemplateString;
-
-        output.print("`");
-        for (var i = 0; i < self.segments.length; i++) {
-            if (!(self.segments[i] instanceof AST_TemplateSegment)) {
-                output.print("${");
-                self.segments[i].print(output);
-                output.print("}");
-            } else if (is_tagged) {
-                output.print(self.segments[i].raw);
-            } else {
-                output.print_template_string_chars(self.segments[i].value);
-            }
-        }
-        output.print("`");
-    });
-
-    AST_Arrow.DEFMETHOD("_do_print", function(output){
-        var self = this;
-        var parent = output.parent();
-        var needs_parens = parent instanceof AST_Binary ||
-            parent instanceof AST_Unary ||
-            (parent instanceof AST_Call && self === parent.expression);
-        if (needs_parens) { output.print("(") }
-        if (self.argnames.length === 1 && self.argnames[0] instanceof AST_Symbol) {
-            self.argnames[0].print(output);
-        } else {
-            output.with_parens(function(){
-                self.argnames.forEach(function(arg, i){
-                    if (i) output.comma();
-                    arg.print(output);
-                });
-            });
-        }
-        output.space();
-        output.print('=>');
-        output.space();
-        if (self.body instanceof AST_Node) {
-            this.body.print(output);
-        } else {
-            print_bracketed(this.body, output);
-        }
-        if (needs_parens) { output.print(")") }
-    });
-
     /* -----[ exits ]----- */
     AST_Exit.DEFMETHOD("_do_print", function(output, kind){
         output.print(kind);
@@ -1031,17 +882,6 @@ function OutputStream(options) {
         self._do_print(output, "throw");
     });
 
-    /* -----[ yield ]----- */
-
-    DEFPRINT(AST_Yield, function(self, output){
-        var star = self.is_star ? "*" : "";
-        output.print("yield" + star);
-        if (self.expression) {
-            output.space();
-            self.expression.print(output);
-        }
-    });
-
     /* -----[ loop control ]----- */
     AST_LoopControl.DEFMETHOD("_do_print", function(output, kind){
         output.print(kind);
@@ -1062,7 +902,7 @@ function OutputStream(options) {
     function make_then(self, output) {
         var b = self.body;
         if (output.option("bracketize")
-            || output.option("ie8") && b instanceof AST_Do)
+            || !output.option("screw_ie8") && b instanceof AST_Do)
             return make_block(b, output);
         // The squeezer replaces "block"-s that contain only a single
         // statement with the statement itself; technically, the AST
@@ -1190,107 +1030,12 @@ function OutputStream(options) {
         if (!avoid_semicolon)
             output.semicolon();
     });
-    DEFPRINT(AST_Let, function(self, output){
-        self._do_print(output, "let");
-    });
     DEFPRINT(AST_Var, function(self, output){
         self._do_print(output, "var");
     });
     DEFPRINT(AST_Const, function(self, output){
         self._do_print(output, "const");
     });
-    DEFPRINT(AST_Import, function(self, output) {
-        output.print("import");
-        output.space();
-        if (self.imported_name) {
-            self.imported_name.print(output);
-        }
-        if (self.imported_name && self.imported_names) {
-            output.print(",");
-            output.space();
-        }
-        if (self.imported_names) {
-            if (self.imported_names.length === 1 && self.imported_names[0].foreign_name.name === "*") {
-                self.imported_names[0].print(output);
-            } else {
-                output.print("{");
-                self.imported_names.forEach(function (name_import, i) {
-                    output.space();
-                    name_import.print(output);
-                    if (i < self.imported_names.length - 1) {
-                        output.print(",");
-                        output.space();
-                    }
-                });
-                output.space();
-                output.print("}");
-            }
-        }
-        if (self.imported_name || self.imported_names) {
-            output.space();
-            output.print("from")
-            output.space();
-        }
-        self.module_name.print(output);
-        output.semicolon();
-    });
-
-    DEFPRINT(AST_NameImport, function(self, output) {
-        var definition = self.name.definition();
-        var names_are_different =
-            (definition && definition.mangled_name || self.name.name) !==
-            self.foreign_name.name;
-        if (names_are_different) {
-            output.print(self.foreign_name.name);
-            output.space();
-            output.print("as");
-            output.space();
-            self.name.print(output);
-        } else {
-            self.name.print(output);
-        }
-    });
-
-    DEFPRINT(AST_Export, function(self, output) {
-        output.print("export");
-        output.space();
-        if (self.is_default) {
-            output.print("default");
-            output.space();
-        }
-        if (self.exported_names) {
-            output.space();
-
-            if (self.exported_names.length === 1 && self.exported_names[0].name.name === "*") {
-                self.exported_names[0].print(output);
-            } else {
-                output.print("{");
-                self.exported_names.forEach(function (name_import, i) {
-                    output.space();
-                    name_import.print(output);
-                    if (i < self.exported_names.length - 1) {
-                        output.print(",");
-                        output.space();
-                    }
-                });
-                output.space();
-                output.print("}");
-            }
-            output.space();
-        }
-        else if (self.exported_value) {
-            self.exported_value.print(output);
-        } else if (self.exported_definition) {
-            self.exported_definition.print(output);
-        }
-        if (self.module_name) {
-            output.space();
-            output.print("from");
-            output.space();
-            self.module_name.print(output);
-        }
-        output.semicolon();
-    });
 
     function parenthesize_for_noin(node, output, noin) {
         if (!noin) node.print(output);
@@ -1338,19 +1083,18 @@ function OutputStream(options) {
         AST_Call.prototype._codegen(self, output);
     });
 
-    AST_Sequence.DEFMETHOD("_do_print", function(output){
-        this.expressions.forEach(function(node, index) {
-            if (index > 0) {
-                output.comma();
-                if (output.should_break()) {
-                    output.newline();
-                    output.indent();
-                }
+    AST_Seq.DEFMETHOD("_do_print", function(output){
+        this.car.print(output);
+        if (this.cdr) {
+            output.comma();
+            if (output.should_break()) {
+                output.newline();
+                output.indent();
             }
-            node.print(output);
-        });
+            this.cdr.print(output);
+        }
     });
-    DEFPRINT(AST_Sequence, function(self, output){
+    DEFPRINT(AST_Seq, function(self, output){
         self._do_print(output);
         // var p = output.parent();
         // if (p instanceof AST_Statement) {
@@ -1463,49 +1207,9 @@ function OutputStream(options) {
         });
         else output.print("{}");
     });
-    DEFPRINT(AST_Class, function(self, output){
-        output.print("class");
-        output.space();
-        if (self.name) {
-            self.name.print(output);
-            output.space();
-        }
-        if (self.extends) {
-            var parens = (
-                   !(self.extends instanceof AST_SymbolRef)
-                && !(self.extends instanceof AST_PropAccess)
-                && !(self.extends instanceof AST_ClassExpression)
-                && !(self.extends instanceof AST_Function)
-            );
-            output.print("extends");
-            if (parens) {
-                output.print("(");
-            } else {
-                output.space();
-            }
-            self.extends.print(output);
-            if (parens) {
-                output.print(")");
-            } else {
-                output.space();
-            }
-        }
-        if (self.properties.length > 0) output.with_block(function(){
-            self.properties.forEach(function(prop, i){
-                if (i) {
-                    output.newline();
-                }
-                output.indent();
-                prop.print(output);
-            });
-            output.newline();
-        });
-        else output.print("{}");
-    });
-    DEFPRINT(AST_NewTarget, function(self, output) {
-        output.print("new.target");
-    });
-    AST_ObjectProperty.DEFMETHOD("print_property_name", function(key, quote, output) {
+    DEFPRINT(AST_ObjectKeyVal, function(self, output){
+        var key = self.key;
+        var quote = self.quote;
         if (output.option("quote_keys")) {
             output.print_string(key + "");
         } else if ((typeof key == "number"
@@ -1513,7 +1217,7 @@ function OutputStream(options) {
                     && +key + "" == key)
                    && parseFloat(key) >= 0) {
             output.print(make_num(key));
-        } else if (RESERVED_WORDS(key) ? !output.option("ie8") : is_identifier_string(key)) {
+        } else if (RESERVED_WORDS(key) ? output.option("screw_ie8") : is_identifier_string(key)) {
             if (quote && output.option("keep_quoted_props")) {
                 output.print_string(key, quote);
             } else {
@@ -1522,98 +1226,29 @@ function OutputStream(options) {
         } else {
             output.print_string(key, quote);
         }
-    });
-    DEFPRINT(AST_ObjectKeyVal, function(self, output){
-        function get_name(self) {
-            var def = self.definition();
-            return def ? def.mangled_name || def.name : self.name;
-        }
-
-        var allowShortHand = output.option("shorthand");
-        if (allowShortHand &&
-            self.value instanceof AST_Symbol &&
-            is_identifier_string(self.key) &&
-            get_name(self.value) === self.key
-        ) {
-            self.print_property_name(self.key, self.quote, output);
-
-        } else if (allowShortHand &&
-            self.value instanceof AST_DefaultAssign &&
-            self.value.left instanceof AST_Symbol &&
-            is_identifier_string(self.key) &&
-            get_name(self.value.left) === self.key
-        ) {
-            self.print_property_name(self.key, self.quote, output);
-            output.print("=");
-            self.value.right.print(output);
-        } else {
-            if (!(self.key instanceof AST_Node)) {
-                self.print_property_name(self.key, self.quote, output);
-            } else {
-                output.with_square(function() {
-                    self.key.print(output);
-                });
-            }
-            output.colon();
-            self.value.print(output);
-        }
-    });
-    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, self, output) {
-        if (self.static) {
-            output.print("static");
-            output.space();
-        }
-        output.print(type);
-        output.space();
-        if (self.key instanceof AST_SymbolMethod) {
-            self.print_property_name(self.key.name, self.quote, output);
-        } else {
-            output.with_square(function() {
-                self.key.print(output);
-            });
-        }
-        self.value._do_print(output, true);
+        output.colon();
+        self.value.print(output);
     });
     DEFPRINT(AST_ObjectSetter, function(self, output){
-        self._print_getter_setter("set", self, output);
-    });
-    DEFPRINT(AST_ObjectGetter, function(self, output){
-        self._print_getter_setter("get", self, output);
-    });
-    DEFPRINT(AST_ConciseMethod, function(self, output){
-        if (self.static) {
-            output.print("static");
-            output.space();
-        }
-        if (self.is_generator) {
-            output.print("*");
-        }
-        if (self.key instanceof AST_SymbolMethod) {
-            self.print_property_name(self.key.name, self.quote, output);
-        } else {
-            output.with_square(function() {
-                self.key.print(output);
-            });
-        }
+        output.print("set");
+        output.space();
+        self.key.print(output);
         self.value._do_print(output, true);
     });
-    AST_Symbol.DEFMETHOD("_do_print", function(output){
-        var def = this.definition();
-        output.print_name(def ? def.mangled_name || def.name : this.name);
+    DEFPRINT(AST_ObjectGetter, function(self, output){
+        output.print("get");
+        output.space();
+        self.key.print(output);
+        self.value._do_print(output, true);
     });
-    DEFPRINT(AST_Symbol, function (self, output) {
-        self._do_print(output);
-    });
-    DEFPRINT(AST_SymbolDeclaration, function(self, output){
-        self._do_print(output);
+    DEFPRINT(AST_Symbol, function(self, output){
+        var def = self.definition();
+        output.print_name(def ? def.mangled_name || def.name : self.name);
     });
     DEFPRINT(AST_Hole, noop);
     DEFPRINT(AST_This, function(self, output){
         output.print("this");
     });
-    DEFPRINT(AST_Super, function(self, output){
-        output.print("super");
-    });
     DEFPRINT(AST_Constant, function(self, output){
         output.print(self.getValue());
     });
@@ -1628,14 +1263,45 @@ function OutputStream(options) {
         }
     });
 
+    function regexp_safe_literal(code) {
+        return [
+            0x5c   , // \
+            0x2f   , // /
+            0x2e   , // .
+            0x2b   , // +
+            0x2a   , // *
+            0x3f   , // ?
+            0x28   , // (
+            0x29   , // )
+            0x5b   , // [
+            0x5d   , // ]
+            0x7b   , // {
+            0x7d   , // }
+            0x24   , // $
+            0x5e   , // ^
+            0x3a   , // :
+            0x7c   , // |
+            0x21   , // !
+            0x0a   , // \n
+            0x0d   , // \r
+            0x00   , // \0
+            0xfeff , // Unicode BOM
+            0x2028 , // unicode "line separator"
+            0x2029 , // unicode "paragraph separator"
+        ].indexOf(code) < 0;
+    };
+
     DEFPRINT(AST_RegExp, function(self, output){
-        var regexp = self.getValue();
-        var str = regexp.toString();
-        if (regexp.raw_source) {
-            str = "/" + regexp.raw_source + str.slice(str.lastIndexOf("/"));
-        }
+        var str = self.getValue().toString();
         if (output.option("ascii_only")) {
             str = output.to_ascii(str);
+        } else if (output.option("unescape_regexps")) {
+            str = str.split("\\\\").map(function(str){
+                return str.replace(/\\u[0-9a-fA-F]{4}|\\x[0-9a-fA-F]{2}/g, function(s){
+                    var code = parseInt(s.substr(2), 16);
+                    return regexp_safe_literal(code) ? String.fromCharCode(code) : s;
+                });
+            }).join("\\\\");
         }
         output.print(str);
         var p = output.parent();

lib/propmangle.js

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

lib/scope.js

@@ -49,9 +49,7 @@ 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.index = index;
     this.id = SymbolDef.next_id++;
@@ -64,17 +62,11 @@ 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_SymbolMethod
-            || (options.keep_classnames
-                && (this.orig[0] instanceof AST_SymbolClass
-                    || this.orig[0] instanceof AST_SymbolDefClass));
+                    || this.orig[0] instanceof AST_SymbolDefun));
     },
     mangle: function(options) {
         var cache = options.cache && options.cache.props;
@@ -84,7 +76,7 @@ SymbolDef.prototype = {
         else if (!this.mangled_name && !this.unmangleable(options)) {
             var s = this.scope;
             var sym = this.orig[0];
-            if (options.ie8 && sym instanceof AST_SymbolLambda)
+            if (!options.screw_ie8 && sym instanceof AST_SymbolLambda)
                 s = s.parent_scope;
             var def;
             if (this.defun && (def = this.defun.variables.get(this.name))) {
@@ -101,8 +93,7 @@ SymbolDef.prototype = {
 AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     options = defaults(options, {
         cache: null,
-        ie8: false,
-        safari10: false,
+        screw_ie8: true,
     });
 
     // pass 1: setup scope chaining and handle definitions
@@ -110,35 +101,15 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     var scope = self.parent_scope = null;
     var labels = new Dictionary();
     var defun = null;
-    var in_destructuring = null;
-    var in_export = false;
-    var in_block = 0;
-    var for_scopes = [];
     var tw = new TreeWalker(function(node, descend){
-        if (node.is_block_scope()) {
+        if (node instanceof AST_Catch) {
             var save_scope = scope;
             scope = new AST_Scope(node);
             scope.init_scope_vars(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;
-            }
-            if (options.safari10) {
-                if (node instanceof AST_For || node instanceof AST_ForIn) {
-                    for_scopes.push(scope);
-                }
-            }
             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;
@@ -152,22 +123,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             labels = save_labels;
             return true;        // don't descend again in TreeWalker
         }
-        if (node instanceof AST_Export) {
-            in_export = true;
-            descend();
-            in_export = false;
-            return true;
-        }
-        if (node instanceof AST_BlockStatement
-            || node instanceof AST_Switch
-            || node instanceof AST_Try
-            || node instanceof AST_Catch
-            || node instanceof AST_Finally) {
-            in_block++;
-            descend();
-            in_block--;
-            return true;
-        }
         if (node instanceof AST_LabeledStatement) {
             var l = node.label;
             if (labels.has(l.name)) {
@@ -186,15 +141,12 @@ 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;
-        }
         if (node instanceof AST_Label) {
             node.thedef = node;
             node.references = [];
         }
         if (node instanceof AST_SymbolLambda) {
-            defun.def_function(node, in_export, in_block);
+            defun.def_function(node);
         }
         else if (node instanceof AST_SymbolDefun) {
             // Careful here, the scope where this should be defined is
@@ -202,28 +154,11 @@ 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.
-            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, in_block);
-        }
-        else if (node instanceof AST_SymbolClass) {
-            defun.def_variable(node, in_export, in_block);
-        }
-        else if (node instanceof AST_SymbolImport) {
-            scope.def_variable(node, in_export, in_block);
-        }
-        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, in_block);
+            (node.scope = defun.parent_scope).def_function(node);
         }
         else if (node instanceof AST_SymbolVar
-            || node instanceof AST_SymbolLet
             || node instanceof AST_SymbolConst) {
-            var def = ((node instanceof AST_SymbolBlockDeclaration) ? scope : defun).def_variable(node, in_export, in_block);
-            def.destructuring = in_destructuring;
+            defun.def_variable(node);
             if (defun !== scope) {
                 node.mark_enclosed(options);
                 var def = scope.find_variable(node);
@@ -234,7 +169,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             }
         }
         else if (node instanceof AST_SymbolCatch) {
-            scope.def_variable(node, in_export, in_block).defun = defun;
+            scope.def_variable(node).defun = defun;
         }
         else if (node instanceof AST_LabelRef) {
             var sym = labels.get(node.name);
@@ -250,7 +185,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
 
     // pass 2: find back references and eval
     var func = null;
-    var cls = null;
     var globals = self.globals = new Dictionary();
     var tw = new TreeWalker(function(node, descend){
         if (node instanceof AST_Lambda) {
@@ -260,13 +194,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
             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;
@@ -293,7 +220,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
     self.walk(tw);
 
     // pass 3: fix up any scoping issue with IE8
-    if (options.ie8) {
+    if (!options.screw_ie8) {
         self.walk(new TreeWalker(function(node, descend) {
             if (node instanceof AST_SymbolCatch) {
                 var name = node.name;
@@ -310,19 +237,6 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options){
         }));
     }
 
-    // pass 4: add symbol definitions to loop scopes
-    // Safari/Webkit bug workaround - loop init let variable shadowing argument.
-    // https://github.com/mishoo/UglifyJS2/issues/1753
-    // https://bugs.webkit.org/show_bug.cgi?id=171041
-    if (options.safari10) {
-        for (var i = 0; i < for_scopes.length; i++) {
-            var scope = for_scopes[i];
-            scope.parent_scope.variables.each(function(def) {
-                push_uniq(scope.enclosed, def);
-            });
-        }
-    }
-
     if (options.cache) {
         this.cname = options.cache.cname;
     }
@@ -351,27 +265,10 @@ AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope){
     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_IterationStatement.DEFMETHOD("is_block_scope", function(){
-     return true;
-});
-
 AST_Lambda.DEFMETHOD("init_scope_vars", function(){
     AST_Scope.prototype.init_scope_vars.apply(this, arguments);
     this.uses_arguments = false;
-    this.def_variable(new AST_SymbolConst({
+    this.def_variable(new AST_SymbolVar({
         name: "arguments",
         start: this.start,
         end: this.end
@@ -404,24 +301,16 @@ AST_Scope.DEFMETHOD("find_variable", function(name){
         || (this.parent_scope && this.parent_scope.find_variable(name));
 });
 
-AST_Scope.DEFMETHOD("def_function", function(symbol, in_export, in_block){
-    this.functions.set(symbol.name, this.def_variable(symbol, in_export, in_block));
+AST_Scope.DEFMETHOD("def_function", function(symbol){
+    this.functions.set(symbol.name, this.def_variable(symbol));
 });
 
-AST_Scope.DEFMETHOD("def_variable", function(symbol, in_export, in_block){
+AST_Scope.DEFMETHOD("def_variable", function(symbol){
     var def;
     if (!this.variables.has(symbol.name)) {
         def = new SymbolDef(this, this.variables.size(), symbol);
         this.variables.set(symbol.name, def);
-        def.object_destructuring_arg = symbol.object_destructuring_arg;
-        if (in_export) {
-            def.export = true;
-        }
-        if (in_block && symbol instanceof AST_SymbolBlockDeclaration) {
-            def.global = false;
-        } else {
-            def.global = !this.parent_scope;
-        }
+        def.global = !this.parent_scope;
     } else {
         def = this.variables.get(symbol.name);
         def.orig.push(symbol);
@@ -436,8 +325,8 @@ AST_Scope.DEFMETHOD("next_mangled", function(options){
         if (!is_identifier(m)) continue; // skip over "do"
 
         // https://github.com/mishoo/UglifyJS2/issues/242 -- do not
-        // shadow a name reserved from mangling.
-        if (options.reserved.indexOf(m) >= 0) continue;
+        // shadow a name excepted from mangling.
+        if (options.except.indexOf(m) >= 0) continue;
 
         // we must ensure that the mangled name does not shadow a name
         // from some parent scope that is referenced in this or in
@@ -469,8 +358,7 @@ AST_Function.DEFMETHOD("next_mangled", function(options, def){
 });
 
 AST_Symbol.DEFMETHOD("unmangleable", function(options){
-    var def = this.definition();
-    return def && def.unmangleable(options);
+    return this.definition().unmangleable(options);
 });
 
 // labels are always mangleable
@@ -506,10 +394,10 @@ AST_Symbol.DEFMETHOD("global", function(){
 AST_Toplevel.DEFMETHOD("_default_mangler_options", function(options){
     return defaults(options, {
         eval        : false,
-        ie8         : false,
-        keep_classnames: false,
+        except      : [],
         keep_fnames : false,
-        reserved    : [],
+        screw_ie8   : true,
+        sort        : false, // Ignored. Flag retained for backwards compatibility.
         toplevel    : false,
     });
 });
@@ -518,7 +406,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
     options = this._default_mangler_options(options);
 
     // Never mangle arguments
-    options.reserved.push('arguments');
+    options.except.push('arguments');
 
     // We only need to mangle declaration nodes.  Special logic wired
     // into the code generator will display the mangled name if it's
@@ -529,7 +417,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
 
     if (options.cache) {
         this.globals.each(function(symbol){
-            if (options.reserved.indexOf(symbol.name) < 0) {
+            if (options.except.indexOf(symbol.name) < 0) {
                 to_mangle.push(symbol);
             }
         });
@@ -546,7 +434,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
         if (node instanceof AST_Scope) {
             var p = tw.parent(), a = [];
             node.variables.each(function(symbol){
-                if (options.reserved.indexOf(symbol.name) < 0) {
+                if (options.except.indexOf(symbol.name) < 0) {
                     a.push(symbol);
                 }
             });
@@ -559,19 +447,13 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options){
             node.mangled_name = name;
             return true;
         }
-        var mangle_with_block_scope =
-            (!options.ie8 && node instanceof AST_SymbolCatch) ||
-            node instanceof AST_SymbolBlockDeclaration;
-        if (mangle_with_block_scope) {
+        if (options.screw_ie8 && node instanceof AST_SymbolCatch) {
             to_mangle.push(node.definition());
             return;
         }
     });
     this.walk(tw);
-    to_mangle.forEach(function(def){
-        if (def.destructuring && !def.destructuring.is_array) return;
-        def.mangle(options);
-    });
+    to_mangle.forEach(function(def){ def.mangle(options) });
 
     if (options.cache) {
         options.cache.cname = this.cname;
@@ -622,27 +504,21 @@ AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options){
         else if (node instanceof AST_With)
             base54.consider("with");
         else if (node instanceof AST_ObjectSetter)
-            base54.consider("set" + (typeof node.key === "string" ? node.key : ""));
+            base54.consider("set" + 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("get" + node.key);
+        else if (node instanceof AST_ObjectKeyVal)
             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)
@@ -692,3 +568,89 @@ var base54 = (function() {
     };
     return base54;
 })();
+
+AST_Toplevel.DEFMETHOD("scope_warnings", function(options){
+    options = defaults(options, {
+        assign_to_global : true,
+        eval             : true,
+        func_arguments   : true,
+        nested_defuns    : true,
+        undeclared       : false, // this makes a lot of noise
+        unreferenced     : true,
+    });
+    var tw = new TreeWalker(function(node){
+        if (options.undeclared
+            && node instanceof AST_SymbolRef
+            && node.undeclared())
+        {
+            // XXX: this also warns about JS standard names,
+            // i.e. Object, Array, parseInt etc.  Should add a list of
+            // exceptions.
+            AST_Node.warn("Undeclared symbol: {name} [{file}:{line},{col}]", {
+                name: node.name,
+                file: node.start.file,
+                line: node.start.line,
+                col: node.start.col
+            });
+        }
+        if (options.assign_to_global)
+        {
+            var sym = null;
+            if (node instanceof AST_Assign && node.left instanceof AST_SymbolRef)
+                sym = node.left;
+            else if (node instanceof AST_ForIn && node.init instanceof AST_SymbolRef)
+                sym = node.init;
+            if (sym
+                && (sym.undeclared()
+                    || (sym.global() && sym.scope !== sym.definition().scope))) {
+                AST_Node.warn("{msg}: {name} [{file}:{line},{col}]", {
+                    msg: sym.undeclared() ? "Accidental global?" : "Assignment to global",
+                    name: sym.name,
+                    file: sym.start.file,
+                    line: sym.start.line,
+                    col: sym.start.col
+                });
+            }
+        }
+        if (options.eval
+            && node instanceof AST_SymbolRef
+            && node.undeclared()
+            && node.name == "eval") {
+            AST_Node.warn("Eval is used [{file}:{line},{col}]", node.start);
+        }
+        if (options.unreferenced
+            && (node instanceof AST_SymbolDeclaration || node instanceof AST_Label)
+            && !(node instanceof AST_SymbolCatch)
+            && node.unreferenced()) {
+            AST_Node.warn("{type} {name} is declared but not referenced [{file}:{line},{col}]", {
+                type: node instanceof AST_Label ? "Label" : "Symbol",
+                name: node.name,
+                file: node.start.file,
+                line: node.start.line,
+                col: node.start.col
+            });
+        }
+        if (options.func_arguments
+            && node instanceof AST_Lambda
+            && node.uses_arguments) {
+            AST_Node.warn("arguments used in function {name} [{file}:{line},{col}]", {
+                name: node.name ? node.name.name : "anonymous",
+                file: node.start.file,
+                line: node.start.line,
+                col: node.start.col
+            });
+        }
+        if (options.nested_defuns
+            && node instanceof AST_Defun
+            && !(tw.parent() instanceof AST_Scope)) {
+            AST_Node.warn("Function {name} declared in nested statement \"{type}\" [{file}:{line},{col}]", {
+                name: node.name.name,
+                type: tw.parent().TYPE,
+                file: node.start.file,
+                line: node.start.line,
+                col: node.start.col
+            });
+        }
+    });
+    this.walk(tw);
+});

lib/transform.js

@@ -163,18 +163,10 @@ 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);
-        if (self.body instanceof AST_Node) {
-            self.body = self.body.transform(tw);
-        } else {
-            self.body = do_list(self.body, tw);
-        }
+        self.body = do_list(self.body, tw);
     });
 
     _(AST_Call, function(self, tw){
@@ -182,8 +174,9 @@ TreeTransformer.prototype = new TreeWalker;
         self.args = do_list(self.args, tw);
     });
 
-    _(AST_Sequence, function(self, tw){
-        self.expressions = do_list(self.expressions, tw);
+    _(AST_Seq, function(self, tw){
+        self.car = self.car.transform(tw);
+        self.cdr = self.cdr.transform(tw);
     });
 
     _(AST_Dot, function(self, tw){
@@ -195,10 +188,6 @@ 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);
     });
@@ -223,36 +212,7 @@ 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_Export, function(self, tw){
-        if (self.exported_value) self.exported_value = self.exported_value.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

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

package.json

@@ -1,10 +1,10 @@
 {
-  "name": "uglify-es",
+  "name": "uglify-js",
   "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
-  "homepage": "https://github.com/mishoo/UglifyJS2/tree/harmony",
+  "homepage": "http://lisperator.net/uglifyjs",
   "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
   "license": "BSD-2-Clause",
-  "version": "3.0.9",
+  "version": "2.8.25",
   "engines": {
     "node": ">=0.8.0"
   },
@@ -29,13 +29,20 @@
     "LICENSE"
   ],
   "dependencies": {
-    "commander": "~2.9.0",
-    "source-map": "~0.5.1"
+    "source-map": "~0.5.1",
+    "yargs": "~3.10.0"
   },
   "devDependencies": {
     "acorn": "~5.0.3",
-    "mocha": "~2.3.4",
-    "semver": "~5.3.0"
+    "mocha": "~2.3.4"
+  },
+  "optionalDependencies": {
+    "uglify-to-browserify": "~1.0.0"
+  },
+  "browserify": {
+    "transform": [
+      "uglify-to-browserify"
+    ]
   },
   "scripts": {
     "test": "node test/run-tests.js"

test/benchmark.js

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

test/compress/angular-inject.js

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

test/compress/arrays.js

@@ -1,5 +1,3 @@
-// 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,,];
@@ -93,79 +91,6 @@ constant_join_2: {
     }
 }
 
-spread_with_variable_as_last_element: {
-    input: {
-        var values = [4, 5, 6];
-        var a = [1, 2, 3, ...values];
-    }
-    expect: {
-        var values = [4, 5, 6];
-        var a = [1, 2, 3, ...values];
-    }
-}
-
-spread_with_variable_in_middle: {
-    input: {
-        var values = [4, 5, 6];
-        var a = [1, 2, 3, ...values, 7,,,];
-    }
-    expect: {
-        var values = [4, 5, 6];
-        var a = [1, 2, 3, ...values, 7,,,];
-    }
-}
-
-spread_with_variable_at_front: {
-    input: {
-        var values = [1, 2, 3];
-        var a = [...values, 4, 5, 6];
-    }
-    expect: {
-        var values = [1, 2, 3];
-        var a = [...values, 4, 5, 6];
-    }
-}
-
-spread_with_variable_at_front_after_elisions: {
-    input: {
-        var values = [1, 2, 3];
-        var a = [,,,...values, 4, 5, 6];
-    }
-    expect: {
-        var values = [1, 2, 3];
-        var a = [,,,...values, 4, 5, 6];
-    }
-}
-
-spread_with_array_at_end: {
-    input: {
-        var a = [1, 2, ...[4, 5, 6]];
-    }
-    expect: {
-        var a = [1, 2, ...[4, 5, 6]];
-    }
-}
-
-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]
-    }
-}
-
 constant_join_3: {
     options = {
         unsafe: true,

test/compress/arrow.js

@@ -1,137 +0,0 @@
-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";'
-}
-
-arrow_with_regexp: {
-    input: {
-        num => /\d{11,14}/.test( num )
-    }
-    expect: {
-        num => /\d{11,14}/.test( num )
-    }
-}

test/compress/ascii.js

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

test/compress/block-scope.js

@@ -1,177 +0,0 @@
-
-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;
-        let ex;
-        const why;
-        class Zed {};
-        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/collapse_vars.js

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

test/compress/conditionals.js

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

test/compress/dead-code.js

@@ -90,28 +90,6 @@ dead_code_constant_boolean_should_warn_more: {
     expect_stdout: true
 }
 
-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,

test/compress/destructuring.js

@@ -1,332 +0,0 @@
-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: {
-    beautify = {
-        ecma: 6
-    }
-    input: {
-        var {cc,} = foo;
-    }
-    expect_exact: "var{cc}=foo;"
-}
-
-nested_destructuring_objects: {
-    beautify = {
-        ecma: 6
-    }
-    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: {
-    beautify = {
-        ecma: 6
-    }
-    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: {
-    beautify = {
-        ecma: 6
-    }
-    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: {
-    beautify = {
-        ecma: 6
-    }
-    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});"
-}
-
-destructuring_remove_unused_1: {
-    options = {
-        unused: true
-    }
-    input: {
-        function a() {
-            var unused = "foo";
-            var a = [1];
-            var [b] = a;
-            f(b);
-        }
-        function b() {
-            var unused = "foo";
-            var a = {b: 1};
-            var {b} = a;
-            f(b);
-        }
-        function c() {
-            var unused = "foo";
-            var a = [[1]];
-            var [[b]] = a;
-            f(b);
-        }
-        function d() {
-            var unused = "foo";
-            var a = {b: {b:1}};
-            var {b:{b}} = a;
-            f(b);
-        }
-        function e() {
-            var unused = "foo";
-            var a = [1, 2, 3, 4, 5];
-            var x = [[1, 2, 3]];
-            var y = {h: 1};
-            var [b, ...c] = a;
-            var [...[e, f]] = x;
-            var [...{g: h}] = y;
-            f(b, c, e, f, g);
-        }
-    }
-    expect: {
-        function a() {
-            var a = [1];
-            var [b] = a;
-            f(b);
-        }
-        function b() {
-            var a = {b: 1};
-            var {b} = a;
-            f(b);
-        }
-        function c() {
-            var a = [[1]];
-            var [[b]] = a;
-            f(b);
-        }
-        function d() {
-            var a = {b: {b:1}};
-            var {b:{b}} = a;
-            f(b);
-        }
-        function e() {
-            var a = [1, 2, 3, 4, 5];
-            var x = [[1, 2, 3]];
-            var y = {h: 1};
-            var [b, ...c] = a;
-            var [...[e, f]] = x;
-            var [...{g: h}] = y;
-            f(b, c, e, f, g);
-        }
-    }
-}
-
-destructuring_remove_unused_2: {
-    options = {
-        unused: true
-    }
-    input: {
-        function a() {
-            var unused = "foo";
-            var a = [,,1];
-            var [b] = a;
-            f(b);
-        }
-        function b() {
-            var unused = "foo";
-            var a = [{a: [1]}];
-            var [{b: a}] = a;
-            f(b);
-        }
-    }
-    expect: {
-        function a() {
-            var a = [,,1];
-            var [b] = a;
-            f(b);
-        }
-        function b() {
-            var a = [{a: [1]}];
-            var [{b: a}] = a;
-            f(b);
-        }
-    }
-}
-
-object_destructuring_may_need_parentheses: {
-    beautify = {
-        ecma: 6
-    }
-    input: {
-        ({a, b} = {a: 1, b: 2});
-    }
-    expect_exact: "({a,b}={a:1,b:2});"
-}
-
-destructuring_with_undefined_as_default_assignment: {
-    options = {
-        evaluate: true
-    }
-    input: {
-        [foo = undefined] = bar;
-        [foo = void 0] = bar;
-    }
-    expect: {
-        [foo] = bar;
-        [foo] = bar;
-    }
-}
-
-destructuring_dont_evaluate_with_undefined_as_default_assignment: {
-    options = {
-        evaluate: false
-    }
-    input: {
-        [foo = undefined] = bar;
-    }
-    expect: {
-        [foo = void 0] = bar;
-    }
-}
-
-reduce_vars: {
-    options = {
-        reduce_vars: true,
-    }
-    input: {
-        {const [aa, [bb, cc]] = dd;}
-        {let [aa, [bb, cc]] = dd;}
-        var [aa, [bb, cc]] = dd;
-        [aa, [bb, cc]] = dd;
-        {const {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
-        {let {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
-        var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
-        ({aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}});
-        const [{a},b] = c;
-        let [{a},b] = c;
-        var [{a},b] = c;
-        [{a},b] = c;
-        for (const [x,y] in pairs);
-        for (let [x,y] in pairs);
-        for (var [x,y] in pairs);
-        for ([x,y] in pairs);
-    }
-    expect: {
-        {const [aa, [bb, cc]] = dd;}
-        {let [aa, [bb, cc]] = dd;}
-        var [aa, [bb, cc]] = dd;
-        [aa, [bb, cc]] = dd;
-        {const {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
-        {let {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};}
-        var {aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}};
-        ({aa, bb: {cc, dd}} = {aa:1, bb: {cc:2, dd: 3}});
-        const [{a},b] = c;
-        let [{a},b] = c;
-        var [{a},b] = c;
-        [{a},b] = c;
-        for (const [x,y] in pairs);
-        for (let [x,y] in pairs);
-        for (var [x,y] in pairs);
-        for ([x,y] in pairs);
-    }
-}
-
-unused: {
-    options = {
-        unused: true,
-    }
-    input: {
-        let { foo: [, , ...a] } = { foo: [1, 2, 3, 4], bar: 5 };
-        console.log(a);
-    }
-    expect: {
-        let { foo: [, , ...a] } = { foo: [1, 2, 3, 4], bar: 5 };
-        console.log(a);
-    }
-}
-
-issue_1886: {
-    options = {
-        collapse_vars: true,
-    }
-    input: {
-        let [a] = [1];
-        console.log(a);
-    }
-    expect: {
-        let [a] = [1];
-        console.log(a);
-    }
-    expect_exact: "1"
-}

test/compress/directives.js

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

test/compress/drop-unused.js

@@ -164,87 +164,6 @@ used_var_in_catch: {
     }
 }
 
-unused_block_decls_in_catch: {
-    options = { unused: true };
-    input: {
-        function foo() {
-            try {
-                foo();
-            } catch(ex) {
-                let x = 10;
-                const y = 10;
-                class Zee {};
-            }
-        }
-    }
-    expect: {
-        function foo() {
-            try {
-                foo();
-            } catch(ex) {}
-        }
-    }
-}
-
-used_block_decls_in_catch: {
-    options = { unused: true };
-    input: {
-        function foo() {
-            try {
-                foo();
-            } catch(ex) {
-                let x = 10;
-                const y = 10;
-                class Zee {};
-            }
-            console.log(x, y, Zee);
-        }
-    }
-    expect: {
-        function foo() {
-            try {
-                foo();
-            } catch(ex) {}
-            console.log(x, y, Zee);
-        }
-    }
-}
-
-unused_block_decls: {
-    options = { unused: true };
-    input: {
-        function foo() {
-            {
-                const x;
-            }
-            {
-                let y;
-            }
-            console.log(x, y);
-        }
-    }
-    expect: {
-        function foo() {
-            console.log(x, y);
-        }
-    }
-}
-
-unused_keep_harmony_destructuring: {
-    options = { unused: true };
-    input: {
-        function foo() {
-            var {x, y} = foo;
-            var a = foo;
-        }
-    }
-    expect:  {
-        function foo() {
-            var {x, y} = foo;
-        }
-    }
-}
-
 keep_fnames: {
     options = { unused: true, keep_fnames: true, unsafe: true };
     input: {
@@ -1016,8 +935,7 @@ issue_1715_3: {
             try {
                 console;
             } catch (a) {
-                var a;
-                x();
+                var a = x();
             }
         }
         f();
@@ -1112,33 +1030,6 @@ delete_assign_2: {
     expect_stdout: true
 }
 
-drop_var: {
-    options = {
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        var a;
-        console.log(a, b);
-        var a = 1, b = 2;
-        console.log(a, b);
-        var a = 3;
-        console.log(a, b);
-    }
-    expect: {
-        console.log(a, b);
-        var a = 1, b = 2;
-        console.log(a, b);
-        a = 3;
-        console.log(a, b);
-    }
-    expect_stdout: [
-        "undefined undefined",
-        "1 2",
-        "3 2",
-    ]
-}
-
 issue_1830_1: {
     options = {
         unused: true,
@@ -1174,61 +1065,6 @@ issue_1830_2: {
     expect_stdout: "1"
 }
 
-issue_1838: {
-    options = {
-        join_vars: true,
-        loops: true,
-        unused: true,
-    }
-    beautify = {
-        beautify: true,
-    }
-    input: {
-        function f() {
-            var b = a;
-            while (c);
-        }
-    }
-    expect_exact: [
-        "function f() {",
-        "    for (a; c; ) ;",
-        "}",
-    ]
-}
-
-var_catch_toplevel: {
-    options = {
-        conditionals: true,
-        negate_iife: true,
-        reduce_vars: true,
-        side_effects: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            a--;
-            try {
-                a++;
-            } catch(a) {
-                if (a) var a;
-                var a = 10;
-            }
-        }
-        f();
-    }
-    expect: {
-        !function() {
-            a--;
-            try {
-                a++;
-            } catch(a) {
-                var a;
-            }
-        }();
-    }
-}
-
 reassign_const: {
     options = {
         cascade: true,
@@ -1253,30 +1089,3 @@ reassign_const: {
     }
     expect_stdout: true
 }
-
-issue_1968: {
-    options = {
-        unused: true,
-    }
-    input: {
-        function f(c) {
-            var a;
-            if (c) {
-                let b;
-                return (a = 2) + (b = 3);
-            }
-        }
-        console.log(f(1));
-    }
-    expect: {
-        function f(c) {
-            if (c) {
-                let b;
-                return 2 + (b = 3);
-            }
-        }
-        console.log(f(1));
-    }
-    expect_stdout: "5"
-    node_version: ">=6"
-}

test/compress/evaluate.js

@@ -224,100 +224,6 @@ positive_zero: {
     expect_stdout: true
 }
 
-pow: {
-    options = { evaluate: true }
-    input: {
-        var a = 5 ** 3;
-    }
-    expect: {
-        var a = 125;
-    }
-}
-
-pow_sequence: {
-    options = {
-        evaluate: true
-    }
-    input: {
-        var a = 2 ** 3 ** 2;
-    }
-    expect: {
-        var a = 512;
-    }
-}
-
-pow_mixed: {
-    options = {
-        evaluate: true
-    }
-    input: {
-        var a = 5 + 2 ** 3 + 5;
-        var b = 5 * 3 ** 2;
-        var c = 5 ** 3 * 2;
-        var d = 5 ** +3;
-    }
-    expect: {
-        var a = 18;
-        var b = 45;
-        var c = 250;
-        var d = 125;
-    }
-}
-
-pow_with_right_side_evaluating_to_unary: {
-    options = {
-        evaluate: true
-    }
-    input: {
-        var a = (4 - 7) ** foo;
-        var b = ++bar ** 3;
-        var c = --baz ** 2;
-    }
-    expect_exact: "var a=(-3)**foo;var b=++bar**3;var c=--baz**2;"
-}
-
-pow_with_number_constants: {
-    options = {
-        evaluate: true
-    }
-    input: {
-        var a = 5 ** NaN;
-        /* NaN exponent results to NaN */
-        var b = 42 ** +0;
-        /* +0 exponent results to NaN */
-        var c = 42 ** -0;
-        /* -0 exponent results to NaN */
-        var d = NaN ** 1;
-        /* NaN with non-zero exponent is NaN */
-        var e = 2 ** Infinity;
-        /* abs(base) > 1 with Infinity as exponent is Infinity */
-        var f = 2 ** -Infinity;
-        /* abs(base) > 1 with -Infinity as exponent is +0 */
-        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);
-        var m = 3 ** -10;  // Result will be 0.000016935087808430286, which is too long
-    }
-    expect: {
-        var a = NaN;
-        var b = 1;
-        var c = 1;
-        var d = NaN;
-        var e = 1/0;
-        var f = 0;
-        var g = NaN;
-        var h = 1/0;
-        var i = -1/0;
-        var j = .125;
-        var k = .125;
-        var l = .25;
-        var m = 3 ** -10;
-    }
-}
-
 unsafe_constant: {
     options = {
         evaluate  : true,
@@ -1016,12 +922,12 @@ delete_binary_1: {
         console.log(delete (true && (0 / 0)));
     }
     expect: {
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
+        console.log((void 0, !0));
+        console.log((void 0, !0));
+        console.log((1 / 0, !0));
+        console.log((1 / 0, !0));
+        console.log((NaN, !0));
+        console.log((NaN, !0));
     }
     expect_stdout: true
 }
@@ -1042,12 +948,12 @@ delete_binary_2: {
         console.log(delete (false || (0 / 0)));
     }
     expect: {
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
-        console.log(!0);
+        console.log((void 0, !0));
+        console.log((void 0, !0));
+        console.log((Infinity, !0));
+        console.log((1 / 0, !0));
+        console.log((NaN, !0));
+        console.log((NaN, !0));
     }
     expect_stdout: true
 }
@@ -1083,50 +989,3 @@ Infinity_NaN_undefined_LHS: {
         "}",
     ]
 }
-
-issue_1964_1: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        unsafe_regexp: false,
-        unused: true,
-    }
-    input: {
-        function f() {
-            var long_variable_name = /\s/;
-            return "a b c".split(long_variable_name)[1];
-        }
-        console.log(f());
-    }
-    expect: {
-        function f() {
-            var long_variable_name = /\s/;
-            return "a b c".split(long_variable_name)[1];
-        }
-        console.log(f());
-    }
-    expect_stdout: "b"
-}
-
-issue_1964_2: {
-    options = {
-        evaluate: true,
-        reduce_vars: true,
-        unsafe_regexp: true,
-        unused: true,
-    }
-    input: {
-        function f() {
-            var long_variable_name = /\s/;
-            return "a b c".split(long_variable_name)[1];
-        }
-        console.log(f());
-    }
-    expect: {
-        function f() {
-            return "a b c".split(/\s/)[1];
-        }
-        console.log(f());
-    }
-    expect_stdout: "b"
-}

test/compress/expansions.js

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

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

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

test/compress/harmony.js

@@ -1,585 +0,0 @@
-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"(){}}'
-}
-
-classes_with_expression_as_expand: {
-    input: {
-        class D extends (calls++, C) {}
-    }
-    expect_exact: "class D extends(calls++,C){}"
-}
-
-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";'
-}
-
-import_all_statement: {
-    input: {
-        import * from 'lel';
-        import * as Lel from 'lel';
-    }
-    expect_exact: 'import*from"lel";import*as Lel from"lel";'
-}
-
-export_statement: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        export default 1 + 2;
-        export var foo = 4;
-        export let foo = 6;
-        export const foo = 6;
-        export function foo() {};
-        export class foo { };
-    }
-    expect_exact: "export default 3;export var foo=4;export let foo=6;export const foo=6;export function foo(){};export class foo{};"
-}
-
-export_default_object_expression: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        export default {
-            foo: 1 + 2,
-            bar() { return 4; },
-            get baz() { return this.foo; },
-        };
-    }
-    expect_exact: "export default{foo:3,bar(){return 4},get baz(){return this.foo}};"
-}
-
-export_default_array: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        export default [ 1 + 2, foo ];
-    }
-    expect_exact: "export default[3,foo];"
-}
-
-export_default_anon_function: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        export default function(){
-            console.log(1 + 2);
-        }
-    }
-    expect_exact: "export default function(){console.log(3)};"
-}
-
-export_default_anon_class: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        export default class {
-            foo() { console.log(1 + 2); }
-        }
-    }
-    expect_exact: "export default class{foo(){console.log(3)}};"
-}
-
-export_module_statement: {
-    input: {
-        export * from "a.js";
-        export {A} from "a.js";
-        export {A, B} from "a.js";
-        export {C};
-    }
-    expect_exact: 'export*from"a.js";export{A}from"a.js";export{A,B}from"a.js";export{C};'
-}
-
-import_statement_mangling: {
-    mangle = { toplevel: true };
-    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));"
-}
-
-default_assign: {
-    options = {
-        keep_fargs: false,
-        unused: true,
-    }
-    input: {
-        function f(a, b = 3) {
-            console.log(a);
-        }
-
-        g = ([[] = 123]) => {};
-        h = ([[x, y, z] = [4, 5, 6]] = []) => {};
-
-        function i([[x, y, z] = [4, 5, 6]] = []) {
-            console.log(b);
-        };
-    }
-    expect: {
-        function f(a) {
-            console.log(a);
-        }
-
-        g = ([[] = 123]) => {};
-        h = ([[x, y, z] = [4, 5, 6]] = []) => {};
-
-        function i([[x, y, z] = [4, 5, 6]] = []) {
-            console.log(b);
-        };
-    }
-}
-
-expansion: {
-    options = {
-        keep_fargs: false,
-        unused: true,
-    }
-    input: {
-        function f(a, ...b) {
-            console.log(a);
-        }
-    }
-    expect: {
-        function f(a) {
-            console.log(a);
-        }
-    }
-}
-
-issue_1613: {
-  mangle = { toplevel: true };
-  input: {
-    const name = 1;
-    const foo = {
-      name
-    };
-  }
-  expect_exact: "const n=1;const c={name:n};"
-}
-
-format_methods: {
-    beautify = {
-        beautify: true,
-    }
-    input: {
-        class A extends B {constructor(a){x()} static s(b,c){y()} run(d,e,f){z()}}
-    }
-    expect_exact: [
-        "class A extends B {",
-        "    constructor(a) {",
-        "        x();",
-        "    }",
-        "    static s(b, c) {",
-        "        y();",
-        "    }",
-        "    run(d, e, f) {",
-        "        z();",
-        "    }",
-        "}",
-    ]
-}
-
-issue_1898: {
-    options = {
-    }
-    mangle = {
-    }
-    input: {
-        class Foo {
-            bar() {
-                for (const x of [ 6, 5 ]) {
-                    for (let y of [ 4, 3 ]) {
-                        for (var z of [ 2, 1 ]) {
-                            console.log(x, y, z);
-                        }
-                    }
-                }
-            }
-        }
-        new Foo().bar();
-    }
-    expect: {
-        class Foo {
-            bar() {
-                for (const n of [ 6, 5 ])
-                    for (let r of [ 4, 3 ])
-                        for (var o of [ 2, 1 ])
-                            console.log(n, r, o);
-            }
-        }
-        new Foo().bar();
-    }
-}
-
-issue_1753: {
-    mangle = { safari10: true };
-    input: {
-        class SomeClass {
-            constructor(props) {
-                let pickedSets = [];
-                for (let i = 0; i < 6; i++) {
-                    pickedSets.push({
-                        mainDrawNumbers: [],
-                        extraDrawNumbers: []
-                    });
-                }
-            }
-        }
-    }
-    expect: {
-        class SomeClass {
-            constructor(r) {
-                let a = [];
-                for (let s = 0; s < 6; s++)
-                    a.push({
-                        mainDrawNumbers: [],
-                        extraDrawNumbers: []
-                    });
-            }
-        }
-    }
-}
-
-issue_1753_disable: {
-    mangle = { safari10: false }
-    input: {
-        class SomeClass {
-            constructor(props) {
-                let pickedSets = [];
-                for (let i = 0; i < 6; i++) {
-                    pickedSets.push({
-                        mainDrawNumbers: [],
-                        extraDrawNumbers: []
-                    });
-                }
-            }
-        }
-    }
-    expect: {
-        class SomeClass {
-            constructor(r) {
-                let a = [];
-                for (let r = 0; r < 6; r++)
-                    a.push({
-                        mainDrawNumbers: [],
-                        extraDrawNumbers: []
-                    });
-            }
-        }
-    }
-}
-
-class_extends: {
-    options = {
-        evaluate: true,
-    }
-    input: {
-        function f() {
-            class foo extends bar {}
-            class pro extends some.prop {}
-            class arr extends stuff[1 - 1] {}
-            class bin extends (a || b) {}
-            class seq extends (a, b) {}
-            class ter extends (a ? b : c) {}
-            class uni extends (!0) {}
-        }
-    }
-    expect_exact: "function f(){class foo extends bar{}class pro extends some.prop{}class arr extends stuff[0]{}class bin extends(a||b){}class seq extends(a,b){}class ter extends(a?b:c){}class uni extends(!0){}}"
-}
-
-class_extends_class: {
-    options = {
-    }
-    input: {
-        class anon extends class {} {}
-        class named extends class base {} {}
-    }
-    expect_exact: "class anon extends class{}{}class named extends class base{}{}"
-}
-
-class_extends_function: {
-    options = {
-    }
-    input: {
-        class anon extends function(){} {}
-        class named extends function base(){} {}
-    }
-    expect_exact: "class anon extends function(){}{}class named extends function base(){}{}"
-}
-
-class_extends_regex: {
-    options = {
-    }
-    input: {
-        function f() {
-            class rx1 extends (/rx/) {}
-            // class rx2 extends /rx/ {}  // FIXME - parse error
-        }
-    }
-    expect_exact: "function f(){class rx1 extends(/rx/){}}"
-}

test/compress/hoist.js

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

@@ -53,12 +53,3 @@ 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/issue-1001.js

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

test/compress/issue-1043.js

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

@@ -1,9 +0,0 @@
-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-1212.js

@@ -1,76 +0,0 @@
-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-1321.js

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

test/compress/issue-1446.js

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

test/compress/issue-1466.js

@@ -1,291 +0,0 @@
-same_variable_in_multiple_for_loop: {
-    options = {
-        hoist_funs: true,
-        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: true,
-    }
-    mangle = {}
-    input: {
-        for (let i = 0; i < 3; i++) {
-            let a = 100;
-            console.log(i, a);
-            for (let i = 0; i < 2; i++) {
-                console.log(i, a);
-                let c = 2;
-                console.log(c);
-            }
-        }
-    }
-    expect: {
-        for (let o = 0; o < 3; o++) {
-            let l = 100;
-            console.log(o, l);
-            for (let o = 0; o < 2; o++) {
-                console.log(o, l);
-                let c = 2;
-                console.log(c);
-            }
-        }
-    }
-    expect_stdout: true
-}
-
-same_variable_in_multiple_forOf: {
-    options = {
-        hoist_funs: true,
-        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: true,
-    }
-    mangle = {}
-    input: {
-        var test = [ "a", "b", "c" ];
-        for (let tmp of test) {
-            console.log(tmp);
-            let dd;
-            dd = [ "e", "f", "g" ];
-            for (let tmp of dd) {
-                console.log(tmp);
-            }
-        }
-    }
-    expect: {
-        var test = [ "a", "b", "c" ];
-        for (let o of test) {
-            console.log(o);
-            let e;
-            e = [ "e", "f", "g" ];
-            for (let o of e)
-                console.log(o);
-        }
-    }
-    expect_stdout: true
-}
-
-same_variable_in_multiple_forIn: {
-    options = {
-        hoist_funs: true,
-        dead_code: true,
-        conditionals: true,
-        comparisons: true,
-        evaluate: true,
-        booleans: true,
-        loops: true,
-        unused: false,
-        keep_fargs: true,
-        if_return: true,
-        join_vars: true,
-        cascade: true,
-        side_effects: true,
-        collapse_vars: true,
-    }
-    mangle = {}
-    input: {
-        var test = [ "a", "b", "c" ];
-        for (let tmp in test) {
-            console.log(tmp);
-            let dd;
-            dd = [ "e", "f", "g" ];
-            for (let tmp in test) {
-                console.log(tmp);
-            }
-        }
-    }
-    expect: {
-        var test = [ "a", "b", "c" ];
-        for (let o in test) {
-            console.log(o);
-            let e;
-            e = [ "e", "f", "g" ];
-            for (let o in test)
-                console.log(o);
-        }
-    }
-    expect_stdout: true
-}
-
-different_variable_in_multiple_for_loop: {
-    options = {
-        hoist_funs: true,
-        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: true,
-    }
-    mangle = {}
-    input: {
-        for (let i = 0; i < 3; i++) {
-            let a = 100;
-            console.log(i, a);
-            for (let j = 0; j < 2; j++) {
-                console.log(j, a);
-                let c = 2;
-                console.log(c);
-            }
-        }
-    }
-    expect: {
-        for (let o = 0; o < 3; o++) {
-            let l = 100;
-            console.log(o, l);
-            for (let o = 0; o < 2; o++) {
-                console.log(o, l);
-                let c = 2;
-                console.log(c);
-            }
-        }
-    }
-    expect_stdout: true
-}
-
-different_variable_in_multiple_forOf: {
-    options = {
-        hoist_funs: true,
-        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: true,
-    }
-    mangle = {}
-    input: {
-        var test = [ "a", "b", "c" ];
-        for (let tmp of test) {
-            console.log(tmp);
-            let dd;
-            dd = [ "e", "f", "g" ];
-            for (let t of dd) {
-                console.log(t);
-            }
-        }
-    }
-    expect: {
-        var test = [ "a", "b", "c" ];
-        for (let o of test) {
-            console.log(o);
-            let e;
-            e = [ "e", "f", "g" ];
-            for (let o of e)
-                console.log(o);
-        }
-    }
-    expect_stdout: true
-}
-
-different_variable_in_multiple_forIn: {
-    options = {
-        hoist_funs: true,
-        dead_code: true,
-        conditionals: true,
-        comparisons: true,
-        evaluate: true,
-        booleans: true,
-        loops: true,
-        unused: false,
-        keep_fargs: true,
-        if_return: true,
-        join_vars: true,
-        cascade: true,
-        side_effects: true,
-        collapse_vars: true,
-    }
-    mangle = {}
-    input: {
-        var test = [ "a", "b", "c" ];
-        for (let tmp in test) {
-            console.log(tmp);
-            let dd;
-            dd = [ "e", "f", "g" ];
-            for (let t in test) {
-                console.log(t);
-            }
-        }
-    }
-    expect: {
-        var test = [ "a", "b", "c" ];
-        for (let o in test) {
-            console.log(o);
-            let e;
-            e = [ "e", "f", "g" ];
-            for (let o in test)
-                console.log(o);
-        }
-    }
-    expect_stdout: true
-}
-
-more_variable_in_multiple_for: {
-    options = {
-        hoist_funs: true,
-        dead_code: true,
-        conditionals: true,
-        comparisons: true,
-        evaluate: true,
-        booleans: true,
-        loops: true,
-        unused: false,
-        keep_fargs: true,
-        if_return: true,
-        join_vars: true,
-        cascade: true,
-        side_effects: true,
-        collapse_vars: true,
-    }
-    mangle = {}
-    input: {
-        for (let a = 9, i = 0; i < 20; i += a) {
-            let b = a++ + i;
-            console.log(a, b, i);
-            for (let k = b, m = b*b, i = 0; i < 10; i++) {
-                console.log(a, b, m, k, i);
-            }
-        }
-    }
-    expect: {
-        for (let o = 9, l = 0; l < 20; l += o) {
-            let c = o++ + l;
-            console.log(o, c, l);
-            for (let l = c, e = c * c, f = 0; f < 10; f++)
-                console.log(o, c, e, l, f);
-        }
-    }
-    expect_stdout: true
-}

test/compress/issue-1588.js

@@ -1,9 +1,9 @@
 screw_ie8: {
     options = {
-        ie8: false,
+        screw_ie8: true,
     }
     mangle = {
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         try { throw "foo"; } catch (x) { console.log(x); }
@@ -16,10 +16,10 @@ screw_ie8: {
 
 support_ie8: {
     options = {
-        ie8: true,
+        screw_ie8: false,
     }
     mangle = {
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         try { throw "foo"; } catch (x) { console.log(x); }

test/compress/issue-1609.js

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

test/compress/issue-1704.js

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

test/compress/issue-1733.js

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

test/compress/issue-1770.js

@@ -103,3 +103,137 @@ numeric_literal: {
         "8 7 8",
     ]
 }
+
+identifier: {
+    mangle_props = {}
+    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 = {
+            a: 1,
+            b: 2,
+            c: 3,
+            d: 4,
+            e: 5,
+            f: 6,
+            g: 7,
+            h: 8,
+            i: 9,
+            j: 10,
+            k: 11,
+            l: 12,
+            m: 13,
+            n: 14,
+            o: 15,
+            p: 16,
+            q: 17,
+            r: 18,
+            s: 19,
+            t: 20,
+            u: 21,
+            v: 22,
+            w: 23,
+            x: 24,
+            y: 25,
+            z: 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,
+            aa: 57,
+            ba: 58,
+            ca: 59,
+            da: 60,
+            ea: 61,
+        };
+    }
+}

test/compress/issue-1787.js

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

test/compress/issue-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

@@ -1,34 +0,0 @@
-
-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,
-        ecma: 6
-    }
-    beautify = {
-        ecma: 6
-    }
-    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-640.js

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

test/compress/issue-926.js

@@ -1,9 +0,0 @@
-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/join-vars.js

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

@@ -245,7 +245,7 @@ issue_1532: {
 issue_186: {
     beautify = {
         beautify: false,
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         var x = 3;
@@ -264,7 +264,7 @@ issue_186: {
 issue_186_ie8: {
     beautify = {
         beautify: false,
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         var x = 3;
@@ -283,7 +283,7 @@ issue_186_ie8: {
 issue_186_beautify: {
     beautify = {
         beautify: true,
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         var x = 3;
@@ -310,7 +310,7 @@ issue_186_beautify: {
 issue_186_beautify_ie8: {
     beautify = {
         beautify: true,
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         var x = 3;
@@ -340,7 +340,7 @@ issue_186_bracketize: {
     beautify = {
         beautify: false,
         bracketize: true,
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         var x = 3;
@@ -360,7 +360,7 @@ issue_186_bracketize_ie8: {
     beautify = {
         beautify: false,
         bracketize: true,
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         var x = 3;
@@ -380,7 +380,7 @@ issue_186_beautify_bracketize: {
     beautify = {
         beautify: true,
         bracketize: true,
-        ie8: false,
+        screw_ie8: true,
     }
     input: {
         var x = 3;
@@ -412,7 +412,7 @@ issue_186_beautify_bracketize_ie8: {
     beautify = {
         beautify: true,
         bracketize: true,
-        ie8: true,
+        screw_ie8: false,
     }
     input: {
         var x = 3;

test/compress/negate-iife.js

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

test/compress/new.js

@@ -82,19 +82,3 @@ new_with_unary_prefix: {
     }
     expect_exact: 'var bar=(+new Date).toString(32);';
 }
-
-new_with_assignement_expression: {
-    options = {
-        evaluate: true
-    }
-    input: {
-        var a;
-        new x(a = 5 * 2, b = [1, 2, 3], c = {a: "a", b: "b", cd: "c" + "d"});
-        new y([a, b] = [3, 4]);
-    }
-    expect: {
-        var a;
-        new x(a = 10, b = [1, 2, 3], c = {a: "a", b: "b", cd: "cd"});
-        new y([a, b] = [3, 4]);
-    }
-}

test/compress/node_version.js

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

test/compress/object.js

@@ -1,512 +0,0 @@
-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: {
-    beautify = {
-        ecma: 6
-    }
-    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: {
-    beautify = {
-        ecma: 6
-    }
-    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

@@ -1,180 +0,0 @@
-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=>b;a=>\"lel\";"
-}
-
-arrow_return: {
-    input: {
-        () => {};
-        () => { return; };
-        a => { return 1; }
-        a => { return -b }
-        a => { return b; var b; }
-        (x, y) => { return x - y; }
-    }
-    expect_exact: "()=>{};()=>{};a=>1;a=>-b;a=>{return b;var b};(x,y)=>x-y;"
-}
-
-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: {
-    beautify = {
-        ecma: 6
-    }
-    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: {
-    beautify = {
-        ecma: 6
-    }
-    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: {
-    beautify = {
-        ecma: 6
-    }
-    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

@@ -13,7 +13,7 @@ keep_properties: {
 dot_properties: {
     options = {
         properties: true,
-        ie8: true,
+        screw_ie8: false
     };
     input: {
         a["foo"] = "bar";
@@ -36,7 +36,7 @@ dot_properties: {
 dot_properties_es5: {
     options = {
         properties: true,
-        ie8: false,
+        screw_ie8: true
     };
     input: {
         a["foo"] = "bar";
@@ -125,7 +125,7 @@ evaluate_string_length: {
 
 mangle_properties: {
     mangle_props = {
-        keep_quoted: false
+        ignore_quoted: false
     };
     input: {
         a["foo"] = "bar";
@@ -148,8 +148,7 @@ mangle_unquoted_properties: {
         properties: false
     }
     mangle_props = {
-        builtins: true,
-        keep_quoted: true
+        ignore_quoted: true
     }
     beautify = {
         beautify: false,
@@ -234,13 +233,12 @@ mangle_debug_suffix: {
     }
 }
 
-mangle_debug_suffix_keep_quoted: {
+mangle_debug_suffix_ignore_quoted: {
     options = {
         properties: false
     }
     mangle_props = {
-        builtins: true,
-        keep_quoted: true,
+        ignore_quoted: true,
         debug: "XYZ",
         reserved: []
     }

test/compress/reduce_vars.js

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

test/compress/screw-ie8.js

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

test/compress/sequences.js

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

test/compress/string-literal.js

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

test/compress/super.js

@@ -1,9 +0,0 @@
-
-super_can_be_parsed: {
-    input: {
-        super(1,2);
-        super.meth();
-    }
-    expect_exact: "super(1,2);super.meth();"
-}
-

test/compress/template-string.js

@@ -1,402 +0,0 @@
-template_strings: {
-    beautify = {
-        quote_style: 3
-    }
-    input: {
-        ``;
-        `xx\`x`;
-        `${ foo + 2 }`;
-        ` foo ${ bar + `baz ${ qux }` }`;
-    }
-    expect_exact: "``;`xx\\`x`;`${foo+2}`;` foo ${bar+`baz ${qux}`}`;";
-}
-
-template_string_prefixes: {
-    beautify = {
-        quote_style: 3
-    }
-    input: {
-        String.raw`foo`;
-        foo `bar`;
-    }
-    expect_exact: "String.raw`foo`;foo`bar`;";
-}
-
-template_strings_ascii_only: {
-    beautify = {
-        ascii_only: true,
-        quote_style: 3
-    }
-    input: {
-        var foo = `foo
-        bar
-        ↂωↂ`;
-        var bar = `\``;
-    }
-    expect_exact: "var foo=`foo\\n        bar\\n        \\u2182\\u03c9\\u2182`;var bar=`\\``;"
-}
-
-template_strings_without_ascii_only: {
-    beautify = {
-        quote_style: 3
-    }
-    input: {
-        var foo = `foo
-        bar
-        ↂωↂ`
-    }
-    expect_exact: "var foo=`foo\\n        bar\\n        ↂωↂ`;"
-}
-
-template_string_with_constant_expression: {
-    options = {
-        evaluate: true
-    }
-    beautify = {
-        quote_style: 3
-    }
-    input: {
-        var foo = `${4 + 4} equals 4 + 4`;
-    }
-    expect: {
-        var foo = `8 equals 4 + 4`;
-    }
-}
-
-template_string_with_predefined_constants: {
-    options = {
-        evaluate: true
-    }
-    beautify = {
-        quote_style: 3
-    }
-    input: {
-        var foo = `This is ${undefined}`;
-        var bar = `This is ${NaN}`;
-        var baz = `This is ${null}`;
-        var foofoo = `This is ${Infinity}`;
-        var foobar = "This is ${1/0}";
-        var foobaz = 'This is ${1/0}';
-        var barfoo = "This is ${NaN}";
-        var bazfoo = "This is ${null}";
-        var bazbaz = `This is ${1/0}`;
-        var barbar = `This is ${0/0}`;
-        var barbar = "This is ${0/0}";
-        var barber = 'This is ${0/0}';
-
-        var a = `${4**11}`; // 8 in template vs 7 chars - 4194304
-        var b = `${4**12}`; // 8 in template vs 8 chars - 16777216
-        var c = `${4**14}`; // 8 in template vs 9 chars - 268435456
-    }
-    expect: {
-        var foo = `This is undefined`;
-        var bar = `This is NaN`;
-        var baz = `This is null`;
-        var foofoo = `This is ${1/0}`;
-        var foobar = "This is ${1/0}";
-        var foobaz = 'This is ${1/0}';
-        var barfoo = "This is ${NaN}";
-        var bazfoo = "This is ${null}";
-        var bazbaz = `This is ${1/0}`;
-        var barbar = `This is NaN`;
-        var barbar = "This is ${0/0}";
-        var barber = 'This is ${0/0}';
-
-        var a = `4194304`;
-        var b = `16777216`; // Potential for further concatentation
-        var c = `${4**14}`; // Not worth converting
-    }
-}
-
-template_string_evaluate_with_many_segments: {
-    options = {
-        evaluate: true
-    }
-    beautify = {
-        quote_style: 3
-    }
-    input: {
-        var foo = `Hello ${guest()}, welcome to ${location()}${"."}`;
-        var bar = `${1}${2}${3}${4}${5}${6}${7}${8}${9}${0}`;
-        var baz = `${foobar()}${foobar()}${foobar()}${foobar()}`;
-        var buzz = `${1}${foobar()}${2}${foobar()}${3}${foobar()}`;
-    }
-    expect: {
-        var foo = `Hello ${guest()}, welcome to ${location()}.`;
-        var bar = `1234567890`;
-        var baz = `${foobar()}${foobar()}${foobar()}${foobar()}`;
-        var buzz = `1${foobar()}2${foobar()}3${foobar()}`;
-    }
-}
-
-template_string_with_many_segments: {
-    beautify = {
-        quote_style: 3
-    }
-    input: {
-        var foo = `Hello ${guest()}, welcome to ${location()}${"."}`;
-        var bar = `${1}${2}${3}${4}${5}${6}${7}${8}${9}${0}`;
-        var baz = `${foobar()}${foobar()}${foobar()}${foobar()}`;
-        var buzz = `${1}${foobar()}${2}${foobar()}${3}${foobar()}`;
-    }
-    expect: {
-        var foo = `Hello ${guest()}, welcome to ${location()}${"."}`;
-        var bar = `${1}${2}${3}${4}${5}${6}${7}${8}${9}${0}`;
-        var baz = `${foobar()}${foobar()}${foobar()}${foobar()}`;
-        var buzz = `${1}${foobar()}${2}${foobar()}${3}${foobar()}`;
-    }
-}
-
-template_string_to_normal_string: {
-    options = {
-        evaluate: true
-    }
-    beautify = {
-        quote_style: 0
-    }
-    input: {
-        var foo = `This is ${undefined}`;
-        var bar = "Decimals " + `${1}${2}${3}${4}${5}${6}${7}${8}${9}${0}`;
-    }
-    expect: {
-        var foo = `This is undefined`;
-        var bar = "Decimals 1234567890";
-    }
-}
-
-template_concattenating_string: {
-    options = {
-        evaluate: true
-    }
-    beautify = {
-        quote_style: 3 // Yes, keep quotes
-    }
-    input: {
-        var foo = "Have a nice " + `day. ${`day. ` + `day.`}`;
-        var bar = "Have a nice " + `${day()}`;
-    }
-    expect: {
-        var foo = "Have a nice day. day. day.";
-        var bar = "Have a nice " + `${day()}`;
-    }
-}
-
-evaluate_nested_templates: {
-    options = {
-        evaluate: true
-    }
-    beautify = {
-        quote_style: 0
-    }
-    input: {
-        var baz = `${`${`${`foo`}`}`}`;
-    }
-    expect: {
-        var baz = `foo`;
-    }
-}
-
-enforce_double_quotes: {
-    beautify = {
-        quote_style: 1
-    }
-    input: {
-        var foo = `Hello world`;
-        var bar = `Hello ${'world'}`;
-        var baz = `Hello ${world()}`;
-    }
-    expect: {
-        var foo = `Hello world`;
-        var bar = `Hello ${"world"}`;
-        var baz = `Hello ${world()}`;
-    }
-}
-
-enforce_single_quotes: {
-    beautify = {
-        quote_style: 2
-    }
-    input: {
-        var foo = `Hello world`;
-        var bar = `Hello ${"world"}`;
-        var baz = `Hello ${world()}`;
-    }
-    expect: {
-        var foo = `Hello world`;
-        var bar = `Hello ${'world'}`;
-        var baz = `Hello ${world()}`;
-    }
-}
-
-enforce_double_quotes_and_evaluate: {
-    beautify = {
-        quote_style: 1
-    }
-    options = {
-        evaluate: true
-    }
-    input: {
-        var foo = `Hello world`;
-        var bar = `Hello ${'world'}`;
-        var baz = `Hello ${world()}`;
-    }
-    expect: {
-        var foo = `Hello world`;
-        var bar = `Hello world`;
-        var baz = `Hello ${world()}`;
-    }
-}
-
-enforce_single_quotes_and_evaluate: {
-    beautify = {
-        quote_style: 2
-    }
-    options = {
-        evaluate: true
-    }
-    input: {
-        var foo = `Hello world`;
-        var bar = `Hello ${"world"}`;
-        var baz = `Hello ${world()}`;
-    }
-    expect: {
-        var foo = `Hello world`;
-        var bar = `Hello world`;
-        var baz = `Hello ${world()}`;
-    }
-}
-
-respect_inline_script: {
-    beautify = {
-        inline_script: true,
-        quote_style: 3
-    }
-    input: {
-        var foo = `</script>${content}`;
-        var bar = `<!--`;
-        var baz = `-->`;
-    }
-    expect_exact: "var foo=`<\\/script>${content}`;var bar=`\\x3c!--`;var baz=`--\\x3e`;";
-}
-
-do_not_optimize_tagged_template_1: {
-    beautify = {
-        quote_style: 0
-    }
-    options = {
-        evaluate: true
-    }
-    input: {
-        var foo = tag`Shall not be optimized. ${"But " + "this " + "is " + "fine."}`;
-        var bar = tag`Don't even mind changing my quotes!`;
-    }
-    expect_exact:
-        'var foo=tag`Shall not be optimized. ${"But this is fine."}`;var bar=tag`Don\'t even mind changing my quotes!`;';
-}
-
-do_not_optimize_tagged_template_2: {
-    options = {
-        evaluate: true
-    }
-    input: {
-        var foo = tag`test` + " something out";
-    }
-    expect_exact: 'var foo=tag`test`+" something out";';
-}
-
-keep_raw_content_in_tagged_template: {
-    options = {
-        evaluate: true
-    }
-    input: {
-        var foo = tag`\u0020\u{20}\u{00020}\x20\40\040 `;
-    }
-    expect_exact: "var foo=tag`\\u0020\\u{20}\\u{00020}\\x20\\40\\040 `;";
-}
-
-allow_chained_templates: {
-    input: {
-        var foo = tag`a``b``c``d`;
-    }
-    expect: {
-        var foo = tag`a``b``c``d`;
-    }
-}
-
-check_escaped_chars: {
-    input: {
-        var foo = `\u0020\u{20}\u{00020}\x20\40\040 `;
-    }
-    expect_exact: "var foo=`       `;";
-}
-
-escape_dollar_curly: {
-    options = {
-        evaluate: true
-    }
-    input: {
-        console.log(`\$\{ beep \}`)
-        console.log(`${1-0}\${2-0}$\{3-0}${4-0}`)
-        console.log(`$${""}{not an expression}`)
-    }
-    expect_exact: "console.log(`\\${ beep }`);console.log(`1\\${2-0}\\${3-0}4`);console.log(`\\${not an expression}`);"
-}
-
-template_starting_with_newline: {
-    options = {
-        dead_code: true
-    }
-    input: {
-        function foo(e) {
-            return `
-this is a template string!`;
-        };
-    }
-    expect_exact: "function foo(e){return`\\nthis is a template string!`}"
-}
-
-template_with_newline: {
-    options = {
-        dead_code: true
-    }
-    input: {
-        function foo(e) {
-            return `yep,
-this is a template string!`;
-        };
-    }
-    expect_exact: "function foo(e){return`yep,\\nthis is a template string!`}"
-}
-
-template_ending_with_newline: {
-    options = {
-        dead_code: true
-    }
-    input: {
-        function foo(e) {
-            return `this is a template string!
-`;
-        };
-    }
-    expect_exact: "function foo(e){return`this is a template string!\\n`}"
-}
-
-issue_1856: {
-    beautify = {
-        ascii_only: false,
-    }
-    input: {
-        console.log(`\\n\\r\\u2028\\u2029\n\r\u2028\u2029`);
-    }
-    expect_exact: "console.log(`\\\\n\\\\r\\\\u2028\\\\u2029\\n\\r\\u2028\\u2029`);"
-}
-
-issue_1856_ascii_only: {
-    beautify = {
-        ascii_only: true,
-    }
-    input: {
-        console.log(`\\n\\r\\u2028\\u2029\n\r\u2028\u2029`);
-    }
-    expect_exact: "console.log(`\\\\n\\\\r\\\\u2028\\\\u2029\\n\\r\\u2028\\u2029`);"
-}

test/compress/try-catch.js

@@ -1,12 +0,0 @@
-catch_destructuring_with_sequence: {
-    beautify = {
-        ecma: 6
-    }
-    input: {
-        try {
-            throw {};
-        } catch ({xCover = (0, function() {})} ) {
-        }
-    }
-    expect_exact: "try{throw{}}catch({xCover=(0,function(){})}){}"
-}

test/compress/unicode.js

@@ -15,106 +15,3 @@ unicode_parse_variables: {
         var l০ = 3;
     }
 }
-
-unicode_escaped_identifier: {
-    beautify = {ecma: 6}
-    input: {
-        var \u{61} = "foo";
-        var \u{10000} = "bar";
-    }
-    expect_exact: 'var a="foo";var \u{10000}="bar";';
-}
-
-unicode_identifier_ascii_only: {
-    beautify = {ascii_only: true, ecma: 6}
-    input: {
-        var \u{0061} = "hi";
-        var bar = "h\u{0065}llo";
-        var \u{10000} = "testing \u{101111}";
-    }
-    expect_exact: 'var a="hi";var bar="hello";var \\u{10000}="testing \\u{101111}";'
-}
-
-unicode_string_literals: {
-    beautify = {ascii_only: true, ecma: 6}
-    input: {
-        var a = "6 length unicode character: \u{101111}";
-    }
-    expect_exact: 'var a="6 length unicode character: \\u{101111}";'
-}
-
-// Don't escape identifiers below es6 (or in this case double escaped in expect_exact)
-unicode_output_es5_surrogates: {
-    beautify = {ascii_only: true, ecma: 5}
-    input: {
-        var \u{10000} = "6 length unicode character: \u{10FFFF}";
-    }
-    expect_exact: 'var \u{10000}="6 length unicode character: \\udbff\\udfff";'
-}
-
-check_escape_style: {
-    beautify = {ascii_only: true, ecma: 6}
-    input: {
-        var a = "\x01";
-        var \ua0081 = "\x10"; // \u0081 only in ID_Continue
-        var \u0100 = "\u0100";
-        var \u1000 = "\u1000";
-        var \u{10000} = "\u{10000}";
-        var \u{2f800} = "\u{100000}";
-    }
-    expect_exact: 'var a="\\x01";var \\ua0081="\\x10";var \\u0100="\\u0100";var \\u1000="\\u1000";var \\u{10000}="\\u{10000}";var \\u{2f800}="\\u{100000}";'
-}
-
-// Don't escape identifiers below es6, no escaped identifiers support and no \u{} syntax
-check_escape_style_es5: {
-    beautify = {ascii_only: true, ecma: 5}
-    input: {
-        var a = "\x01";
-        var \ua0081 = "\x10"; // \u0081 only in ID_Continue
-        var \u0100 = "\u0100";
-        var \u1000 = "\u1000";
-        var \u{10000} = "\u{10000}"; // Identifier won't be escaped in es 5.1
-        var \u{2f800} = "\u{100000}"; // Same
-    }
-    expect_exact: 'var a="\\x01";var \\ua0081="\\x10";var \\u0100="\\u0100";var \\u1000="\\u1000";var \ud800\udc00="\\ud800\\udc00";var \ud87e\udc00="\\udbc0\\udc00";'
-}
-
-ID_continue_with_surrogate_pair: {
-    beautify = {ascii_only: true, ecma: 6}
-    input: {
-        var \u{2f800}\u{2f800}\u{2f800}\u{2f800} = "\u{100000}\u{100000}\u{100000}\u{100000}\u{100000}";
-    }
-    expect_exact: 'var \\u{2f800}\\u{2f800}\\u{2f800}\\u{2f800}="\\u{100000}\\u{100000}\\u{100000}\\u{100000}\\u{100000}";'
-}
-
-escape_non_escaped_identifier: {
-    beautify = {ascii_only: true, ecma: 6}
-    input: {
-        var µþ = "µþ";
-    }
-    expect_exact: 'var \\u00b5\\u00fe="\\xb5\\xfe";'
-}
-
-non_escape_2_non_escape: {
-    beautify = {ascii_only: false, ecma: 6}
-    input: {
-        var µþ = "µþ";
-    }
-    expect_exact: 'var µþ="µþ";'
-}
-
-non_escape_2_half_escape1: {
-    beautify = {ascii_only: false, ascii_identifiers: true, ecma: 6}
-    input: {
-        var µþ = "µþ";
-    }
-    expect_exact: 'var \\u00b5\\u00fe="µþ";'
-}
-
-non_escape_2_half_escape2: {
-    beautify = {ascii_only: true, ascii_identifiers: false, ecma: 6}
-    input: {
-        var µþ = "µþ";
-    }
-    expect_exact: 'var µþ="\\xb5\\xfe";'
-}

test/compress/yield.js

@@ -1,192 +0,0 @@
-generators: {
-    input: {
-        function* fn() {};
-    }
-    expect_exact: "function*fn(){}"
-}
-
-generators_yield: {
-    input: {
-      function* fn() {
-        yield remote();
-      }
-    }
-    expect_exact: "function*fn(){yield remote()}"
-}
-
-generators_yield_assign: {
-    input: {
-      function* fn() {
-          var x = {};
-          x.prop = yield 5;
-      }
-    }
-    expect_exact: "function*fn(){var x={};x.prop=yield 5}"
-}
-
-generator_yield_undefined: {
-    input: {
-        function* fn() {
-            yield;
-        }
-    }
-    expect_exact: "function*fn(){yield}"
-}
-
-yield_optimize_expression: {
-    options = {
-    }
-    input: {
-        function* f1() { yield; }
-        function* f2() { yield undefined; }
-        function* f3() { yield null; }
-        function* f4() { yield* undefined; }
-    }
-    expect: {
-        function* f1() { yield }
-        function* f2() { yield; }
-        function* f3() { yield null; }
-        function* f4() { yield* void 0; }
-    }
-}
-
-yield_statements: {
-    input: {
-        function* fn() {
-            var a = (yield 1) + (yield 2);
-            var b = (yield 3) === (yield 4);
-            var c = (yield 5) << (yield 6);
-            var d = yield 7;
-            var e = (yield 8) ? yield 9 : yield 10;
-            var f = -(yield 11);
-        }
-    }
-    expect_exact: "function*fn(){var a=(yield 1)+(yield 2);var b=(yield 3)===(yield 4);var c=(yield 5)<<(yield 6);var d=yield 7;var e=(yield 8)?yield 9:yield 10;var f=-(yield 11)}"
-}
-
-yield_as_identifier_in_function_in_generator: {
-    input: {
-        var g = function*() {
-            function h() {
-                yield = 1;
-            }
-        };
-    }
-    expect: {
-        var g = function*() {
-            function h() {
-                yield = 1;
-            }
-        };
-    }
-}
-
-yield_before_punctuators: {
-    input: {
-        iter = (function*() {
-            assignmentResult = [ x = yield ] = value;
-        })();
-        function* g1() { (yield) }
-        function* g2() { [yield] }
-        function* g3() { return {yield} } // Added return to avoid {} drop
-        function* g4() { yield, yield; }
-        function* g5() { (yield) ? yield : yield; }
-    }
-    expect: {
-        iter = (function*() {
-            assignmentResult = [ x = yield ] = value;
-        })();
-        function* g1() { (yield) }
-        function* g2() { [yield] }
-        function* g3() { return {yield} }
-        function* g4() { yield, yield; }
-        function* g5() { (yield) ? yield : yield; }
-    }
-}
-
-yield_as_identifier_outside_strict_mode: {
-    input: {
-        import yield from "bar";
-        yield = 123;
-        while (true) {
-            yield:
-            for(;;) break yield;
-
-            foo();
-        }
-        while (true)
-            yield: for(;;) continue yield;
-        function yield(){}
-        function foo(...yield){}
-        try { new Error("") } catch (yield) {}
-        var yield = "foo";
-    }
-    expect: {
-        import yield from "bar";
-        yield = 123;
-        while (true) {
-            yield:
-            for(;;) break yield;
-
-            foo();
-        }
-        while (true)
-            yield: for(;;) continue yield;
-        function yield(){}
-        function foo(...yield){}
-        try { new Error("") } catch (yield) {}
-        var yield = "foo";
-    }
-}
-
-empty_generator_as_parameter_with_side_effects: {
-    options = {
-        side_effects: true
-    }
-    input: {
-        var GeneratorPrototype = Object.getPrototypeOf(
-          Object.getPrototypeOf(function*() {}())
-        );
-        evaluate(GeneratorPrototype);
-    }
-    expect_exact: "var GeneratorPrototype=Object.getPrototypeOf(Object.getPrototypeOf(function*(){}()));evaluate(GeneratorPrototype);"
-}
-
-empty_generator_as_parameter_without_side_effects: {
-    options = {
-        side_effects: false
-    }
-    input: {
-        var GeneratorPrototype = Object.getPrototypeOf(
-          Object.getPrototypeOf(function*() {}())
-        );
-        evaluate(GeneratorPrototype);
-    }
-    expect_exact: "var GeneratorPrototype=Object.getPrototypeOf(Object.getPrototypeOf(function*(){}()));evaluate(GeneratorPrototype);"
-}
-
-yield_dot: {
-    options = {
-    }
-    input: {
-        function* foo(){
-            yield x.foo;
-            (yield x).foo;
-            yield (yield obj.foo()).bar();
-        }
-    }
-    expect_exact: "function*foo(){yield x.foo;(yield x).foo;yield(yield obj.foo()).bar()}"
-}
-
-yield_sub: {
-    options = {
-    }
-    input: {
-        function* foo(){
-            yield x['foo'];
-            (yield x)['foo'];
-            yield (yield obj.foo())['bar']();
-        }
-    }
-    expect_exact: 'function*foo(){yield x["foo"];(yield x)["foo"];yield(yield obj.foo())["bar"]()}'
-}

test/exports.js

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

test/input/invalid/const.js

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

test/input/invalid/delete.js

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

test/input/invalid/else.js

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

test/input/invalid/function_1.js

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

test/input/invalid/function_2.js

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

test/input/invalid/function_3.js

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

test/input/invalid/return.js

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

test/input/invalid/try.js

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

test/input/invalid/var.js

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

test/jetstream.js

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

test/mocha/accessorTokens-1492.js

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

test/mocha/arguments.js

@@ -1,4 +1,4 @@
-var UglifyJS = require("../node");
+var UglifyJS = require('../../');
 var assert = require("assert");
 
 describe("arguments", function() {
@@ -27,253 +27,4 @@ describe("arguments", function() {
         assert.strictEqual(ast.body[0].body[0].uses_arguments, true);
         assert.strictEqual(ast.body[0].body[0].body[0].uses_arguments, false);
     });
-
-    it("Should parse a function containing default assignment correctly", function() {
-        var ast = UglifyJS.parse("function foo(a = 123) {}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // First argument
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_DefaultAssign);
-        assert(ast.body[0].argnames[0].left instanceof UglifyJS.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].argnames[0].operator, "=");
-        assert(ast.body[0].argnames[0].right instanceof UglifyJS.AST_Number);
-
-        ast = UglifyJS.parse("function foo(a = a) {}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // First argument
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_DefaultAssign);
-        assert(ast.body[0].argnames[0].left instanceof UglifyJS.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].argnames[0].operator, "=");
-        assert(ast.body[0].argnames[0].right instanceof UglifyJS.AST_SymbolRef);
-    });
-
-    it("Should parse a function containing default assignments in destructuring correctly", function() {
-        var ast = UglifyJS.parse("function foo([a = 123]) {}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // First argument
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].is_array, true);
-        assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
-        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_DefaultAssign);
-        assert(ast.body[0].argnames[0].names[0].left instanceof UglifyJS.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].argnames[0].names[0].operator, "=");
-        assert(ast.body[0].argnames[0].names[0].right instanceof UglifyJS.AST_Number);
-
-
-        ast = UglifyJS.parse("function foo({a = 123}) {}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // First argument
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].is_array, false);
-        assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
-        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
-
-        // Property a of first argument
-        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_DefaultAssign);
-        assert(ast.body[0].argnames[0].names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].argnames[0].names[0].value.operator, "=");
-        assert(ast.body[0].argnames[0].names[0].value.right instanceof UglifyJS.AST_Number);
-
-
-        ast = UglifyJS.parse("function foo({a: a = 123}) {}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // First argument
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].is_array, false);
-        assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
-
-        // Content destructuring of first argument
-        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
-        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_DefaultAssign);
-
-        // Property a of first argument
-        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_DefaultAssign);
-        assert(ast.body[0].argnames[0].names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].argnames[0].names[0].value.operator, "=");
-        assert(ast.body[0].argnames[0].names[0].value.right instanceof UglifyJS.AST_Number);
-    });
-
-    it("Should parse a function containing default assignments in complex destructuring correctly", function() {
-        var ast = UglifyJS.parse("function foo([a, [b = 123]]){}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // Check first argument
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].is_array, true);
-        assert.strictEqual(ast.body[0].argnames[0].names.length, 2);
-
-        // Check whole destructuring structure of first argument
-        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
-        assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].names[1].is_array, true);
-
-        // Check content of second destructuring element (which is the nested destructuring pattern)
-        assert(ast.body[0].argnames[0].names[1].names[0] instanceof UglifyJS.AST_DefaultAssign);
-        assert(ast.body[0].argnames[0].names[1].names[0].left instanceof UglifyJS.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].argnames[0].names[1].names[0].operator, "=");
-        assert(ast.body[0].argnames[0].names[1].names[0].right instanceof UglifyJS.AST_Number);
-
-
-        ast = UglifyJS.parse("function foo([a, {b: c = 123}]){}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // Check first argument
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].is_array, true);
-        assert.strictEqual(ast.body[0].argnames[0].names.length, 2);
-
-        // Check whole destructuring structure of first argument
-        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
-        assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].names[1].is_array, false);
-
-        // Check content of second destructuring element (which is the nested destructuring pattern)
-        assert(ast.body[0].argnames[0].names[1].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].argnames[0].names[1].names[0].key, "b");
-        assert(ast.body[0].argnames[0].names[1].names[0].value instanceof UglifyJS.AST_DefaultAssign);
-
-        // Property b of second argument
-        assert(ast.body[0].argnames[0].names[1].names[0].value instanceof UglifyJS.AST_DefaultAssign);
-        assert(ast.body[0].argnames[0].names[1].names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].argnames[0].names[1].names[0].value.operator, "=");
-        assert(ast.body[0].argnames[0].names[1].names[0].value.right instanceof UglifyJS.AST_Number);
-
-
-        ast = UglifyJS.parse("function foo({a, b: {b = 123}}){}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // Check first argument
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].is_array, false);
-        assert.strictEqual(ast.body[0].argnames[0].names.length, 2);
-
-        // Check whole destructuring structure of first argument
-        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
-        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_SymbolFunarg);
-        assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].argnames[0].names[1].key, "b");
-        assert(ast.body[0].argnames[0].names[1].value instanceof UglifyJS.AST_Destructuring);
-
-        // Check content of nested destructuring in first parameter
-        var content = ast.body[0].argnames[0].names[1].value
-        assert.strictEqual(content.is_array, false);
-        assert.strictEqual(content.names.length, 1);
-        assert(content.names[0] instanceof UglifyJS.AST_ObjectKeyVal);
-        assert.strictEqual(content.names[0].key, "b");
-        assert(content.names[0].value instanceof UglifyJS.AST_DefaultAssign);
-        assert(content.names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
-        assert.strictEqual(content.names[0].value.operator, "=");
-        assert(content.names[0].value.right instanceof UglifyJS.AST_Number);
-
-
-        ast = UglifyJS.parse("function foo({a: {b = 123}}){}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // Check first argument
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].is_array, false);
-        assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
-
-        // Check whole destructuring structure of first argument
-        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
-        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_Destructuring);
-
-        // Check content of nested destructuring
-        content = ast.body[0].argnames[0].names[0].value
-        assert.strictEqual(content.is_array, false);
-        assert.strictEqual(content.names.length, 1);
-        assert(content.names[0] instanceof UglifyJS.AST_ObjectKeyVal);
-        assert.strictEqual(content.names[0].key, "b");
-        assert(content.names[0].value instanceof UglifyJS.AST_DefaultAssign);
-        assert(content.names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
-        assert.strictEqual(content.names[0].value.operator, "=");
-        assert(content.names[0].value.right instanceof UglifyJS.AST_Number);
-    });
-
-    it("Should parse spread correctly", function() {
-        var ast = UglifyJS.parse("function foo(a, b, ...c){}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 3);
-
-        // Check parameters
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_SymbolFunarg);
-        assert(ast.body[0].argnames[1] instanceof UglifyJS.AST_SymbolFunarg);
-        assert(ast.body[0].argnames[2] instanceof UglifyJS.AST_Expansion);
-        assert(ast.body[0].argnames[2].expression instanceof UglifyJS.AST_SymbolFunarg);
-
-
-        ast = UglifyJS.parse("function foo([a, b, ...c]){}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // Check first parameter
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].is_array, true);
-
-        // Check content first parameter
-        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
-        assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_SymbolFunarg);
-        assert(ast.body[0].argnames[0].names[2] instanceof UglifyJS.AST_Expansion);
-        assert(ast.body[0].argnames[0].names[2].expression instanceof UglifyJS.AST_SymbolFunarg);
-
-
-        ast = UglifyJS.parse("function foo([a, b, [c, ...d]]){}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // Check first parameter
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].is_array, true);
-
-        // Check content outer destructuring array
-        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
-        assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_SymbolFunarg);
-        assert(ast.body[0].argnames[0].names[2] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].names[2].is_array, true);
-
-        // Check content nested destructuring array
-        assert.strictEqual(ast.body[0].argnames[0].names[2].names.length, 2);
-        assert(ast.body[0].argnames[0].names[2].names[0] instanceof UglifyJS.AST_SymbolFunarg);
-        assert(ast.body[0].argnames[0].names[2].names[1] instanceof UglifyJS.AST_Expansion);
-        assert(ast.body[0].argnames[0].names[2].names[1].expression instanceof UglifyJS.AST_SymbolFunarg);
-
-
-        ast = UglifyJS.parse("function foo({a: [b, ...c]}){}");
-        assert(ast.body[0] instanceof UglifyJS.AST_Defun);
-        assert.strictEqual(ast.body[0].argnames.length, 1);
-
-        // Check first parameter
-        assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].is_array, false);
-
-        // Check outer destructuring object
-        assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
-        assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
-        assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_Destructuring);
-        assert.strictEqual(ast.body[0].argnames[0].names[0].value.is_array, true);
-
-        // Check content nested destructuring array
-        assert.strictEqual(ast.body[0].argnames[0].names[0].value.names.length, 2);
-        assert(ast.body[0].argnames[0].names[0].value.names[0] instanceof UglifyJS.AST_SymbolFunarg);
-        assert(ast.body[0].argnames[0].names[0].value.names[1] instanceof UglifyJS.AST_Expansion);
-        assert(ast.body[0].argnames[0].names[0].value.names[1].expression instanceof UglifyJS.AST_SymbolFunarg);
-    });
-});
+});

test/mocha/arrow.js

@@ -1,402 +0,0 @@
-var assert = require("assert");
-var uglify = require("../node");
-
-describe("Arrow functions", function() {
-    it("Should not accept spread tokens on non-last parameters or without arguments parentheses", function() {
-        var tests = [
-            "var a = ...a => {return a.join()}",
-            "var b = (a, ...b, c) => { return a + b.join() + c}",
-            "var c = (...a, b) => a.join()"
-        ];
-        var test = function(code) {
-            return function() {
-                uglify.parse(code);
-            }
-        }
-        var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                e.message === "Unexpected token: expand (...)";
-        }
-
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error);
-        }
-    });
-    it("Should not accept holes in object binding patterns, while still allowing a trailing elision", function() {
-        var tests = [
-            "f = ({, , ...x} = [1, 2]) => {};"
-        ];
-        var test = function(code) {
-            return function() {
-                uglify.parse(code);
-            }
-        }
-        var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                e.message === "Unexpected token: punc (,)";
-        }
-
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error);
-        }
-    });
-    it("Should not accept newlines before arrow token", function() {
-        var tests = [
-            "f = foo\n=> 'foo';",
-            "f = (foo, bar)\n=> 'foo';",
-            "f = ()\n=> 'foo';",
-            "foo((bar)\n=>'baz';);"
-        ];
-        var test = function(code) {
-            return function() {
-                uglify.parse(code);
-            }
-        }
-        var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                e.message === "Unexpected newline before arrow (=>)";
-        }
-
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error);
-        }
-    });
-    it("Should not accept arrow functions in the middle or end of an expression", function() {
-        var tests = [
-            "typeof x => 0",
-            "0 + x => 0"
-        ];
-        var test = function(code) {
-            return function() {
-                uglify.parse(code);
-            }
-        }
-        var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                e.message === "Unexpected token: arrow (=>)";
-        }
-
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error);
-        }
-    });
-
-    it("Should parse a function containing default assignment correctly", function() {
-        var ast = uglify.parse("var a = (a = 123) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // First argument
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_DefaultAssign);
-        assert(ast.body[0].definitions[0].value.argnames[0].left instanceof uglify.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].operator, "=");
-        assert(ast.body[0].definitions[0].value.argnames[0].right instanceof uglify.AST_Number);
-
-        ast = uglify.parse("var a = (a = a) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // First argument
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_DefaultAssign);
-        assert(ast.body[0].definitions[0].value.argnames[0].left instanceof uglify.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].operator, "=");
-        assert(ast.body[0].definitions[0].value.argnames[0].right instanceof uglify.AST_SymbolRef);
-    });
-
-    it("Should parse a function containing default assignments in destructuring correctly", function() {
-        var ast = uglify.parse("var a = ([a = 123]) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // First argument
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_DefaultAssign);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].left instanceof uglify.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].operator, "=");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].right instanceof uglify.AST_Number);
-
-
-        ast = uglify.parse("var a = ({a = 123}) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // First argument
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
-
-        // First object element in first argument
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_DefaultAssign);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.left instanceof uglify.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.operator, "=");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.right instanceof uglify.AST_Number);
-
-
-        ast = uglify.parse("var a = ({a: a = 123}) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // First argument
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
-
-        // Content destructuring of first argument
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectProperty);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_DefaultAssign);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.left instanceof uglify.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.operator, "=");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.right instanceof uglify.AST_Number);
-    });
-
-    it("Should parse a function containing default assignments in complex destructuring correctly", function() {
-        var ast = uglify.parse("var a = ([a, [b = 123]]) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // Check first argument
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 2);
-
-        // Check whole destructuring structure of first argument
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].is_array, true);
-
-        // Check content of second destructuring element (which is the nested destructuring pattern)
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0] instanceof uglify.AST_DefaultAssign);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].left instanceof uglify.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].operator, "=");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].right instanceof uglify.AST_Number);
-
-
-        ast = uglify.parse("var a = ([a, {b: c = 123}]) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // Check first argument
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 2);
-
-        // Check whole destructuring structure of first argument
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].is_array, false);
-
-        // Check content of second destructuring element (which is the nested destructuring pattern)
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0] instanceof uglify.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].key, "b");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value instanceof uglify.AST_DefaultAssign);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value.left instanceof uglify.AST_SymbolFunarg);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value.operator, "=");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value.right instanceof uglify.AST_Number);
-
-
-        ast = uglify.parse("var a = ({a, b: {b = 123}}) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // Check first argument
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 2);
-
-        // First argument, property 1
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_SymbolFunarg);
-
-        // First argument, property 2
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].key, "b");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1].value instanceof uglify.AST_Destructuring);
-
-        // Check content of nested destructuring
-        var content = ast.body[0].definitions[0].value.argnames[0].names[1].value
-        assert.strictEqual(content.is_array, false);
-        assert.strictEqual(content.names.length, 1);
-        assert(content.names[0] instanceof uglify.AST_ObjectKeyVal);
-
-        // Content of first property in nested destructuring
-        assert.strictEqual(content.names[0].key, "b");
-        assert(content.names[0].value instanceof uglify.AST_DefaultAssign);
-        assert(content.names[0].value.left instanceof uglify.AST_SymbolFunarg);
-        assert.strictEqual(content.names[0].value.operator, "=");
-        assert(content.names[0].value.right instanceof uglify.AST_Number);
-
-
-        ast = uglify.parse("var a = ({a: {b = 123}}) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // Check first argument
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
-
-        // Check whole destructuring structure of first argument
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_Destructuring);
-
-        // Check content of nested destructuring
-        content = ast.body[0].definitions[0].value.argnames[0].names[0].value
-        assert.strictEqual(content.is_array, false);
-        assert.strictEqual(content.names.length, 1);
-        assert(content.names[0] instanceof uglify.AST_ObjectKeyVal);
-
-        // Check first property of nested destructuring
-        assert.strictEqual(content.names[0].key, "b");
-        assert(content.names[0].value instanceof uglify.AST_DefaultAssign);
-        assert(content.names[0].value.left instanceof uglify.AST_SymbolFunarg);
-        assert.strictEqual(content.names[0].value.operator, "=");
-        assert(content.names[0].value.right instanceof uglify.AST_Number);
-    });
-
-    it("Should parse spread correctly", function() {
-        var ast = uglify.parse("var a = (a, b, ...c) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 3);
-
-        // Check parameters
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_SymbolFunarg);
-        assert(ast.body[0].definitions[0].value.argnames[1] instanceof uglify.AST_SymbolFunarg);
-        assert(ast.body[0].definitions[0].value.argnames[2] instanceof uglify.AST_Expansion);
-        assert(ast.body[0].definitions[0].value.argnames[2].expression instanceof uglify.AST_SymbolFunarg);
-
-
-        ast = uglify.parse("var a = ([a, b, ...c]) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // Check first parameter
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
-
-        // Check content first parameter
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_SymbolFunarg);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[2] instanceof uglify.AST_Expansion);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[2].expression instanceof uglify.AST_SymbolFunarg);
-
-
-        ast = uglify.parse("var a = ([a, b, [c, ...d]]) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // Check first parameter
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
-
-        // Check content outer destructuring array
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_SymbolFunarg);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[2] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[2].is_array, true);
-
-        // Check content nested destructuring array
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[2].names.length, 2);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[2].names[0] instanceof uglify.AST_SymbolFunarg);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[2].names[1] instanceof uglify.AST_Expansion);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[2].names[1].expression instanceof uglify.AST_SymbolFunarg);
-
-
-        ast = uglify.parse("var a = ({a: [b, ...c]}) => {}");
-        assert(ast.body[0] instanceof uglify.AST_Var);
-        assert.strictEqual(ast.body[0].definitions.length, 1);
-        assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
-        assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
-        assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
-
-        // Check first parameter
-        assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
-
-        // Check outer destructuring object
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_Destructuring);
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.is_array, true);
-
-        // Check content nested destructuring array
-        assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.names.length, 2);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.names[0] instanceof uglify.AST_SymbolFunarg);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.names[1] instanceof uglify.AST_Expansion);
-        assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.names[1].expression instanceof uglify.AST_SymbolFunarg);
-    });
-
-    it("Should handle arrow function with bind", function() {
-        function minify(code) {
-            return uglify.minify(code, {
-                mangle: false
-            }).code;
-        }
-
-        assert.strictEqual(
-            minify(minify("test(((index) => { console.log(this, index); }).bind(this, 1));")),
-            "test((index=>{console.log(this,index)}).bind(this,1));"
-        );
-        assert.strictEqual(
-            minify(minify('test(((index) => { console.log(this, index); })["bind"](this, 1));')),
-            "test((index=>{console.log(this,index)}).bind(this,1));"
-        );
-    });
-
-});

test/mocha/builtins.js

@@ -1,34 +0,0 @@
-var UglifyJS = require("../../");
-var assert = require("assert");
-
-describe("builtins", function() {
-    it ("Should not mangle builtins", function() {
-        var test = "function foo(something){\n" +
-            "    return [Object,Array,Function,Number,String,Boolean,Error,Math,Date,RegExp,Symbol,Map,Promise,Proxy,Reflect,Set,WeakMap,WeakSet,Float32Array,something];\n" +
-            "};";
-
-        var result = UglifyJS.minify(test, {parse: {bare_returns: true}}).code;
-
-        assert.strictEqual(result.indexOf("something"), -1);
-
-        assert.notEqual(result.indexOf("Object"), -1);
-        assert.notEqual(result.indexOf("Array"), -1);
-        assert.notEqual(result.indexOf("Function"), -1);
-        assert.notEqual(result.indexOf("Number"), -1);
-        assert.notEqual(result.indexOf("String"), -1);
-        assert.notEqual(result.indexOf("Boolean"), -1);
-        assert.notEqual(result.indexOf("Error"), -1);
-        assert.notEqual(result.indexOf("Math"), -1);
-        assert.notEqual(result.indexOf("Date"), -1);
-        assert.notEqual(result.indexOf("RegExp"), -1);
-        assert.notEqual(result.indexOf("Symbol"), -1);
-        assert.notEqual(result.indexOf("Promise"), -1);
-        assert.notEqual(result.indexOf("Proxy"), -1);
-        assert.notEqual(result.indexOf("Reflect"), -1);
-        assert.notEqual(result.indexOf("Set"), -1);
-        assert.notEqual(result.indexOf("WeakMap"), -1);
-        assert.notEqual(result.indexOf("WeakSet"), -1);
-        assert.notEqual(result.indexOf("Map"), -1);
-        assert.notEqual(result.indexOf("Float32Array"), -1);
-    });
-});

test/mocha/class.js

@@ -1,57 +0,0 @@
-var assert = require("assert");
-var uglify = require("../node");
-
-describe("Class", function() {
-    it("Should not accept spread on non-last parameters in methods", function() {
-        var tests = [
-            "class foo { bar(...a, b) { return a.join(b) } }",
-            "class foo { bar(a, b, ...c, d) { return c.join(a + b) + d } }",
-            "class foo { *bar(...a, b) { return a.join(b) } }",
-            "class foo { *bar(a, b, ...c, d) { return c.join(a + b) + d } }"
-        ];
-        var test = function(code) {
-            return function() {
-                uglify.parse(code);
-            }
-        }
-        var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                /^Unexpected token: /.test(e.message);
-        }
-
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error);
-        }
-    });
-
-    it("Should return the correct token for class methods", function() {
-        var tests = [
-            {
-                code: "class foo{static test(){}}",
-                token_value_start: "static",
-                token_value_end: "}"
-            },
-            {
-                code: "class bar{*procedural(){}}",
-                token_value_start: "*",
-                token_value_end: "}"
-            },
-            {
-                code: "class foobar{aMethod(){}}",
-                token_value_start: "aMethod",
-                token_value_end: "}"
-            },
-            {
-                code: "class foobaz{get something(){}}",
-                token_value_start: "get",
-                token_value_end: "}"
-            }
-        ];
-
-        for (var i = 0; i < tests.length; i++) {
-            var ast = uglify.parse(tests[i].code);
-            assert.strictEqual(ast.body[0].properties[0].start.value, tests[i].token_value_start);
-            assert.strictEqual(ast.body[0].properties[0].end.value, tests[i].token_value_end);
-        }
-    });
-});

test/mocha/cli.js

@@ -2,10 +2,6 @@ var assert = require("assert");
 var exec = require("child_process").exec;
 var readFileSync = require("fs").readFileSync;
 
-function read(path) {
-    return readFileSync(path, "utf8");
-}
-
 describe("bin/uglifyjs", function () {
     var uglifyjscmd = '"' + process.argv[0] + '" bin/uglifyjs';
     it("should produce a functional build when using --self", function (done) {
@@ -19,12 +15,12 @@ describe("bin/uglifyjs", function () {
             eval(stdout);
 
             assert.strictEqual(typeof WrappedUglifyJS, 'object');
-            assert.strictEqual(WrappedUglifyJS.minify("foo([true,,2+3]);").code, "foo([!0,,5]);");
+            assert.strictEqual(true, WrappedUglifyJS.parse('foo;') instanceof WrappedUglifyJS.AST_Node);
 
             done();
         });
     });
-    it("Should be able to filter comments correctly with `--comments all`", function (done) {
+    it("Should be able to filter comments correctly with `--comment all`", function (done) {
         var command = uglifyjscmd + ' test/input/comments/filter.js --comments all';
 
         exec(command, function (err, stdout) {
@@ -54,18 +50,18 @@ describe("bin/uglifyjs", function () {
             done();
         });
     });
-    it("Should append source map to output when using --source-map url=inline", function (done) {
-        var command = uglifyjscmd + " test/input/issue-1323/sample.js --source-map url=inline";
+    it("Should append source map to output when using --source-map-inline", function (done) {
+       var command = uglifyjscmd + ' test/input/issue-1323/sample.js --source-map-inline';
 
-        exec(command, function (err, stdout) {
-            if (err) throw err;
+       exec(command, function (err, stdout) {
+           if (err) throw err;
 
-            assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n" +
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=\n");
-            done();
-        });
+           assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n" +
+               "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=\n");
+           done();
+       });
     });
-    it("should not append source map to output when not using --source-map url=inline", function (done) {
+    it("should not append source map to output when not using --source-map-inline", function (done) {
         var command = uglifyjscmd + ' test/input/issue-1323/sample.js';
 
         exec(command, function (err, stdout) {
@@ -76,134 +72,130 @@ describe("bin/uglifyjs", function () {
         });
     });
     it("Should work with --keep-fnames (mangle only)", function (done) {
-        var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m';
+       var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m';
 
-        exec(command, function (err, stdout) {
-            if (err) throw err;
+       exec(command, function (err, stdout) {
+           if (err) throw err;
 
-            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
-            done();
-        });
+           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
+           done();
+       });
     });
     it("Should work with --keep-fnames (mangle & compress)", function (done) {
-        var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m -c unused=false';
+       var command = uglifyjscmd + ' test/input/issue-1431/sample.js --keep-fnames -m -c unused=false';
 
-        exec(command, function (err, stdout) {
-            if (err) throw err;
+       exec(command, function (err, stdout) {
+           if (err) throw err;
 
-            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(5==f(g)());\n");
-            done();
-        });
+           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(5==f(g)());\n");
+           done();
+       });
     });
     it("Should work with keep_fnames under mangler options", function (done) {
-        var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep_fnames=true';
+       var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep_fnames=true';
 
-        exec(command, function (err, stdout) {
-            if (err) throw err;
+       exec(command, function (err, stdout) {
+           if (err) throw err;
 
-            assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
-            done();
-        });
+           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
+           done();
+       });
     });
     it("Should work with --define (simple)", function (done) {
-        var command = uglifyjscmd + ' test/input/global_defs/simple.js --define D=5 -c';
+       var command = uglifyjscmd + ' test/input/global_defs/simple.js --define D=5 -c';
 
-        exec(command, function (err, stdout) {
-            if (err) throw err;
+       exec(command, function (err, stdout) {
+           if (err) throw err;
 
-            assert.strictEqual(stdout, "console.log(5);\n");
-            done();
-        });
+           assert.strictEqual(stdout, "console.log(5);\n");
+           done();
+       });
     });
     it("Should work with --define (nested)", function (done) {
-        var command = uglifyjscmd + ' test/input/global_defs/nested.js --define C.D=5,C.V=3 -c';
+       var command = uglifyjscmd + ' test/input/global_defs/nested.js --define C.D=5,C.V=3 -c';
 
-        exec(command, function (err, stdout) {
-            if (err) throw err;
+       exec(command, function (err, stdout) {
+           if (err) throw err;
 
-            assert.strictEqual(stdout, "console.log(3,5);\n");
-            done();
-        });
+           assert.strictEqual(stdout, "console.log(3,5);\n");
+           done();
+       });
     });
     it("Should work with --define (AST_Node)", function (done) {
-        var command = uglifyjscmd + ' test/input/global_defs/simple.js --define console.log=stdout.println -c';
+       var command = uglifyjscmd + ' test/input/global_defs/simple.js --define console.log=stdout.println -c';
 
-        exec(command, function (err, stdout) {
-            if (err) throw err;
+       exec(command, function (err, stdout) {
+           if (err) throw err;
 
-            assert.strictEqual(stdout, "stdout.println(D);\n");
-            done();
-        });
+           assert.strictEqual(stdout, "stdout.println(D);\n");
+           done();
+       });
     });
     it("Should work with `--beautify`", function (done) {
-        var command = uglifyjscmd + ' test/input/issue-1482/input.js -b';
+       var command = uglifyjscmd + ' test/input/issue-1482/input.js -b';
 
-        exec(command, function (err, stdout) {
-            if (err) throw err;
+       exec(command, function (err, stdout) {
+           if (err) throw err;
 
-            assert.strictEqual(stdout, read("test/input/issue-1482/default.js"));
-            done();
-        });
+           assert.strictEqual(stdout, readFileSync("test/input/issue-1482/default.js", "utf8"));
+           done();
+       });
     });
     it("Should work with `--beautify bracketize`", function (done) {
-        var command = uglifyjscmd + ' test/input/issue-1482/input.js -b bracketize';
+       var command = uglifyjscmd + ' test/input/issue-1482/input.js -b bracketize';
 
-        exec(command, function (err, stdout) {
-            if (err) throw err;
+       exec(command, function (err, stdout) {
+           if (err) throw err;
 
-            assert.strictEqual(stdout, read("test/input/issue-1482/bracketize.js"));
-            done();
-        });
+           assert.strictEqual(stdout, readFileSync("test/input/issue-1482/bracketize.js", "utf8"));
+           done();
+       });
     });
     it("Should process inline source map", function(done) {
-        var command = uglifyjscmd + " test/input/issue-520/input.js -mc toplevel --source-map content=inline,url=inline";
+        var command = uglifyjscmd + ' test/input/issue-520/input.js -mc toplevel --in-source-map inline --source-map-inline';
 
         exec(command, function (err, stdout) {
             if (err) throw err;
 
-            assert.strictEqual(stdout, read("test/input/issue-520/output.js"));
+            assert.strictEqual(stdout, readFileSync("test/input/issue-520/output.js", "utf8"));
             done();
         });
     });
     it("Should warn for missing inline source map", function(done) {
-        var command = uglifyjscmd + " test/input/issue-1323/sample.js --source-map content=inline,url=inline";
+        var command = uglifyjscmd + ' test/input/issue-1323/sample.js --in-source-map inline';
 
         exec(command, function (err, stdout, stderr) {
             if (err) throw err;
 
-            assert.strictEqual(stdout, [
-                "var bar=function(){function foo(bar){return bar}return foo}();",
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaW5wdXQvaXNzdWUtMTMyMy9zYW1wbGUuanMiXSwibmFtZXMiOlsiYmFyIiwiZm9vIl0sIm1hcHBpbmdzIjoiQUFBQSxHQUFJQSxLQUFNLFdBQ04sUUFBU0MsS0FBS0QsS0FDVixNQUFPQSxLQUdYLE1BQU9DIn0=",
-                "",
-            ].join("\n"));
+            assert.strictEqual(stdout, "var bar=function(){function foo(bar){return bar}return foo}();\n");
             assert.strictEqual(stderr, "WARN: inline source map not found\n");
             done();
         });
     });
     it("Should fail with multiple input and inline source map", function(done) {
-        var command = uglifyjscmd + " test/input/issue-520/input.js test/input/issue-520/output.js --source-map content=inline,url=inline";
+        var command = uglifyjscmd + ' test/input/issue-520/input.js test/input/issue-520/output.js --in-source-map inline --source-map-inline';
 
         exec(command, function (err, stdout, stderr) {
             assert.ok(err);
-            assert.strictEqual(stderr.split(/\n/)[0], "ERROR: inline source map only works with singular input");
+            assert.strictEqual(stderr, "ERROR: Inline source map only works with singular input\n");
             done();
         });
     });
     it("Should fail with acorn and inline source map", function(done) {
-        var command = uglifyjscmd + " test/input/issue-520/input.js --source-map content=inline,url=inline -p acorn";
+        var command = uglifyjscmd + ' test/input/issue-520/input.js --in-source-map inline --source-map-inline --acorn';
 
         exec(command, function (err, stdout, stderr) {
             assert.ok(err);
-            assert.strictEqual(stderr, "ERROR: inline source map only works with built-in parser\n");
+            assert.strictEqual(stderr, "ERROR: Inline source map only works with built-in parser\n");
             done();
         });
     });
     it("Should fail with SpiderMonkey and inline source map", function(done) {
-        var command = uglifyjscmd + " test/input/issue-520/input.js --source-map content=inline,url=inline -p spidermonkey";
+        var command = uglifyjscmd + ' test/input/issue-520/input.js --in-source-map inline --source-map-inline --spidermonkey';
 
         exec(command, function (err, stdout, stderr) {
             assert.ok(err);
-            assert.strictEqual(stderr, "ERROR: inline source map only works with built-in parser\n");
+            assert.strictEqual(stderr, "ERROR: Inline source map only works with built-in parser\n");
             done();
         });
     });
@@ -216,7 +208,7 @@ describe("bin/uglifyjs", function () {
             assert.strictEqual(lines[0], "Parse error at test/input/invalid/simple.js:1,12");
             assert.strictEqual(lines[1], "function f(a{}");
             assert.strictEqual(lines[2], "            ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token punc «{», expected punc «,»");
+            assert.strictEqual(lines[3], "SyntaxError: Unexpected token punc «{», expected punc «,»");
             done();
         });
     });
@@ -229,7 +221,7 @@ describe("bin/uglifyjs", function () {
             assert.strictEqual(lines[0], "Parse error at test/input/invalid/tab.js:1,12");
             assert.strictEqual(lines[1], "\t\tfoo(\txyz, 0abc);");
             assert.strictEqual(lines[2], "\t\t    \t     ^");
-            assert.strictEqual(lines[3], "ERROR: Invalid syntax: 0abc");
+            assert.strictEqual(lines[3], "SyntaxError: Invalid syntax: 0abc");
             done();
         });
     });
@@ -242,7 +234,7 @@ describe("bin/uglifyjs", function () {
             assert.strictEqual(lines[0], "Parse error at test/input/invalid/eof.js:2,0");
             assert.strictEqual(lines[1], "foo, bar(");
             assert.strictEqual(lines[2], "         ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: eof (undefined)");
+            assert.strictEqual(lines[3], "SyntaxError: Unexpected token: eof (undefined)");
             done();
         });
     });
@@ -255,299 +247,138 @@ describe("bin/uglifyjs", function () {
             assert.strictEqual(lines[0], "Parse error at test/input/invalid/loop-no-body.js:2,0");
             assert.strictEqual(lines[1], "for (var i = 0; i < 1; i++) ");
             assert.strictEqual(lines[2], "                            ^");
-            assert.strictEqual(lines[3], "ERROR: Unexpected token: eof (undefined)");
+            assert.strictEqual(lines[3], "SyntaxError: Unexpected token: eof (undefined)");
             done();
         });
     });
+    it("Should support hyphen as shorthand", function(done) {
+       var command = uglifyjscmd + ' test/input/issue-1431/sample.js -m keep-fnames=true';
+
+       exec(command, function (err, stdout) {
+           if (err) throw err;
+
+           assert.strictEqual(stdout, "function f(r){return function(){function n(n){return n*n}return r(n)}}function g(n){return n(1)+n(2)}console.log(f(g)()==5);\n");
+           done();
+       });
+    });
     it("Should throw syntax error (5--)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/assign_1.js';
+       var command = uglifyjscmd + ' test/input/invalid/assign_1.js';
 
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/assign_1.js:1,18",
-                "console.log(1 || 5--);",
-                "                  ^",
-                "ERROR: Invalid use of -- operator"
-            ].join("\n"));
-            done();
-        });
+       exec(command, function (err, stdout, stderr) {
+           assert.ok(err);
+           assert.strictEqual(stdout, "");
+           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+               "Parse error at test/input/invalid/assign_1.js:1,18",
+               "console.log(1 || 5--);",
+               "                  ^",
+               "SyntaxError: Invalid use of -- operator"
+           ].join("\n"));
+           done();
+       });
     });
     it("Should throw syntax error (Math.random() /= 2)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/assign_2.js';
+       var command = uglifyjscmd + ' test/input/invalid/assign_2.js';
 
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/assign_2.js:1,32",
-                "console.log(2 || (Math.random() /= 2));",
-                "                                ^",
-                "ERROR: Invalid assignment"
-            ].join("\n"));
-            done();
-        });
+       exec(command, function (err, stdout, stderr) {
+           assert.ok(err);
+           assert.strictEqual(stdout, "");
+           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+               "Parse error at test/input/invalid/assign_2.js:1,32",
+               "console.log(2 || (Math.random() /= 2));",
+               "                                ^",
+               "SyntaxError: Invalid assignment"
+           ].join("\n"));
+           done();
+       });
     });
     it("Should throw syntax error (++this)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/assign_3.js';
+       var command = uglifyjscmd + ' test/input/invalid/assign_3.js';
 
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/assign_3.js:1,17",
-                "console.log(3 || ++this);",
-                "                 ^",
-                "ERROR: Invalid use of ++ operator"
-            ].join("\n"));
-            done();
-        });
+       exec(command, function (err, stdout, stderr) {
+           assert.ok(err);
+           assert.strictEqual(stdout, "");
+           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+               "Parse error at test/input/invalid/assign_3.js:1,17",
+               "console.log(3 || ++this);",
+               "                 ^",
+               "SyntaxError: Invalid use of ++ operator"
+           ].join("\n"));
+           done();
+       });
     });
     it("Should throw syntax error (++null)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/assign_4.js';
+       var command = uglifyjscmd + ' test/input/invalid/assign_4.js';
 
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/assign_4.js:1,0",
-                "++null",
-                "^",
-                "ERROR: Invalid use of ++ operator"
-            ].join("\n"));
-            done();
-        });
+       exec(command, function (err, stdout, stderr) {
+           assert.ok(err);
+           assert.strictEqual(stdout, "");
+           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+               "Parse error at test/input/invalid/assign_4.js:1,0",
+               "++null",
+               "^",
+               "SyntaxError: Invalid use of ++ operator"
+           ].join("\n"));
+           done();
+       });
     });
     it("Should throw syntax error (a.=)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/dot_1.js';
+       var command = uglifyjscmd + ' test/input/invalid/dot_1.js';
 
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/dot_1.js:1,2",
-                "a.=",
-                "  ^",
-                "ERROR: Unexpected token: operator (=)"
-            ].join("\n"));
-            done();
-        });
+       exec(command, function (err, stdout, stderr) {
+           assert.ok(err);
+           assert.strictEqual(stdout, "");
+           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+               "Parse error at test/input/invalid/dot_1.js:1,2",
+               "a.=",
+               "  ^",
+               "SyntaxError: Unexpected token: operator (=)"
+           ].join("\n"));
+           done();
+       });
     });
     it("Should throw syntax error (%.a)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/dot_2.js';
+       var command = uglifyjscmd + ' test/input/invalid/dot_2.js';
 
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/dot_2.js:1,0",
-                "%.a;",
-                "^",
-                "ERROR: Unexpected token: operator (%)"
-            ].join("\n"));
-            done();
-        });
+       exec(command, function (err, stdout, stderr) {
+           assert.ok(err);
+           assert.strictEqual(stdout, "");
+           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+               "Parse error at test/input/invalid/dot_2.js:1,0",
+               "%.a;",
+               "^",
+               "SyntaxError: Unexpected token: operator (%)"
+           ].join("\n"));
+           done();
+       });
     });
     it("Should throw syntax error (a./();)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/dot_3.js';
+       var command = uglifyjscmd + ' test/input/invalid/dot_3.js';
 
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/dot_3.js:1,2",
-                "a./();",
-                "  ^",
-                "ERROR: Unexpected token: operator (/)"
-            ].join("\n"));
-            done();
-        });
+       exec(command, function (err, stdout, stderr) {
+           assert.ok(err);
+           assert.strictEqual(stdout, "");
+           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+               "Parse error at test/input/invalid/dot_3.js:1,2",
+               "a./();",
+               "  ^",
+               "SyntaxError: Unexpected token: operator (/)"
+           ].join("\n"));
+           done();
+       });
     });
     it("Should throw syntax error ({%: 1})", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/object.js';
+       var command = uglifyjscmd + ' test/input/invalid/object.js';
 
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/object.js:1,13",
-                "console.log({%: 1});",
-                "             ^",
-                "ERROR: Unexpected token: operator (%)"
-            ].join("\n"));
-            done();
-        });
-    });
-    it("Should throw syntax error (const a)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/const.js';
-
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/const.js:7,11",
-                "    const a;",
-                "           ^",
-                "ERROR: Missing initializer in const declaration"
-            ].join("\n"));
-            done();
-        });
-    });
-    it("Should throw syntax error (delete x)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/delete.js';
-
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/delete.js:13,11",
-                "    delete x;",
-                "           ^",
-                "ERROR: Calling delete on expression not allowed in strict mode"
-            ].join("\n"));
-            done();
-        });
-    });
-    it("Should throw syntax error (function g(arguments))", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/function_1.js';
-
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/function_1.js:4,11",
-                "function g(arguments) {",
-                "           ^",
-                "ERROR: Unexpected arguments in strict mode"
-            ].join("\n"));
-            done();
-        });
-    });
-    it("Should throw syntax error (function eval())", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/function_2.js';
-
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/function_2.js:4,9",
-                "function eval() {",
-                "         ^",
-                "ERROR: Unexpected eval in strict mode"
-            ].join("\n"));
-            done();
-        });
-    });
-    it("Should throw syntax error (iife arguments())", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/function_3.js';
-
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/function_3.js:4,10",
-                "!function arguments() {",
-                "          ^",
-                "ERROR: Unexpected arguments in strict mode"
-            ].join("\n"));
-            done();
-        });
-    });
-    it("Should throw syntax error (catch(eval))", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/try.js';
-
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/try.js:7,18",
-                "    try {} catch (eval) {}",
-                "                  ^",
-                "ERROR: Unexpected eval identifier as parameter inside strict mode"
-            ].join("\n"));
-            done();
-        });
-    });
-    it("Should throw syntax error (var eval)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/var.js';
-
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/var.js:7,8",
-                "    var eval;",
-                "        ^",
-                "ERROR: Unexpected eval in strict mode"
-            ].join("\n"));
-            done();
-        });
-    });
-    it("Should throw syntax error (else)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/else.js';
-
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/else.js:1,7",
-                "if (0) else 1;",
-                "       ^",
-                "ERROR: Unexpected token: keyword (else)"
-            ].join("\n"));
-            done();
-        });
-    });
-    it("Should throw syntax error (return)", function(done) {
-        var command = uglifyjscmd + ' test/input/invalid/return.js';
-
-        exec(command, function (err, stdout, stderr) {
-            assert.ok(err);
-            assert.strictEqual(stdout, "");
-            assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
-                "Parse error at test/input/invalid/return.js:1,0",
-                "return 42;",
-                "^",
-                "ERROR: 'return' outside of function"
-            ].join("\n"));
-            done();
-        });
-    });
-    it("Should handle literal string as source map input", function(done) {
-        var command = [
-            uglifyjscmd,
-            "test/input/issue-1236/simple.js",
-            "--source-map",
-            'content="' + read_map() + '",url=inline'
-        ].join(" ");
-
-        exec(command, function (err, stdout) {
-            if (err) throw err;
-
-            assert.strictEqual(stdout, [
-                '"use strict";var foo=function foo(x){return"foo "+x};console.log(foo("bar"));',
-                "//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImZvbyIsIngiLCJjb25zb2xlIiwibG9nIl0sIm1hcHBpbmdzIjoiWUFBQSxJQUFJQSxLQUFNLFFBQU5BLEtBQU1DLEdBQUEsTUFBSyxPQUFTQSxFQUN4QkMsU0FBUUMsSUFBSUgsSUFBSSJ9",
-                ""
-            ].join("\n"));
-            done();
-        });
-
-        function read_map() {
-            var map = JSON.parse(read("./test/input/issue-1236/simple.js.map"));
-            delete map.sourcesContent;
-            return JSON.stringify(map).replace(/"/g, '\\"');
-        }
-    });
-    it("Should dump AST as JSON", function(done) {
-        var command = uglifyjscmd + " test/input/global_defs/simple.js -mco ast";
-        exec(command, function (err, stdout) {
-            if (err) throw err;
-
-            var ast = JSON.parse(stdout);
-            assert.strictEqual(ast._class, "AST_Toplevel");
-            assert.ok(Array.isArray(ast.body));
-            done();
-        });
+       exec(command, function (err, stdout, stderr) {
+           assert.ok(err);
+           assert.strictEqual(stdout, "");
+           assert.strictEqual(stderr.split(/\n/).slice(0, 4).join("\n"), [
+               "Parse error at test/input/invalid/object.js:1,13",
+               "console.log({%: 1});",
+               "             ^",
+               "SyntaxError: Unexpected token: operator (%)"
+           ].join("\n"));
+           done();
+       });
     });
 });

test/mocha/comment-filter.js

@@ -1,4 +1,4 @@
-var UglifyJS = require("../node");
+var UglifyJS = require('../../');
 var assert = require("assert");
 
 describe("comment filters", function() {
@@ -75,6 +75,7 @@ describe("comment filters", function() {
 
     it("Should handle shebang and preamble correctly", function() {
         var code = UglifyJS.minify("#!/usr/bin/node\nvar x = 10;", {
+            fromString: true,
             output: { preamble: "/* Build */" }
         }).code;
         assert.strictEqual(code, "#!/usr/bin/node\n/* Build */\nvar x=10;");
@@ -82,6 +83,7 @@ describe("comment filters", function() {
 
     it("Should handle preamble without shebang correctly", function() {
         var code = UglifyJS.minify("var x = 10;", {
+            fromString: true,
             output: { preamble: "/* Build */" }
         }).code;
         assert.strictEqual(code, "/* Build */\nvar x=10;");

test/mocha/comment.js

@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../node");
+var uglify = require("../../");
 
 describe("Comment", function() {
     it("Should recognize eol of single line comments", function() {
@@ -20,7 +20,7 @@ describe("Comment", function() {
 
         for (var i = 0; i < tests.length; i++) {
             assert.throws(function() {
-                uglify.parse(tests[i]);
+                uglify.parse(tests[i], {fromString: true})
             }, fail, tests[i]);
         }
     });
@@ -31,8 +31,7 @@ describe("Comment", function() {
             "/*Some comment 2\r\n\r\n\r\n*/\r\n>\n\n\n\n\n\n",
             "/*Some comment 3\r\r\r*/\r>\n\n\n\n\n\n",
             "/*Some comment 4\u2028\u2028\u2028*/\u2028>\n\n\n\n\n\n",
-            "/*Some comment 5\u2029\u2029\u2029*/\u2029>\n\n\n\n\n\n",
-            "/*Some comment 6\udbff\udfff\udbff\udfff\n\n\n*/\n>\n\n\n\n\n"
+            "/*Some comment 5\u2029\u2029\u2029*/\u2029>\n\n\n\n\n\n"
         ];
 
         var fail = function(e) {
@@ -44,7 +43,7 @@ describe("Comment", function() {
 
         for (var i = 0; i < tests.length; i++) {
             assert.throws(function() {
-                uglify.parse(tests[i]);
+                uglify.parse(tests[i], {fromString: true})
             }, fail, tests[i]);
         }
     });

test/mocha/comment_before_constant.js

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

test/mocha/destructuring.js

@@ -1,138 +0,0 @@
-var assert = require("assert");
-var uglify = require("../node");
-
-describe("Destructuring", function() {
-    it("Should generate similar trees for destructuring in left hand side expressions, definitions, functions and arrow functions", function() {
-        var patterns = [
-            "[]",
-            "{}",
-
-            "[a, b, c]",
-            "{a: b, c: d}",
-            "{a}",
-            "{a, b}",
-
-            "{a: {}}",
-            "{a: []}",
-            "[{}]",
-            "[[]]",
-            "{a: {b}}",
-
-            // Can't do `a = 123` with lhs expression, so only test in destructuring
-            "[foo = bar]",
-            "{a = 123}",
-            "[{foo: abc = 123}]",
-            "{foo: [abc = 123]}",
-
-            "[...foo]",
-            "[...{}]",
-            "[...[]]"
-
-            // Can't do `...` because that is an invalid lhs expression, spread in array destructuring should be fine though
-        ];
-
-        var types = [
-            {
-                name: "lhs",
-                symbolType: uglify.AST_SymbolRef,
-                tree: function (ast) {
-                    return ast.body[0].body.left;
-                },
-                generate: function (code) {
-                    return "(" + code + " = a)";
-                }
-            },
-            {
-                name: "var",
-                symbolType: uglify.AST_SymbolVar,
-                tree: function (ast) {
-                    return ast.body[0].definitions[0].name;
-                },
-                generate: function (code) {
-                    return "var " + code + " = a";
-                }
-            },
-            {
-                name: "function",
-                symbolType: uglify.AST_SymbolFunarg,
-                tree: function (ast) {
-                    return ast.body[0].argnames[0];
-                },
-                generate: function (code) {
-                    return "function a(" + code + ") {}";
-                }
-            },
-            {
-                name: "arrow",
-                symbolType: uglify.AST_SymbolFunarg,
-                tree: function (ast) {
-                    return ast.body[0].definitions[0].value.argnames[0];
-                },
-                generate: function (code) {
-                    return "var a = (" + code + ") => {}";
-                }
-            }
-        ];
-
-        var walker = function(type, ref, code, result) {
-            var w = new uglify.TreeWalker(function(node) {
-                if (w.parent() instanceof uglify.AST_DefaultAssign &&
-                    w.parent().right === node
-                ) {
-                    return true; // Don't check the content of the default assignment
-
-                } else if (node instanceof uglify.AST_Symbol) {
-                    assert(node instanceof type.symbolType,
-                        node.TYPE + " while " + type.symbolType.TYPE + " expected at pos " +
-                        node.start.pos + " in `" + code + "`  (" + ref + ")"
-                    );
-
-                    result.push([
-                        new uglify.AST_Symbol({
-                            start: node.start,
-                            name: node.name,
-                            end: node.end
-                        }),
-                        w.parent()
-                    ]);
-
-                    return;
-                }
-
-                result.push([node, w.parent()]);
-            });
-
-            return w;
-        };
-
-        var getNodeType = function(node) {
-            return node[0].TYPE + (node[1] ? " " + node[1].TYPE : "");
-        }
-
-        for (var i = 0; i < patterns.length; i++) {
-            var results = [];
-
-            for (var j = 0; j < types.length; j++) {
-                var code = types[j].generate(patterns[i])
-                var ast = types[j].tree(
-                    uglify.parse(code)
-                );
-                results.push([]);
-                ast.walk(walker(
-                    types[j],
-                    "`" + patterns[i] + "` on " + types[j].name,
-                    code,
-                    results[j]
-                ));
-
-                if (j > 0) {
-                    assert.deepEqual(
-                        results[0].map(getNodeType),
-                        results[j].map(getNodeType),
-                        "AST disagree on " + patterns[i] + " with " + types[j].name
-                    );
-                }
-            }
-        }
-    });
-});

test/mocha/directives.js

@@ -1,5 +1,5 @@
 var assert = require("assert");
-var uglify = require("../node");
+var uglify = require("../../");
 
 describe("Directives", function() {
     it ("Should allow tokenizer to store directives state", function() {
@@ -62,10 +62,10 @@ describe("Directives", function() {
     it("Should know which strings are directive and which ones are not", function() {
         var test_directive = function(tokenizer, test) {
             test.directives.map(function(directive) {
-                assert.strictEqual(tokenizer.has_directive(directive), true, "Didn't found directive `" + directive + "` at the end of `" + test.input + '`');
+                assert.strictEqual(tokenizer.has_directive(directive), true, directive + " in " + test.input);
             });
             test.non_directives.map(function(fake_directive) {
-                assert.strictEqual(tokenizer.has_directive(fake_directive), false, "Unexpectedly found directive `" + fake_directive + "` at the end of `" + test.input + '`');
+                assert.strictEqual(tokenizer.has_directive(fake_directive), false, fake_directive + " in " + test.input);
             });
         }
 
@@ -156,16 +156,6 @@ describe("Directives", function() {
                 input: '"use strict";try{"use asm";',
                 directives: ["use strict"],
                 non_directives: ["use\nstrict", "use \nstrict", "use asm"]
-            },
-            {
-                input: 'class foo {',
-                directives: ["use strict"],
-                non_directives: ["use\nstrict", "use asm"]
-            },
-            {
-                input: 'class foo {}',
-                directives: [],
-                non_directives: ["use strict", "use asm", "use\nstrict"]
             }
         ];
 
@@ -207,7 +197,7 @@ describe("Directives", function() {
         assert.strictEqual(
             uglify.minify(
                 '"use strict";\'use strict\';"use strict";"use strict";;\'use strict\';console.log(\'use strict\');',
-                {output: {beautify: true, quote_style: 3}, compress: false}
+                {fromString: true, output: {beautify: true, quote_style: 3}, compress: false}
             ).code,
             '"use strict";\n\n\'use strict\';\n\n"use strict";\n\n"use strict";\n\n;\'use strict\';\n\nconsole.log(\'use strict\');'
         );
@@ -235,7 +225,7 @@ describe("Directives", function() {
 
         for (var i = 0; i < tests.length; i++) {
             assert.strictEqual(
-                uglify.minify(tests[i][0], {compress: false, mangle: false}).code,
+                uglify.minify(tests[i][0], {fromString: true, quote_style: 3, compress: false, mangle: false}).code,
                 tests[i][1],
                 tests[i][0]
             );
@@ -244,7 +234,7 @@ describe("Directives", function() {
 
     it("Should add double semicolon when relying on automatic semicolon insertion", function() {
         var code = uglify.minify('"use strict";"use\\x20strict";',
-            {output: {semicolons: false}, compress: false}
+            {fromString: true, output: {semicolons: false}, compress: false}
         ).code;
         assert.strictEqual(code, '"use strict";;"use strict"\n');
     });
@@ -350,7 +340,7 @@ describe("Directives", function() {
         ];
         for (var i = 0; i < tests.length; i++) {
             assert.strictEqual(
-                uglify.minify(tests[i][0], {output:{quote_style: tests[i][1]}, compress: false}).code,
+                uglify.minify(tests[i][0], {fromString: true, output:{quote_style: tests[i][1]}, compress: false}).code,
                 tests[i][2],
                 tests[i][0] + " using mode " + tests[i][1]
             );
@@ -382,50 +372,10 @@ describe("Directives", function() {
 
         for (var i = 0; i < tests.length; i++) {
             assert.strictEqual(
-                uglify.minify(tests[i][0]).code,
+                uglify.minify(tests[i][0], {fromString: true}).code,
                 tests[i][1],
                 tests[i][0]
             );
         }
     });
-    it("Should be detect implicit usages of strict mode from tree walker", function() {
-        var tests = [
-            {
-                input: 'class foo {bar(){_check_}}',
-                directives: ["use strict"],
-                non_directives: ["use bar"]
-            },
-            {
-                input: 'class foo {bar(){}}_check_',
-                directives: [],
-                non_directives: ["use strict", "use bar"]
-            }
-        ];
-
-        var i = 0;
-        var checked;
-        var checkWalker = new uglify.TreeWalker(function(node, descend) {
-            if (node instanceof uglify.AST_Symbol && node.name === "_check_") {
-                checked = true;
-                for (var j = 0; j < tests[i].directives.length; j++) {
-                    assert.ok(checkWalker.has_directive(tests[i].directives[j]),
-                        "Did not found directive '" + tests[i].directives[j] +  "' in test " + tests[i].input)
-                }
-                for (var k = 0; k < tests[i].non_directives.length; k++) {
-                    assert.equal(checkWalker.has_directive(tests[i].non_directives[k]), undefined,
-                        "Found directive '" + tests[i].non_directives[k] +  "' in test " + tests[i].input)
-                }
-            }
-        });
-
-        for (; i < tests.length; i++) {
-            // Do tests - iterate the ast in each test - check only when _check_ occurs - fail when no _check_ has been found
-            checked = false;
-            var ast = uglify.parse(tests[i].input);
-            ast.walk(checkWalker);
-            if (!checked) {
-                throw "No _check_ symbol found in " + tests[i].input;
-            }
-        }
-    });
 });

test/mocha/eof.js

@@ -1,35 +0,0 @@
-var assert = require("assert");
-var uglify = require("../node");
-
-describe("EOF", function() {
-    it("Should test code for at least throwing syntax error when incomplete", function() {
-        var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error;
-        }
-        var parse = function(test) {
-            return function() {
-                uglify.parse(test);
-            }
-        }
-        // Chops off 1 char at a time until limit or start of string is reached
-        // The passed code must still be valid when unchopped
-        var test_eol = function(input, chopLimit) {
-            if (chopLimit === undefined) {
-                chopLimit = input.length - 1;
-            }
-
-            assert.doesNotThrow(parse(input), "Expected valid code for \n" + input);
-
-            for (var i = input.length - 1; chopLimit > 0; chopLimit--, i--) {
-                var code = input.substr(0, i);
-                assert.throws(parse(code), error, code);
-            }
-        }
-
-        test_eol("var \\u1234", 7); // Incomplete identifier
-        test_eol("'Incomplete string'");
-        test_eol("/Unterminated regex/");
-        test_eol("` Unterminated template string`");
-        test_eol("/* Unfinishing multiline comment */");
-    });
-});

test/mocha/export.js

@@ -1,40 +0,0 @@
-var assert = require("assert");
-var uglify = require("../node");
-
-describe("Export", function() {
-    it ("Should parse export directives", function() {
-
-        var inputs = [
-            ['export * from "a.js"', ['*'], "a.js"],
-            ['export {A} from "a.js"', ['A'], "a.js"],
-            ['export {A as X} from "a.js"', ['X'], "a.js"],
-            ['export {A as Foo, B} from "a.js"', ['Foo', 'B'], "a.js"],
-            ['export {A, B} from "a.js"', ['A', 'B'], "a.js"],
-        ];
-
-        var test = function(code) {
-            return uglify.parse(code);
-        };
-
-        var extractNames = function(symbols) {
-            var ret = [];
-            for (var i = 0; i < symbols.length; i++) {
-                ret.push(symbols[i].name.name)
-            }
-            return ret;
-        };
-
-        for (var i = 0; i < inputs.length; i++) {
-            var ast = test(inputs[i][0]);
-            var names = inputs[i][1];
-            var filename = inputs[i][2];
-            assert(ast instanceof uglify.AST_Toplevel);
-            assert.equal(ast.body.length, 1);
-            var st = ast.body[0];
-            assert(st instanceof uglify.AST_Export);
-            var actualNames = extractNames(st.exported_names);
-            assert.deepEqual(actualNames, names);
-            assert.equal(st.module_name.value, filename)
-        }
-    })
-});

test/mocha/expression.js

@@ -1,32 +0,0 @@
-var assert = require("assert");
-var uglify = require("../node");
-
-describe("Expression", function() {
-    it("Should not allow the first exponentiation operator to be prefixed with an unary operator", function() {
-        var tests = [
-            "+5 ** 3",
-            "-5 ** 3",
-            "~5 ** 3",
-            "!5 ** 3",
-            "void 5 ** 3",
-            "typeof 5 ** 3",
-            "delete 5 ** 3",
-            "var a = -(5) ** 3;"
-        ];
-
-        var fail = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                /^Unexpected token: operator \((?:[!+~-]|void|typeof|delete)\)/.test(e.message);
-        }
-
-        var exec = function(test) {
-            return function() {
-                uglify.parse(test);
-            }
-        }
-
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(exec(tests[i]), fail, tests[i]);
-        }
-    });
-});

test/mocha/function.js

@@ -1,252 +0,0 @@
-var assert = require("assert");
-var uglify = require("../node");
-
-describe("Function", function() {
-    it ("Should parse binding patterns correctly", function() {
-        // Function argument nodes are correct
-        function get_args(args) {
-            return args.map(function (arg) {
-                return [arg.TYPE, arg.name];
-            });
-        }
-
-        // Destructurings as arguments
-        var destr_fun1 = uglify.parse('(function ({a, b}) {})').body[0].body;
-        var destr_fun2 = uglify.parse('(function ([a, [b]]) {})').body[0].body;
-        var destr_fun3 = uglify.parse('({a, b}) => null').body[0].body;
-        var destr_fun4 = uglify.parse('([a, [b]]) => null').body[0].body;
-
-        assert.equal(destr_fun1.argnames.length, 1);
-        assert.equal(destr_fun2.argnames.length, 1);
-        assert.equal(destr_fun3.argnames.length, 1);
-        assert.equal(destr_fun4.argnames.length, 1);
-
-        var destruct1 = destr_fun1.argnames[0];
-        var destruct2 = destr_fun2.argnames[0];
-        var destruct3 = destr_fun3.argnames[0];
-        var destruct4 = destr_fun4.argnames[0];
-
-        assert(destruct1 instanceof uglify.AST_Destructuring);
-        assert(destruct2 instanceof uglify.AST_Destructuring);
-        assert(destruct3 instanceof uglify.AST_Destructuring);
-        assert(destruct4 instanceof uglify.AST_Destructuring);
-        assert(destruct2.names[1] instanceof uglify.AST_Destructuring);
-        assert(destruct4.names[1] instanceof uglify.AST_Destructuring);
-
-        assert.equal(destruct1.start.value, '{');
-        assert.equal(destruct1.end.value, '}');
-        assert.equal(destruct2.start.value, '[');
-        assert.equal(destruct2.end.value, ']');
-        assert.equal(destruct3.start.value, '{');
-        assert.equal(destruct3.end.value, '}');
-        assert.equal(destruct4.start.value, '[');
-        assert.equal(destruct4.end.value, ']');
-
-        assert.equal(destruct1.is_array, false);
-        assert.equal(destruct2.is_array, true);
-        assert.equal(destruct3.is_array, false);
-        assert.equal(destruct4.is_array, true);
-
-        // destruct 1
-        assert.deepEqual(
-            [
-                destruct1.names[0].TYPE,
-                destruct1.names[0].key,
-                destruct1.names[0].value.name
-            ],
-            ['ObjectKeyVal', 'a', 'a']
-        );
-        assert.deepEqual(
-            [
-                destruct1.names[1].TYPE,
-                destruct1.names[1].key,
-                destruct1.names[1].value.name
-            ],
-            ['ObjectKeyVal', 'b', 'b']
-        );
-
-        // destruct 2
-        assert.deepEqual(
-            [
-                destruct2.names[0].TYPE,
-                destruct2.names[0].name
-            ],
-            ['SymbolFunarg', 'a']
-        );
-        assert.deepEqual(
-            [
-                destruct2.names[1].names[0].TYPE,
-                destruct2.names[1].names[0].name
-            ],
-            ['SymbolFunarg', 'b']
-        );
-
-        // destruct 3
-        assert.strictEqual(typeof destruct3.names[0].key, "string");
-        assert.strictEqual(destruct3.names[0].key, "a");
-        assert.strictEqual(destruct3.names[0].value.TYPE, "SymbolFunarg");
-        assert.strictEqual(destruct3.names[0].value.name, "a");
-        assert.strictEqual(typeof destruct3.names[1].key, "string");
-        assert.strictEqual(destruct3.names[1].key, "b");
-        assert.strictEqual(destruct3.names[1].value.TYPE, "SymbolFunarg");
-        assert.strictEqual(destruct3.names[1].value.name, "b");
-
-        // destruct 4
-        assert.deepEqual(
-            [
-                destruct4.names[0].TYPE,
-                destruct4.names[0].name
-            ],
-            ['SymbolFunarg', 'a']
-        );
-        assert.strictEqual(destruct4.names[1].TYPE, "Destructuring");
-        assert.deepEqual(
-            [
-                destruct4.names[1].names[0].TYPE,
-                destruct4.names[1].names[0].name
-            ],
-            ['SymbolFunarg', 'b']
-        );
-
-        assert.deepEqual(
-            get_args(destr_fun1.args_as_names()),
-            [['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
-        );
-        assert.deepEqual(
-            get_args(destr_fun2.args_as_names()),
-            [['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
-        );
-        assert.deepEqual(
-            get_args(destr_fun3.args_as_names()),
-            [['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
-        );
-        assert.deepEqual(
-            get_args(destr_fun4.args_as_names()),
-            [['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
-        );
-
-        // Making sure we don't accidentally accept things which
-        // Aren't argument destructurings
-
-        assert.throws(function () {
-            uglify.parse('(function ( { a, [ b ] } ) { })')
-        });
-
-        assert.throws(function () {
-            uglify.parse('(function (1) { })');
-        }, /Invalid function parameter/);
-
-        assert.throws(function () {
-            uglify.parse('(function (this) { })');
-        });
-
-        assert.throws(function () {
-            uglify.parse('(function ([1]) { })');
-        }, /Invalid function parameter/);
-
-        assert.throws(function () {
-            uglify.parse('(function [a] { })');
-        });
-
-        // generators
-        var generators_def = uglify.parse('function* fn() {}').body[0];
-        assert.equal(generators_def.is_generator, true);
-
-        assert.throws(function () {
-            uglify.parse('function* (){ }');
-        });
-
-        var generators_yield_def = uglify.parse('function* fn() {\nyield remote();\}').body[0].body[0];
-        assert.strictEqual(generators_yield_def.body.is_star, false);
-    });
-    it("Should not accept spread on non-last parameters", function() {
-        var tests = [
-            "var a = function(...a, b) { return a.join(b) }",
-            "var b = function(a, b, ...c, d) { return c.join(a + b) + d }",
-            "function foo(...a, b) { return a.join(b) }",
-            "function bar(a, b, ...c, d) { return c.join(a + b) + d }",
-            "var a = function*(...a, b) { return a.join(b) }",
-            "var b = function*(a, b, ...c, d) { return c.join(a + b) + d }",
-            "function* foo(...a, b) { return a.join(b) }",
-            "function* bar(a, b, ...c, d) { return c.join(a + b) + d }"
-        ];
-        var test = function(code) {
-            return function() {
-                uglify.parse(code);
-            }
-        }
-        var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                /^Unexpected token: /.test(e.message);
-        }
-
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error);
-        }
-    });
-    it("Should not accept empty parameters after elision", function() {
-        var tests = [
-            "(function(,){})()",
-            "(function(a,){})()",
-        ];
-        var test = function(code) {
-            return function() {
-                uglify.parse(code);
-            }
-        }
-        var error = function(e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                e.message === "Invalid function parameter";
-        }
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error);
-        }
-    });
-    it("Should not accept an initializer when parameter is a rest parameter", function() {
-        var tests = [
-            "(function(...a = b){})()",
-            "(function(a, ...b = [c, d]))"
-        ];
-        var test = function(code) {
-            return function () {
-                uglify.parse(code);
-            }
-        }
-        var error = function (e) {
-            return e instanceof uglify.JS_Parse_Error;
-        }
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error, tests[i]);
-        }
-    });
-    it("Shoult not accept duplicated identifiers inside parameters in strict mode or when using default assigment or spread", function() {
-        // From: ES2016 9.2.12 FunctionDeclarationInstantiation (func, argumentsList)
-        // NOTE Early errors ensure that duplicate parameter names can only occur
-        // in non-strict functions that do not have parameter default values or
-        // rest parameters.
-        var tests = [
-            "(function(a = 1, a){})()",
-            "(function(a, [a = 3]){})()",
-            "(function(a, b, c, d, [{e: [...a]}]){})()",
-            "'use strict'; (function(a, a){})",
-            "(function({a, a = b}))",
-            "(function(a, [...a]){})",
-            "(function(a, ...a){})",
-            "(function(a, [a, ...b]){})",
-            "(function(a, {b: a, c: [...d]}){})",
-            "(function(a, a, {b: [...c]}){})"
-        ];
-        var test = function(code) {
-            return function () {
-                uglify.parse(code);
-            }
-        }
-        var error = function (e) {
-            return e instanceof uglify.JS_Parse_Error &&
-                /^Parameter [a-zA-Z]+ was used already$/.test(e.message);
-        }
-        for (var i = 0; i < tests.length; i++) {
-            assert.throws(test(tests[i]), error, tests[i]);
-        }
-    });
-});

test/mocha/getter-setter.js

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

test/mocha/glob.js

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

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

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

test/mocha/input-sourcemaps.js

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

test/mocha/let.js

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