terser 5.3.6 → 5.5.0

package/dist/bundle.min.js

@@ -324,6 +324,9 @@ function set_annotation(node, annotation) {
 
  ***********************************************************************/
 
+var LATEST_RAW = "";  // Only used for numbers and template strings
+var LATEST_TEMPLATE_END = true;
+
 var KEYWORDS = "break case catch class const continue debugger default delete do else export extends 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 = "enum implements import interface package private protected public static super this " + KEYWORDS_ATOM + " " + KEYWORDS;
@@ -379,6 +382,9 @@ var OPERATORS = makePredicate([
     "=",
     "+=",
     "-=",
+    "||=",
+    "&&=",
+    "??=",
     "/=",
     "*=",
     "**=",
@@ -639,29 +645,23 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         } else if (!is_comment) {
             prev_was_dot = false;
         }
-        var ret = {
-            type    : type,
-            value   : value,
-            line    : S.tokline,
-            col     : S.tokcol,
-            pos     : S.tokpos,
-            endline : S.line,
-            endcol  : S.col,
-            endpos  : S.pos,
-            nlb     : S.newline_before,
-            file    : filename
-        };
-        if (/^(?:num|string|regexp)$/i.test(type)) {
-            ret.raw = $TEXT.substring(ret.pos, ret.endpos);
-        }
+        const line     = S.tokline;
+        const col      = S.tokcol;
+        const pos      = S.tokpos;
+        const nlb      = S.newline_before;
+        const file     = filename;
+        let comments_before = [];
+        let comments_after  = [];
+
         if (!is_comment) {
-            ret.comments_before = S.comments_before;
-            ret.comments_after = S.comments_before = [];
+            comments_before = S.comments_before;
+            comments_after = S.comments_before = [];
         }
         S.newline_before = false;
-        ret = new AST_Token(ret);
-        if (!is_comment) previous_token = ret;
-        return ret;
+        const tok = new AST_Token(type, value, line, col, pos, nlb, comments_before, comments_after, file);
+
+        if (!is_comment) previous_token = tok;
+        return tok;
     }
 
     function skip_whitespace() {
@@ -713,6 +713,9 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             return RE_NUM_LITERAL.test(ch);
         });
         if (prefix) num = prefix + num;
+
+        LATEST_RAW = num;
+
         if (RE_OCT_NUMBER.test(num) && next_token.has_directive("use strict")) {
             parse_error("Legacy octal literals are not allowed in strict mode");
         }
@@ -820,15 +823,17 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     }
 
     var read_string = with_eof_error("Unterminated string constant", function() {
-        var quote = next(), ret = "";
+        const start_pos = S.pos;
+        var quote = next(), ret = [];
         for (;;) {
             var ch = next(true, true);
             if (ch == "\\") ch = read_escaped_char(true, true);
             else if (ch == "\r" || ch == "\n") parse_error("Unterminated string constant");
             else if (ch == quote) break;
-            ret += ch;
+            ret.push(ch);
         }
-        var tok = token("string", ret);
+        var tok = token("string", ret.join(""));
+        LATEST_RAW = S.text.slice(start_pos, S.pos);
         tok.quote = quote;
         return tok;
     });
@@ -847,7 +852,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
                 next(true, true);
                 S.brace_counter++;
                 tok = token(begin ? "template_head" : "template_substitution", content);
-                tok.raw = raw;
+                LATEST_RAW = raw;
+                LATEST_TEMPLATE_END = false;
                 return tok;
             }
 
@@ -863,8 +869,8 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         }
         S.template_braces.pop();
         tok = token(begin ? "template_head" : "template_substitution", content);
-        tok.raw = raw;
-        tok.end = true;
+        LATEST_RAW = raw;
+        LATEST_TEMPLATE_END = true;
         return tok;
     });
 
@@ -897,7 +903,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     });
 
     var read_name = with_eof_error("Unterminated identifier name", function() {
-        var name, ch, escaped = false;
+        var name = [], ch, escaped = false;
         var read_escaped_identifier_char = function() {
             escaped = true;
             next();
@@ -908,17 +914,19 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         };
 
         // Read first character (ID_Start)
-        if ((name = peek()) === "\\") {
-            name = read_escaped_identifier_char();
-            if (!is_identifier_start(name)) {
+        if ((ch = peek()) === "\\") {
+            ch = read_escaped_identifier_char();
+            if (!is_identifier_start(ch)) {
                 parse_error("First identifier char is an invalid identifier char");
             }
-        } else if (is_identifier_start(name)) {
+        } else if (is_identifier_start(ch)) {
             next();
         } else {
             return "";
         }
 
+        name.push(ch);
+
         // Read ID_Continue
         while ((ch = peek()) != null) {
             if ((ch = peek()) === "\\") {
@@ -932,12 +940,13 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
                 }
                 next();
             }
-            name += ch;
+            name.push(ch);
         }
-        if (RESERVED_WORDS.has(name) && escaped) {
+        const name_str = name.join("");
+        if (RESERVED_WORDS.has(name_str) && escaped) {
             parse_error("Escaped characters are not allowed in keywords");
         }
-        return name;
+        return name_str;
     });
 
     var read_regexp = with_eof_error("Unterminated regular expression", function(source) {
@@ -961,7 +970,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             source += ch;
         }
         const flags = read_name();
-        return token("regexp", { source, flags });
+        return token("regexp", "/" + source + "/" + flags);
     });
 
     function read_operator(prefix) {
@@ -1154,7 +1163,9 @@ var UNARY_PREFIX = makePredicate([
 
 var UNARY_POSTFIX = makePredicate([ "--", "++" ]);
 
-var ASSIGNMENT = makePredicate([ "=", "+=", "-=", "/=", "*=", "**=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&=" ]);
+var ASSIGNMENT = makePredicate([ "=", "+=", "-=", "??=", "&&=", "||=", "/=", "*=", "**=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&=" ]);
+
+var LOGICAL_ASSIGNMENT = makePredicate([ "??=", "&&=", "||=" ]);
 
 var PRECEDENCE = (function(a, ret) {
     for (var i = 0; i < a.length; ++i) {
@@ -1192,7 +1203,7 @@ function parse($TEXT, options) {
     // Useful because comments_before property of call with parens outside
     // contains both comments inside and outside these parens. Used to find the
     // right #__PURE__ comments for an expression
-    const outer_comments_before_counts = new Map();
+    const outer_comments_before_counts = new WeakMap();
 
     options = defaults(options, {
         bare_returns   : false,
@@ -1326,7 +1337,7 @@ function parse($TEXT, options) {
           case "string":
             if (S.in_directives) {
                 var token = peek();
-                if (!S.token.raw.includes("\\")
+                if (!LATEST_RAW.includes("\\")
                     && (is_token(token, "punc", ";")
                         || is_token(token, "punc", "}")
                         || has_newline_before(token)
@@ -2309,7 +2320,12 @@ function parse($TEXT, options) {
             ret = _make_symbol(AST_SymbolRef);
             break;
           case "num":
-            ret = new AST_Number({ start: tok, end: tok, value: tok.value });
+            ret = new AST_Number({
+                start: tok,
+                end: tok,
+                value: tok.value,
+                raw: LATEST_RAW
+            });
             break;
           case "big_int":
             ret = new AST_BigInt({ start: tok, end: tok, value: tok.value });
@@ -2323,7 +2339,9 @@ function parse($TEXT, options) {
             });
             break;
           case "regexp":
-            ret = new AST_RegExp({ start: tok, end: tok, value: tok.value });
+            const [_, source, flags] = tok.value.match(/^\/(.*)\/(\w*)$/);
+
+            ret = new AST_RegExp({ start: tok, end: tok, value: { source, flags } });
             break;
           case "atom":
             switch (tok.value) {
@@ -2493,22 +2511,19 @@ function parse($TEXT, options) {
 
         segments.push(new AST_TemplateSegment({
             start: S.token,
-            raw: S.token.raw,
+            raw: LATEST_RAW,
             value: S.token.value,
             end: S.token
         }));
-        while (!S.token.end) {
+
+        while (!LATEST_TEMPLATE_END) {
             next();
             handle_regexp();
             segments.push(expression(true));
 
-            if (!is_token("template_substitution")) {
-                unexpected();
-            }
-
             segments.push(new AST_TemplateSegment({
                 start: S.token,
-                raw: S.token.raw,
+                raw: LATEST_RAW,
                 value: S.token.value,
                 end: S.token
             }));
@@ -2602,6 +2617,7 @@ function parse($TEXT, options) {
                     left: value,
                     operator: "=",
                     right: expression(false),
+                    logical: false,
                     end: prev()
                 });
             }
@@ -3370,11 +3386,13 @@ function parse($TEXT, options) {
         if (is("operator") && ASSIGNMENT.has(val)) {
             if (is_assignable(left) || (left = to_destructuring(left)) instanceof AST_Destructuring) {
                 next();
+
                 return new AST_Assign({
                     start    : start,
                     left     : left,
                     operator : val,
                     right    : maybe_assign(no_in),
+                    logical  : LOGICAL_ASSIGNMENT.has(val),
                     end      : prev()
                 });
             }
@@ -3518,8 +3536,54 @@ function DEFNODE(type, props, methods, base = AST_Node) {
     return ctor;
 }
 
-var AST_Token = DEFNODE("Token", "type value line col pos endline endcol endpos nlb comments_before comments_after file raw quote end", {
-}, null);
+const has_tok_flag = (tok, flag) => Boolean(tok.flags & flag);
+const set_tok_flag = (tok, flag, truth) => {
+    if (truth) {
+        tok.flags |= flag;
+    } else {
+        tok.flags &= ~flag;
+    }
+};
+
+const TOK_FLAG_NLB          = 0b0001;
+const TOK_FLAG_QUOTE_SINGLE = 0b0010;
+const TOK_FLAG_QUOTE_EXISTS = 0b0100;
+
+class AST_Token {
+    constructor(type, value, line, col, pos, nlb, comments_before, comments_after, file) {
+        this.flags = (nlb ? 1 : 0);
+
+        this.type = type;
+        this.value = value;
+        this.line = line;
+        this.col = col;
+        this.pos = pos;
+        this.comments_before = comments_before;
+        this.comments_after = comments_after;
+        this.file = file;
+
+        Object.seal(this);
+    }
+
+    get nlb() {
+        return has_tok_flag(this, TOK_FLAG_NLB);
+    }
+
+    set nlb(new_nlb) {
+        set_tok_flag(this, TOK_FLAG_NLB, new_nlb);
+    }
+
+    get quote() {
+        return !has_tok_flag(this, TOK_FLAG_QUOTE_EXISTS)
+            ? ""
+            : (has_tok_flag(this, TOK_FLAG_QUOTE_SINGLE) ? "'" : '"');
+    }
+
+    set quote(quote_type) {
+        set_tok_flag(this, TOK_FLAG_QUOTE_SINGLE, quote_type === "'");
+        set_tok_flag(this, TOK_FLAG_QUOTE_EXISTS, !!quote_type);
+    }
+}
 
 var AST_Node = DEFNODE("Node", "start end", {
     _clone: function(deep) {
@@ -3988,7 +4052,7 @@ var AST_TemplateSegment = DEFNODE("TemplateSegment", "value raw", {
     $documentation: "A segment of a template string literal",
     $propdoc: {
         value: "Content of the segment",
-        raw: "Raw content of the segment"
+        raw: "Raw source of the segment",
     }
 });
 
@@ -4500,8 +4564,11 @@ var AST_Conditional = DEFNODE("Conditional", "condition consequent alternative",
     },
 });
 
-var AST_Assign = DEFNODE("Assign", null, {
+var AST_Assign = DEFNODE("Assign", "logical", {
     $documentation: "An assignment expression — `a = b + 5`",
+    $propdoc: {
+        logical: "Whether it's a logical assignment"
+    }
 }, AST_Binary);
 
 var AST_DefaultAssign = DEFNODE("DefaultAssign", null, {
@@ -4792,11 +4859,11 @@ var AST_String = DEFNODE("String", "value quote", {
     }
 }, AST_Constant);
 
-var AST_Number = DEFNODE("Number", "value literal", {
+var AST_Number = DEFNODE("Number", "value raw", {
     $documentation: "A number literal",
     $propdoc: {
         value: "[number] the numeric value",
-        literal: "[string] numeric value as string (optional)"
+        raw: "[string] numeric value as string"
     }
 }, AST_Constant);
 
@@ -5875,6 +5942,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 return new AST_String(args);
               case "number":
                 args.value = val;
+                args.raw = M.raw || val.toString();
                 return new AST_Number(args);
               case "boolean":
                 return new (val ? AST_True : AST_False)(args);
@@ -6399,22 +6467,10 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
 
     def_to_moz(AST_Constant, function To_Moz_Literal(M) {
         var value = M.value;
-        if (typeof value === "number" && (value < 0 || (value === 0 && 1 / value < 0))) {
-            return {
-                type: "UnaryExpression",
-                operator: "-",
-                prefix: true,
-                argument: {
-                    type: "Literal",
-                    value: -value,
-                    raw: M.start.raw
-                }
-            };
-        }
         return {
             type: "Literal",
             value: value,
-            raw: M.start.raw
+            raw: M.raw || M.print_to_string()
         };
     });
 
@@ -6439,40 +6495,36 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
 
     /* -----[ tools ]----- */
 
-    function raw_token(moznode) {
-        if (moznode.type == "Literal") {
-            return moznode.raw != null ? moznode.raw : moznode.value + "";
-        }
-    }
-
     function my_start_token(moznode) {
         var loc = moznode.loc, start = loc && loc.start;
         var range = moznode.range;
-        return new AST_Token({
-            file    : loc && loc.source,
-            line    : start && start.line,
-            col     : start && start.column,
-            pos     : range ? range[0] : moznode.start,
-            endline : start && start.line,
-            endcol  : start && start.column,
-            endpos  : range ? range[0] : moznode.start,
-            raw     : raw_token(moznode),
-        });
+        return new AST_Token(
+            "",
+            "",
+            start && start.line || 0,
+            start && start.column || 0,
+            range ? range [0] : moznode.start,
+            false,
+            [],
+            [],
+            loc && loc.source,
+        );
     }
 
     function my_end_token(moznode) {
         var loc = moznode.loc, end = loc && loc.end;
         var range = moznode.range;
-        return new AST_Token({
-            file    : loc && loc.source,
-            line    : end && end.line,
-            col     : end && end.column,
-            pos     : range ? range[1] : moznode.end,
-            endline : end && end.line,
-            endcol  : end && end.column,
-            endpos  : range ? range[1] : moznode.end,
-            raw     : raw_token(moznode),
-        });
+        return new AST_Token(
+            "",
+            "",
+            end && end.line || 0,
+            end && end.column || 0,
+            range ? range [0] : moznode.end,
+            false,
+            [],
+            [],
+            loc && loc.source,
+        );
     }
 
     function map(moztype, mytype, propmap) {
@@ -7868,6 +7920,9 @@ function OutputStream(options) {
         }
         output.print("`");
     });
+    DEFPRINT(AST_TemplateSegment, function(self, output) {
+        output.print_template_string_chars(self.value);
+    });
 
     AST_Arrow.DEFMETHOD("_do_print", function(output) {
         var self = this;
@@ -8605,8 +8660,8 @@ function OutputStream(options) {
         output.print_string(self.getValue(), self.quote, output.in_directive);
     });
     DEFPRINT(AST_Number, function(self, output) {
-        if ((output.option("keep_numbers") || output.use_asm) && self.start && self.start.raw != null) {
-            output.print(self.start.raw);
+        if ((output.option("keep_numbers") || output.use_asm) && self.raw) {
+            output.print(self.raw);
         } else {
             output.print(make_num(self.getValue()));
         }
@@ -10664,6 +10719,7 @@ AST_Scope.DEFMETHOD("process_expression", function(insert, compressor) {
 function read_property(obj, key) {
     key = get_value(key);
     if (key instanceof AST_Node) return;
+
     var value;
     if (obj instanceof AST_Array) {
         var elements = obj.elements;
@@ -10678,6 +10734,7 @@ function read_property(obj, key) {
             if (!value && props[i].key === key) value = props[i].value;
         }
     }
+
     return value instanceof AST_SymbolRef && value.fixed_value() || value;
 }
 
@@ -10810,38 +10867,56 @@ function is_modified(compressor, tw, node, value, level, immutable) {
             || value instanceof AST_This;
     }
 
-    function mark_escaped(tw, d, scope, node, value, level, depth) {
+    // A definition "escapes" when its value can leave the point of use.
+    // Example: `a = b || c`
+    // In this example, "b" and "c" are escaping, because they're going into "a"
+    //
+    // def.escaped is != 0 when it escapes.
+    //
+    // When greater than 1, it means that N chained properties will be read off
+    // of that def before an escape occurs. This is useful for evaluating
+    // property accesses, where you need to know when to stop.
+    function mark_escaped(tw, d, scope, node, value, level = 0, depth = 1) {
         var parent = tw.parent(level);
         if (value) {
             if (value.is_constant()) return;
             if (value instanceof AST_ClassExpression) return;
         }
-        if (parent instanceof AST_Assign && parent.operator == "=" && node === parent.right
+
+        if (
+            parent instanceof AST_Assign && (parent.operator === "=" || parent.logical) && node === parent.right
             || parent instanceof AST_Call && (node !== parent.expression || parent instanceof AST_New)
             || parent instanceof AST_Exit && node === parent.value && node.scope !== d.scope
             || parent instanceof AST_VarDef && node === parent.value
-            || parent instanceof AST_Yield && node === parent.value && node.scope !== d.scope) {
+            || parent instanceof AST_Yield && node === parent.value && node.scope !== d.scope
+        ) {
             if (depth > 1 && !(value && value.is_constant_expression(scope))) depth = 1;
             if (!d.escaped || d.escaped > depth) d.escaped = depth;
             return;
-        } else if (parent instanceof AST_Array
+        } else if (
+            parent instanceof AST_Array
             || parent instanceof AST_Await
             || parent instanceof AST_Binary && lazy_op.has(parent.operator)
             || parent instanceof AST_Conditional && node !== parent.condition
             || parent instanceof AST_Expansion
-            || parent instanceof AST_Sequence && node === parent.tail_node()) {
+            || parent instanceof AST_Sequence && node === parent.tail_node()
+        ) {
             mark_escaped(tw, d, scope, parent, parent, level + 1, depth);
         } else if (parent instanceof AST_ObjectKeyVal && node === parent.value) {
             var obj = tw.parent(level + 1);
+
             mark_escaped(tw, d, scope, obj, obj, level + 2, depth);
         } else if (parent instanceof AST_PropAccess && node === parent.expression) {
             value = read_property(value, parent.property);
+
             mark_escaped(tw, d, scope, parent, value, level + 1, depth + 1);
             if (value) return;
         }
+
         if (level > 0) return;
         if (parent instanceof AST_Sequence && node !== parent.tail_node()) return;
         if (parent instanceof AST_SimpleStatement) return;
+
         d.direct_access = true;
     }
 
@@ -10865,32 +10940,64 @@ function is_modified(compressor, tw, node, value, level, immutable) {
             suppress(node.left);
             return;
         }
+
+        const finish_walk = () => {
+            if (node.logical) {
+                node.left.walk(tw);
+
+                push(tw);
+                node.right.walk(tw);
+                pop(tw);
+
+                return true;
+            }
+        };
+
         var sym = node.left;
-        if (!(sym instanceof AST_SymbolRef)) return;
+        if (!(sym instanceof AST_SymbolRef)) return finish_walk();
+
         var def = sym.definition();
         var safe = safe_to_assign(tw, def, sym.scope, node.right);
         def.assignments++;
-        if (!safe) return;
+        if (!safe) return finish_walk();
+
         var fixed = def.fixed;
-        if (!fixed && node.operator != "=") return;
+        if (!fixed && node.operator != "=" && !node.logical) return finish_walk();
+
         var eq = node.operator == "=";
         var value = eq ? node.right : node;
-        if (is_modified(compressor, tw, node, value, 0)) return;
+        if (is_modified(compressor, tw, node, value, 0)) return finish_walk();
+
         def.references.push(sym);
-        if (!eq) def.chained = true;
-        def.fixed = eq ? function() {
-            return node.right;
-        } : function() {
-            return make_node(AST_Binary, node, {
-                operator: node.operator.slice(0, -1),
-                left: fixed instanceof AST_Node ? fixed : fixed(),
-                right: node.right
-            });
-        };
+
+        if (!node.logical) {
+            if (!eq) def.chained = true;
+
+            def.fixed = eq ? function() {
+                return node.right;
+            } : function() {
+                return make_node(AST_Binary, node, {
+                    operator: node.operator.slice(0, -1),
+                    left: fixed instanceof AST_Node ? fixed : fixed(),
+                    right: node.right
+                });
+            };
+        }
+
+        if (node.logical) {
+            mark(tw, def, false);
+            push(tw);
+            node.right.walk(tw);
+            pop(tw);
+            return true;
+        }
+
         mark(tw, def, false);
         node.right.walk(tw);
         mark(tw, def, true);
+
         mark_escaped(tw, def, sym.scope, node, value, 0, 1);
+
         return true;
     });
     def_reduce_vars(AST_Binary, function(tw) {
@@ -11493,7 +11600,8 @@ function tighten_body(statements, compressor) {
             }
             // Stop immediately if these node types are encountered
             var parent = scanner.parent();
-            if (node instanceof AST_Assign && node.operator != "=" && lhs.equivalent_to(node.left)
+            if (node instanceof AST_Assign
+                    && (node.logical || node.operator != "=" && lhs.equivalent_to(node.left))
                 || node instanceof AST_Await
                 || node instanceof AST_Call && lhs instanceof AST_PropAccess && lhs.equivalent_to(node.expression)
                 || node instanceof AST_Debugger
@@ -11561,6 +11669,7 @@ function tighten_body(statements, compressor) {
                     }
                     return make_node(AST_Assign, candidate, {
                         operator: "=",
+                        logical: false,
                         left: make_node(AST_SymbolRef, candidate.name, candidate.name),
                         right: value
                     });
@@ -11865,6 +11974,7 @@ function tighten_body(statements, compressor) {
             var parent = scanner.parent(level);
             if (parent instanceof AST_Assign) {
                 if (write_only
+                    && !parent.logical
                     && !(parent.left instanceof AST_PropAccess
                         || lvalues.has(parent.left.name))) {
                     return find_stop(parent, level + 1, write_only);
@@ -11919,7 +12029,9 @@ function tighten_body(statements, compressor) {
         }
 
         function get_lhs(expr) {
-            if (expr instanceof AST_VarDef && expr.name instanceof AST_SymbolDeclaration) {
+            if (expr instanceof AST_Assign && expr.logical) {
+                return false;
+            } else if (expr instanceof AST_VarDef && expr.name instanceof AST_SymbolDeclaration) {
                 var def = expr.name.definition();
                 if (!member(expr.name, def.orig)) return;
                 var referenced = def.references.length - def.replaced;
@@ -11930,14 +12042,20 @@ function tighten_body(statements, compressor) {
                     return make_node(AST_SymbolRef, expr.name, expr.name);
                 }
             } else {
-                const lhs = expr[expr instanceof AST_Assign ? "left" : "expression"];
+                const lhs = expr instanceof AST_Assign
+                    ? expr.left
+                    : expr.expression;
                 return !is_ref_of(lhs, AST_SymbolConst)
                     && !is_ref_of(lhs, AST_SymbolLet) && lhs;
             }
         }
 
         function get_rvalue(expr) {
-            return expr[expr instanceof AST_Assign ? "right" : "value"];
+            if (expr instanceof AST_Assign) {
+                return expr.right;
+            } else {
+                return expr.value;
+            }
         }
 
         function get_lvalues(expr) {
@@ -11996,7 +12114,9 @@ function tighten_body(statements, compressor) {
                 && !(in_loop
                     && (lvalues.has(lhs.name)
                         || candidate instanceof AST_Unary
-                        || candidate instanceof AST_Assign && candidate.operator != "="));
+                        || (candidate instanceof AST_Assign
+                            && !candidate.logical
+                            && candidate.operator != "=")));
         }
 
         function value_has_side_effects(expr) {
@@ -12423,7 +12543,7 @@ function tighten_body(statements, compressor) {
         var def = defn.definitions[defn.definitions.length - 1];
         if (!(def.value instanceof AST_Object)) return;
         var exprs;
-        if (body instanceof AST_Assign) {
+        if (body instanceof AST_Assign && !body.logical) {
             exprs = [ body ];
         } else if (body instanceof AST_Sequence) {
             exprs = body.expressions.slice();
@@ -12646,6 +12766,8 @@ function is_undefined(node, compressor) {
             && (this.left._dot_throw(compressor) || this.right._dot_throw(compressor));
     });
     def_may_throw_on_access(AST_Assign, function(compressor) {
+        if (this.logical) return true;
+
         return this.operator == "="
             && this.right._dot_throw(compressor);
     });
@@ -13870,6 +13992,7 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
     var drop_vars = !(self instanceof AST_Toplevel) || compressor.toplevel.vars;
     const assign_as_unused = r_keep_assign.test(compressor.option("unused")) ? return_false : function(node) {
         if (node instanceof AST_Assign
+            && !node.logical
             && (has_flag(node, WRITE_ONLY) || node.operator == "=")
         ) {
             return node.left;
@@ -14088,6 +14211,7 @@ AST_Scope.DEFMETHOD("drop_unused", function(compressor) {
                                     sym.references.push(ref);
                                     var assign = make_node(AST_Assign, def, {
                                         operator: "=",
+                                        logical: false,
                                         left: ref,
                                         right: def.value
                                     });
@@ -14523,6 +14647,8 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
         }
     });
     def_drop_side_effect_free(AST_Assign, function(compressor) {
+        if (this.logical) return this;
+
         var left = this.left;
         if (left.has_side_effects(compressor)
             || compressor.has_directive("use strict")
@@ -15119,6 +15245,7 @@ AST_Definitions.DEFMETHOD("to_assignments", function(compressor) {
             var name = make_node(AST_SymbolRef, def.name, def.name);
             assignments.push(make_node(AST_Assign, def, {
                 operator : "=",
+                logical: false,
                 left     : name,
                 right    : def.value
             }));
@@ -15149,6 +15276,17 @@ def_optimize(AST_Definitions, function(self) {
     return self;
 });
 
+def_optimize(AST_VarDef, function(self) {
+    if (
+        self.name instanceof AST_SymbolLet
+        && self.value != null
+        && is_undefined(self.value)
+    ) {
+        self.value = null;
+    }
+    return self;
+});
+
 def_optimize(AST_Import, function(self) {
     return self;
 });
@@ -15733,6 +15871,7 @@ def_optimize(AST_Call, function(self, compressor) {
         def.references.push(sym);
         if (value) expressions.push(make_node(AST_Assign, self, {
             operator: "=",
+            logical: false,
             left: sym,
             right: value.clone()
         }));
@@ -15776,6 +15915,7 @@ def_optimize(AST_Call, function(self, compressor) {
                     def.references.push(sym);
                     expressions.splice(pos++, 0, make_node(AST_Assign, var_def, {
                         operator: "=",
+                        logical: false,
                         left: sym,
                         right: make_node(AST_Undefined, name)
                     }));
@@ -16296,7 +16436,7 @@ def_optimize(AST_Binary, function(self, compressor) {
                 var l = self.left;
                 var r = self.right.evaluate(compressor);
                 if (r != self.right) {
-                    l.segments[l.segments.length - 1].value += r.toString();
+                    l.segments[l.segments.length - 1].value += String(r);
                     return l;
                 }
             }
@@ -16305,7 +16445,7 @@ def_optimize(AST_Binary, function(self, compressor) {
                 var r = self.right;
                 var l = self.left.evaluate(compressor);
                 if (l != self.left) {
-                    r.segments[0].value = l.toString() + r.segments[0].value ;
+                    r.segments[0].value = String(l) + r.segments[0].value;
                     return r;
                 }
             }
@@ -16733,6 +16873,10 @@ function is_reachable(self, defs) {
 const ASSIGN_OPS = makePredicate("+ - / * % >> << >>> | ^ &");
 const ASSIGN_OPS_COMMUTATIVE = makePredicate("* | ^ &");
 def_optimize(AST_Assign, function(self, compressor) {
+    if (self.logical) {
+        return self.lift_sequences(compressor);
+    }
+
     var def;
     if (compressor.option("dead_code")
         && self.left instanceof AST_SymbolRef
@@ -16950,16 +17094,20 @@ def_optimize(AST_Conditional, function(self, compressor) {
     //                   |
     //                   v
     // exp = foo ? something : something_else;
-    if (consequent instanceof AST_Assign
+    if (
+        consequent instanceof AST_Assign
         && alternative instanceof AST_Assign
-        && consequent.operator == alternative.operator
+        && consequent.operator === alternative.operator
+        && consequent.logical === alternative.logical
         && consequent.left.equivalent_to(alternative.left)
         && (!self.condition.has_side_effects(compressor)
             || consequent.operator == "="
-                && !consequent.left.has_side_effects(compressor))) {
+                && !consequent.left.has_side_effects(compressor))
+    ) {
         return make_node(AST_Assign, self, {
             operator: consequent.operator,
             left: consequent.left,
+            logical: consequent.logical,
             right: make_node(AST_Conditional, self, {
                 condition: self.condition,
                 consequent: consequent.right,
@@ -17555,9 +17703,12 @@ def_optimize(AST_Yield, function(self, compressor) {
 });
 
 def_optimize(AST_TemplateString, function(self, compressor) {
-    if (!compressor.option("evaluate")
-    || compressor.parent() instanceof AST_PrefixedTemplateString)
+    if (
+        !compressor.option("evaluate")
+        || compressor.parent() instanceof AST_PrefixedTemplateString
+    ) {
         return self;
+    }
 
     var segments = [];
     for (var i = 0; i < self.segments.length; i++) {
@@ -17593,7 +17744,17 @@ def_optimize(AST_TemplateString, function(self, compressor) {
     if (segments.length == 1) {
         return make_node(AST_String, self, segments[0]);
     }
-    if (segments.length === 3 && segments[1] instanceof AST_Node) {
+
+    if (
+        segments.length === 3
+        && segments[1] instanceof AST_Node
+        && (
+            segments[1].is_string(compressor)
+            || segments[1].is_number(compressor)
+            || is_nullish(segments[1])
+            || compressor.option("unsafe")
+        )
+    ) {
         // `foo${bar}` => "foo" + bar
         if (segments[2].value === "") {
             return make_node(AST_Binary, self, {
@@ -17604,7 +17765,7 @@ def_optimize(AST_TemplateString, function(self, compressor) {
                 right: segments[1],
             });
         }
-        // `{bar}baz` => bar + "baz"
+        // `${bar}baz` => bar + "baz"
         if (segments[0].value === "") {
             return make_node(AST_Binary, self, {
                 operator: "+",
@@ -26661,4 +26822,3 @@ exports._run_cli = run_cli;
 exports.minify = minify;
 
 })));
-//# sourceMappingURL=bundle.min.js.map