v3.11.5

fix corner case in merge_vars (#4258 )
fixes #4257
2020-11-03 08:59:02 +08:00 · 2020-11-02 01:01:00 +08:00 · 2020-11-01 14:34:07 +08:00 · 2020-11-01 10:37:21 +08:00 · 2020-10-30 11:06:48 +08:00 · 2020-10-30 11:06:31 +08:00
43 changed files with 4586 additions and 775 deletions
--- a/README.md
+++ b/README.md
@@ -784,6 +784,9 @@ to be `false` and all symbol names will be omitted.
 - `unused` (default: `true`) -- drop unreferenced functions and variables (simple
  direct variable assignments do not count as references unless set to `"keep_assign"`)

+- `varify` (default: `true`) -- convert block-scoped declaractions into `var`
+  whenever safe to do so
+
 ## Mangle options

 - `eval` (default `false`) -- Pass `true` to mangle names visible in scopes
--- a/bin/uglifyjs
+++ b/bin/uglifyjs
@@ -276,7 +276,9 @@ function convert_ast(fn) {
 function run() {
    var content = options.sourceMap && options.sourceMap.content;
    if (content && content != "inline") {
-        UglifyJS.AST_Node.info("Using input source map: " + content);
+        UglifyJS.AST_Node.info("Using input source map: {content}", {
+            content : content,
+        });
        options.sourceMap.content = read_file(content, content);
    }
    try {
--- a/lib/ast.js
+++ b/lib/ast.js
@@ -137,17 +137,17 @@ var AST_Node = DEFNODE("Node", "start end", {
 }, null);

 (AST_Node.log_function = function(fn, verbose) {
-    var printed = Object.create(null);
-    if (fn) {
-        AST_Node.info = verbose ? function(text, props) {
-            log("INFO: " + string_template(text, props));
-        } : noop;
-        AST_Node.warn = function(text, props) {
-            log("WARN: " + string_template(text, props));
-        };
-    } else {
+    if (!fn) {
        AST_Node.info = AST_Node.warn = noop;
+        return;
    }
+    var printed = Object.create(null);
+    AST_Node.info = verbose ? function(text, props) {
+        log("INFO: " + string_template(text, props));
+    } : noop;
+    AST_Node.warn = function(text, props) {
+        log("WARN: " + string_template(text, props));
+    };

    function log(msg) {
        if (printed[msg]) return;
@@ -203,6 +203,10 @@ var AST_Directive = DEFNODE("Directive", "value quote", {
    },
 }, AST_Statement);

+var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
+    $documentation: "The empty statement (empty block or simply a semicolon)"
+}, AST_Statement);
+
 function must_be_expression(node, prop) {
    if (!(node[prop] instanceof AST_Node)) throw new Error(prop + " must be AST_Node");
    if (node[prop] instanceof AST_Statement && !(node[prop] instanceof AST_Function)) {
@@ -226,6 +230,34 @@ var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
    },
 }, AST_Statement);

+var AST_BlockScope = DEFNODE("BlockScope", "enclosed functions make_def parent_scope variables", {
+    $documentation: "Base class for all statements introducing a lexical scope",
+    $propdoc: {
+        enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
+        functions: "[Object/S] like `variables`, but only lists function declarations",
+        parent_scope: "[AST_Scope?/S] link to the parent scope",
+        variables: "[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
+    },
+    clone: function(deep) {
+        var node = this._clone(deep);
+        if (this.enclosed) node.enclosed = this.enclosed.slice();
+        if (this.functions) node.functions = this.functions.clone();
+        if (this.variables) node.variables = this.variables.clone();
+        return node;
+    },
+    pinned: function() {
+        return this.resolve().pinned();
+    },
+    resolve: function() {
+        return this.parent_scope.resolve();
+    },
+    _validate: function() {
+        if (this.parent_scope == null) return;
+        if (!(this.parent_scope instanceof AST_BlockScope)) throw new Error("parent_scope must be AST_BlockScope");
+        if (!(this.resolve() instanceof AST_Scope)) throw new Error("must be contained within AST_Scope");
+    },
+}, AST_Statement);
+
 function walk_body(node, visitor) {
    node.body.forEach(function(node) {
        node.walk(visitor);
@@ -249,16 +281,12 @@ var AST_Block = DEFNODE("Block", "body", {
            if (node instanceof AST_Function) throw new Error("body cannot contain AST_Function");
        });
    },
-}, AST_Statement);
+}, AST_BlockScope);

 var AST_BlockStatement = DEFNODE("BlockStatement", null, {
    $documentation: "A block statement",
 }, AST_Block);

-var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
-    $documentation: "The empty statement (empty block or simply a semicolon)"
-}, 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: {
@@ -268,7 +296,7 @@ var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", {
        if (!(this.body instanceof AST_Statement)) throw new Error("body must be AST_Statement");
        if (this.body instanceof AST_Function) throw new Error("body cannot be AST_Function");
    },
-}, AST_Statement);
+}, AST_BlockScope);

 var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", {
    $documentation: "Statement with a label",
@@ -412,38 +440,9 @@ var AST_With = DEFNODE("With", "expression", {

 /* -----[ scope and functions ]----- */

-var AST_BlockScope = DEFNODE("BlockScope", "enclosed functions make_def parent_scope variables", {
+var AST_Scope = DEFNODE("Scope", "uses_eval uses_with", {
    $documentation: "Base class for all statements introducing a lexical scope",
    $propdoc: {
-        enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
-        functions: "[Object/S] like `variables`, but only lists function declarations",
-        parent_scope: "[AST_Scope?/S] link to the parent scope",
-        variables: "[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
-    },
-    clone: function(deep) {
-        var node = this._clone(deep);
-        if (this.enclosed) node.enclosed = this.enclosed.slice();
-        if (this.functions) node.functions = this.functions.clone();
-        if (this.variables) node.variables = this.variables.clone();
-        return node;
-    },
-    pinned: function() {
-        return this.resolve().pinned();
-    },
-    resolve: function() {
-        return this.parent_scope.resolve();
-    },
-    _validate: function() {
-        if (this.parent_scope == null) return;
-        if (!(this.parent_scope instanceof AST_BlockScope)) throw new Error("parent_scope must be AST_BlockScope");
-        if (!(this.resolve() instanceof AST_Scope)) throw new Error("must be contained within AST_Scope");
-    },
-}, AST_Block);
-
-var AST_Scope = DEFNODE("Scope", "cname uses_eval uses_with", {
-    $documentation: "Base class for all statements introducing a lexical scope",
-    $propdoc: {
-        cname: "[integer/S] current index for mangling variables (used internally by the mangler)",
        uses_eval: "[boolean/S] tells whether this scope contains a direct call to the global `eval`",
        uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
    },
@@ -451,7 +450,7 @@ var AST_Scope = DEFNODE("Scope", "cname uses_eval uses_with", {
        return this.uses_eval || this.uses_with;
    },
    resolve: return_this,
-}, AST_BlockScope);
+}, AST_Block);

 var AST_Toplevel = DEFNODE("Toplevel", "globals", {
    $documentation: "The toplevel scope",
@@ -704,19 +703,21 @@ 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] symbol for the exception"
+        argname: "[AST_SymbolCatch?] symbol for the exception, or null if not present",
    },
    walk: function(visitor) {
        var node = this;
        visitor.visit(node, function() {
-            node.argname.walk(visitor);
+            if (node.argname) node.argname.walk(visitor);
            walk_body(node, visitor);
        });
    },
    _validate: function() {
-        if (!(this.argname instanceof AST_SymbolCatch)) throw new Error("argname must be AST_SymbolCatch");
+        if (this.argname != null) {
+            if (!(this.argname instanceof AST_SymbolCatch)) throw new Error("argname must be AST_SymbolCatch");
+        }
    },
-}, AST_BlockScope);
+}, AST_Block);

 var AST_Finally = DEFNODE("Finally", null, {
    $documentation: "A `finally` node; only makes sense as part of a `try` statement"
@@ -736,14 +737,41 @@ var AST_Definitions = DEFNODE("Definitions", "definitions", {
                defn.walk(visitor);
            });
        });
-    }
+    },
+    _validate: function() {
+        if (this.definitions.length < 1) throw new Error("must have at least one definition");
+    },
 }, AST_Statement);

+var AST_Const = DEFNODE("Const", null, {
+    $documentation: "A `const` statement",
+    _validate: function() {
+        this.definitions.forEach(function(node) {
+            if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]");
+            if (!(node.name instanceof AST_SymbolConst)) throw new Error("name must be AST_SymbolConst");
+            must_be_expression(node, "value");
+        });
+    },
+}, AST_Definitions);
+
+var AST_Let = DEFNODE("Let", null, {
+    $documentation: "A `let` statement",
+    _validate: function() {
+        this.definitions.forEach(function(node) {
+            if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]");
+            if (!(node.name instanceof AST_SymbolLet)) throw new Error("name must be AST_SymbolLet");
+            if (node.value != null) must_be_expression(node, "value");
+        });
+    },
+}, AST_Definitions);
+
 var AST_Var = DEFNODE("Var", null, {
    $documentation: "A `var` statement",
    _validate: function() {
        this.definitions.forEach(function(node) {
            if (!(node instanceof AST_VarDef)) throw new Error("definitions must be AST_VarDef[]");
+            if (!(node.name instanceof AST_SymbolVar)) throw new Error("name must be AST_SymbolVar");
+            if (node.value != null) must_be_expression(node, "value");
        });
    },
 }, AST_Definitions);
@@ -761,10 +789,6 @@ var AST_VarDef = DEFNODE("VarDef", "name value", {
            if (node.value) node.value.walk(visitor);
        });
    },
-    _validate: function() {
-        if (!(this.name instanceof AST_SymbolVar)) throw new Error("name must be AST_SymbolVar");
-        if (this.value != null) must_be_expression(this, "value");
-    },
 });

 /* -----[ OTHER ]----- */
@@ -1030,12 +1054,12 @@ var AST_ObjectGetter = DEFNODE("ObjectGetter", null, {
 }, AST_ObjectProperty);

 var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
+    $documentation: "Base class for all symbols",
    $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",
    _validate: function() {
        if (typeof this.name != "string") throw new Error("name must be string");
    },
@@ -1049,6 +1073,14 @@ var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
    $documentation: "A declaration symbol (symbol in var, function name or argument, symbol in catch)",
 }, AST_Symbol);

+var AST_SymbolConst = DEFNODE("SymbolConst", null, {
+    $documentation: "Symbol defining a constant",
+}, AST_SymbolDeclaration);
+
+var AST_SymbolLet = DEFNODE("SymbolLet", null, {
+    $documentation: "Symbol defining a lexical-scoped variable",
+}, AST_SymbolDeclaration);
+
 var AST_SymbolVar = DEFNODE("SymbolVar", null, {
    $documentation: "Symbol defining a variable",
 }, AST_SymbolDeclaration);
--- a/lib/compress.js
+++ b/lib/compress.js
--- a/lib/minify.js
+++ b/lib/minify.js
@@ -33,7 +33,9 @@ function read_source_map(name, toplevel) {
            return to_ascii(match[2]);
        }
    }
-    AST_Node.warn("inline source map not found: " + name);
+    AST_Node.warn("inline source map not found: {name}", {
+        name: name,
+    });
 }

 function parse_source_map(content) {
@@ -258,6 +260,7 @@ function minify(files, options) {
    } catch (ex) {
        return { error: ex };
    } finally {
+        AST_Node.log_function();
        AST_Node.disable_validation();
    }
 }
--- a/lib/output.js
+++ b/lib/output.js
@@ -107,6 +107,9 @@ function OutputStream(options) {
    var OUTPUT = "";

    var to_utf8 = options.ascii_only ? function(str, identifier) {
+        if (identifier) str = str.replace(/[\ud800-\udbff][\udc00-\udfff]/g, function(ch) {
+            return "\\u{" + (ch.charCodeAt(0) - 0xd7c0 << 10 | ch.charCodeAt(1) - 0xdc00).toString(16) + "}";
+        });
        return str.replace(/[\u0000-\u001f\u007f-\uffff]/g, function(ch) {
            var code = ch.charCodeAt(0).toString(16);
            if (code.length <= 2 && !identifier) {
@@ -835,10 +838,6 @@ function OutputStream(options) {
        use_asm = was_asm;
    }

-    AST_StatementWithBody.DEFMETHOD("_do_print_body", function(output) {
-        force_statement(this.body, output);
-    });
-
    DEFPRINT(AST_Statement, function(output) {
        this.body.print(output);
        output.semicolon();
@@ -897,7 +896,7 @@ function OutputStream(options) {
            self.condition.print(output);
        });
        output.space();
-        self._do_print_body(output);
+        force_statement(self.body, output);
    });
    DEFPRINT(AST_For, function(output) {
        var self = this;
@@ -927,7 +926,7 @@ function OutputStream(options) {
            }
        });
        output.space();
-        self._do_print_body(output);
+        force_statement(self.body, output);
    });
    DEFPRINT(AST_ForIn, function(output) {
        var self = this;
@@ -941,7 +940,7 @@ function OutputStream(options) {
            self.object.print(output);
        });
        output.space();
-        self._do_print_body(output);
+        force_statement(self.body, output);
    });
    DEFPRINT(AST_With, function(output) {
        var self = this;
@@ -951,7 +950,7 @@ function OutputStream(options) {
            self.expression.print(output);
        });
        output.space();
-        self._do_print_body(output);
+        force_statement(self.body, output);
    });

    /* -----[ functions ]----- */
@@ -994,7 +993,7 @@ function OutputStream(options) {
    /* -----[ if ]----- */
    function make_then(self, output) {
        var b = self.body;
-        if (output.option("braces")
+        if (output.option("braces") && !(b instanceof AST_Const || b instanceof AST_Let)
            || output.option("ie8") && b instanceof AST_Do)
            return make_block(b, output);
        // The squeezer replaces "block"-s that contain only a single
@@ -1036,7 +1035,7 @@ function OutputStream(options) {
            else
                force_statement(self.alternative, output);
        } else {
-            self._do_print_body(output);
+            force_statement(self.body, output);
        }
    });

@@ -1099,10 +1098,12 @@ function OutputStream(options) {
    DEFPRINT(AST_Catch, function(output) {
        var self = this;
        output.print("catch");
-        output.space();
-        output.with_parens(function() {
-            self.argname.print(output);
-        });
+        if (self.argname) {
+            output.space();
+            output.with_parens(function() {
+                self.argname.print(output);
+            });
+        }
        output.space();
        print_braced(self, output);
    });
@@ -1112,17 +1113,22 @@ function OutputStream(options) {
        print_braced(this, output);
    });

-    DEFPRINT(AST_Var, function(output) {
-        var self = this;
-        output.print("var");
-        output.space();
-        self.definitions.forEach(function(def, i) {
-            if (i) output.comma();
-            def.print(output);
-        });
-        var p = output.parent();
-        if (p && p.init !== self || !(p instanceof AST_For || p instanceof AST_ForIn)) output.semicolon();
-    });
+    function print_definitinos(type) {
+        return function(output) {
+            var self = this;
+            output.print(type);
+            output.space();
+            self.definitions.forEach(function(def, i) {
+                if (i) output.comma();
+                def.print(output);
+            });
+            var p = output.parent();
+            if (p && p.init !== self || !(p instanceof AST_For || p instanceof AST_ForIn)) output.semicolon();
+        };
+    }
+    DEFPRINT(AST_Const, print_definitinos("const"));
+    DEFPRINT(AST_Let, print_definitinos("let"));
+    DEFPRINT(AST_Var, print_definitinos("var"));

    function parenthesize_for_noin(node, output, noin) {
        var parens = false;
@@ -1379,13 +1385,12 @@ function OutputStream(options) {
    });

    function force_statement(stat, output) {
-        if (output.option("braces")) {
+        if (output.option("braces") && !(stat instanceof AST_Const || stat instanceof AST_Let)) {
            make_block(stat, output);
+        } else if (!stat || stat instanceof AST_EmptyStatement) {
+            output.force_semicolon();
        } else {
-            if (!stat || stat instanceof AST_EmptyStatement)
-                output.force_semicolon();
-            else
-                stat.print(output);
+            stat.print(output);
        }
    }

--- a/lib/parse.js
+++ b/lib/parse.js
@@ -44,7 +44,7 @@

 "use strict";

-var KEYWORDS = "break case catch const continue debugger default delete do else finally for function if in instanceof new return switch throw try typeof var void while with";
+var KEYWORDS = "break case catch const continue debugger default delete do else finally for function if in instanceof let new return switch throw try typeof var void while with";
 var KEYWORDS_ATOM = "false null true";
 var RESERVED_WORDS = [
    "abstract boolean byte char class double enum export extends final float goto implements import int interface let long native package private protected public short static super synchronized this throws transient volatile yield",
@@ -58,10 +58,9 @@ RESERVED_WORDS = makePredicate(RESERVED_WORDS);
 KEYWORDS_BEFORE_EXPRESSION = makePredicate(KEYWORDS_BEFORE_EXPRESSION);
 KEYWORDS_ATOM = makePredicate(KEYWORDS_ATOM);

-var OPERATOR_CHARS = makePredicate(characters("+-*&%=<>!?|~^"));
-
-var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
-var RE_OCT_NUMBER = /^0[0-7]+$/;
+var RE_BIN_NUMBER = /^0b([01]+)$/i;
+var RE_HEX_NUMBER = /^0x([0-9a-f]+)$/i;
+var RE_OCT_NUMBER = /^0o?([0-7]+)$/i;

 var OPERATORS = makePredicate([
    "in",
@@ -110,31 +109,21 @@ var OPERATORS = makePredicate([
    "||"
 ]);

-var WHITESPACE_CHARS = makePredicate(characters(" \u00a0\n\r\t\f\u000b\u200b\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000\uFEFF"));
+var NEWLINE_CHARS = "\n\r\u2028\u2029";
+var OPERATOR_CHARS = "+-*&%=<>!?|~^";
+var PUNC_BEFORE_EXPRESSION = "[{(,;:";
+var PUNC_CHARS = PUNC_BEFORE_EXPRESSION + ")}]";
+var WHITESPACE_CHARS = NEWLINE_CHARS + " \u00a0\t\f\u000b\u200b\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\uFEFF";
+var NON_IDENTIFIER_CHARS = makePredicate(characters("./'\"" + OPERATOR_CHARS + PUNC_CHARS + WHITESPACE_CHARS));

-var NEWLINE_CHARS = makePredicate(characters("\n\r\u2028\u2029"));
-
-var PUNC_BEFORE_EXPRESSION = makePredicate(characters("[{(,;:"));
-
-var PUNC_CHARS = makePredicate(characters("[]{}(),;:"));
+NEWLINE_CHARS = makePredicate(characters(NEWLINE_CHARS));
+OPERATOR_CHARS = makePredicate(characters(OPERATOR_CHARS));
+PUNC_BEFORE_EXPRESSION = makePredicate(characters(PUNC_BEFORE_EXPRESSION));
+PUNC_CHARS = makePredicate(characters(PUNC_CHARS));
+WHITESPACE_CHARS = makePredicate(characters(WHITESPACE_CHARS));

 /* -----[ Tokenizer ]----- */

-// regexps adapted from http://xregexp.com/plugins/#unicode
-var UNICODE = {
-    letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B2\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FCC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA78E\\uA790-\\uA7AD\\uA7B0\\uA7B1\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB5F\\uAB64\\uAB65\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"),
-    digit: new RegExp("[\\u0030-\\u0039\\u0660-\\u0669\\u06F0-\\u06F9\\u07C0-\\u07C9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE6-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0DE6-\\u0DEF\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29\\u1040-\\u1049\\u1090-\\u1099\\u17E0-\\u17E9\\u1810-\\u1819\\u1946-\\u194F\\u19D0-\\u19D9\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1B50-\\u1B59\\u1BB0-\\u1BB9\\u1C40-\\u1C49\\u1C50-\\u1C59\\uA620-\\uA629\\uA8D0-\\uA8D9\\uA900-\\uA909\\uA9D0-\\uA9D9\\uA9F0-\\uA9F9\\uAA50-\\uAA59\\uABF0-\\uABF9\\uFF10-\\uFF19]"),
-    non_spacing_mark: new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065E\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0900-\\u0902\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F90-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1DC0-\\u1DE6\\u1DFD-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA67C\\uA67D\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"),
-    space_combining_mark: new RegExp("[\\u0903\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u0982\\u0983\\u09BE-\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u09D7\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B3E\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0B57\\u0BBE\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD7\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0-\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D57\\u0D82\\u0D83\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0F3E\\u0F3F\\u0F7F\\u102B\\u102C\\u1031\\u1038\\u103B\\u103C\\u1056\\u1057\\u1062-\\u1064\\u1067-\\u106D\\u1083\\u1084\\u1087-\\u108C\\u108F\\u109A-\\u109C\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A19-\\u1A1B\\u1A55\\u1A57\\u1A61\\u1A63\\u1A64\\u1A6D-\\u1A72\\u1B04\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF2\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BD-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAA7B\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]"),
-    connector_punctuation: new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]")
-};
-
-function is_letter(code) {
-    return (code >= 97 && code <= 122)
-        || (code >= 65 && code <= 90)
-        || (code >= 0xaa && UNICODE.letter.test(String.fromCharCode(code)));
-}
-
 function is_surrogate_pair_head(code) {
    return code >= 0xd800 && code <= 0xdbff;
 }
@@ -147,36 +136,8 @@ function is_digit(code) {
    return code >= 48 && code <= 57;
 }

-function is_alphanumeric_char(code) {
-    return is_digit(code) || is_letter(code);
-}
-
-function is_unicode_digit(code) {
-    return UNICODE.digit.test(String.fromCharCode(code));
-}
-
-function is_unicode_combining_mark(ch) {
-    return UNICODE.non_spacing_mark.test(ch) || UNICODE.space_combining_mark.test(ch);
-}
-
-function is_unicode_connector_punctuation(ch) {
-    return UNICODE.connector_punctuation.test(ch);
-}
-
-function is_identifier_start(code) {
-    return code == 36 || code == 95 || is_letter(code);
-}
-
 function is_identifier_char(ch) {
-    var code = ch.charCodeAt(0);
-    return is_identifier_start(code)
-        || is_digit(code)
-        || code == 8204 // \u200c: zero-width non-joiner <ZWNJ>
-        || code == 8205 // \u200d: zero-width joiner <ZWJ> (in my ECMA-262 PDF, this is also 200c)
-        || is_unicode_combining_mark(ch)
-        || is_unicode_connector_punctuation(ch)
-        || is_unicode_digit(code)
-    ;
+    return !NON_IDENTIFIER_CHARS[ch];
 }

 function is_identifier_string(str) {
@@ -184,14 +145,12 @@ function is_identifier_string(str) {
 }

 function parse_js_number(num) {
-    if (RE_HEX_NUMBER.test(num)) {
-        return parseInt(num.substr(2), 16);
-    } else if (RE_OCT_NUMBER.test(num)) {
-        return parseInt(num.substr(1), 8);
-    } else {
-        var val = parseFloat(num);
-        if (val == num) return val;
-    }
+    var match;
+    if (match = RE_BIN_NUMBER.exec(num)) return parseInt(match[1], 2);
+    if (match = RE_HEX_NUMBER.exec(num)) return parseInt(match[1], 16);
+    if (match = RE_OCT_NUMBER.exec(num)) return parseInt(match[1], 8);
+    var val = parseFloat(num);
+    if (val == num) return val;
 }

 function JS_Parse_Error(message, filename, line, col, pos) {
@@ -347,11 +306,13 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
              case (after_e = false, 46): // .
                return (!has_dot && !has_x && !has_e) ? (has_dot = true) : false;
            }
-            return is_alphanumeric_char(code);
+            return is_digit(code) || /[_0-9a-fo]/i.test(ch);
        });
        if (prefix) num = prefix + num;
-        if (RE_OCT_NUMBER.test(num) && next_token.has_directive("use strict")) {
-            parse_error("Legacy octal literals are not allowed in strict mode");
+        if (/^0[0-7_]+$/.test(num)) {
+            if (next_token.has_directive("use strict")) parse_error("Legacy octal literals are not allowed in strict mode");
+        } else {
+            num = num.replace(has_x ? /([1-9a-f]|.0)_(?=[0-9a-f])/gi : /([1-9]|.0)_(?=[0-9])/gi, "$1");
        }
        var valid = parse_js_number(num);
        if (!isNaN(valid)) return token("num", valid);
@@ -361,20 +322,30 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
    function read_escaped_char(in_string) {
        var ch = next(true, in_string);
        switch (ch.charCodeAt(0)) {
-          case 110 : return "\n";
-          case 114 : return "\r";
-          case 116 : return "\t";
-          case 98  : return "\b";
-          case 118 : return "\u000b"; // \v
-          case 102 : return "\f";
-          case 120 : return String.fromCharCode(hex_bytes(2)); // \x
-          case 117 : return String.fromCharCode(hex_bytes(4)); // \u
-          case 10  : return ""; // newline
-          case 13  :            // \r
-            if (peek() == "\n") { // DOS newline
-                next(true, in_string);
-                return "";
-            }
+          case 110: return "\n";
+          case 114: return "\r";
+          case 116: return "\t";
+          case 98:  return "\b";
+          case 118: return "\u000b";                            // \v
+          case 102: return "\f";
+          case 120: return String.fromCharCode(hex_bytes(2));   // \x
+          case 117:                                             // \u
+            if (peek() != "{") return String.fromCharCode(hex_bytes(4));
+            next();
+            var num = 0;
+            do {
+                var digit = parseInt(next(true), 16);
+                if (isNaN(digit)) parse_error("Invalid hex-character pattern in string");
+                num = num * 16 + digit;
+            } while (peek() != "}");
+            next();
+            if (num < 0x10000) return String.fromCharCode(num);
+            if (num > 0x10ffff) parse_error("Invalid character code: " + num);
+            return String.fromCharCode((num >> 10) + 0xd7c0) + String.fromCharCode((num & 0x03ff) + 0xdc00);
+          case 13:                                              // \r
+            // DOS newline
+            if (peek() == "\n") next(true, in_string);
+          case 10:  return "";                                  // \n
        }
        if (ch >= "0" && ch <= "7")
            return read_octal_escape_sequence(ch);
@@ -451,7 +422,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {

    function read_name() {
        var backslash = false, name = "", ch, escaped = false, hex;
-        while ((ch = peek()) != null) {
+        while (ch = peek()) {
            if (!backslash) {
                if (ch == "\\") escaped = backslash = true, next();
                else if (is_identifier_char(ch)) name += next();
@@ -590,7 +561,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
            if (is_digit(code)) return read_num();
            if (PUNC_CHARS[ch]) return token("punc", next());
            if (OPERATOR_CHARS[ch]) return read_operator();
-            if (code == 92 || is_identifier_start(code)) return read_word();
+            if (code == 92 || !NON_IDENTIFIER_CHARS[ch]) return read_word();
            break;
        }
        parse_error("Unexpected character '" + ch + "'");
@@ -835,6 +806,12 @@ function parse($TEXT, options) {
                next();
                return break_cont(AST_Break);

+              case "const":
+                next();
+                var node = const_();
+                semicolon();
+                return node;
+
              case "continue":
                next();
                return break_cont(AST_Continue);
@@ -877,6 +854,12 @@ function parse($TEXT, options) {
                next();
                return if_();

+              case "let":
+                next();
+                var node = let_();
+                semicolon();
+                return node;
+
              case "return":
                if (S.in_function == 0 && !options.bare_returns)
                    croak("'return' outside of function");
@@ -991,7 +974,9 @@ function parse($TEXT, options) {
        expect("(");
        var init = null;
        if (!is("punc", ";")) {
-            init = is("keyword", "var")
+            init = is("keyword", "const")
+                ? (next(), const_(true))
+                : is("keyword", "var")
                ? (next(), var_(true))
                : expression(true, true);
            if (is("operator", "in")) {
@@ -1133,9 +1118,12 @@ function parse($TEXT, options) {
        if (is("keyword", "catch")) {
            var start = S.token;
            next();
-            expect("(");
-            var name = as_symbol(AST_SymbolCatch);
-            expect(")");
+            var name = null;
+            if (is("punc", "(")) {
+                next();
+                name = as_symbol(AST_SymbolCatch);
+                expect(")");
+            }
            bcatch = new AST_Catch({
                start   : start,
                argname : name,
@@ -1161,13 +1149,22 @@ function parse($TEXT, options) {
        });
    }

-    function vardefs(no_in) {
+    function vardefs(type, no_in, must_init) {
        var a = [];
        for (;;) {
+            var start = S.token;
+            var name = as_symbol(type);
+            var value = null;
+            if (is("operator", "=")) {
+                next();
+                value = expression(false, no_in);
+            } else if (must_init) {
+                croak("Missing initializer in declaration");
+            }
            a.push(new AST_VarDef({
-                start : S.token,
-                name  : as_symbol(AST_SymbolVar),
-                value : is("operator", "=") ? (next(), expression(false, no_in)) : null,
+                start : start,
+                name  : name,
+                value : value,
                end   : prev()
            }));
            if (!is("punc", ","))
@@ -1177,10 +1174,26 @@ function parse($TEXT, options) {
        return a;
    }

+    var const_ = function(no_in) {
+        return new AST_Const({
+            start       : prev(),
+            definitions : vardefs(AST_SymbolConst, no_in, true),
+            end         : prev()
+        });
+    };
+
+    var let_ = function(no_in) {
+        return new AST_Let({
+            start       : prev(),
+            definitions : vardefs(AST_SymbolLet, no_in),
+            end         : prev()
+        });
+    };
+
    var var_ = function(no_in) {
        return new AST_Var({
            start       : prev(),
-            definitions : vardefs(no_in),
+            definitions : vardefs(AST_SymbolVar, no_in),
            end         : prev()
        });
    };
--- a/lib/scope.js
+++ b/lib/scope.js
@@ -68,8 +68,8 @@ SymbolDef.prototype = {
        if (this.global && cache && cache.has(this.name)) {
            this.mangled_name = cache.get(this.name);
        } else if (!this.mangled_name && !this.unmangleable(options)) {
-            var def;
-            if (def = this.redefined()) {
+            var def = this.redefined();
+            if (def) {
                this.mangled_name = def.mangled_name || def.name;
            } else {
                this.mangled_name = next_mangled_name(this.scope, options, this);
@@ -80,7 +80,15 @@ SymbolDef.prototype = {
        }
    },
    redefined: function() {
-        return this.defun && this.defun.variables.get(this.name);
+        var scope = this.defun;
+        if (!scope) return;
+        var name = this.name;
+        var def = scope.variables.get(name)
+            || scope instanceof AST_Toplevel && scope.globals.get(name)
+            || this.orig[0] instanceof AST_SymbolConst && find_if(function(def) {
+                return def.name == name;
+            }, scope.enclosed);
+        if (def && def !== this) return def.redefined() || def;
    },
    unmangleable: function(options) {
        return this.global && !options.toplevel
@@ -114,13 +122,32 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
            });
            return true;
        }
-        if (node instanceof AST_BlockScope) {
-            walk_scope(descend);
+        if (node instanceof AST_SwitchBranch) {
+            node.init_vars(scope);
+            descend();
+            return true;
+        }
+        if (node instanceof AST_Try) {
+            walk_scope(function() {
+                walk_body(node, tw);
+            });
+            if (node.bcatch) node.bcatch.walk(tw);
+            if (node.bfinally) node.bfinally.walk(tw);
            return true;
        }
        if (node instanceof AST_With) {
-            for (var s = scope; s; s = s.parent_scope) s.uses_with = true;
-            return;
+            var s = scope;
+            do {
+                s = s.resolve();
+                if (s.uses_with) break;
+                s.uses_with = true;
+            } while (s = s.parent_scope);
+            walk_scope(descend);
+            return true;
+        }
+        if (node instanceof AST_BlockScope) {
+            walk_scope(descend);
+            return true;
        }
        if (node instanceof AST_Symbol) {
            node.scope = scope;
@@ -131,6 +158,8 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
        }
        if (node instanceof AST_SymbolCatch) {
            scope.def_variable(node).defun = defun;
+        } else if (node instanceof AST_SymbolConst) {
+            scope.def_variable(node).defun = defun;
        } else if (node instanceof AST_SymbolDefun) {
            defun.def_function(node, tw.parent());
            entangle(defun, scope);
@@ -140,13 +169,15 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
        } else if (node instanceof AST_SymbolLambda) {
            var def = defun.def_function(node, node.name == "arguments" ? undefined : defun);
            if (options.ie8) def.defun = defun.parent_scope.resolve();
+        } else if (node instanceof AST_SymbolLet) {
+            scope.def_variable(node);
        } else if (node instanceof AST_SymbolVar) {
            defun.def_variable(node, null);
            entangle(defun, scope);
        }

        function walk_scope(descend) {
-            node.init_scope_vars(scope);
+            node.init_vars(scope);
            var save_defun = defun;
            var save_scope = scope;
            if (node instanceof AST_Scope) defun = node;
@@ -183,15 +214,18 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
            var sym = node.scope.find_variable(name);
            if (!sym) {
                sym = self.def_global(node);
-            } else if (sym.scope instanceof AST_Lambda && name == "arguments") {
+            } else if (name == "arguments" && sym.scope instanceof AST_Lambda) {
                sym.scope.uses_arguments = true;
            }
            if (name == "eval") {
                var parent = tw.parent();
                if (parent.TYPE == "Call" && parent.expression === node) {
-                    for (var s = node.scope; s && !s.uses_eval; s = s.parent_scope) {
+                    var s = node.scope;
+                    do {
+                        s = s.resolve();
+                        if (s.uses_eval) break;
                        s.uses_eval = true;
-                    }
+                    } while (s = s.parent_scope);
                } else if (sym.undeclared) {
                    self.uses_eval = true;
                }
@@ -200,7 +234,7 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
            node.reference(options);
            return true;
        }
-        // ensure mangling works if catch reuses a scope variable
+        // ensure mangling works if `catch` reuses a scope variable
        if (node instanceof AST_SymbolCatch) {
            var def = node.definition().redefined();
            if (def) for (var s = node.scope; s; s = s.parent_scope) {
@@ -209,6 +243,12 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
            }
            return true;
        }
+        // ensure compression works if `const` reuses a scope variable
+        if (node instanceof AST_SymbolConst) {
+            var redef = node.definition().redefined();
+            if (redef) redef.const_redefs = true;
+            return true;
+        }
    });
    self.walk(tw);

@@ -237,10 +277,13 @@ AST_Toplevel.DEFMETHOD("figure_out_scope", function(options) {
    function redefine(node, scope) {
        var name = node.name;
        var old_def = node.thedef;
+        if (!all(old_def.orig, function(sym) {
+            return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet);
+        })) return;
        var new_def = scope.find_variable(name);
        if (new_def) {
-            var redef;
-            while (redef = new_def.redefined()) new_def = redef;
+            var redef = new_def.redefined();
+            if (redef) new_def = redef;
        } else {
            new_def = self.globals.get(name);
        }
@@ -273,22 +316,27 @@ AST_Toplevel.DEFMETHOD("def_global", function(node) {
    }
 });

-function init_scope_vars(scope, parent) {
-    scope.cname = -1;                               // the current index for mangling functions/variables
+function init_block_vars(scope, parent) {
    scope.enclosed = [];                            // variables from this or outer scope(s) that are referenced from this or inner scopes
-    scope.uses_eval = false;                        // will be set to true if this or nested scope uses the global `eval`
-    scope.uses_with = false;                        // will be set to true if this or some nested scope uses the `with` statement
    scope.parent_scope = parent;                    // the parent scope (null if this is the top level)
    scope.functions = new Dictionary();             // map name to AST_SymbolDefun (functions defined in this scope)
    scope.variables = new Dictionary();             // map name to AST_SymbolVar (variables defined in this scope; includes functions)
    if (parent) scope.make_def = parent.make_def;   // top-level tracking of SymbolDef instances
 }

-AST_BlockScope.DEFMETHOD("init_scope_vars", function(parent_scope) {
+function init_scope_vars(scope, parent) {
+    init_block_vars(scope, parent);
+    scope.uses_eval = false;                        // will be set to true if this or nested scope uses the global `eval`
+    scope.uses_with = false;                        // will be set to true if this or some nested scope uses the `with` statement
+}
+
+AST_BlockScope.DEFMETHOD("init_vars", function(parent_scope) {
+    init_block_vars(this, parent_scope);
+});
+AST_Scope.DEFMETHOD("init_vars", function(parent_scope) {
    init_scope_vars(this, parent_scope);
 });
-
-AST_Lambda.DEFMETHOD("init_scope_vars", function(parent_scope) {
+AST_Lambda.DEFMETHOD("init_vars", function(parent_scope) {
    init_scope_vars(this, parent_scope);
    this.uses_arguments = false;
    this.def_variable(new AST_SymbolFunarg({
@@ -346,8 +394,9 @@ AST_BlockScope.DEFMETHOD("def_variable", function(symbol, init) {
 function names_in_use(scope, options) {
    var names = scope.names_in_use;
    if (!names) {
-        scope.names_in_use = names = Object.create(null);
+        scope.cname = -1;
        scope.cname_holes = [];
+        scope.names_in_use = names = Object.create(null);
        var cache = options.cache && options.cache.props;
        scope.enclosed.forEach(function(def) {
            if (def.unmangleable(options)) names[def.name] = true;
@@ -445,7 +494,11 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
            lname = save_nesting;
            return true;
        }
-        if (node instanceof AST_Scope) {
+        if (node instanceof AST_BlockScope) {
+            var to_mangle = [];
+            node.variables.each(function(def) {
+                if (!defer_redef(def)) to_mangle.push(def);
+            });
            descend();
            if (options.cache && node instanceof AST_Toplevel) {
                node.globals.each(mangle);
@@ -455,9 +508,7 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
                sym.scope = node;
                sym.reference(options);
            }
-            node.variables.each(function(def) {
-                if (!defer_redef(def)) mangle(def);
-            });
+            to_mangle.forEach(mangle);
            return true;
        }
        if (node instanceof AST_Label) {
@@ -468,13 +519,6 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
            node.mangled_name = name;
            return true;
        }
-        if (!options.ie8 && node instanceof AST_Catch) {
-            var def = node.argname.definition();
-            var redef = defer_redef(def, node.argname);
-            descend();
-            if (!redef) mangle(def);
-            return true;
-        }
    });
    this.walk(tw);
    redefined.forEach(mangle);
@@ -489,7 +533,8 @@ AST_Toplevel.DEFMETHOD("mangle_names", function(options) {
        if (!redef) return false;
        redefined.push(def);
        def.references.forEach(reference);
-        if (node) reference(node);
+        var node = def.orig[0];
+        if (node instanceof AST_SymbolCatch || node instanceof AST_SymbolConst) reference(node);
        return true;

        function reference(sym) {
--- a/lib/transform.js
+++ b/lib/transform.js
@@ -116,7 +116,7 @@ TreeTransformer.prototype = new TreeWalker;
        if (self.bfinally) self.bfinally = self.bfinally.transform(tw);
    });
    DEF(AST_Catch, function(self, tw) {
-        self.argname = self.argname.transform(tw);
+        if (self.argname) self.argname = self.argname.transform(tw);
        self.body = do_list(self.body, tw);
    });
    DEF(AST_Definitions, function(self, tw) {
--- a/lib/utils.js
+++ b/lib/utils.js
@@ -143,8 +143,9 @@ function push_uniq(array, el) {
 }

 function string_template(text, props) {
-    return text.replace(/\{(.+?)\}/g, function(str, p) {
-        return props && props[p];
+    return text.replace(/\{([^}]+)\}/g, function(str, p) {
+        var value = props[p];
+        return value instanceof AST_Node ? value.print_to_string() : value;
    });
 }

--- a/package.json
+++ b/package.json
@@ -3,7 +3,7 @@
  "description": "JavaScript parser, mangler/compressor and beautifier toolkit",
  "author": "Mihai Bazon <mihai.bazon@gmail.com> (http://lisperator.net/)",
  "license": "BSD-2-Clause",
-  "version": "3.11.1",
+  "version": "3.11.5",
  "engines": {
    "node": ">=0.8.0"
  },
--- a/test/compress.js
+++ b/test/compress.js
@@ -315,6 +315,7 @@ function test_case(test) {
        if (test.mangle.properties) U.mangle_properties(output, test.mangle.properties);
    }
    var output_code = make_code(output, output_options);
+    U.AST_Node.log_function();
    if (expect != output_code) {
        log([
            "!!! failed",
@@ -386,7 +387,7 @@ function test_case(test) {
            mangle: test.mangle
        });
        var actual = stdout[toplevel ? 1 : 0];
-        if (test.expect_stdout === true) {
+        if (test.expect_stdout === true || test.expect_stdout instanceof Error && test.expect_stdout.name === actual.name) {
            test.expect_stdout = actual;
        }
        if (!sandbox.same_stdout(test.expect_stdout, actual)) {
--- a/test/compress/arguments.js
+++ b/test/compress/arguments.js
@@ -783,3 +783,27 @@ issue_3420_7: {
    }
    expect_stdout: "true"
 }
+
+issue_4200: {
+    options = {
+        arguments: true,
+        keep_fargs: false,
+    }
+    input: {
+        var o = {
+            get p() {
+                return arguments[0];
+            },
+        };
+        console.log(o.p);
+    }
+    expect: {
+        var o = {
+            get p() {
+                return arguments[0];
+            },
+        };
+        console.log(o.p);
+    }
+    expect_stdout: "undefined"
+}
--- a/test/compress/ascii.js
+++ b/test/compress/ascii.js
@@ -1,35 +0,0 @@
-ascii_only_true: {
-    options = {}
-    beautify = {
-        ascii_only : true,
-        ie8        : false,
-        beautify   : false,
-    }
-    input: {
-        function f() {
-            return "\x000\x001\x007\x008\x00" +
-                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" +
-                   "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" +
-                   "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
-        }
-    }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\0"+"\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\b\\t\\n\\v\\f\\r\\x0e\\x0f"+"\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f"+\' !"# ... }~\\x7f\\x80\\x81 ... \\xfe\\xff\\u0fff\\uffff\'}'
-}
-
-ascii_only_false: {
-    options = {}
-    beautify = {
-        ascii_only : false,
-        ie8        : false,
-        beautify   : false,
-    }
-    input: {
-        function f() {
-            return "\x000\x001\x007\x008\x00" +
-                   "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" +
-                   "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" +
-                   "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff";
-        }
-    }
-    expect_exact: 'function f(){return"\\x000\\x001\\x007\\x008\\0"+"\\0\x01\x02\x03\x04\x05\x06\x07\\b\\t\\n\\v\\f\\r\x0e\x0f"+"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"+\' !"# ... }~\x7f\x80\x81 ... \xfe\xff\u0fff\uffff\'}'
-}
--- a/test/compress/asm.js
+++ b/test/compress/asm.js
@@ -76,9 +76,8 @@ asm_mixed: {
                start = start | 0;
                end = end | 0;
                var sum = 0.0, p = 0, q = 0;
-                for (p = start << 3, q = end << 3; (p | 0) < (q | 0); p = p + 8 | 0) {
+                for (p = start << 3, q = end << 3; (p | 0) < (q | 0); p = p + 8 | 0)
                    sum = sum + +log(values[p >> 3]);
-                }
                return +sum;
            }
            function geometricMean(start, end) {
@@ -91,7 +90,8 @@ asm_mixed: {
        function no_asm_GeometricMean(stdlib, foreign, buffer) {
            function logSum(start, end) {
                start |= 0, end |= 0;
-                for (var sum = 0, p = 0, q = 0, p = start << 3, q = end << 3; (0 | p) < (0 | q); p = p + 8 | 0) sum += +log(values[p >> 3]);
+                for (var sum = 0, p = 0, q = 0, p = start << 3, q = end << 3; (0 | p) < (0 | q); p = p + 8 | 0)
+                    sum += +log(values[p >> 3]);
                return +sum;
            }
            function geometricMean(start, end) {
--- a/test/compress/collapse_vars.js
+++ b/test/compress/collapse_vars.js
@@ -346,9 +346,8 @@ collapse_vars_if: {
            return "x" != "Bar" + x / 4 ? g9 : g5;
        }
        function f3(x) {
-            if (x) {
+            if (x)
                return 1;
-            }
            return 2;
        }
    }
@@ -4192,9 +4191,8 @@ issue_2436_11: {
            if (isCollection(arg1)) {
                var size = arg1, max = arg2, min = 0, res = _randomDataForMatrix(size.valueOf(), min, max, _randomInt);
                return size && true === size.isMatrix ? matrix(res) : res;
-            } else {
+            } else
                return _randomInt(min = arg1, max = arg2);
-            }
        }
    }
 }
@@ -4310,9 +4308,8 @@ issue_2497: {
        function sample() {
            if (true)
                for (var i = 0; i < 1; ++i)
-                    for (var k = 0; k < 1; ++k) {
+                    for (var k = 0; k < 1; ++k)
                        value = (value = 1) ? value + 1 : 0;
-                    }
            else
                for (i = 0; i < 1; ++i)
                    for (k = 0; k < 1; ++k)
@@ -8559,3 +8556,49 @@ issue_4070: {
    }
    expect_stdout: "NaN"
 }
+
+issue_4242: {
+    options = {
+        collapse_vars: true,
+        conditionals: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        console.log(function() {
+            if (console)
+                var a = function(){}, b = (!1 === console || a)();
+        }());
+    }
+    expect: {
+        console.log(function() {
+            console && (!1 === console || function(){})();
+        }());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4248: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = 0;
+        try {
+            a = 1;
+            b[1];
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect: {
+        var a = 0;
+        try {
+            a = 1;
+            b[1];
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect_stdout: "1"
+}
--- a/test/compress/conditionals.js
+++ b/test/compress/conditionals.js
@@ -55,14 +55,15 @@ ifs_3_should_warn: {
    }
    input: {
        var x, y;
-        if (x && !(x + "1") && y) { // 1
+        // 1
+        if (x && !(x + "1") && y) {
            var qq;
            foo();
        } else {
            bar();
        }
-
-        if (x || !!(x + "1") || y) { // 2
+        // 2
+        if (x || !!(x + "1") || y) {
            foo();
        } else {
            var jj;
@@ -71,9 +72,25 @@ ifs_3_should_warn: {
    }
    expect: {
        var x, y;
-        var qq; bar();          // 1
-        var jj; foo();          // 2
+        // 1
+        var qq; bar();
+        // 2
+        foo(); var jj;
    }
+    expect_warnings: [
+        "WARN: + in boolean context always true [test/compress/conditionals.js:3,18]",
+        "WARN: Boolean && always false [test/compress/conditionals.js:3,12]",
+        "WARN: Condition left of && always false [test/compress/conditionals.js:3,12]",
+        "WARN: Condition always false [test/compress/conditionals.js:3,12]",
+        "WARN: Dropping unreachable code [test/compress/conditionals.js:3,34]",
+        "WARN: + in boolean context always true [test/compress/conditionals.js:10,19]",
+        "WARN: Boolean || always true [test/compress/conditionals.js:10,12]",
+        "WARN: Condition left of || always true [test/compress/conditionals.js:10,12]",
+        "WARN: Condition always true [test/compress/conditionals.js:10,12]",
+        "WARN: Dropping unreachable code [test/compress/conditionals.js:12,15]",
+        "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:3,12]",
+        "WARN: Dropping side-effect-free statement [test/compress/conditionals.js:10,12]",
+    ]
 }

 ifs_4: {
@@ -1159,7 +1176,7 @@ issue_1645_2: {
    expect_stdout: true
 }

-condition_symbol_matches_consequent: {
+condition_matches_consequent: {
    options = {
        conditionals: true,
    }
@@ -1188,6 +1205,35 @@ condition_symbol_matches_consequent: {
    expect_stdout: "3 7 true 4"
 }

+condition_matches_alternative: {
+    options = {
+        conditionals: true,
+    }
+    input: {
+        function foo(x, y) {
+            return x.p ? y[0] : x.p;
+        }
+        function bar() {
+            return g ? h : g;
+        }
+        var g = 4;
+        var h = 5;
+        console.log(foo({ p: 3 }, [ null ]), foo({ p: 0 }, [ 7 ]), foo({ p: true } , [ false ]), bar());
+    }
+    expect: {
+        function foo(x, y) {
+            return x.p && y[0];
+        }
+        function bar() {
+            return g && h;
+        }
+        var g = 4;
+        var h = 5;
+        console.log(foo({ p: 3 }, [ null ]), foo({ p: 0 }, [ 7 ]), foo({ p: true } , [ false ]), bar());
+    }
+    expect_stdout: "null 0 false 5"
+}
+
 delete_conditional_1: {
    options = {
        booleans: true,
--- a/test/compress/const.js
+++ b/test/compress/const.js
--- a/test/compress/dead-code.js
+++ b/test/compress/dead-code.js
@@ -59,6 +59,9 @@ dead_code_2_should_warn: {
        f();
    }
    expect_stdout: true
+    expect_warnings: [
+        "WARN: Dropping unreachable code [test/compress/dead-code.js:8,12]",
+    ]
    node_version: "<=4"
 }

@@ -89,11 +92,21 @@ dead_code_constant_boolean_should_warn_more: {
        function bar() {}
        // nothing for the while
        // as for the for, it should keep:
-        var moo;
        var x = 10, y;
+        var moo;
        bar();
    }
    expect_stdout: true
+    expect_warnings: [
+        "WARN: + in boolean context always true [test/compress/dead-code.js:1,33]",
+        "WARN: Boolean || always true [test/compress/dead-code.js:1,16]",
+        "WARN: Dropping unreachable code [test/compress/dead-code.js:1,45]",
+        "WARN: Boolean expression always true [test/compress/dead-code.js:6,47]",
+        "WARN: Boolean && always false [test/compress/dead-code.js:6,28]",
+        "WARN: Dropping unreachable code [test/compress/dead-code.js:6,63]",
+        "WARN: Dropping side-effect-free statement [test/compress/dead-code.js:1,15]",
+        "WARN: Dropping side-effect-free statement [test/compress/dead-code.js:6,28]",
+    ]
    node_version: "<=4"
 }

--- a/test/compress/drop-unused.js
+++ b/test/compress/drop-unused.js
@@ -2993,6 +2993,38 @@ issue_4146: {
    expect_stdout: "function"
 }

+var_catch_redefined: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            throw "PASS";
+        } catch (a) {
+            function f() {
+                return a;
+            }
+            console.log(a);
+        }
+        f();
+    }
+    expect: {
+        var a = "FAIL";
+        try {
+            throw "PASS";
+        } catch (a) {
+            function f() {
+                return a;
+            }
+            console.log(a);
+        }
+        f();
+    }
+    expect_stdout: "PASS"
+}
+
 single_use_catch_redefined: {
    options = {
        reduce_vars: true,
@@ -3023,3 +3055,60 @@ single_use_catch_redefined: {
    }
    expect_stdout: true
 }
+
+issue_4184: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            var a = function() {}, b = [ a, 1 && b, a = {} ];
+            try {
+                throw 42;
+            } catch (a) {
+                {
+                    console.log(a);
+                }
+            }
+        })();
+    }
+    expect: {
+        (function() {
+            var b = [ function() {}, 1 && b, {} ];
+            try {
+                throw 42;
+            } catch (a) {
+                console.log(a);
+            }
+        })();
+    }
+    expect_stdout: "42"
+}
+
+issue_4235: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        (function() {
+            {
+                const f = 0;
+            }
+            (function f() {
+                var f = console.log(f);
+            })();
+        })();
+    }
+    expect: {
+        (function() {
+            f = console.log(f),
+            void 0;
+            var f;
+        })();
+    }
+    expect_stdout: "undefined"
+}
--- a/test/compress/evaluate.js
+++ b/test/compress/evaluate.js
@@ -3014,3 +3014,36 @@ issue_4119_4: {
    }
    expect_stdout: "PASS"
 }
+
+issue_4214: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        function f(a) {
+            return function() {
+                try {
+                    return a;
+                } finally {
+                    var b = 0;
+                }
+            }(a++ && this());
+        }
+        var c = f();
+        console.log(c);
+    }
+    expect: {
+        var c = function(a) {
+            return function() {
+                try {
+                    return a;
+                } finally {}
+            }(a++ && this());
+        }();
+        console.log(c);
+    }
+    expect_stdout: "NaN"
+}
--- a/test/compress/functions.js
+++ b/test/compress/functions.js
@@ -4987,3 +4987,131 @@ catch_defun: {
    }
    expect_stdout: true
 }
+
+catch_no_argname: {
+    options = {
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        var a = "PASS";
+        function f() {
+            return a;
+        }
+        try {
+            throw a;
+        } catch {
+            function g() {
+                return a;
+            }
+            console.log(a, f(), g());
+        }
+        console.log(a, f(), g());
+    }
+    expect: {
+        var a = "PASS";
+        try {
+            throw a;
+        } catch {
+            console.log(a, a, a);
+        }
+        console.log(a, a, a);
+    }
+    expect_stdout: [
+        "PASS PASS PASS",
+        "PASS PASS PASS",
+    ]
+    node_version: ">=10"
+}
+
+issue_4186: {
+    options = {
+        conditionals: true,
+        inline: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        sequences: true,
+        unused: true,
+    }
+    input: {
+        console.log(typeof function() {
+            return function() {
+                function f() {
+                    if (1)
+                        g();
+                    else
+                        (function() {
+                            return f;
+                        });
+                }
+                return f;
+                function g() {
+                    if (1) {
+                        if (0)
+                            h;
+                        else
+                            h();
+                        var key = 0;
+                    }
+                }
+                function h() {
+                    return factory;
+                }
+            };
+        }()());
+    }
+    expect: {
+        console.log(typeof function() {
+            return function f() {
+                1 ? void (1 && (0 ? h : h(), 0)) : function() {
+                    return f;
+                };
+            };
+            function h() {
+                return factory;
+            }
+        }());
+    }
+    expect_stdout: "function"
+}
+
+issue_4233: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            try {
+                var a = function() {};
+                try {
+                    throw 42;
+                } catch (a) {
+                    (function() {
+                        console.log(typeof a);
+                    })();
+                    var a;
+                }
+            } catch (e) {}
+        })();
+    }
+    expect: {
+        (function() {
+            try {
+                var a = function() {};
+                try {
+                    throw 42;
+                } catch (a) {
+                    (function() {
+                        console.log(typeof a);
+                    })();
+                    var a;
+                }
+            } catch (e) {}
+        })();
+    }
+    expect_stdout: "number"
+}
--- a/test/compress/ie8.js
+++ b/test/compress/ie8.js
@@ -2819,3 +2819,88 @@ direct_inline_catch_redefined: {
    }
    expect_stdout: true
 }
+
+issue_4186: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        ie8: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    mangle = {
+        ie8: true,
+        toplevel: true,
+    }
+    input: {
+        function f() {
+            (function NaN() {
+                var a = 1;
+                while (a--)
+                    try {} finally {
+                        console.log(0/0);
+                        var b;
+                    }
+            })(f);
+        }
+        f();
+        NaN;
+    }
+    expect: {
+        (function() {
+            (function NaN() {
+                var n = 1;
+                while (n--)
+                    console.log(0/0);
+            })();
+        })();
+        NaN;
+    }
+    expect_stdout: "NaN"
+}
+
+issue_4235: {
+    options = {
+        ie8: true,
+        unused: true,
+    }
+    input: {
+        try {} catch (e) {}
+        console.log(function e() {
+            var e = 0;
+        }());
+    }
+    expect: {
+        try {} catch (e) {}
+        console.log(function e() {}());
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4250: {
+    options = {
+        ie8: true,
+        loops: true,
+        unused: true,
+    }
+    input: {
+        console.log(function f() {
+            (function() {
+                for (f in "f");
+            })();
+            return f;
+            var f;
+        }());
+    }
+    expect: {
+        console.log(function f() {
+            (function() {
+                for (f in "f");
+            })();
+            return f;
+            var f;
+        }());
+    }
+    expect_stdout: "0"
+}
--- a/test/compress/issue-1034.js
+++ b/test/compress/issue-1034.js
@@ -39,7 +39,7 @@ non_hoisted_function_after_return: {
        "WARN: Dropping unreachable code [test/compress/issue-1034.js:4,16]",
        "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
        "WARN: Dropping unreachable code [test/compress/issue-1034.js:10,12]",
-        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:11,21]"
+        "WARN: Dropping unused function UnusedFunction [test/compress/issue-1034.js:11,21]",
    ]
 }

@@ -84,19 +84,16 @@ non_hoisted_function_after_return_2a: {
        }
    }
    expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:4,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:4,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:7,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:4,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:7,16]",
        "WARN: Dropping unused variable a [test/compress/issue-1034.js:4,20]",
        "WARN: Dropping unused function nope [test/compress/issue-1034.js:11,21]",
-        "INFO: pass 0: last_count: Infinity, count: 36",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:9,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:9,12]",
+        "INFO: pass 0: last_count: Infinity, count: 35",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:9,12]",
        "WARN: Dropping unreachable code [test/compress/issue-1034.js:12,12]",
        "INFO: Dropping unused variable b [test/compress/issue-1034.js:7,20]",
        "INFO: Dropping unused variable c [test/compress/issue-1034.js:9,16]",
-        "INFO: pass 1: last_count: 36, count: 18",
+        "INFO: pass 1: last_count: 35, count: 18",
    ]
 }

@@ -138,10 +135,7 @@ non_hoisted_function_after_return_2b: {
        }
    }
    expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:6,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:6,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:8,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:8,12]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:8,12]",
        "WARN: Dropping unreachable code [test/compress/issue-1034.js:12,12]",
    ]
 }
@@ -242,19 +236,16 @@ non_hoisted_function_after_return_2a_strict: {
    }
    expect_stdout: "5 6"
    expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:5,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:5,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:8,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:8,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:5,16]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:8,16]",
        "WARN: Dropping unused variable a [test/compress/issue-1034.js:5,20]",
        "WARN: Dropping unused function nope [test/compress/issue-1034.js:12,21]",
-        "INFO: pass 0: last_count: Infinity, count: 47",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:10,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:10,12]",
+        "INFO: pass 0: last_count: Infinity, count: 46",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:10,12]",
        "WARN: Dropping unreachable code [test/compress/issue-1034.js:13,12]",
        "INFO: Dropping unused variable b [test/compress/issue-1034.js:8,20]",
        "INFO: Dropping unused variable c [test/compress/issue-1034.js:10,16]",
-        "INFO: pass 1: last_count: 47, count: 29",
+        "INFO: pass 1: last_count: 46, count: 29",
    ]
 }

@@ -301,10 +292,7 @@ non_hoisted_function_after_return_2b_strict: {
    }
    expect_stdout: "5 6"
    expect_warnings: [
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:7,16]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:7,16]",
-        "WARN: Dropping unreachable code [test/compress/issue-1034.js:9,12]",
-        "WARN: Declarations in unreachable code! [test/compress/issue-1034.js:9,12]",
+        "WARN: Dropping initialization in unreachable code [test/compress/issue-1034.js:9,12]",
        "WARN: Dropping unreachable code [test/compress/issue-1034.js:13,12]",
    ]
 }
--- a/test/compress/issue-1105.js
+++ b/test/compress/issue-1105.js
@@ -151,15 +151,18 @@ Infinity_not_in_with_scope: {
        unused: true,
    }
    input: {
-        var o = { Infinity: 'oInfinity' };
+        var o = { Infinity: "FAIL" };
        var vInfinity = "Infinity";
        vInfinity = Infinity;
+        console.log(vInfinity);
    }
    expect: {
-        var o = { Infinity: 'oInfinity' }
-        var vInfinity = "Infinity"
-        vInfinity = 1/0
+        var o = { Infinity: "FAIL" };
+        var vInfinity = "Infinity";
+        vInfinity = 1/0;
+        console.log(vInfinity);
    }
+    expect_stdout: "Infinity"
 }

 Infinity_in_with_scope: {
@@ -167,15 +170,18 @@ Infinity_in_with_scope: {
        unused: true,
    }
    input: {
-        var o = { Infinity: 'oInfinity' };
+        var o = { Infinity: "PASS" };
        var vInfinity = "Infinity";
        with (o) { vInfinity = Infinity; }
+        console.log(vInfinity);
    }
    expect: {
-        var o = { Infinity: 'oInfinity' }
-        var vInfinity = "Infinity"
-        with (o) vInfinity = Infinity
+        var o = { Infinity: "PASS" };
+        var vInfinity = "Infinity";
+        with (o) vInfinity = Infinity;
+        console.log(vInfinity);
    }
+    expect_stdout: "PASS"
 }

 assorted_Infinity_NaN_undefined_in_with_scope: {
--- a/test/compress/let.js
+++ b/test/compress/let.js
@@ -0,0 +1,952 @@
+retain_block: {
+    options = {}
+    input: {
+        "use strict";
+        {
+            let a = "FAIL";
+        }
+        var a = "PASS";
+        console.log(a);
+    }
+    expect: {
+        "use strict";
+        {
+            let a = "FAIL";
+        }
+        var a = "PASS";
+        console.log(a);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+if_dead_branch: {
+    options = {
+        conditionals: true,
+        dead_code: true,
+        evaluate: true,
+    }
+    input: {
+        "use strict";
+        console.log(function() {
+            if (0) {
+                let a = 0;
+            }
+            return typeof a;
+        }());
+    }
+    expect: {
+        "use strict";
+        console.log(function() {
+            0;
+            {
+                let a;
+            }
+            return typeof a;
+        }());
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+merge_vars_1: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        let a = console;
+        console.log(typeof a);
+        var b = typeof a;
+        console.log(b);
+    }
+    expect: {
+        "use strict";
+        let a = console;
+        console.log(typeof a);
+        var b = typeof a;
+        console.log(b);
+    }
+    expect_stdout: [
+        "object",
+        "object",
+    ]
+    node_version: ">=4"
+}
+
+merge_vars_2: {
+    options = {
+        inline: true,
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        var a = 0;
+        (function() {
+            var b = function f() {
+                let c = a && f;
+                c.var += 0;
+            }();
+            console.log(b);
+        })(1 && --a);
+    }
+    expect: {
+        "use strict";
+        var a = 0;
+        1 && --a,
+        b = function f() {
+            let c = a && f;
+            c.var += 0;
+        }(),
+        void console.log(b);
+        var b;
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+merge_vars_3: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        {
+            let a = 0;
+            var b = console;
+            console.log(typeof b);
+        }
+        var a = 1;
+        console.log(typeof a);
+    }
+    expect: {
+        "use strict";
+        {
+            let a = 0;
+            var b = console;
+            console.log(typeof b);
+        }
+        var a = 1;
+        console.log(typeof a);
+    }
+    expect_stdout: [
+        "object",
+        "number",
+    ]
+    node_version: ">=4"
+}
+
+use_before_init_1: {
+    options = {
+        evaluate: true,
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        a = "foo";
+        let a = "bar";
+    }
+    expect: {
+        "use strict";
+        a = "foo";
+        let a = "bar";
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+use_before_init_2: {
+    options = {
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        try {
+            a = "foo";
+        } catch (e) {
+            console.log("PASS");
+        }
+        let a = "bar";
+    }
+    expect: {
+        "use strict";
+        try {
+            a = "foo";
+        } catch (e) {
+            console.log("PASS");
+        }
+        let a = "bar";
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+use_before_init_3: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        try {
+            a;
+        } catch (e) {
+            console.log("PASS");
+        }
+        let a = 42;
+    }
+    expect: {
+        "use strict";
+        try {
+            a;
+        } catch (e) {
+            console.log("PASS");
+        }
+        let a = 42;
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+use_before_init_4: {
+    options = {
+        reduce_vars: true,
+    }
+    input: {
+        "use strict";
+        try {
+            console.log(a);
+        } catch (e) {
+            console.log("PASS");
+        }
+        let a = "FAIL";
+    }
+    expect: {
+        "use strict";
+        try {
+            console.log(a);
+        } catch (e) {
+            console.log("PASS");
+        }
+        let a = "FAIL";
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+collapse_block: {
+    options = {
+        collapse_vars: true,
+        pure_getters: "strict",
+        unsafe: true,
+    }
+    input: {
+        "use strict";
+        {
+            let a = typeof console;
+            console.log(a);
+        }
+    }
+    expect: {
+        "use strict";
+        {
+            let a = typeof console;
+            console.log(a);
+        }
+    }
+    expect_stdout: "object"
+    node_version: ">=4"
+}
+
+reduce_block_1: {
+    options = {
+        reduce_vars: true,
+    }
+    input: {
+        "use strict";
+        {
+            let a = typeof console;
+            console.log(a);
+        }
+    }
+    expect: {
+        "use strict";
+        {
+            let a = typeof console;
+            console.log(a);
+        }
+    }
+    expect_stdout: "object"
+    node_version: ">=4"
+}
+
+reduce_block_2: {
+    options = {
+        reduce_vars: true,
+    }
+    input: {
+        "use strict";
+        {
+            let a = typeof console;
+            console.log(a);
+        }
+        console.log(typeof a);
+    }
+    expect: {
+        "use strict";
+        {
+            let a = typeof console;
+            console.log(a);
+        }
+        console.log(typeof a);
+    }
+    expect_stdout: [
+        "object",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+reduce_block_2_toplevel: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        {
+            let a = typeof console;
+            console.log(a);
+        }
+        console.log(typeof a);
+    }
+    expect: {
+        "use strict";
+        {
+            let a = typeof console;
+            console.log(a);
+        }
+        console.log(typeof a);
+    }
+    expect_stdout: [
+        "object",
+        "undefined",
+    ]
+    node_version: ">=4"
+}
+
+hoist_props: {
+    options = {
+        hoist_props: true,
+        reduce_vars: true,
+    }
+    input: {
+        "use strict";
+        {
+            let o = {
+                p: "PASS",
+            };
+            console.log(o.p);
+        }
+    }
+    expect: {
+        "use strict";
+        {
+            let o = {
+                p: "PASS",
+            };
+            console.log(o.p);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+loop_block_1: {
+    options = {
+        loops: true,
+    }
+    input: {
+        "use strict";
+        do {
+            let o = console;
+            console.log(typeof o.log);
+        } while (!console);
+    }
+    expect: {
+        "use strict";
+        do {
+            let o = console;
+            console.log(typeof o.log);
+        } while (!console);
+    }
+    expect_stdout: "function"
+    node_version: ">=4"
+}
+
+loop_block_2: {
+    options = {
+        loops: true,
+    }
+    input: {
+        "use strict";
+        do {
+            let o = {};
+            (function() {
+                console.log(typeof this, o.p++);
+            })();
+        } while (!console);
+    }
+    expect: {
+        "use strict";
+        do {
+            let o = {};
+            (function() {
+                console.log(typeof this, o.p++);
+            })();
+        } while (!console);
+    }
+    expect_stdout: "undefined NaN"
+    node_version: ">=4"
+}
+
+do_continue: {
+    options = {
+        loops: true,
+    }
+    input: {
+        "use strict";
+        try {
+            do {
+                {
+                    let a = 0;
+                    continue;
+                }
+            } while ([ A ]);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            do {
+                let a = 0;
+                continue;
+            } while ([ A ]);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+dead_block_after_return: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        "use strict";
+        (function(a) {
+            console.log(a);
+            return;
+            {
+                let a = "FAIL";
+            }
+        })("PASS");
+    }
+    expect: {
+        "use strict";
+        (function(a) {
+            console.log(a);
+            return;
+            {
+                let a;
+            }
+        })("PASS");
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+do_if_continue_1: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        do {
+            if (console) {
+                console.log("PASS");
+                {
+                    let a = 0;
+                    var b;
+                    continue;
+                }
+            }
+        } while (b);
+    }
+    expect: {
+        "use strict";
+        do {
+            if (!console);
+            else {
+                console.log("PASS");
+                {
+                    let a = 0;
+                    var b;
+                }
+            }
+        } while (b);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+do_if_continue_2: {
+    options = {
+        if_return: true,
+    }
+    input: {
+        "use strict";
+        do {
+            if (console) {
+                console.log("FAIL");
+                {
+                    let a = 0;
+                    A = 0;
+                    continue;
+                }
+            }
+        } while (A);
+    }
+    expect: {
+        "use strict";
+        do {
+            if (!console);
+            else {
+                console.log("FAIL");
+                {
+                    let a = 0;
+                    A = 0;
+                }
+            }
+        } while (A);
+    }
+    expect_stdout: ReferenceError("A is not defined")
+    node_version: ">=4"
+}
+
+drop_unused: {
+    options = {
+        evaluate: true,
+        side_effects: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        function f(a) {
+            let b = a, c = b;
+            0 && c.p++;
+        }
+        console.log(f());
+    }
+    expect: {
+        "use strict";
+        function f(a) {
+            let b = a;
+            b;
+        }
+        console.log(f());
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_4191: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        {
+            let a = function() {};
+        }
+        console.log(typeof a);
+    }
+    expect: {
+        "use strict";
+        {
+            let a = function() {};
+        }
+        console.log(typeof a);
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_4197: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        "use strict";
+        var a = 0;
+        try {
+            let b = function() {
+                a = 1;
+                b[1];
+            }();
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect: {
+        "use strict";
+        var a = 0;
+        try {
+            let b = function() {
+                a = 1;
+                b[1];
+            }();
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect_stdout: "1"
+    node_version: ">=4"
+}
+
+issue_4202: {
+    options = {
+        inline: true,
+        toplevel: true,
+    }
+    input: {
+        "use strict";
+        {
+            let o = {};
+            (function() {
+                function f() {
+                    o.p = 42;
+                }
+                f(f);
+            })();
+            console.log(o.p++);
+        }
+    }
+    expect: {
+        "use strict";
+        {
+            let o = {};
+            (function() {
+                function f() {
+                    o.p = 42;
+                }
+                f(f);
+            })();
+            console.log(o.p++);
+        }
+    }
+    expect_stdout: "42"
+    node_version: ">=4"
+}
+
+issue_4207: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        {
+            let a = function() {};
+            console.log(a.length);
+        }
+    }
+    expect: {
+        "use strict";
+        {
+            let a = function() {};
+            console.log(a.length);
+        }
+    }
+    expect_stdout: "0"
+    node_version: ">=4"
+}
+
+issue_4218: {
+    options = {
+        reduce_funcs: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+    }
+    input: {
+        "use strict";
+        var a;
+        {
+            let a = function() {};
+            var b = 0 * a;
+        }
+        console.log(typeof a, b);
+    }
+    expect: {
+        "use strict";
+        var b = 0 * function() {};
+        console.log(typeof void 0, b);
+    }
+    expect_stdout: "undefined NaN"
+    node_version: ">=4"
+}
+
+issue_4210: {
+    options = {
+        reduce_vars: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        var a;
+        (function() {
+            try {
+                throw 42;
+            } catch (e) {
+                let a = typeof e;
+                console.log(a);
+            } finally {
+                return a = "foo";
+            }
+        })();
+        console.log(typeof a);
+    }
+    expect: {
+        "use strict";
+        var a;
+        (function() {
+            try {
+                throw 42;
+            } catch (e) {
+                let a = typeof e;
+                console.log(a);
+            } finally {
+                return a = "foo";
+            }
+        })();
+        console.log(typeof a);
+    }
+    expect_stdout: [
+        "number",
+        "string",
+    ]
+    node_version: ">=4"
+}
+
+issue_4212_1: {
+    options = {
+        dead_code: true,
+    }
+    input: {
+        "use strict";
+        console.log({
+            get b() {
+                let a = 0;
+                return a /= 0;
+            }
+        }.b);
+    }
+    expect: {
+        "use strict";
+        console.log({
+            get b() {
+                let a = 0;
+                return a / 0;
+            }
+        }.b);
+    }
+    expect_stdout: "NaN"
+    node_version: ">=4"
+}
+
+issue_4212_2: {
+    options = {
+        reduce_vars: true,
+    }
+    input: {
+        "use strict";
+        console.log({
+            get b() {
+                let a = 0;
+                return a /= 0;
+            }
+        }.b);
+    }
+    expect: {
+        "use strict";
+        console.log({
+            get b() {
+                let a = 0;
+                return a /= 0;
+            }
+        }.b);
+    }
+    expect_stdout: "NaN"
+    node_version: ">=4"
+}
+
+skip_braces: {
+    beautify = {
+        beautify: true,
+        braces: true,
+    }
+    input: {
+        "use strict";
+        if (console)
+            let a = console.log(typeof a);
+    }
+    expect_exact: [
+        '"use strict";',
+        "",
+        "if (console) let a = console.log(typeof a);",
+    ]
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_4225: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        let a = void typeof b;
+        let b = 42;
+        console.log(a, b);
+    }
+    expect: {
+        "use strict";
+        let a = void b;
+        let b = 42;
+        console.log(a, b);
+    }
+    expect_stdout: true
+    node_version: ">=4"
+}
+
+issue_4229: {
+    options = {
+        ie8: true,
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        try {
+            (function f() {
+                f;
+                let f;
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        "use strict";
+        try {
+            (function f() {
+                f;
+                let f;
+            })();
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+issue_4231: {
+    options = {
+        ie8: true,
+        side_effects: true,
+    }
+    input: {
+        "use strict";
+        typeof a == 0;
+        console.log(typeof function a() {
+            let a;
+        });
+    }
+    expect: {
+        "use strict";
+        console.log(typeof function a() {
+            let a;
+        });
+    }
+    expect_stdout: "function"
+    node_version: ">=4"
+}
+
+issue_4245: {
+    options = {
+        booleans: true,
+    }
+    input: {
+        "use strict";
+        let a = f();
+        function f() {
+            typeof a;
+        }
+    }
+    expect: {
+        "use strict";
+        let a = f();
+        function f() {
+            a,
+            1;
+        }
+    }
+    expect_stdout: ReferenceError("a is not defined")
+    node_version: ">=4"
+}
+
+issue_4248: {
+    options = {
+        collapse_vars: true,
+    }
+    input: {
+        var a = "FAIL";
+        try {
+            (function() {
+                "use strict";
+                a = "PASS";
+                b[a];
+                let b;
+            })();
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect: {
+        var a = "FAIL";
+        try {
+            (function() {
+                "use strict";
+                a = "PASS";
+                b[a];
+                let b;
+            })();
+        } catch (e) {
+            console.log(a);
+        }
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
--- a/test/compress/loops.js
+++ b/test/compress/loops.js
@@ -201,7 +201,7 @@ evaluate: {
    }
 }

-issue_1532: {
+issue_1532_1: {
    options = {
        evaluate: true,
        loops: true,
@@ -210,18 +210,56 @@ issue_1532: {
        function f(x, y) {
            do {
                if (x) break;
-                foo();
+                console.log(y);
            } while (false);
        }
+        f(null, "PASS");
+        f(42, "FAIL");
+    }
+    expect: {
+        function f(x, y) {
+            for (; !x && (console.log(y), false););
+        }
+        f(null, "PASS");
+        f(42, "FAIL");
+    }
+    expect_stdout: "PASS"
+}
+
+issue_1532_2: {
+    options = {
+        evaluate: true,
+        loops: true,
+    }
+    input: {
+        function f(x, y) {
+            do {
+                if (x) {
+                    console.log(x);
+                    break;
+                }
+                console.log(y);
+            } while (false);
+        }
+        f(null, "PASS");
+        f(42, "FAIL");
    }
    expect: {
        function f(x, y) {
            do {
-                if (x) break;
-                foo();
-            } while (false);
+                if (x) {
+                    console.log(x);
+                    break;
+                }
+            } while (console.log(y), false);
        }
+        f(null, "PASS");
+        f(42, "FAIL");
    }
+    expect_stdout: [
+        "PASS",
+        "42",
+    ]
 }

 issue_186: {
@@ -509,8 +547,8 @@ dead_code_condition: {
        console.log(a);
    }
    expect: {
-        var c;
        var a = 0, b = 5;
+        var c;
        a += 1, 0,
        console.log(a);
    }
@@ -1088,3 +1126,131 @@ issue_4091_2: {
    }
    expect_stdout: "undefined"
 }
+
+issue_4182_1: {
+    options = {
+        loops: true,
+    }
+    input: {
+        (function() {
+            do {
+                try {
+                    return;
+                } finally {
+                    continue;
+                }
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect: {
+        (function() {
+            do {
+                try {
+                    return;
+                } finally {
+                    continue;
+                }
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4182_2: {
+    options = {
+        loops: true,
+    }
+    input: {
+        (function() {
+            L: do {
+                do {
+                    try {
+                        return;
+                    } finally {
+                        continue L;
+                    }
+                    console.log("FAIL");
+                } while (0);
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect: {
+        (function() {
+            L: do {
+                do {
+                    try {
+                        return;
+                    } finally {
+                        continue L;
+                    }
+                } while (console.log("FAIL"), 0);
+                console.log("FAIL");
+            } while (0);
+            console.log("PASS");
+        })();
+    }
+    expect_stdout: "PASS"
+}
+
+do_continue: {
+    options = {
+        loops: true,
+    }
+    input: {
+        try {
+            do {
+                continue;
+            } while ([ A ]);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect: {
+        try {
+            do {
+                continue;
+            } while ([ A ]);
+        } catch (e) {
+            console.log("PASS");
+        }
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4240: {
+    options = {
+        loops: true,
+        reduce_funcs: true,
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function(a) {
+            function f() {
+                var o = { PASS: 42 };
+                for (a in o);
+            }
+            (function() {
+                if (f());
+            })();
+            console.log(a);
+        })();
+    }
+    expect: {
+        (function(a) {
+            (function() {
+                if (function() {
+                    for (a in { PASS: 42 });
+                }());
+            })();
+            console.log(a);
+        })();
+    }
+    expect_stdout: "PASS"
+}
--- a/test/compress/merge_vars.js
+++ b/test/compress/merge_vars.js
@@ -466,7 +466,7 @@ issue_4112: {
                var o = e;
                for (e in o);
                var a = function() {};
-                console.log;
+                console.log(typeof a);
                return a;
            }
        }());
@@ -479,12 +479,15 @@ issue_4112: {
                var a = e;
                for (e in a);
                a = function() {};
-                console.log;
+                console.log(typeof a);
                return a;
            }
        }());
    }
-    expect_stdout: "function"
+    expect_stdout: [
+        "function",
+        "function",
+    ]
 }

 issue_4115: {
@@ -3008,3 +3011,175 @@ issue_4168_use_strict: {
    }
    expect_stdout: "PASS true 42"
 }
+
+issue_4237_1: {
+    options = {
+        merge_vars: true,
+    }
+    input: {
+        console.log(function(a) {
+            do {
+                var b = a++;
+                if (b)
+                    return "FAIL";
+                continue;
+                var c = 42;
+            } while ("undefined" != typeof c);
+            return "PASS";
+        }(0));
+    }
+    expect: {
+        console.log(function(a) {
+            do {
+                var b = a++;
+                if (b)
+                    return "FAIL";
+                continue;
+                var c = 42;
+            } while ("undefined" != typeof c);
+            return "PASS";
+        }(0));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4237_2: {
+    options = {
+        dead_code: true,
+        evaluate: true,
+        loops: true,
+        merge_vars: true,
+        switches: true,
+    }
+    input: {
+        console.log(function(a) {
+            do {
+                switch (0) {
+                  case 0:
+                    var b = a++;
+                  default:
+                    while (b)
+                        return "FAIL";
+                }
+                try {
+                    var c = 0;
+                } finally {
+                    continue;
+                }
+                var d = 0;
+            } while ("undefined" != typeof d);
+            return "PASS";
+        }(0));
+    }
+    expect: {
+        console.log(function(a) {
+            do {
+                switch (0) {
+                  case 0:
+                    var b = a++;
+                    if (b)
+                        return "FAIL";
+                }
+                try {
+                    var c = 0;
+                } finally {
+                    continue;
+                }
+                var d = 0;
+            } while ("undefined" != typeof d);
+            return "PASS";
+        }(0));
+    }
+    expect_stdout: "PASS"
+}
+
+issue_4253: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        switch (0) {
+          default:
+            var a = "FAIL";
+            a = a && a;
+            try {
+                break;
+            } catch (e) {}
+            var b = 42;
+        }
+        console.log(b);
+    }
+    expect: {
+        switch (0) {
+          default:
+            var a = "FAIL";
+            a = a && a;
+            try {
+                break;
+            } catch (e) {}
+            var b = 42;
+        }
+        console.log(b);
+    }
+    expect_stdout: "undefined"
+}
+
+issue_4255: {
+    options = {
+        dead_code: true,
+        loops: true,
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        L: for (var a = 2; --a;)
+            for (var b = 0; console.log(b); --b)
+                break L;
+    }
+    expect: {
+        L: for (var a = 2; --a;) {
+            var b = 0;
+            if (console.log(b))
+                break L;
+        }
+    }
+    expect_stdout: "0"
+}
+
+issue_4257: {
+    options = {
+        merge_vars: true,
+        toplevel: true,
+    }
+    input: {
+        var a = 0;
+        for (var i = 0; i < 2; i++)
+            switch (--a) {
+              case 0:
+                var b = 0;
+                break;
+              case 0:
+              default:
+                var c = 1 + (0 | (b && A));
+                console.log(c);
+            }
+    }
+    expect: {
+        var a = 0;
+        for (var i = 0; i < 2; i++)
+            switch (--a) {
+              case 0:
+                var b = 0;
+                break;
+              case 0:
+              default:
+                var c = 1 + (0 | (b && A));
+                console.log(c);
+            }
+    }
+    expect_stdout: [
+        "1",
+        "1",
+    ]
+}
--- a/test/compress/properties.js
+++ b/test/compress/properties.js
@@ -1123,11 +1123,7 @@ new_this: {
            }
        }.f(42);
    }
-    expect: {
-        new function(a) {
-            this.a = a;
-        }(42);
-    }
+    expect: {}
 }

 issue_2513: {
--- a/test/compress/pure_getters.js
+++ b/test/compress/pure_getters.js
@@ -848,9 +848,8 @@ collapse_vars_1_true: {
    }
    expect: {
        function f(a, b) {
-            for (;;) {
+            for (;;)
                if (a.g() || b.p) break;
-            }
        }
    }
 }
--- a/test/compress/reduce_vars.js
+++ b/test/compress/reduce_vars.js
@@ -7535,3 +7535,69 @@ global_assign: {
    }
    expect_stdout: "PASS"
 }
+
+issue_4188_1: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            try {
+                while (A)
+                    var a = function() {}, b = a;
+            } catch (a) {
+                console.log(function() {
+                    return typeof a;
+                }(), typeof b);
+            }
+        })();
+    }
+    expect: {
+        (function() {
+            try {
+                while (A)
+                    var a = function() {}, b = a;
+            } catch (a) {
+                console.log(function() {
+                    return typeof a;
+                }(), typeof b);
+            }
+        })();
+    }
+    expect_stdout: "object undefined"
+}
+
+issue_4188_2: {
+    options = {
+        reduce_vars: true,
+        unused: true,
+    }
+    input: {
+        (function() {
+            try {
+                throw 42;
+            } catch (a) {
+                console.log(function() {
+                    return typeof a;
+                }(), typeof b);
+            }
+            while (!console)
+                var a = function() {}, b = a;
+        })();
+    }
+    expect: {
+        (function() {
+            try {
+                throw 42;
+            } catch (a) {
+                console.log(function() {
+                    return typeof a;
+                }(), typeof b);
+            }
+            while (!console)
+                var a = function() {}, b = a;
+        })();
+    }
+    expect_stdout: "number undefined"
+}
--- a/test/compress/side_effects.js
+++ b/test/compress/side_effects.js
@@ -416,3 +416,20 @@ issue_4008: {
        "PASS",
    ]
 }
+
+trim_new: {
+    options = {
+        side_effects: true,
+    }
+    input: {
+        new function(a) {
+            console.log(a);
+        }("PASS");
+    }
+    expect: {
+        (function(a) {
+            console.log(a);
+        })("PASS");
+    }
+    expect_stdout: "PASS"
+}
--- a/test/compress/unicode.js
+++ b/test/compress/unicode.js
@@ -1,3 +1,37 @@
+ascii_only_false: {
+    options = {}
+    beautify = {
+        ascii_only: false,
+    }
+    input: {
+        console.log(
+            "\x000\x001\x007\x008\x00",
+            "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
+            "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",
+            "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff"
+        );
+    }
+    expect_exact: 'console.log("\\x000\\x001\\x007\\x008\\0","\\0\x01\x02\x03\x04\x05\x06\x07\\b\\t\\n\\v\\f\\r\x0e\x0f","\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",\' !"# ... }~\x7f\x80\x81 ... \xfe\xff\u0fff\uffff\');'
+    expect_stdout: true
+}
+
+ascii_only_true: {
+    options = {}
+    beautify = {
+        ascii_only: true,
+    }
+    input: {
+        console.log(
+            "\x000\x001\x007\x008\x00",
+            "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
+            "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",
+            "\x20\x21\x22\x23 ... \x7d\x7e\x7f\x80\x81 ... \xfe\xff\u0fff\uffff"
+        );
+    }
+    expect_exact: 'console.log("\\x000\\x001\\x007\\x008\\0","\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\b\\t\\n\\v\\f\\r\\x0e\\x0f","\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f",\' !"# ... }~\\x7f\\x80\\x81 ... \\xfe\\xff\\u0fff\\uffff\');'
+    expect_stdout: true
+}
+
 unicode_parse_variables: {
    options = {}
    input: {
@@ -141,3 +175,35 @@ issue_2569: {
    }
    expect_exact: 'new RegExp("[\\udc42-\\udcaa\\udd74-\\udd96\\ude45-\\ude4f\\udea3-\\udecc]");'
 }
+
+surrogate_pair: {
+    beautify = {
+        ascii_only: false,
+    }
+    input: {
+        var \u{2f800} = {
+            \u{2f801}: "\u{100000}",
+        };
+        \u{2f800}.\u{2f802} = "\u{100001}";
+        console.log(typeof \u{2f800}, \u{2f800}.\u{2f801}, \u{2f800}["\u{2f802}"]);
+    }
+    expect_exact: 'var \ud87e\udc00={"\ud87e\udc01":"\udbc0\udc00"};\ud87e\udc00.\ud87e\udc02="\udbc0\udc01";console.log(typeof \ud87e\udc00,\ud87e\udc00.\ud87e\udc01,\ud87e\udc00["\ud87e\udc02"]);'
+    expect_stdout: "object \udbc0\udc00 \udbc0\udc01"
+    node_version: ">=4"
+}
+
+surrogate_pair_ascii: {
+    beautify = {
+        ascii_only: true,
+    }
+    input: {
+        var \u{2f800} = {
+            \u{2f801}: "\u{100000}",
+        };
+        \u{2f800}.\u{2f802} = "\u{100001}";
+        console.log(typeof \u{2f800}, \u{2f800}.\u{2f801}, \u{2f800}["\u{2f802}"]);
+    }
+    expect_exact: 'var \\u{2f800}={"\\ud87e\\udc01":"\\udbc0\\udc00"};\\u{2f800}.\\u{2f802}="\\udbc0\\udc01";console.log(typeof \\u{2f800},\\u{2f800}.\\u{2f801},\\u{2f800}["\\ud87e\\udc02"]);'
+    expect_stdout: "object \udbc0\udc00 \udbc0\udc01"
+    node_version: ">=4"
+}
--- a/test/compress/varify.js
+++ b/test/compress/varify.js
@@ -0,0 +1,236 @@
+reduce_merge_const: {
+    options = {
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        const a = console;
+        console.log(typeof a);
+        var b = typeof a;
+        console.log(b);
+    }
+    expect: {
+        var b = console;
+        console.log(typeof b);
+        b = typeof b;
+        console.log(b);
+    }
+    expect_stdout: [
+        "object",
+        "object",
+    ]
+}
+
+reduce_merge_let: {
+    options = {
+        merge_vars: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        let a = console;
+        console.log(typeof a);
+        var b = typeof a;
+        console.log(b);
+    }
+    expect: {
+        "use strict";
+        var b = console;
+        console.log(typeof b);
+        b = typeof b;
+        console.log(b);
+    }
+    expect_stdout: [
+        "object",
+        "object",
+    ]
+    node_version: ">=4"
+}
+
+reduce_block_const: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        {
+            const a = typeof console;
+            console.log(a);
+        }
+    }
+    expect: {
+        var a = typeof console;
+        console.log(a);
+    }
+    expect_stdout: "object"
+}
+
+reduce_block_let: {
+    options = {
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        {
+            let a = typeof console;
+            console.log(a);
+        }
+    }
+    expect: {
+        "use strict";
+        var a = typeof console;
+        console.log(a);
+    }
+    expect_stdout: "object"
+    node_version: ">=4"
+}
+
+hoist_props_const: {
+    options = {
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        {
+            const o = {
+                p: "PASS",
+            };
+            console.log(o.p);
+        }
+    }
+    expect: {
+        var o_p = "PASS";
+        console.log(o_p);
+    }
+    expect_stdout: "PASS"
+}
+
+hoist_props_let: {
+    options = {
+        hoist_props: true,
+        passes: 2,
+        reduce_vars: true,
+        toplevel: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        {
+            let o = {
+                p: "PASS",
+            };
+            console.log(o.p);
+        }
+    }
+    expect: {
+        "use strict";
+        var o_p = "PASS";
+        console.log(o_p);
+    }
+    expect_stdout: "PASS"
+    node_version: ">=4"
+}
+
+scope_adjustment_const: {
+    options = {
+        conditionals: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        for (var k in [ 42 ])
+            console.log(function f() {
+                if (k) {
+                    const a = 0;
+                }
+            }());
+    }
+    expect: {
+        for (var k in [ 42 ])
+            console.log(void (k && 0));
+    }
+    expect_stdout: "undefined"
+}
+
+scope_adjustment_let: {
+    options = {
+        conditionals: true,
+        inline: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        for (var k in [ 42 ])
+            console.log(function f() {
+                if (k) {
+                    let a = 0;
+                }
+            }());
+    }
+    expect: {
+        "use strict";
+        for (var k in [ 42 ])
+            console.log(void (k && 0));
+    }
+    expect_stdout: "undefined"
+    node_version: ">=4"
+}
+
+issue_4191_const: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        const a = function() {};
+        console.log(typeof a, a());
+    }
+    expect: {
+        function a() {};
+        console.log(typeof a, a());
+    }
+    expect_stdout: "function undefined"
+}
+
+issue_4191_let: {
+    options = {
+        functions: true,
+        reduce_vars: true,
+        toplevel: true,
+        unused: true,
+        varify: true,
+    }
+    input: {
+        "use strict";
+        let a = function() {};
+        console.log(typeof a, a());
+    }
+    expect: {
+        "use strict";
+        function a() {};
+        console.log(typeof a, a());
+    }
+    expect_stdout: "function undefined"
+    node_version: ">=4"
+}
--- a/test/input/issue-3294/output.js
+++ b/test/input/issue-3294/output.js
@@ -1,2 +1,2 @@
-new function(){console.log(3)};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUErQyxJQUFyQyxXQUFnQkEsUUFBUUMsSUFBSSJ9
+console.log(3);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSJ9
--- a/test/input/issue-520/output.js
+++ b/test/input/issue-520/output.js
@@ -1,2 +1,2 @@
-new function(){console.log(3)};
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUErQyxJQUFyQyxXQUFnQkEsUUFBUUMsSUFBSSJ9
+console.log(3);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0ZGluIl0sInNvdXJjZXNDb250ZW50IjpbImNsYXNzIEZvbyB7IGNvbnN0cnVjdG9yKCl7Y29uc29sZS5sb2coMSsyKTt9IH0gbmV3IEZvbygpO1xuIl0sIm5hbWVzIjpbImNvbnNvbGUiLCJsb2ciXSwibWFwcGluZ3MiOiJBQUEwQkEsUUFBUUMsSUFBSSJ9
--- a/test/jetstream.js
+++ b/test/jetstream.js
@@ -60,7 +60,7 @@ if (typeof phantom == "undefined") {
        var port = server.address().port;
        if (debug) {
            console.log("http://localhost:" + port + "/");
-        } else {
+        } else (function install() {
            child_process.spawn(process.platform == "win32" ? "npm.cmd" : "npm", [
                "install",
                "phantomjs-prebuilt@2.1.14",
@@ -71,7 +71,10 @@ if (typeof phantom == "undefined") {
            ], {
                stdio: [ "ignore", 1, 2 ]
            }).on("exit", function(code) {
-                if (code) throw new Error("npm install failed!");
+                if (code) {
+                    console.log("npm install failed with code", code);
+                    return install();
+                }
                var program = require("phantomjs-prebuilt").exec(process.argv[1], port);
                program.stdout.pipe(process.stdout);
                program.stderr.pipe(process.stderr);
@@ -82,7 +85,7 @@ if (typeof phantom == "undefined") {
                    process.exit(0);
                });
            });
-        }
+        })();
    });
    server.timeout = 0;
 } else {
--- a/test/mocha/number-literal.js
+++ b/test/mocha/number-literal.js
@@ -28,4 +28,65 @@ describe("Number literals", function() {
            assert.throws(test(inputs[i]), error, inputs[i]);
        }
    });
+    it("Should parse binary, hexadecimal, octal and underscore correctly", function() {
+        [
+            "42",
+            "4_2",
+            "052",
+            "0o52",
+            "0O52",
+            "0o5_2",
+            "0x2a",
+            "0X2A",
+            "0x2_a",
+            "0b101010",
+            "0B101010",
+            "0b101_010",
+            "0.0000000042e+10",
+            "0.0000000042E+10",
+            "0.0_000000042e+10",
+            "0.0000000042e+1_0",
+            "0.000_000_004_2e+1_0",
+            "0.000_000_004_2e+1_0-0B101_010+0x2_A-0o5_2+4_2",
+        ].forEach(function(code) {
+            var result = UglifyJS.minify(code, {
+                compress: {
+                    expression: true,
+                },
+            });
+            if (result.error) throw result.error;
+            assert.strictEqual(result.code, "42;");
+        });
+    });
+    it("Should reject invalid use of underscore", function() {
+        [
+            "_42",
+            "_+42",
+            "+_42",
+        ].forEach(function(code) {
+            var node = UglifyJS.parse(code, {
+                expression: true,
+            });
+            assert.ok(!node.is_constant(), code);
+            assert.ok(!(node instanceof UglifyJS.AST_Statement), code);
+        });
+        [
+            "42_",
+            "4__2",
+            "0_52",
+            "05_2",
+            "0_o52",
+            "0o_52",
+            "0.0000000042_e10",
+            "0.0000000042e_10",
+            "0.0000000042e_+10",
+            "0.0000000042e+_10",
+        ].forEach(function(code) {
+            assert.throws(function() {
+                UglifyJS.parse(code);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error;
+            }, code);
+        });
+    });
 });
--- a/test/mocha/string-literal.js
+++ b/test/mocha/string-literal.js
@@ -1,64 +1,58 @@
 var assert = require("assert");
+var run_code = require("../sandbox").run_code;
 var UglifyJS = require("../node");

 describe("String literals", function() {
    it("Should throw syntax error if a string literal contains a newline", function() {
-        var inputs = [
+        [
            "'\n'",
            "'\r'",
            '"\r\n"',
            "'\u2028'",
-            '"\u2029"'
-        ];
-
-        var test = function(input) {
-            return function() {
+            '"\u2029"',
+        ].forEach(function(input) {
+            assert.throws(function() {
                var ast = UglifyJS.parse(input);
-            };
-        };
-
-        var error = function(e) {
-            return e instanceof UglifyJS.JS_Parse_Error
-                && e.message === "Unterminated string constant";
-        };
-
-        for (var input in inputs) {
-            assert.throws(test(inputs[input]), error);
-        }
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && e.message === "Unterminated string constant";
+            });
+        });
+    });
+    it("Should handle line continuation correctly", function() {
+        [
+            '"\\\r"',
+            '"\\\n"',
+            '"\\\r\n"',
+        ].forEach(function(str) {
+            var code = "console.log(" + str + ");";
+            var result = UglifyJS.minify(code);
+            if (result.error) throw result.error;
+            assert.strictEqual(run_code(result.code), run_code(code));
+        });
    });
-
    it("Should not throw syntax error if a string has a line continuation", function() {
-        var output = UglifyJS.parse('var a = "a\\\nb";').print_to_string();
-        assert.equal(output, 'var a="ab";');
+        var ast = UglifyJS.parse('var a = "a\\\nb";');
+        assert.equal(ast.print_to_string(), 'var a="ab";');
    });
-
    it("Should throw error in strict mode if string contains escaped octalIntegerLiteral", function() {
-        var inputs = [
+        [
            '"use strict";\n"\\76";',
            '"use strict";\nvar foo = "\\76";',
            '"use strict";\n"\\1";',
            '"use strict";\n"\\07";',
-            '"use strict";\n"\\011"'
-        ];
-
-        var test = function(input) {
-            return function() {
+            '"use strict";\n"\\011"',
+        ].forEach(function(input) {
+            assert.throws(function() {
                var output = UglifyJS.parse(input);
-            }
-        };
-
-        var error = function(e) {
-            return e instanceof UglifyJS.JS_Parse_Error
-                && e.message === "Legacy octal escape sequences are not allowed in strict mode";
-        }
-
-        for (var input in inputs) {
-            assert.throws(test(inputs[input]), error);
-        }
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && e.message === "Legacy octal escape sequences are not allowed in strict mode";
+            });
+        });
    });
-
    it("Should not throw error outside strict mode if string contains escaped octalIntegerLiteral", function() {
-        var tests = [
+        [
            [ ';"\\76";', ';">";' ],
            [ ';"\\0";', ';"\\0";' ],
            [ ';"\\08"', ';"\\x008";' ],
@@ -66,19 +60,15 @@ describe("String literals", function() {
            [ ';"\\0008"', ';"\\x008";' ],
            [ ';"use\\\n strict";\n"\\07";', ';"use strict";"\07";' ],
            [ '"use strict" === "use strict";\n"\\76";', '"use strict"==="use strict";">";' ],
-        ];
-
-        for (var test in tests) {
-            var output = UglifyJS.parse(tests[test][0]).print_to_string();
-            assert.equal(output, tests[test][1]);
-        }
+        ].forEach(function(test) {
+            var ast = UglifyJS.parse(test[0]);
+            assert.equal(ast.print_to_string(), test[1]);
+        });
    });
-
    it("Should not throw error when digit is 8 or 9", function() {
        assert.equal(UglifyJS.parse('"use strict";;"\\08"').print_to_string(), '"use strict";;"\\x008";');
        assert.equal(UglifyJS.parse('"use strict";;"\\09"').print_to_string(), '"use strict";;"\\x009";');
    });
-
    it("Should not unescape unpaired surrogates", function() {
        var code = [];
        for (var i = 0; i <= 0xF; i++) {
@@ -115,4 +105,33 @@ describe("String literals", function() {
        assert.ok(code.length > ascii.code.length);
        assert.strictEqual(eval(code), eval(ascii.code));
    });
+    it("Should reject invalid Unicode escape sequence", function() {
+        [
+            'var foo = "\\u-111"',
+            'var bar = "\\u{-1}"',
+            'var baz = "\\ugggg"',
+        ].forEach(function(test) {
+            assert.throws(function() {
+                UglifyJS.parse(test);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && e.message === "Invalid hex-character pattern in string";
+            });
+        });
+    });
+    it("Should reject invalid code points in Unicode escape sequence", function() {
+        [
+            // A bit over the valid range
+            '"\\u{110000}"',
+            // 32-bit overflow resulting in "a"
+            '"\\u{100000061}"',
+        ].forEach(function(test) {
+            assert.throws(function() {
+                UglifyJS.parse(test);
+            }, function(e) {
+                return e instanceof UglifyJS.JS_Parse_Error
+                    && /^Invalid character code: /.test(e.message);
+            });
+        });
+    });
 });
--- a/test/mocha/with.js
+++ b/test/mocha/with.js
@@ -17,7 +17,7 @@ describe("With", function() {
        var ast = UglifyJS.parse("with(e) {f(1, 2)}");
        ast.figure_out_scope();
        assert.equal(ast.uses_with, true);
-        assert.equal(ast.body[0].expression.scope.uses_with, true);
-        assert.equal(ast.body[0].body.body[0].body.expression.scope.uses_with, true);
+        assert.equal(ast.body[0].expression.scope.resolve().uses_with, true);
+        assert.equal(ast.body[0].body.body[0].body.expression.scope.resolve().uses_with, true);
    });
 });
--- a/test/reduce.js
+++ b/test/reduce.js
@@ -121,7 +121,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                return;
            }
            // preserve for (var xxx; ...)
-            if (parent instanceof U.AST_For && parent.init === node && node instanceof U.AST_Var) return node;
+            if (parent instanceof U.AST_For && parent.init === node && node instanceof U.AST_Definitions) return node;
            // preserve for (xxx in ...)
            if (parent instanceof U.AST_ForIn && parent.init === node) return node;

@@ -145,7 +145,9 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                return permute < 2 ? expr : wrap_with_console_log(expr);
            }
            else if (node instanceof U.AST_BlockStatement) {
-                if (in_list) {
+                if (in_list && node.body.filter(function(node) {
+                    return node instanceof U.AST_Const;
+                }).length == 0) {
                    node.start._permute++;
                    CHANGED = true;
                    return List.splice(node.body);
@@ -410,7 +412,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                    start: {},
                });
            }
-            else if (node instanceof U.AST_Var) {
+            else if (node instanceof U.AST_Definitions) {
                // remove empty var statement
                if (node.definitions.length == 0) return in_list ? List.skip : new U.AST_EmptyStatement({
                    start: {},
@@ -427,7 +429,7 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                    if (node.TYPE == "Call" && node.expression.print_to_string() == "console.log") {
                        return to_sequence(node.args);
                    }
-                    if (node instanceof U.AST_Catch) {
+                    if (node instanceof U.AST_Catch && node.argname) {
                        descend(node, this);
                        node.body.unshift(new U.AST_SimpleStatement({
                            body: wrap_with_console_log(new U.AST_SymbolRef(node.argname)),
@@ -499,7 +501,26 @@ module.exports = function reduce_test(testcase, minify_options, reduce_options)
                log("// reduce test pass " + pass + ": " + testcase.length + " bytes");
            }
        }
-        testcase = try_beautify(testcase, minify_options, differs.unminified_result, result_cache, max_timeout);
+        var beautified = U.minify(testcase, {
+            compress: false,
+            mangle: false,
+            output: {
+                beautify: true,
+                braces: true,
+                comments: true,
+            },
+        });
+        testcase = {
+            code: testcase,
+        };
+        if (!beautified.error) {
+            diff = test_for_diff(beautified.code, minify_options, result_cache, max_timeout);
+            if (diff && !diff.timed_out && !diff.error) {
+                testcase = beautified;
+                testcase.code = "// (beautified)\n" + testcase.code;
+                differs = diff;
+            }
+        }
        var lines = [ "" ];
        if (isNaN(max_timeout)) {
            lines.push("// minify error: " + to_comment(strip_color_codes(differs.minified_result.stack)));
@@ -538,34 +559,6 @@ function trim_trailing_whitespace(value) {
    return ("" + value).replace(/\s+$/, "");
 }

-function try_beautify(testcase, minify_options, expected, result_cache, timeout) {
-    var result = U.minify(testcase, {
-        compress: false,
-        mangle: false,
-        output: {
-            beautify: true,
-            braces: true,
-            comments: true,
-        },
-    });
-    if (result.error) return {
-        code: testcase,
-    };
-    var toplevel = sandbox.has_toplevel(minify_options);
-    if (isNaN(timeout)) {
-        if (!U.minify(result.code, minify_options).error) return {
-            code: testcase,
-        };
-    } else {
-        var actual = run_code(result.code, toplevel, result_cache, timeout).result;
-        if (!sandbox.same_stdout(expected, actual)) return {
-            code: testcase,
-        };
-    }
-    result.code = "// (beautified)\n" + result.code;
-    return result;
-}
-
 function has_exit(fn) {
    var found = false;
    var tw = new U.TreeWalker(function(node) {
@@ -600,7 +593,7 @@ function is_error(result) {
 }

 function is_timed_out(result) {
-    return is_error(result) && /timed out/.test(result);
+    return is_error(result) && /timed out/.test(result.message);
 }

 function is_statement(node) {
--- a/test/ufuzz/index.js
+++ b/test/ufuzz/index.js
@@ -275,6 +275,7 @@ var CANNOT_RETURN = true;
 var NO_DEFUN = false;
 var DEFUN_OK = true;
 var DONT_STORE = true;
+var NO_CONST = true;

 var VAR_NAMES = [
    "a",
@@ -312,6 +313,7 @@ var TYPEOF_OUTCOMES = [
    "crap",
 ];

+var block_vars = [];
 var unique_vars = [];
 var loops = 0;
 var funcs = 0;
@@ -329,6 +331,7 @@ function strictMode() {

 function createTopLevelCode() {
    VAR_NAMES.length = INITIAL_NAMES_LEN; // prune any previous names still in the list
+    block_vars.length = 0;
    unique_vars.length = 0;
    loops = 0;
    funcs = 0;
@@ -374,33 +377,77 @@ function filterDirective(s) {
    return s;
 }

+function createBlockVariables(recurmax, stmtDepth, canThrow, fn) {
+    var block_len = block_vars.length;
+    var var_len = VAR_NAMES.length;
+    var consts = [];
+    var lets = [];
+    unique_vars.push("a", "b", "c", "undefined", "NaN", "Infinity");
+    while (!rng(block_vars.length > block_len ? 10 : 100)) {
+        var name = createVarName(MANDATORY, DONT_STORE);
+        if (rng(2)) {
+            consts.push(name);
+        } else {
+            lets.push(name);
+        }
+        block_vars.push(name);
+    }
+    unique_vars.length -= 6;
+    fn(function() {
+        if (rng(2)) {
+            return createDefinitions("const", consts) + "\n" + createDefinitions("let", lets) + "\n";
+        } else {
+            return createDefinitions("let", lets) + "\n" + createDefinitions("const", consts) + "\n";
+        }
+    });
+    block_vars.length = block_len;
+    if (consts.length || lets.length) VAR_NAMES.splice(var_len, consts.length + lets.length);
+
+    function createDefinitions(type, names) {
+        if (!names.length) return "";
+        var save = VAR_NAMES;
+        VAR_NAMES = VAR_NAMES.filter(function(name) {
+            return names.indexOf(name) < 0;
+        });
+        var len = VAR_NAMES.length;
+        var s = type + " " + names.map(function(name) {
+            var value = createExpression(recurmax, NO_COMMA, stmtDepth, canThrow);
+            VAR_NAMES.push(name);
+            return name + " = " + value;
+        }).join(", ") + ";";
+        VAR_NAMES = save.concat(VAR_NAMES.slice(len));
+        return s;
+    }
+}
+
 function createFunction(recurmax, allowDefun, canThrow, stmtDepth) {
    if (--recurmax < 0) { return ";"; }
    if (!STMT_COUNT_FROM_GLOBAL) stmtDepth = 0;
-    var namesLenBefore = VAR_NAMES.length;
+    var s = [];
    var name;
-    if (allowDefun || rng(5) > 0) {
-        name = "f" + funcs++;
-    } else {
-        unique_vars.push("a", "b", "c");
-        name = createVarName(MANDATORY, !allowDefun);
-        unique_vars.length -= 3;
-    }
-    var s = [
-        "function " + name + "(" + createParams() + "){",
-        strictMode()
-    ];
-    if (rng(5) === 0) {
-        // functions with functions. lower the recursion to prevent a mess.
-        s.push(createFunctions(rng(5) + 1, Math.ceil(recurmax * 0.7), DEFUN_OK, canThrow, stmtDepth));
-    } else {
-        // functions with statements
-        s.push(createStatements(3, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth));
-    }
-    s.push("}", "");
-    s = filterDirective(s).join("\n");
+    createBlockVariables(recurmax, stmtDepth, canThrow, function(defns) {
+        var namesLenBefore = VAR_NAMES.length;
+        if (allowDefun || rng(5) > 0) {
+            name = "f" + funcs++;
+        } else {
+            unique_vars.push("a", "b", "c");
+            name = createVarName(MANDATORY, !allowDefun);
+            unique_vars.length -= 3;
+        }
+        s.push("function " + name + "(" + createParams() + "){", strictMode());
+        s.push(defns());
+        if (rng(5) === 0) {
+            // functions with functions. lower the recursion to prevent a mess.
+            s.push(createFunctions(rng(5) + 1, Math.ceil(recurmax * 0.7), DEFUN_OK, canThrow, stmtDepth));
+        } else {
+            // functions with statements
+            s.push(_createStatements(3, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth));
+        }
+        s.push("}", "");
+        s = filterDirective(s).join("\n");

-    VAR_NAMES.length = namesLenBefore;
+        VAR_NAMES.length = namesLenBefore;
+    });

    if (!allowDefun) {
        // avoid "function statements" (decl inside statements)
@@ -414,7 +461,7 @@ function createFunction(recurmax, allowDefun, canThrow, stmtDepth) {
    return s + ";";
 }

-function createStatements(n, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) {
+function _createStatements(n, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) {
    if (--recurmax < 0) { return ";"; }
    var s = "";
    while (--n > 0) {
@@ -423,6 +470,15 @@ function createStatements(n, recurmax, canThrow, canBreak, canContinue, cannotRe
    return s;
 }

+function createStatements(n, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) {
+    var s = "";
+    createBlockVariables(recurmax, stmtDepth, canThrow, function(defns) {
+        s += defns() + "\n";
+        s += _createStatements(n, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth);
+    });
+    return s;
+}
+
 function enableLoopControl(flag, defaultValue) {
    return Array.isArray(flag) && flag.indexOf("") < 0 ? flag.concat("") : flag || defaultValue;
 }
@@ -496,7 +552,7 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
        var label = createLabel(canBreak, canContinue);
        canBreak = label.break || enableLoopControl(canBreak, CAN_BREAK);
        canContinue = label.continue || enableLoopControl(canContinue, CAN_CONTINUE);
-        var key = rng(10) ? "key" + loop : getVarName();
+        var key = rng(10) ? "key" + loop : getVarName(NO_CONST);
        return [
            "{var expr" + loop + " = " + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "; ",
            label.target + " for (",
@@ -571,13 +627,18 @@ function createStatement(recurmax, canThrow, canBreak, canContinue, cannotReturn
            // the catch var should only be accessible in the catch clause...
            // we have to do go through some trouble here to prevent leaking it
            var nameLenBefore = VAR_NAMES.length;
-            var catchName = createVarName(MANDATORY);
-            var freshCatchName = VAR_NAMES.length !== nameLenBefore;
-            if (!catch_redef) unique_vars.push(catchName);
-            s += " catch (" + catchName + ") { " + createStatements(3, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + " }";
-            // remove catch name
-            if (!catch_redef) unique_vars.pop();
-            if (freshCatchName) VAR_NAMES.splice(nameLenBefore, 1);
+            createBlockVariables(recurmax, stmtDepth, canThrow, function(defns) {
+                var catchName = createVarName(MANDATORY);
+                var freshCatchName = VAR_NAMES.length !== nameLenBefore;
+                if (!catch_redef) unique_vars.push(catchName);
+                s += " catch (" + catchName + ") { ";
+                s += defns() + "\n";
+                s += _createStatements(3, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth);
+                s += " }";
+                // remove catch name
+                if (!catch_redef) unique_vars.pop();
+                if (freshCatchName) VAR_NAMES.splice(nameLenBefore, 1);
+            });
        }
        if (n !== 0) s += " finally { " + createStatements(3, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth) + " }";
        return s;
@@ -597,7 +658,7 @@ function createSwitchParts(recurmax, n, canThrow, canBreak, canContinue, cannotR
        if (hadDefault || rng(5) > 0) {
            s.push(
                "case " + createExpression(recurmax, NO_COMMA, stmtDepth, canThrow) + ":",
-                createStatements(rng(3) + 1, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth),
+                _createStatements(rng(3) + 1, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth),
                rng(10) > 0 ? " break;" : "/* fall-through */",
                ""
            );
@@ -605,7 +666,7 @@ function createSwitchParts(recurmax, n, canThrow, canBreak, canContinue, cannotR
            hadDefault = true;
            s.push(
                "default:",
-                createStatements(rng(3) + 1, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth),
+                _createStatements(rng(3) + 1, recurmax, canThrow, canBreak, canContinue, cannotReturn, stmtDepth),
                ""
            );
        }
@@ -653,7 +714,7 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
      case p++:
        return getVarName();
      case p++:
-        return getVarName() + createAssignment() + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow);
+        return getVarName(NO_CONST) + createAssignment() + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow);
      case p++:
        return createExpression(recurmax, COMMA_OK, stmtDepth, canThrow);
      case p++:
@@ -699,19 +760,22 @@ function _createExpression(recurmax, noComma, stmtDepth, canThrow) {
            );
            break;
          default:
-            var instantiate = rng(4) ? "new " : "";
-            s.push(
-                instantiate + "function " + name + "(){",
-                strictMode()
-            );
-            if (instantiate) for (var i = rng(4); --i >= 0;) {
-                if (rng(2)) s.push("this." + getDotKey(true) + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ";");
-                else  s.push("this[" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "]" + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ";");
-            }
-            s.push(
-                createStatements(rng(5) + 1, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
-                rng(2) == 0 ? "}" : "}()"
-            );
+            createBlockVariables(recurmax, stmtDepth, canThrow, function(defns) {
+                var instantiate = rng(4) ? "new " : "";
+                s.push(
+                    instantiate + "function " + name + "(){",
+                    strictMode(),
+                    defns()
+                );
+                if (instantiate) for (var i = rng(4); --i >= 0;) {
+                    if (rng(2)) s.push("this." + getDotKey(true) + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ";");
+                    else  s.push("this[" + createExpression(recurmax, COMMA_OK, stmtDepth, canThrow) + "]" + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ";");
+                }
+                s.push(
+                    _createStatements(rng(5) + 1, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
+                    rng(2) == 0 ? "}" : "}()"
+                );
+            });
            break;
        }
        VAR_NAMES.length = nameLenBefore;
@@ -847,28 +911,32 @@ function getDotKey(assign) {
 function createAccessor(recurmax, stmtDepth, canThrow) {
    var namesLenBefore = VAR_NAMES.length;
    var s;
-    var prop1 = getDotKey();
-    if (rng(2) == 0) {
-        s = [
-            "get " + prop1 + "(){",
-            strictMode(),
-            createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
-            createStatement(recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth, STMT_RETURN_ETC),
-            "},"
-        ];
-    } else {
-        var prop2;
-        do {
-            prop2 = getDotKey();
-        } while (prop1 == prop2);
-        s = [
-            "set " + prop1 + "(" + createVarName(MANDATORY) + "){",
-            strictMode(),
-            createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
-            "this." + prop2 + createAssignment() + _createBinaryExpr(recurmax, COMMA_OK, stmtDepth, canThrow) + ";",
-            "},"
-        ];
-    }
+    createBlockVariables(recurmax, stmtDepth, canThrow, function(defns) {
+        var prop1 = getDotKey();
+        if (rng(2) == 0) {
+            s = [
+                "get " + prop1 + "(){",
+                strictMode(),
+                defns(),
+                _createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
+                createStatement(recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth, STMT_RETURN_ETC),
+                "},"
+            ];
+        } else {
+            var prop2;
+            do {
+                prop2 = getDotKey();
+            } while (prop1 == prop2);
+            s = [
+                "set " + prop1 + "(" + createVarName(MANDATORY) + "){",
+                strictMode(),
+                defns(),
+                _createStatements(2, recurmax, canThrow, CANNOT_BREAK, CANNOT_CONTINUE, CAN_RETURN, stmtDepth),
+                "this." + prop2 + createAssignment() + _createBinaryExpr(recurmax, COMMA_OK, stmtDepth, canThrow) + ";",
+                "},"
+            ];
+        }
+    });
    VAR_NAMES.length = namesLenBefore;
    return filterDirective(s).join("\n");
 }
@@ -906,7 +974,7 @@ function _createSimpleBinaryExpr(recurmax, noComma, stmtDepth, canThrow) {
      case 1:
        return "(" + createUnarySafePrefix() + "(" + _createSimpleBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + "))";
      case 2:
-        assignee = getVarName();
+        assignee = getVarName(NO_CONST);
        return "(" + assignee + createAssignment() + _createBinaryExpr(recurmax, noComma, stmtDepth, canThrow) + ")";
      case 3:
        assignee = getVarName();
@@ -968,9 +1036,10 @@ function createUnaryPostfix() {
    return UNARY_POSTFIX[rng(UNARY_POSTFIX.length)];
 }

-function getVarName() {
+function getVarName(noConst) {
    // try to get a generated name reachable from current scope. default to just `a`
-    return VAR_NAMES[INITIAL_NAMES_LEN + rng(VAR_NAMES.length - INITIAL_NAMES_LEN)] || "a";
+    var name = VAR_NAMES[INITIAL_NAMES_LEN + rng(VAR_NAMES.length - INITIAL_NAMES_LEN)];
+    return !name || noConst && block_vars.indexOf(name) >= 0 ? "a" : name;
 }

 function createVarName(maybe, dontStore) {
@@ -980,7 +1049,7 @@ function createVarName(maybe, dontStore) {
        do {
            name = VAR_NAMES[rng(VAR_NAMES.length)];
            if (suffix) name += "_" + suffix;
-        } while (unique_vars.indexOf(name) >= 0);
+        } while (unique_vars.indexOf(name) >= 0 || block_vars.indexOf(name) >= 0);
        if (suffix && !dontStore) VAR_NAMES.push(name);
        return name;
    }
@@ -1258,10 +1327,6 @@ function patch_try_catch(orig, toplevel) {
    }
 }

-var fallback_options = [ JSON.stringify({
-    compress: false,
-    mangle: false
-}) ];
 var minify_options = require("./options.json").map(JSON.stringify);
 var original_code, original_result, errored;
 var uglify_code, uglify_result, ok;
@@ -1269,10 +1334,19 @@ for (var round = 1; round <= num_iterations; round++) {
    process.stdout.write(round + " of " + num_iterations + "\r");

    original_code = createTopLevelCode();
-    var orig_result = [ sandbox.run_code(original_code) ];
+    var orig_result = [ sandbox.run_code(original_code), sandbox.run_code(original_code, true) ];
    errored = typeof orig_result[0] != "string";
-    if (!errored) orig_result.push(sandbox.run_code(original_code, true));
-    (errored ? fallback_options : minify_options).forEach(function(options) {
+    if (errored) {
+        println("//=============================================================");
+        println("// original code");
+        try_beautify(original_code, false, orig_result[0], println);
+        println();
+        println();
+        println("original result:");
+        println(orig_result[0]);
+        println();
+    }
+    minify_options.forEach(function(options) {
        var o = JSON.parse(options);
        var toplevel = sandbox.has_toplevel(o);
        o.validate = true;
@@ -1287,13 +1361,20 @@ for (var round = 1; round <= num_iterations; round++) {
                ok = sandbox.same_stdout(sandbox.run_code(sort_globals(original_code)), sandbox.run_code(sort_globals(uglify_code)));
            }
            // ignore numerical imprecision caused by `unsafe_math`
-            if (!ok && typeof uglify_result == "string" && o.compress && o.compress.unsafe_math) {
+            if (!ok && o.compress && o.compress.unsafe_math && typeof original_result == "string" && typeof uglify_result == "string") {
                ok = fuzzy_match(original_result, uglify_result);
                if (!ok) {
                    var fuzzy_result = sandbox.run_code(original_code.replace(/( - 0\.1){3}/g, " - 0.3"), toplevel);
                    ok = sandbox.same_stdout(fuzzy_result, uglify_result);
                }
            }
+            // ignore difference in error message caused by Temporal Dead Zone
+            if (!ok && errored && uglify_result.name == "ReferenceError" && original_result.name == "ReferenceError") ok = true;
+            // ignore spurious time-outs
+            if (!ok && errored && /timed out/.test(original_result.message) && !/timed out/.test(uglify_result.message)) {
+                if (!orig_result[toplevel ? 3 : 2]) orig_result[toplevel ? 3 : 2] = sandbox.run_code(original_code, toplevel, 10000);
+                ok = sandbox.same_stdout(orig_result[toplevel ? 3 : 2], uglify_result);
+            }
            // ignore difference in error message caused by `in`
            // ignore difference in depth of termination caused by infinite recursion
            if (!ok) {
@@ -1308,16 +1389,6 @@ for (var round = 1; round <= num_iterations; round++) {
            ok = errored && uglify_code.name == original_result.name;
        }
        if (verbose || (verbose_interval && !(round % INTERVAL_COUNT)) || !ok) log(options);
-        else if (errored) {
-            println("//=============================================================");
-            println("// original code");
-            try_beautify(original_code, toplevel, original_result, println);
-            println();
-            println();
-            println("original result:");
-            println(original_result);
-            println();
-        }
        if (!ok && isFinite(num_iterations)) {
            println();
            process.exit(1);
--- a/test/ufuzz/job.js
+++ b/test/ufuzz/job.js
@@ -48,8 +48,10 @@ function run() {
        stderr = "";
        child.stderr.on("data", trap).pipe(process.stdout);
        log = setInterval(function() {
+            stdout = stdout.replace(/[^\r\n]+\r(?=[^\r\n]+\r)/g, "");
            var end = stdout.lastIndexOf("\r");
-            console.log(stdout.slice(stdout.lastIndexOf("\r", end - 1) + 1, end));
+            if (end < 0) return;
+            console.log(stdout.slice(0, end));
            stdout = stdout.slice(end + 1);
        }, 5 * 60 * 1000);
    }
Author	SHA1	Message	Date
Alex Lam S.L	af4ea3ff69	v3.11.5	2020-11-03 08:59:02 +08:00
Alex Lam S.L	e7643248a3	fix corner case in `merge_vars` (#4258 ) fixes #4257	2020-11-02 01:01:00 +08:00
Alex Lam S.L	68091dbf69	fix corner case in `merge_vars` (#4256 ) fixes #4255	2020-11-01 14:34:07 +08:00
Alex Lam S.L	cbf7269296	fix corner case in `merge_vars` (#4254 ) fixes #4253	2020-11-01 10:37:21 +08:00
Alex Lam S.L	d8563caba7	improve resilience against spurious time-outs (#4252 )	2020-10-30 11:06:48 +08:00
Alex Lam S.L	2e0ad40fe6	fix corner case in `ie8` (#4251 ) fixes #4250	2020-10-30 11:06:31 +08:00
Alex Lam S.L	5d12abc41b	fix corner cases in `collapse_vars` (#4249 ) fixes #4248	2020-10-30 10:04:23 +08:00
Alex Lam S.L	79e5c3f564	improve warnings (#4247 ) closes #4244	2020-10-27 17:39:33 +08:00
Alex Lam S.L	607f87c5cd	fix corner case in `booleans` (#4246 ) fixes #4245	2020-10-26 18:53:58 +08:00
Alex Lam S.L	b2775746a7	v3.11.4	2020-10-25 23:40:42 +00:00
Alex Lam S.L	e478da24c7	fix corner case in `collapse_vars` (#4243 ) fixes #4242	2020-10-24 22:44:20 +08:00
Alex Lam S.L	c5df8355ba	fix corner case in `loops` & `unused` (#4241 ) fixes #4240	2020-10-24 13:33:48 +08:00
Alex Lam S.L	ff38d2471f	improve resilience against `npm` failures (#4239 )	2020-10-24 11:22:13 +08:00
Alex Lam S.L	8e86d05c32	fix corner case in `merge_vars` (#4238 ) fixes #4237	2020-10-24 10:19:43 +08:00
Alex Lam S.L	9e40abeded	fix corner case in `unused` (#4236 ) fixes #4235	2020-10-22 22:19:47 +08:00
Alex Lam S.L	23ca7d675f	fix corner case in `functions` (#4234 ) fixes #4233	2020-10-22 10:13:11 +08:00
Alex Lam S.L	fd8c0212b8	fix corner case in `ie8` (#4232 ) fixes #4231	2020-10-20 14:02:39 +08:00
Alex Lam S.L	256950c2c0	fix corner case in `ie8` (#4230 ) fixes #4229	2020-10-20 06:13:23 +08:00
Alex Lam S.L	8ecaa40c6e	extend support for Unicode (#4228 )	2020-10-19 09:34:17 +08:00
Alex Lam S.L	96bf7fceab	support `let` (#4227 )	2020-10-19 08:32:39 +08:00
Alex Lam S.L	6c7226c10e	v3.11.3	2020-10-19 07:25:47 +08:00
Alex Lam S.L	dc575919e2	fix corner case in `side_effects` (#4226 ) fixes #4225	2020-10-18 22:13:10 +08:00
Alex Lam S.L	4298201938	flush `stdout` from `ufuzz` jobs properly (#4224 )	2020-10-16 21:56:54 +08:00
Alex Lam S.L	4f833937fe	fix corner case in `inline` (#4223 ) fixes #4222	2020-10-15 21:52:40 +08:00
Alex Lam S.L	3d71e97dd1	fix corner cases in `braces` & `sequences` (#4221 ) fixes #4220	2020-10-14 23:39:35 +08:00
Alex Lam S.L	7f35d9cee0	fix corner case in `reduce_vars` (#4219 ) fixes #4218	2020-10-14 07:58:04 +08:00
Alex Lam S.L	9f8106e1d8	fix corner case in `collapse_vars` (#4217 ) fixes #4216	2020-10-14 07:18:26 +08:00
Alex Lam S.L	b7b8435721	fix corner case in `evaluate` (#4215 ) fixes #4214	2020-10-14 02:49:45 +08:00
Alex Lam S.L	c0c04c33bb	fix corner cases in `dead_code` & `reduce_vars` (#4213 ) fixes #4212	2020-10-14 00:09:17 +08:00
Alex Lam S.L	0e234a25c5	fix corner case in `reduce_vars` (#4211 ) fixes #4210	2020-10-13 15:52:03 +08:00
Alex Lam S.L	3096f6fdad	restore `inline` functionality disabled by #4204 (#4209 )	2020-10-13 09:33:49 +08:00
Alex Lam S.L	176c09c6a5	fix corner case in `reduce_vars` & `unused` (#4208 ) fixes #4207	2020-10-13 07:32:17 +08:00
Alex Lam S.L	9272f662c0	fix corner case in `collapse_vars` (#4206 ) fixes #4205	2020-10-13 01:30:21 +08:00
Alex Lam S.L	4d33cb2f94	fix corner case in `inilne` (#4204 ) fixes #4202	2020-10-12 23:10:32 +08:00
Alex Lam S.L	00d0eda85b	fix corner case in `arguments` (#4201 ) fixes #4200	2020-10-12 19:03:21 +08:00
Alex Lam S.L	1cdf810f0b	fix corner case in `reduce_vars` (#4203 ) fixes #4198	2020-10-12 19:02:44 +08:00
Alex Lam S.L	b512726cf3	fix corner case in `collapse_vars` (#4199 ) fixes #4197	2020-10-12 14:13:17 +08:00
Alex Lam S.L	9b7a13c8c7	fix corner case in `ie8` & `mangle` (#4196 ) fixes #4195	2020-10-12 12:43:26 +08:00
Alex Lam S.L	74ff6ce261	fix corner case in `dead_code` (#4194 ) fixes #4193	2020-10-12 11:09:26 +08:00
Alex Lam S.L	b1b8898e7c	fix corner case in `functions` (#4192 ) fixes #4191	2020-10-12 09:26:56 +08:00
Alex Lam S.L	55451e7b78	support `const` (#4190 )	2020-10-12 01:18:57 +08:00
Alex Lam S.L	ffcce28ce1	v3.11.2	2020-10-11 21:19:25 +08:00
Alex Lam S.L	9c0feb69e5	fix corner case in `reduce_vars` (#4189 ) fixes #4188	2020-10-07 22:01:39 +08:00
Alex Lam S.L	bc6e105174	fix corner case in `ie8` (#4187 ) fixes #4186	2020-10-06 09:20:41 +08:00
Alex Lam S.L	b91a2459c0	fix corner case in `unused` (#4185 ) fixes #4184	2020-10-05 18:59:03 +08:00
Alex Lam S.L	b7a57fc69d	fix corner case in `loops` (#4183 ) fixes #4182	2020-10-05 17:28:46 +08:00
Alex Lam S.L	2dbe40b01b	enhance `conditionals` (#4181 )	2020-10-05 15:55:37 +08:00
Alex Lam S.L	813ac3ba96	enhance `loops` (#4180 )	2020-10-05 08:26:59 +08:00
Alex Lam S.L	220dc95c0d	clean up scope-related variables (#4179 )	2020-10-05 06:56:52 +08:00
Alex Lam S.L	8f0521d51d	retrofit `try-catch-finally` as block-scoped (#4178 ) - support optional catch binding	2020-10-05 05:30:14 +08:00
Alex Lam S.L	f9946767c9	retrofit `AST_BlockStatement` as block-scoped (#4177 )	2020-10-05 01:58:50 +08:00
Alex Lam S.L	58ac5b9bd5	extend support for numeral literals (#4176 )	2020-10-05 00:05:03 +08:00
Alex Lam S.L	66140b459e	enhance `side_effects` (#4175 )	2020-10-04 23:43:49 +08:00