v3.11.4

fix corner case in collapse_vars (#4243 )
fixes #4242
2020-10-25 23:40:42 +00:00 · 2020-10-24 22:44:20 +08:00 · 2020-10-24 13:33:48 +08:00 · 2020-10-24 11:22:13 +08:00 · 2020-10-24 10:19:43 +08:00 · 2020-10-22 22:19:47 +08:00
21 changed files with 1726 additions and 318 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/lib/ast.js
+++ b/lib/ast.js
@@ -754,6 +754,17 @@ var AST_Const = DEFNODE("Const", null, {
    },
 }, 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() {
@@ -1066,6 +1077,10 @@ 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
@@ -97,6 +97,7 @@ function Compressor(options, false_by_default) {
        unsafe_regexp   : false,
        unsafe_undefined: false,
        unused          : !false_by_default,
+        varify          : !false_by_default,
    }, true);
    var evaluate = this.options["evaluate"];
    this.eval_threshold = /eager/.test(evaluate) ? 1 / 0 : +evaluate;
@@ -488,7 +489,9 @@ merge(Compressor.prototype, {
            if (!(declare || all(def.orig, function(sym) {
                return !(sym instanceof AST_SymbolConst);
            }))) return false;
-            if (def.fixed === undefined) return true;
+            if (def.fixed === undefined) return declare || all(def.orig, function(sym) {
+                return !(sym instanceof AST_SymbolLet);
+            });
            if (def.fixed === null && def.safe_ids) {
                def.safe_ids[def.id] = false;
                delete def.safe_ids;
@@ -1616,7 +1619,7 @@ merge(Compressor.prototype, {
                    if (side_effects && may_modify(node)) return true;
                    var def = node.definition();
                    return (in_try || def.scope.resolve() !== scope) && !all(def.orig, function(sym) {
-                        return !(sym instanceof AST_SymbolConst);
+                        return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet);
                    });
                }
                if (node instanceof AST_This) return symbol_in_lvalues(node, parent);
@@ -1971,6 +1974,7 @@ merge(Compressor.prototype, {
            }

            function foldable(expr) {
+                if (expr instanceof AST_Assign && expr.right.single_use) return;
                var lhs_ids = Object.create(null);
                var marker = new TreeWalker(function(node) {
                    if (node instanceof AST_SymbolRef) lhs_ids[node.definition().id] = true;
@@ -2177,7 +2181,7 @@ merge(Compressor.prototype, {
                var stat = statements[i];
                if (stat instanceof AST_BlockStatement) {
                    if (all(stat.body, function(stat) {
-                        return !(stat instanceof AST_Const);
+                        return !(stat instanceof AST_Const || stat instanceof AST_Let);
                    })) {
                        CHANGED = true;
                        eliminate_spurious_blocks(stat.body);
@@ -2513,7 +2517,7 @@ merge(Compressor.prototype, {
                var line = block.body[i];
                if (line instanceof AST_Var && declarations_only(line)) {
                    decls.push(line);
-                } else if (stat || line instanceof AST_Const) {
+                } else if (stat || line instanceof AST_Const || line instanceof AST_Let) {
                    return false;
                } else {
                    stat = line;
@@ -2829,7 +2833,7 @@ merge(Compressor.prototype, {
        function push(node) {
            if (block) {
                block.push(node);
-                if (node instanceof AST_Const) block.required = true;
+                if (node instanceof AST_Const || node instanceof AST_Let) block.required = true;
            } else {
                target.push(node);
            }
@@ -4106,7 +4110,7 @@ merge(Compressor.prototype, {
        def(AST_SymbolDeclaration, return_false);
        def(AST_SymbolRef, function(compressor) {
            return !(this.is_declared(compressor) && all(this.definition().orig, function(sym) {
-                return !(sym instanceof AST_SymbolConst);
+                return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet);
            }));
        });
        def(AST_This, return_false);
@@ -4360,7 +4364,7 @@ merge(Compressor.prototype, {
            return make_node(AST_EmptyStatement, node);
          case 1:
            var stat = node.body[0];
-            if (!(stat instanceof AST_Const)) return stat;
+            if (!(stat instanceof AST_Const || stat instanceof AST_Let)) return stat;
        }
        return node;
    }
@@ -4460,14 +4464,40 @@ merge(Compressor.prototype, {
            }
            if (node instanceof AST_Const) {
                node.definitions.forEach(function(defn) {
-                    var def = defn.name.definition();
-                    references[def.id] = false;
-                    def = def.redefined();
-                    if (def) references[def.id] = false;
+                    references[defn.name.definition().id] = false;
                    defn.value.walk(tw);
                });
                return true;
            }
+            if (node instanceof AST_Continue) {
+                var target = tw.loopcontrol_target(node);
+                if (!(target instanceof AST_Do)) return true;
+                var stack = [];
+                while (!HOP(segment, "block") || segment.block !== target) {
+                    stack.push(segment);
+                    pop();
+                }
+                segment.loop = "c";
+                push();
+                while (stack.length) {
+                    var seg = stack.pop();
+                    push();
+                    if (HOP(seg, "block")) segment.block = seg.block;
+                    if (HOP(seg, "loop")) segment.loop = seg.loop;
+                }
+                return true;
+            }
+            if (node instanceof AST_Do) {
+                push();
+                segment.block = node;
+                segment.loop = true;
+                var save = segment;
+                node.body.walk(tw);
+                if (segment.loop == "c") segment = save;
+                node.condition.walk(tw);
+                pop();
+                return true;
+            }
            if (node instanceof AST_For) {
                if (node.init) node.init.walk(tw);
                push();
@@ -4501,14 +4531,6 @@ merge(Compressor.prototype, {
                }
                return true;
            }
-            if (node instanceof AST_IterationStatement) {
-                push();
-                segment.block = node;
-                segment.loop = true;
-                descend();
-                pop();
-                return true;
-            }
            if (node instanceof AST_LabeledStatement) {
                push();
                segment.block = node;
@@ -4516,6 +4538,13 @@ merge(Compressor.prototype, {
                pop();
                return true;
            }
+            if (node instanceof AST_Let) {
+                node.definitions.forEach(function(defn) {
+                    references[defn.name.definition().id] = false;
+                    if (defn.value) defn.value.walk(tw);
+                });
+                return true;
+            }
            if (node instanceof AST_Scope) {
                push();
                segment.block = node;
@@ -4594,6 +4623,14 @@ merge(Compressor.prototype, {
                }
                return true;
            }
+            if (node instanceof AST_While) {
+                push();
+                segment.block = node;
+                segment.loop = true;
+                descend();
+                pop();
+                return true;
+            }
        });
        tw.directives = Object.create(compressor.directives);
        self.walk(tw);
@@ -4618,7 +4655,10 @@ merge(Compressor.prototype, {
                if (!tail_refs) continue;
                if (head_refs.start.block !== tail_refs.start.block
                    || !mergeable(head_refs, tail_refs)
-                    || head_refs.start.loop && !mergeable(tail_refs, head_refs)) {
+                    || head_refs.start.loop && !mergeable(tail_refs, head_refs)
+                    || !all(tail_refs, function(sym) {
+                        return sym.scope.find_variable(def.name) === def;
+                    })) {
                    skipped.unshift(tail);
                    continue;
                }
@@ -4715,7 +4755,7 @@ merge(Compressor.prototype, {
            if (!(sym instanceof AST_SymbolRef)) return;
            if (compressor.exposed(sym.definition())) return;
            if (!all(sym.definition().orig, function(sym) {
-                return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLambda);
+                return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLambda || sym instanceof AST_SymbolLet);
            })) return;
            return sym;
        };
@@ -4764,6 +4804,10 @@ merge(Compressor.prototype, {
                    node.definitions.forEach(function(defn) {
                        var def = defn.name.definition();
                        var_defs_by_id.add(def.id, defn);
+                        if (node instanceof AST_Var && def.orig[0] instanceof AST_SymbolCatch) {
+                            var redef = def.redefined();
+                            if (redef) var_defs_by_id.add(redef.id, defn);
+                        }
                        if ((!drop_vars || (node instanceof AST_Const ? def.redefined() : def.const_redefs))
                            && !(def.id in in_use_ids)) {
                            in_use_ids[def.id] = true;
@@ -4956,7 +5000,7 @@ merge(Compressor.prototype, {
                            }
                        } else if (compressor.option("functions")
                            && !compressor.option("ie8")
-                            && !(node instanceof AST_Const)
+                            && !(node instanceof AST_Const || node instanceof AST_Let)
                            && var_defs.length == 1
                            && sym.assignments == 0
                            && def.value instanceof AST_Function
@@ -5100,7 +5144,7 @@ merge(Compressor.prototype, {
                return in_list ? List.skip : make_node(AST_EmptyStatement, node);
              case 1:
                var stat = node.body[0];
-                if (!(stat instanceof AST_Const)) return stat;
+                if (!(stat instanceof AST_Const || stat instanceof AST_Let)) return stat;
            } else if (node instanceof AST_For) {
                // Certain combination of unused name + side effect leads to invalid AST:
                //    https://github.com/mishoo/UglifyJS/issues/44
@@ -5139,7 +5183,7 @@ merge(Compressor.prototype, {
                var def = sym.definition();
                if (!def) return;
                if (def.id in in_use_ids) return;
-                if (def.scope !== self && member(def, self.enclosed)) return;
+                if (def.scope !== self && self.find_variable(sym) === def) return;
                log(sym, "Dropping unused loop variable {name}");
                if (for_ins[def.id] === node) delete for_ins[def.id];
                var body = [];
@@ -5665,7 +5709,7 @@ merge(Compressor.prototype, {
                    return ref.fixed_value() === right;
                })
                && all(def.orig, function(sym) {
-                    return !(sym instanceof AST_SymbolConst);
+                    return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet);
                });
        }
    });
@@ -5883,7 +5927,7 @@ merge(Compressor.prototype, {
        });
        function drop_symbol(ref) {
            return all(ref.definition().orig, function(sym) {
-                return !(sym instanceof AST_SymbolConst);
+                return !(sym instanceof AST_SymbolConst || sym instanceof AST_SymbolLet);
            });
        }
        def(AST_SymbolRef, function(compressor) {
@@ -5896,10 +5940,7 @@ merge(Compressor.prototype, {
                this.write_only = !exp.has_side_effects(compressor);
                return this;
            }
-            if (this.operator == "typeof" && exp instanceof AST_SymbolRef) {
-                if (drop_symbol(exp)) return null;
-                if (exp.is_declared(compressor)) return exp;
-            }
+            if (this.operator == "typeof" && exp instanceof AST_SymbolRef && drop_symbol(exp)) return null;
            var node = exp.drop_side_effect_free(compressor, first_in_statement);
            if (first_in_statement && node && is_iife_call(node)) {
                if (node === exp && this.operator == "!") return this;
@@ -6623,6 +6664,12 @@ merge(Compressor.prototype, {
        });
    });

+    AST_Let.DEFMETHOD("remove_initializers", function() {
+        this.definitions.forEach(function(def) {
+            def.value = null;
+        });
+    });
+
    AST_Var.DEFMETHOD("remove_initializers", function() {
        this.definitions.forEach(function(def) {
            def.value = null;
@@ -6650,20 +6697,17 @@ merge(Compressor.prototype, {
        return make_sequence(this, assignments);
    });

-    OPT(AST_Const, function(self, compressor) {
-        return all(self.definitions, function(defn) {
+    function varify(self, compressor) {
+        return compressor.option("varify") && all(self.definitions, function(defn) {
            var node = defn.name;
            if (!node.fixed_value()) return false;
            var def = node.definition();
            if (compressor.exposed(def)) return false;
            var scope = def.scope.resolve();
-            if (def.scope === scope) return true;
-            if (scope instanceof AST_Toplevel) return !scope.variables.has(node.name) && !scope.globals.has(node.name);
-            var s = def.scope;
-            do {
+            for (var s = def.scope; s !== scope;) {
                s = s.parent_scope;
                if (s.var_names()[node.name]) return false;
-            } while (s !== scope);
+            }
            return true;
        }) ? make_node(AST_Var, self, {
            definitions: self.definitions.map(function(defn) {
@@ -6678,7 +6722,10 @@ merge(Compressor.prototype, {
                });
            })
        }) : self;
-    });
+    }
+
+    OPT(AST_Const, varify);
+    OPT(AST_Let, varify);

    function lift_sequence_in_expression(node, compressor) {
        var exp = node.expression;
--- 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) {
@@ -990,7 +993,7 @@ function OutputStream(options) {
    /* -----[ if ]----- */
    function make_then(self, output) {
        var b = self.body;
-        if (output.option("braces") && !(b instanceof AST_Const)
+        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
@@ -1124,6 +1127,7 @@ function OutputStream(options) {
        };
    }
    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) {
@@ -1381,7 +1385,7 @@ function OutputStream(options) {
    });

    function force_statement(stat, output) {
-        if (output.option("braces") && !(stat instanceof AST_Const)) {
+        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();
--- 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,8 +58,6 @@ RESERVED_WORDS = makePredicate(RESERVED_WORDS);
 KEYWORDS_BEFORE_EXPRESSION = makePredicate(KEYWORDS_BEFORE_EXPRESSION);
 KEYWORDS_ATOM = makePredicate(KEYWORDS_ATOM);

-var OPERATOR_CHARS = makePredicate(characters("+-*&%=<>!?|~^"));
-
 var RE_BIN_NUMBER = /^0b([01]+)$/i;
 var RE_HEX_NUMBER = /^0x([0-9a-f]+)$/i;
 var RE_OCT_NUMBER = /^0o?([0-7]+)$/i;
@@ -111,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;
 }
@@ -148,32 +136,8 @@ function is_digit(code) {
    return code >= 48 && code <= 57;
 }

-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) {
@@ -342,7 +306,7 @@ 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_digit(code) || is_letter(code) || ch == "_";
+            return is_digit(code) || /[_0-9a-fo]/i.test(ch);
        });
        if (prefix) num = prefix + num;
        if (/^0[0-7_]+$/.test(num)) {
@@ -358,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);
@@ -448,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();
@@ -587,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 + "'");
@@ -880,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");
@@ -1202,6 +1182,14 @@ function parse($TEXT, options) {
        });
    };

+    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(),
--- a/lib/scope.js
+++ b/lib/scope.js
@@ -169,6 +169,8 @@ 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);
@@ -275,6 +277,9 @@ 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 = new_def.redefined();
--- 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.3",
+  "version": "3.11.4",
  "engines": {
    "node": ">=0.8.0"
  },
--- 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/collapse_vars.js
+++ b/test/compress/collapse_vars.js
@@ -8556,3 +8556,24 @@ 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"
+}
--- a/test/compress/const.js
+++ b/test/compress/const.js
@@ -161,31 +161,6 @@ merge_vars_3: {
    expect_stdout: true
 }

-reduce_merge_vars: {
-    options = {
-        merge_vars: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: 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",
-    ]
-}
-
 use_before_init_1: {
    options = {
        reduce_vars: true,
@@ -312,24 +287,6 @@ reduce_block_1: {
    expect_stdout: "object"
 }

-reduce_block_1_toplevel: {
-    options = {
-        reduce_vars: true,
-        toplevel: true,
-    }
-    input: {
-        {
-            const a = typeof console;
-            console.log(a);
-        }
-    }
-    expect: {
-        var a = typeof console;
-        console.log(a);
-    }
-    expect_stdout: "object"
-}
-
 reduce_block_2: {
    options = {
        reduce_vars: true,
@@ -373,7 +330,7 @@ reduce_block_2_toplevel: {
    expect_stdout: true
 }

-hoist_props_1: {
+hoist_props: {
    options = {
        hoist_props: true,
        reduce_vars: true,
@@ -397,28 +354,6 @@ hoist_props_1: {
    expect_stdout: "PASS"
 }

-hoist_props_2: {
-    options = {
-        hoist_props: true,
-        passes: 2,
-        reduce_vars: true,
-        toplevel: true,
-    }
-    input: {
-        {
-            const o = {
-                p: "PASS",
-            };
-            console.log(o.p);
-        }
-    }
-    expect: {
-        var o_p = "PASS";
-        console.log(o_p);
-    }
-    expect_stdout: "PASS"
-}
-
 loop_block_1: {
    options = {
        loops: true,
@@ -503,7 +438,7 @@ catch_ie8_1: {
    }
    expect: {
        try {} catch (a) {}
-        console.log(function a() {
+        console.log(function() {
        }());
    }
    expect_stdout: "undefined"
@@ -559,29 +494,6 @@ dead_block_after_return: {
    expect_stdout: true
 }

-const_to_var_scope_adjustment: {
-    options = {
-        conditionals: true,
-        inline: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: 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"
-}
-
 do_if_continue_1: {
    options = {
        if_return: true,
@@ -687,7 +599,7 @@ legacy_scope: {
    expect_stdout: true
 }

-issue_4191_1: {
+issue_4191: {
    options = {
        functions: true,
        reduce_vars: true,
@@ -708,24 +620,6 @@ issue_4191_1: {
    expect_stdout: true
 }

-issue_4191_2: {
-    options = {
-        functions: true,
-        reduce_vars: true,
-        toplevel: true,
-        unused: true,
-    }
-    input: {
-        const a = function() {};
-        console.log(typeof a, a());
-    }
-    expect: {
-        function a() {};
-        console.log(typeof a, a());
-    }
-    expect_stdout: "function undefined"
-}
-
 issue_4193: {
    options = {
        dead_code: true,
@@ -1151,3 +1045,42 @@ issue_4225: {
    }
    expect_stdout: true
 }
+
+issue_4229: {
+    options = {
+        ie8: true,
+        side_effects: true,
+    }
+    input: {
+        (function f() {
+            f;
+            const f = 42;
+        })();
+    }
+    expect: {
+        (function f() {
+            f;
+            const f = 42;
+        })();
+    }
+    expect_stdout: true
+}
+
+issue_4231: {
+    options = {
+        ie8: true,
+        side_effects: true,
+    }
+    input: {
+        typeof a == 0;
+        console.log(typeof function a() {
+            const a = 0;
+        });
+    }
+    expect: {
+        console.log(typeof function a() {
+            const a = 0;
+        });
+    }
+    expect_stdout: "function"
+}
--- a/test/compress/drop-unused.js
+++ b/test/compress/drop-unused.js
@@ -3085,3 +3085,30 @@ issue_4184: {
    }
    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/functions.js
+++ b/test/compress/functions.js
@@ -5076,3 +5076,42 @@ issue_4186: {
    }
    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
@@ -2859,3 +2859,21 @@ issue_4186: {
    }
    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"
+}
--- a/test/compress/let.js
+++ b/test/compress/let.js
@@ -0,0 +1,895 @@
+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"
+}
--- a/test/compress/loops.js
+++ b/test/compress/loops.js
@@ -1222,3 +1222,35 @@ do_continue: {
    }
    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
@@ -3011,3 +3011,84 @@ 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"
+}
--- 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/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/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/ufuzz/index.js
+++ b/test/ufuzz/index.js
@@ -381,32 +381,43 @@ 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);
-        consts.push(name);
+        if (rng(2)) {
+            consts.push(name);
+        } else {
+            lets.push(name);
+        }
        block_vars.push(name);
    }
    unique_vars.length -= 6;
    fn(function() {
-        var s = [];
-        if (consts.length) {
-            var save = VAR_NAMES;
-            VAR_NAMES = VAR_NAMES.filter(function(name) {
-                return consts.indexOf(name) < 0;
-            });
-            var len = VAR_NAMES.length;
-            s.push("const " + consts.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));
+        if (rng(2)) {
+            return createDefinitions("const", consts) + "\n" + createDefinitions("let", lets) + "\n";
+        } else {
+            return createDefinitions("let", lets) + "\n" + createDefinitions("const", consts) + "\n";
        }
-        return s.join("\n");
    });
    block_vars.length = block_len;
-    if (consts.length) VAR_NAMES.splice(var_len, consts.length);
+    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) {
Author	SHA1	Message	Date
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