terser 5.16.2 → 5.16.4

package/lib/ast.js

@@ -111,6 +111,14 @@ class AST_Token {
         Object.seal(this);
     }
 
+    // Return a string summary of the token for node.js console.log
+    [Symbol.for("nodejs.util.inspect.custom")](_depth, options) {
+        const special = str => options.stylize(str, "special");
+        const quote = typeof this.value === "string" && this.value.includes("`") ? "'" : "`";
+        const value = `${quote}${this.value}${quote}`;
+        return `${special("[AST_Token")} ${value} at ${this.line}:${this.col}${special("]")}`;
+    }
+
     get nlb() {
         return has_tok_flag(this, TOK_FLAG_NLB);
     }
@@ -1257,12 +1265,11 @@ var AST_Case = DEFNODE("Case", "expression", function AST_Case(props) {
 
 /* -----[ EXCEPTIONS ]----- */
 
-var AST_Try = DEFNODE("Try", "bcatch bfinally", function AST_Try(props) {
+var AST_Try = DEFNODE("Try", "body bcatch bfinally", function AST_Try(props) {
     if (props) {
+        this.body = props.body;
         this.bcatch = props.bcatch;
         this.bfinally = props.bfinally;
-        this.body = props.body;
-        this.block_scope = props.block_scope;
         this.start = props.start;
         this.end = props.end;
     }
@@ -1271,12 +1278,13 @@ var AST_Try = DEFNODE("Try", "bcatch bfinally", function AST_Try(props) {
 }, {
     $documentation: "A `try` statement",
     $propdoc: {
+        body: "[AST_TryBlock] the try block",
         bcatch: "[AST_Catch?] the catch block, or null if not present",
         bfinally: "[AST_Finally?] the finally block, or null if not present"
     },
     _walk: function(visitor) {
         return visitor._visit(this, function() {
-            walk_body(this, visitor);
+            this.body._walk(visitor);
             if (this.bcatch) this.bcatch._walk(visitor);
             if (this.bfinally) this.bfinally._walk(visitor);
         });
@@ -1284,9 +1292,21 @@ var AST_Try = DEFNODE("Try", "bcatch bfinally", function AST_Try(props) {
     _children_backwards(push) {
         if (this.bfinally) push(this.bfinally);
         if (this.bcatch) push(this.bcatch);
-        let i = this.body.length;
-        while (i--) push(this.body[i]);
+        push(this.body);
     },
+}, AST_Statement);
+
+var AST_TryBlock = DEFNODE("TryBlock", null, function AST_TryBlock(props) {
+    if (props) {
+        this.body = props.body;
+        this.block_scope = props.block_scope;
+        this.start = props.start;
+        this.end = props.end;
+    }
+
+    this.flags = 0;
+}, {
+    $documentation: "The `try` block of a try statement"
 }, AST_Block);
 
 var AST_Catch = DEFNODE("Catch", "argname", function AST_Catch(props) {
@@ -3235,6 +3255,7 @@ export {
     AST_Toplevel,
     AST_True,
     AST_Try,
+    AST_TryBlock,
     AST_Unary,
     AST_UnaryPostfix,
     AST_UnaryPrefix,

package/lib/compress/index.js

@@ -1529,9 +1529,9 @@ def_optimize(AST_Switch, function(self, compressor) {
 });
 
 def_optimize(AST_Try, function(self, compressor) {
-    tighten_body(self.body, compressor);
     if (self.bcatch && self.bfinally && self.bfinally.body.every(is_empty)) self.bfinally = null;
-    if (compressor.option("dead_code") && self.body.every(is_empty)) {
+
+    if (compressor.option("dead_code") && self.body.body.every(is_empty)) {
         var body = [];
         if (self.bcatch) {
             trim_unreachable_code(compressor, self.bcatch, body);
@@ -2737,16 +2737,21 @@ def_optimize(AST_Assign, function(self, compressor) {
     return self;
 
     function in_try(level, node) {
-        var right = self.right;
-        self.right = make_node(AST_Null, right);
-        var may_throw = node.may_throw(compressor);
-        self.right = right;
-        var scope = self.left.definition().scope;
+        function may_assignment_throw() {
+            const right = self.right;
+            self.right = make_node(AST_Null, right);
+            const may_throw = node.may_throw(compressor);
+            self.right = right;
+
+            return may_throw;
+        }
+
+        var stop_at = self.left.definition().scope.get_defun_scope();
         var parent;
-        while ((parent = compressor.parent(level++)) !== scope) {
+        while ((parent = compressor.parent(level++)) !== stop_at) {
             if (parent instanceof AST_Try) {
                 if (parent.bfinally) return true;
-                if (may_throw && parent.bcatch) return true;
+                if (parent.bcatch && may_assignment_throw()) return true;
             }
         }
     }
@@ -2759,7 +2764,13 @@ def_optimize(AST_DefaultAssign, function(self, compressor) {
     var evaluateRight = self.right.evaluate(compressor);
 
     // `[x = undefined] = foo` ---> `[x] = foo`
-    if (evaluateRight === undefined) {
+    // `(arg = undefined) => ...` ---> `(arg) => ...` (unless `keep_fargs`)
+    if (
+        evaluateRight === undefined &&
+        (compressor.parent() instanceof AST_Lambda
+            ? compressor.option("keep_fargs") === false
+            : true)
+    ) {
         self = self.left;
     } else if (evaluateRight !== self.right) {
         evaluateRight = make_node_from_constant(evaluateRight, self.right);

package/lib/compress/inference.js

@@ -300,7 +300,7 @@ export function is_nullish(node, compressor) {
             || any(this.body, compressor);
     });
     def_has_side_effects(AST_Try, function(compressor) {
-        return any(this.body, compressor)
+        return this.body.has_side_effects(compressor)
             || this.bcatch && this.bcatch.has_side_effects(compressor)
             || this.bfinally && this.bfinally.has_side_effects(compressor);
     });
@@ -529,7 +529,7 @@ export function is_nullish(node, compressor) {
     });
     def_may_throw(AST_SymbolClassProperty, return_false);
     def_may_throw(AST_Try, function(compressor) {
-        return this.bcatch ? this.bcatch.may_throw(compressor) : any(this.body, compressor)
+        return this.bcatch ? this.bcatch.may_throw(compressor) : this.body.may_throw(compressor)
             || this.bfinally && this.bfinally.may_throw(compressor);
     });
     def_may_throw(AST_Unary, function(compressor) {

package/lib/compress/inline.js

@@ -92,7 +92,6 @@ import "../size.js";
 import "./evaluate.js";
 import "./drop-side-effect-free.js";
 import "./reduce-vars.js";
-import { is_lhs } from "./inference.js";
 import {
     SQUEEZED,
     INLINED,
@@ -114,6 +113,13 @@ import {
     retain_top_func,
 } from "./common.js";
 
+/**
+ * Module that contains the inlining logic.
+ *
+ * @module
+ *
+ * The stars of the show are `inline_into_symbolref` and `inline_into_call`.
+ */
 
 function within_array_or_object_literal(compressor) {
     var node, level = 0;
@@ -144,136 +150,135 @@ function scope_encloses_variables_in_this_scope(scope, pulled_scope) {
 
 export function inline_into_symbolref(self, compressor) {
     const parent = compressor.parent();
-    if (compressor.option("reduce_vars") && is_lhs(self, parent) !== self) {
-        const def = self.definition();
-        const nearest_scope = compressor.find_scope();
-        if (compressor.top_retain && def.global && compressor.top_retain(def)) {
-            def.fixed = false;
-            def.single_use = false;
-            return self;
-        }
 
-        let fixed = self.fixed_value();
-        let single_use = def.single_use
-            && !(parent instanceof AST_Call
-                && (parent.is_callee_pure(compressor))
-                    || has_annotation(parent, _NOINLINE))
-            && !(parent instanceof AST_Export
-                && fixed instanceof AST_Lambda
-                && fixed.name);
-
-        if (single_use && fixed instanceof AST_Node) {
-            single_use =
-                !fixed.has_side_effects(compressor)
-                && !fixed.may_throw(compressor);
-        }
+    const def = self.definition();
+    const nearest_scope = compressor.find_scope();
+    if (compressor.top_retain && def.global && compressor.top_retain(def)) {
+        def.fixed = false;
+        def.single_use = false;
+        return self;
+    }
 
-        if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
-            if (retain_top_func(fixed, compressor)) {
-                single_use = false;
-            } else if (def.scope !== self.scope
-                && (def.escaped == 1
-                    || has_flag(fixed, INLINED)
-                    || within_array_or_object_literal(compressor)
-                    || !compressor.option("reduce_funcs"))) {
-                single_use = false;
-            } else if (is_recursive_ref(compressor, def)) {
-                single_use = false;
-            } else if (def.scope !== self.scope || def.orig[0] instanceof AST_SymbolFunarg) {
-                single_use = fixed.is_constant_expression(self.scope);
-                if (single_use == "f") {
-                    var scope = self.scope;
-                    do {
-                        if (scope instanceof AST_Defun || is_func_expr(scope)) {
-                            set_flag(scope, INLINED);
-                        }
-                    } while (scope = scope.parent_scope);
-                }
+    let fixed = self.fixed_value();
+    let single_use = def.single_use
+        && !(parent instanceof AST_Call
+            && (parent.is_callee_pure(compressor))
+                || has_annotation(parent, _NOINLINE))
+        && !(parent instanceof AST_Export
+            && fixed instanceof AST_Lambda
+            && fixed.name);
+
+    if (single_use && fixed instanceof AST_Node) {
+        single_use =
+            !fixed.has_side_effects(compressor)
+            && !fixed.may_throw(compressor);
+    }
+
+    if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
+        if (retain_top_func(fixed, compressor)) {
+            single_use = false;
+        } else if (def.scope !== self.scope
+            && (def.escaped == 1
+                || has_flag(fixed, INLINED)
+                || within_array_or_object_literal(compressor)
+                || !compressor.option("reduce_funcs"))) {
+            single_use = false;
+        } else if (is_recursive_ref(compressor, def)) {
+            single_use = false;
+        } else if (def.scope !== self.scope || def.orig[0] instanceof AST_SymbolFunarg) {
+            single_use = fixed.is_constant_expression(self.scope);
+            if (single_use == "f") {
+                var scope = self.scope;
+                do {
+                    if (scope instanceof AST_Defun || is_func_expr(scope)) {
+                        set_flag(scope, INLINED);
+                    }
+                } while (scope = scope.parent_scope);
             }
         }
+    }
 
-        if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
-            single_use =
-                def.scope === self.scope
-                    && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
-                || parent instanceof AST_Call
-                    && parent.expression === self
-                    && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
-                    && !(fixed.name && fixed.name.definition().recursive_refs > 0);
-        }
+    if (single_use && (fixed instanceof AST_Lambda || fixed instanceof AST_Class)) {
+        single_use =
+            def.scope === self.scope
+                && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
+            || parent instanceof AST_Call
+                && parent.expression === self
+                && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
+                && !(fixed.name && fixed.name.definition().recursive_refs > 0);
+    }
 
-        if (single_use && fixed) {
-            if (fixed instanceof AST_DefClass) {
-                set_flag(fixed, SQUEEZED);
-                fixed = make_node(AST_ClassExpression, fixed, fixed);
-            }
-            if (fixed instanceof AST_Defun) {
-                set_flag(fixed, SQUEEZED);
-                fixed = make_node(AST_Function, fixed, fixed);
+    if (single_use && fixed) {
+        if (fixed instanceof AST_DefClass) {
+            set_flag(fixed, SQUEEZED);
+            fixed = make_node(AST_ClassExpression, fixed, fixed);
+        }
+        if (fixed instanceof AST_Defun) {
+            set_flag(fixed, SQUEEZED);
+            fixed = make_node(AST_Function, fixed, fixed);
+        }
+        if (def.recursive_refs > 0 && fixed.name instanceof AST_SymbolDefun) {
+            const defun_def = fixed.name.definition();
+            let lambda_def = fixed.variables.get(fixed.name.name);
+            let name = lambda_def && lambda_def.orig[0];
+            if (!(name instanceof AST_SymbolLambda)) {
+                name = make_node(AST_SymbolLambda, fixed.name, fixed.name);
+                name.scope = fixed;
+                fixed.name = name;
+                lambda_def = fixed.def_function(name);
             }
-            if (def.recursive_refs > 0 && fixed.name instanceof AST_SymbolDefun) {
-                const defun_def = fixed.name.definition();
-                let lambda_def = fixed.variables.get(fixed.name.name);
-                let name = lambda_def && lambda_def.orig[0];
-                if (!(name instanceof AST_SymbolLambda)) {
-                    name = make_node(AST_SymbolLambda, fixed.name, fixed.name);
-                    name.scope = fixed;
-                    fixed.name = name;
-                    lambda_def = fixed.def_function(name);
+            walk(fixed, node => {
+                if (node instanceof AST_SymbolRef && node.definition() === defun_def) {
+                    node.thedef = lambda_def;
+                    lambda_def.references.push(node);
                 }
-                walk(fixed, node => {
-                    if (node instanceof AST_SymbolRef && node.definition() === defun_def) {
-                        node.thedef = lambda_def;
-                        lambda_def.references.push(node);
-                    }
-                });
+            });
+        }
+        if (
+            (fixed instanceof AST_Lambda || fixed instanceof AST_Class)
+            && fixed.parent_scope !== nearest_scope
+        ) {
+            fixed = fixed.clone(true, compressor.get_toplevel());
+
+            nearest_scope.add_child_scope(fixed);
+        }
+        return fixed.optimize(compressor);
+    }
+
+    // multiple uses
+    if (fixed) {
+        let replace;
+
+        if (fixed instanceof AST_This) {
+            if (!(def.orig[0] instanceof AST_SymbolFunarg)
+                && def.references.every((ref) =>
+                    def.scope === ref.scope
+                )) {
+                replace = fixed;
             }
+        } else {
+            var ev = fixed.evaluate(compressor);
             if (
-                (fixed instanceof AST_Lambda || fixed instanceof AST_Class)
-                && fixed.parent_scope !== nearest_scope
+                ev !== fixed
+                && (compressor.option("unsafe_regexp") || !(ev instanceof RegExp))
             ) {
-                fixed = fixed.clone(true, compressor.get_toplevel());
-
-                nearest_scope.add_child_scope(fixed);
+                replace = make_node_from_constant(ev, fixed);
             }
-            return fixed.optimize(compressor);
         }
 
-        // multiple uses
-        if (fixed) {
-            let replace;
+        if (replace) {
+            const name_length = self.size(compressor);
+            const replace_size = replace.size(compressor);
 
-            if (fixed instanceof AST_This) {
-                if (!(def.orig[0] instanceof AST_SymbolFunarg)
-                    && def.references.every((ref) =>
-                        def.scope === ref.scope
-                    )) {
-                    replace = fixed;
-                }
-            } else {
-                var ev = fixed.evaluate(compressor);
-                if (
-                    ev !== fixed
-                    && (compressor.option("unsafe_regexp") || !(ev instanceof RegExp))
-                ) {
-                    replace = make_node_from_constant(ev, fixed);
-                }
+            let overhead = 0;
+            if (compressor.option("unused") && !compressor.exposed(def)) {
+                overhead =
+                    (name_length + 2 + replace_size) /
+                    (def.references.length - def.assignments);
             }
 
-            if (replace) {
-                const name_length = self.size(compressor);
-                const replace_size = replace.size(compressor);
-
-                let overhead = 0;
-                if (compressor.option("unused") && !compressor.exposed(def)) {
-                    overhead =
-                        (name_length + 2 + replace_size) /
-                        (def.references.length - def.assignments);
-                }
-
-                if (replace_size <= name_length + overhead) {
-                    return replace;
-                }
+            if (replace_size <= name_length + overhead) {
+                return replace;
             }
         }
     }

package/lib/compress/reduce-vars.js

@@ -103,15 +103,17 @@ import { lazy_op, is_modified } from "./inference.js";
 import { INLINED, clear_flag } from "./compressor-flags.js";
 import { read_property, has_break_or_continue, is_recursive_ref } from "./common.js";
 
-// Define the method AST_Node#reduce_vars, which goes through the AST in
-// execution order to perform basic flow analysis
-
+/**
+ * Define the method AST_Node#reduce_vars, which goes through the AST in
+ * execution order to perform basic flow analysis
+ */
 function def_reduce_vars(node, func) {
     node.DEFMETHOD("reduce_vars", func);
 }
 
 def_reduce_vars(AST_Node, noop);
 
+/** Clear definition properties */
 function reset_def(compressor, def) {
     def.assignments = 0;
     def.chained = false;
@@ -120,7 +122,10 @@ function reset_def(compressor, def) {
     def.recursive_refs = 0;
     def.references = [];
     def.single_use = undefined;
-    if (def.scope.pinned()) {
+    if (
+        def.scope.pinned()
+        || (def.orig[0] instanceof AST_SymbolFunarg && def.scope.uses_arguments)
+    ) {
         def.fixed = false;
     } else if (def.orig[0] instanceof AST_SymbolConst || !compressor.exposed(def)) {
         def.fixed = def.init;
@@ -442,15 +447,23 @@ def_reduce_vars(AST_Default, function(tw, descend) {
 
 function mark_lambda(tw, descend, compressor) {
     clear_flag(this, INLINED);
-    push(tw);
-    reset_variables(tw, compressor, this);
-    if (this.uses_arguments) {
-        descend();
-        pop(tw);
-        return;
+
+    // Sometimes we detach the lambda for safety, and instead of push()
+    // we go to an entirely fresh lineage of safe_ids.
+    let previous_safe_ids;
+    if (this instanceof AST_Defun || this.uses_arguments || this.pinned()) {
+        previous_safe_ids = tw.safe_ids;
+        tw.safe_ids = Object.create(null);
+    } else {
+        push(tw);
     }
+
+    reset_variables(tw, compressor, this);
+
     var iife;
     if (!this.name
+        && !this.uses_arguments
+        && !this.pinned()
         && (iife = tw.parent()) instanceof AST_Call
         && iife.expression === this
         && !iife.args.some(arg => arg instanceof AST_Expansion)
@@ -476,7 +489,13 @@ function mark_lambda(tw, descend, compressor) {
         });
     }
     descend();
-    pop(tw);
+
+    if (previous_safe_ids) {
+        tw.safe_ids = previous_safe_ids;
+    } else {
+        pop(tw);
+    }
+
     return true;
 }
 
@@ -605,7 +624,7 @@ def_reduce_vars(AST_Toplevel, function(tw, descend, compressor) {
 def_reduce_vars(AST_Try, function(tw, descend, compressor) {
     reset_block_variables(compressor, this);
     push(tw);
-    walk_body(this, tw);
+    this.body.walk(tw);
     pop(tw);
     if (this.bcatch) {
         push(tw);

package/lib/compress/tighten-body.js

@@ -52,7 +52,6 @@ import {
     AST_Break,
     AST_Call,
     AST_Case,
-    AST_Catch,
     AST_Chain,
     AST_Class,
     AST_Conditional,
@@ -71,7 +70,6 @@ import {
     AST_Exit,
     AST_Expansion,
     AST_Export,
-    AST_Finally,
     AST_For,
     AST_ForIn,
     AST_If,
@@ -103,6 +101,7 @@ import {
     AST_SymbolVar,
     AST_This,
     AST_Try,
+    AST_TryBlock,
     AST_Unary,
     AST_UnaryPostfix,
     AST_UnaryPrefix,
@@ -234,13 +233,11 @@ export function tighten_body(statements, compressor) {
     function find_loop_scope_try() {
         var node = compressor.self(), level = 0, in_loop = false, in_try = false;
         do {
-            if (node instanceof AST_Catch || node instanceof AST_Finally) {
-                level++;
-            } else if (node instanceof AST_IterationStatement) {
+            if (node instanceof AST_IterationStatement) {
                 in_loop = true;
             } else if (node instanceof AST_Scope) {
                 break;
-            } else if (node instanceof AST_Try) {
+            } else if (node instanceof AST_TryBlock) {
                 in_try = true;
             }
         } while (node = compressor.parent(level++));
@@ -284,6 +281,9 @@ export function tighten_body(statements, compressor) {
                     && (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_Call || node instanceof AST_PropAccess)
+                    && node.optional
                 || node instanceof AST_Debugger
                 || node instanceof AST_Destructuring
                 || node instanceof AST_Expansion
@@ -457,7 +457,11 @@ export function tighten_body(statements, compressor) {
                 var hit = funarg;
                 var abort = false, replaced = 0, can_replace = !args || !hit;
                 if (!can_replace) {
-                    for (var j = compressor.self().argnames.lastIndexOf(candidate.name) + 1; !abort && j < args.length; j++) {
+                    for (
+                        let j = compressor.self().argnames.lastIndexOf(candidate.name) + 1;
+                        !abort && j < args.length;
+                        j++
+                    ) {
                         args[j].transform(scanner);
                     }
                     can_replace = true;

package/lib/equivalent-to.js

@@ -172,7 +172,7 @@ AST_Switch.prototype.shallow_cmp = pass_through;
 AST_SwitchBranch.prototype.shallow_cmp = pass_through;
 
 AST_Try.prototype.shallow_cmp = function(other) {
-    return (this.bcatch == null ? other.bcatch == null : this.bcatch === other.bcatch) && (this.bfinally == null ? other.bfinally == null : this.bfinally === other.bfinally);
+    return (this.body === other.body) && (this.bcatch == null ? other.bcatch == null : this.bcatch === other.bcatch) && (this.bfinally == null ? other.bfinally == null : this.bfinally === other.bfinally);
 };
 
 AST_Catch.prototype.shallow_cmp = function(other) {

package/lib/mozilla-ast.js

@@ -151,6 +151,7 @@ import {
     AST_Toplevel,
     AST_True,
     AST_Try,
+    AST_TryBlock,
     AST_Unary,
     AST_UnaryPostfix,
     AST_UnaryPrefix,
@@ -344,7 +345,7 @@ import { is_basic_identifier_string } from "./parse.js";
             return new AST_Try({
                 start    : my_start_token(M),
                 end      : my_end_token(M),
-                body     : from_moz(M.block).body,
+                body     : new AST_TryBlock(from_moz(M.block)),
                 bcatch   : from_moz(handlers[0]),
                 bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null
             });
@@ -1315,7 +1316,7 @@ import { is_basic_identifier_string } from "./parse.js";
     def_to_moz(AST_Try, function To_Moz_TryStatement(M) {
         return {
             type: "TryStatement",
-            block: to_moz_block(M),
+            block: to_moz_block(M.body),
             handler: to_moz(M.bcatch),
             guardedHandlers: [],
             finalizer: to_moz(M.bfinally)

package/lib/output.js

@@ -143,6 +143,7 @@ import {
     AST_Throw,
     AST_Toplevel,
     AST_Try,
+    AST_TryBlock,
     AST_Unary,
     AST_UnaryPostfix,
     AST_UnaryPrefix,
@@ -1620,7 +1621,7 @@ function OutputStream(options) {
     DEFPRINT(AST_Try, function(self, output) {
         output.print("try");
         output.space();
-        print_braced(self, output);
+        self.body.print(output);
         if (self.bcatch) {
             output.space();
             self.bcatch.print(output);
@@ -1630,6 +1631,9 @@ function OutputStream(options) {
             self.bfinally.print(output);
         }
     });
+    DEFPRINT(AST_TryBlock, function(self, output) {
+        print_braced(self, output);
+    });
     DEFPRINT(AST_Catch, function(self, output) {
         output.print("catch");
         if (self.argname) {