terser 5.3.6 → 5.5.0

package/lib/ast.js

@@ -93,8 +93,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) {
@@ -563,7 +609,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",
     }
 });
 
@@ -1075,8 +1121,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, {
@@ -1367,11 +1416,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);
 

package/lib/compress/index.js

@@ -528,6 +528,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;
@@ -542,6 +543,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;
 }
 
@@ -674,38 +676,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;
     }
 
@@ -729,32 +749,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) {
@@ -1357,7 +1409,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
@@ -1425,6 +1478,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
                     });
@@ -1729,6 +1783,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);
@@ -1783,7 +1838,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;
@@ -1794,14 +1851,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) {
@@ -1860,7 +1923,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) {
@@ -2287,7 +2352,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();
@@ -2510,6 +2575,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);
     });
@@ -3734,6 +3801,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;
@@ -3952,6 +4020,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
                                     });
@@ -4387,6 +4456,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")
@@ -4983,6 +5054,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
             }));
@@ -5013,6 +5085,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;
 });
@@ -5597,6 +5680,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()
         }));
@@ -5640,6 +5724,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)
                     }));
@@ -6160,7 +6245,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;
                 }
             }
@@ -6169,7 +6254,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;
                 }
             }
@@ -6597,6 +6682,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
@@ -6814,16 +6903,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,
@@ -7419,9 +7512,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++) {
@@ -7457,7 +7553,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, {
@@ -7468,7 +7574,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: "+",

package/lib/mozilla-ast.js

@@ -544,6 +544,7 @@ import {
                 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);
@@ -1068,22 +1069,10 @@ import {
 
     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()
         };
     });
 
@@ -1108,40 +1097,36 @@ import {
 
     /* -----[ 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) {

package/lib/output.js

@@ -1335,6 +1335,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;
@@ -2072,8 +2075,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()));
         }