terser 5.0.0-beta.2 → 5.2.1

package/dist/bundle.min.js

@@ -565,6 +565,15 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
 
     function peek() { return get_full_char(S.text, S.pos); }
 
+    // Used because parsing ?. involves a lookahead for a digit
+    function is_option_chain_op() {
+        const must_be_dot = S.text.charCodeAt(S.pos + 1) === 46;
+        if (!must_be_dot) return false;
+
+        const cannot_be_digit = S.text.charCodeAt(S.pos + 2);
+        return cannot_be_digit < 48 || cannot_be_digit > 57;
+    }
+
     function next(signal_eof, in_string) {
         var ch = get_full_char(S.text, S.pos++);
         if (signal_eof && !ch)
@@ -625,7 +634,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
                            (type == "keyword" && KEYWORDS_BEFORE_EXPRESSION.has(value)) ||
                            (type == "punc" && PUNC_BEFORE_EXPRESSION.has(value))) ||
                            (type == "arrow");
-        if (type == "punc" && value == ".") {
+        if (type == "punc" && (value == "." || value == "?.")) {
             prev_was_dot = true;
         } else if (!is_comment) {
             prev_was_dot = false;
@@ -672,12 +681,14 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
     }
 
     function read_num(prefix) {
-        var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".", is_big_int = false;
+        var has_e = false, after_e = false, has_x = false, has_dot = prefix == ".", is_big_int = false, numeric_separator = false;
         var num = read_while(function(ch, i) {
             if (is_big_int) return false;
 
             var code = ch.charCodeAt(0);
             switch (code) {
+              case 95: // _
+                return (numeric_separator = true);
               case 98: case 66: // bB
                 return (has_x = true); // Can occur in hex sequence, don't return false yet
               case 111: case 79: // oO
@@ -705,6 +716,14 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         if (RE_OCT_NUMBER.test(num) && next_token.has_directive("use strict")) {
             parse_error("Legacy octal literals are not allowed in strict mode");
         }
+        if (numeric_separator) {
+            if (num.endsWith("_")) {
+                parse_error("Numeric separators are not allowed at the end of numeric literals");
+            } else if (num.includes("__")) {
+                parse_error("Only one underscore is allowed as numeric separator");
+            }
+            num = num.replace(/_/g, "");
+        }
         if (num.endsWith("n")) {
             const without_n = num.slice(0, -1);
             const allow_e = RE_HEX_NUMBER.test(without_n);
@@ -1051,6 +1070,14 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
                   return tok;
               }
               case 61: return handle_eq_sign();
+              case 63: {
+                  if (!is_option_chain_op()) break;  // Handled below
+
+                  next(); // ?
+                  next(); // .
+
+                  return token("punc", "?.");
+              }
               case 96: return read_template_characters(true);
               case 123:
                 S.brace_counter++;
@@ -1169,7 +1196,7 @@ function parse($TEXT, options) {
 
     options = defaults(options, {
         bare_returns   : false,
-        ecma           : 2017,
+        ecma           : null,  // Legacy
         expression     : false,
         filename       : null,
         html5_comments : true,
@@ -1277,7 +1304,7 @@ function parse($TEXT, options) {
     }
 
     function embed_tokens(parser) {
-        return function(...args) {
+        return function _embed_tokens_wrapper(...args) {
             const start = S.token;
             const expr = parser(...args);
             expr.start = start;
@@ -1293,7 +1320,7 @@ function parse($TEXT, options) {
         }
     }
 
-    var statement = embed_tokens(function(is_export_default, is_for_body, is_if_body) {
+    var statement = embed_tokens(function statement(is_export_default, is_for_body, is_if_body) {
         handle_regexp();
         switch (S.token.type) {
           case "string":
@@ -1328,7 +1355,7 @@ function parse($TEXT, options) {
                 }
                 return function_(AST_Defun, false, true, is_export_default);
             }
-            if (S.token.value == "import" && !is_token(peek(), "punc", "(")) {
+            if (S.token.value == "import" && !is_token(peek(), "punc", "(") && !is_token(peek(), "punc", ".")) {
                 next();
                 var node = import_();
                 semicolon();
@@ -1749,7 +1776,6 @@ function parse($TEXT, options) {
 
             if (!is("punc", ")")) {
                 expect(",");
-                if (is("punc", ")") && options.ecma < 2017) unexpected();
             }
 
             if (param instanceof AST_Expansion) {
@@ -1994,7 +2020,6 @@ function parse($TEXT, options) {
             if (!is("punc", ")")) {
                 expect(",");
                 if (is("punc", ")")) {
-                    if (options.ecma < 2017) unexpected();
                     trailing_comma = prev();
                     if (maybe_sequence) invalid_sequence = trailing_comma;
                 }
@@ -2263,7 +2288,7 @@ function parse($TEXT, options) {
         var newexp = expr_atom(false), args;
         if (is("punc", "(")) {
             next();
-            args = expr_list(")", options.ecma >= 2017);
+            args = expr_list(")", true);
         } else {
             args = [];
         }
@@ -2376,6 +2401,9 @@ function parse($TEXT, options) {
         if (is("operator", "new")) {
             return new_(allow_calls);
         }
+        if (is("operator", "import")) {
+            return import_meta();
+        }
         var start = S.token;
         var peeked;
         var async = is("name", "async")
@@ -2753,6 +2781,7 @@ function parse($TEXT, options) {
 
     function import_() {
         var start = prev();
+
         var imported_name;
         var imported_names;
         if (is("name")) {
@@ -2787,6 +2816,17 @@ function parse($TEXT, options) {
         });
     }
 
+    function import_meta() {
+        var start = S.token;
+        expect_token("operator", "import");
+        expect_token("punc", ".");
+        expect_token("name", "meta");
+        return subscripts(new AST_ImportMeta({
+            start: start,
+            end: prev()
+        }), false);
+    }
+
     function map_name(is_import) {
         function make_symbol(type) {
             return new type({
@@ -2967,15 +3007,6 @@ function parse($TEXT, options) {
             }
             /* falls through */
           case "name":
-            if (tmp.value == "yield") {
-                if (is_in_generator()) {
-                    token_error(tmp, "Yield cannot be used as identifier inside generators");
-                } else if (!is_token(peek(), "punc", ":")
-                    && !is_token(peek(), "punc", "(")
-                    && S.input.has_directive("use strict")) {
-                    token_error(tmp, "Unexpected yield identifier inside strict mode");
-                }
-            }
           case "string":
           case "num":
           case "big_int":
@@ -3057,16 +3088,17 @@ function parse($TEXT, options) {
         }
     }
 
-    var subscripts = function(expr, allow_calls) {
+    var subscripts = function(expr, allow_calls, is_chain) {
         var start = expr.start;
         if (is("punc", ".")) {
             next();
             return subscripts(new AST_Dot({
                 start      : start,
                 expression : expr,
+                optional   : false,
                 property   : as_name(),
                 end        : prev()
-            }), allow_calls);
+            }), allow_calls, is_chain);
         }
         if (is("punc", "[")) {
             next();
@@ -3075,22 +3107,80 @@ function parse($TEXT, options) {
             return subscripts(new AST_Sub({
                 start      : start,
                 expression : expr,
+                optional   : false,
                 property   : prop,
                 end        : prev()
-            }), allow_calls);
+            }), allow_calls, is_chain);
         }
         if (allow_calls && is("punc", "(")) {
             next();
             var call = new AST_Call({
                 start      : start,
                 expression : expr,
+                optional   : false,
                 args       : call_args(),
                 end        : prev()
             });
             annotate(call);
-            return subscripts(call, true);
+            return subscripts(call, true, is_chain);
+        }
+
+        if (is("punc", "?.")) {
+            next();
+
+            let chain_contents;
+
+            if (allow_calls && is("punc", "(")) {
+                next();
+
+                const call = new AST_Call({
+                    start,
+                    optional: true,
+                    expression: expr,
+                    args: call_args(),
+                    end: prev()
+                });
+                annotate(call);
+
+                chain_contents = subscripts(call, true, true);
+            } else if (is("name")) {
+                chain_contents = subscripts(new AST_Dot({
+                    start,
+                    expression: expr,
+                    optional: true,
+                    property: as_name(),
+                    end: prev()
+                }), allow_calls, true);
+            } else if (is("punc", "[")) {
+                next();
+                const property = expression(true);
+                expect("]");
+                chain_contents = subscripts(new AST_Sub({
+                    start,
+                    expression: expr,
+                    optional: true,
+                    property,
+                    end: prev()
+                }), allow_calls, true);
+            }
+
+            if (!chain_contents) unexpected();
+
+            if (chain_contents instanceof AST_Chain) return chain_contents;
+
+            return new AST_Chain({
+                start,
+                expression: chain_contents,
+                end: prev()
+            });
         }
+
         if (is("template_head")) {
+            if (is_chain) {
+                // a?.b`c` is a syntax error
+                unexpected();
+            }
+
             return subscripts(new AST_PrefixedTemplateString({
                 start: start,
                 prefix: expr,
@@ -3098,6 +3188,7 @@ function parse($TEXT, options) {
                 end: prev()
             }), allow_calls);
         }
+
         return expr;
     };
 
@@ -3116,7 +3207,6 @@ function parse($TEXT, options) {
             }
             if (!is("punc", ")")) {
                 expect(",");
-                if (is("punc", ")") && options.ecma < 2017) unexpected();
             }
         }
         next();
@@ -3320,13 +3410,14 @@ function parse($TEXT, options) {
         return expression(true);
     }
 
-    return (function() {
+    return (function parse_toplevel() {
         var start = S.token;
         var body = [];
         S.input.push_directives_stack();
         if (options.module) S.input.add_directive("use strict");
-        while (!is("eof"))
+        while (!is("eof")) {
             body.push(statement());
+        }
         S.input.pop_directives_stack();
         var end = prev();
         var toplevel = options.toplevel;
@@ -3861,7 +3952,7 @@ var AST_PrefixedTemplateString = DEFNODE("PrefixedTemplateString", "template_str
     $documentation: "A templatestring with a prefix, such as String.raw`foobarbaz`",
     $propdoc: {
         template_string: "[AST_TemplateString] The template string",
-        prefix: "[AST_SymbolRef|AST_PropAccess] The prefix, which can be a symbol such as `foo` or a dotted expression such as `String.raw`."
+        prefix: "[AST_Node] The prefix, which will get called."
     },
     _walk: function(visitor) {
         return visitor._visit(this, function () {
@@ -4198,6 +4289,10 @@ var AST_Import = DEFNODE("Import", "imported_name imported_names module_name", {
     },
 });
 
+var AST_ImportMeta = DEFNODE("ImportMeta", null, {
+    $documentation: "A reference to import.meta",
+});
+
 var AST_Export = DEFNODE("Export", "exported_definition exported_value is_default exported_names module_name", {
     $documentation: "An `export` statement",
     $propdoc: {
@@ -4238,11 +4333,12 @@ var AST_Export = DEFNODE("Export", "exported_definition exported_value is_defaul
 
 /* -----[ OTHER ]----- */
 
-var AST_Call = DEFNODE("Call", "expression args _annotations", {
+var AST_Call = DEFNODE("Call", "expression args optional _annotations", {
     $documentation: "A function call expression",
     $propdoc: {
         expression: "[AST_Node] expression to invoke as function",
         args: "[AST_Node*] array of arguments",
+        optional: "[boolean] whether this is an optional call (IE ?.() )",
         _annotations: "[number] bitfield containing information about the call"
     },
     initialize() {
@@ -4286,11 +4382,13 @@ var AST_Sequence = DEFNODE("Sequence", "expressions", {
     },
 });
 
-var AST_PropAccess = DEFNODE("PropAccess", "expression property", {
+var AST_PropAccess = DEFNODE("PropAccess", "expression property optional", {
     $documentation: "Base class for property access expressions, i.e. `a.foo` or `a[\"foo\"]`",
     $propdoc: {
         expression: "[AST_Node] the “container” expression",
-        property: "[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node"
+        property: "[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node",
+
+        optional: "[boolean] whether this is an optional property access (IE ?.)"
     }
 });
 
@@ -4323,6 +4421,21 @@ var AST_Sub = DEFNODE("Sub", null, {
     },
 }, AST_PropAccess);
 
+var AST_Chain = DEFNODE("Chain", "expression", {
+    $documentation: "A chain expression like a?.b?.(c)?.[d]",
+    $propdoc: {
+        expression: "[AST_Call|AST_Dot|AST_Sub] chain element."
+    },
+    _walk: function (visitor) {
+        return visitor._visit(this, function() {
+            this.expression._walk(visitor);
+        });
+    },
+    _children_backwards(push) {
+        push(this.expression);
+    },
+});
+
 var AST_Unary = DEFNODE("Unary", "operator expression", {
     $documentation: "Base class for unary expressions",
     $propdoc: {
@@ -4945,6 +5058,7 @@ AST_Break: AST_Break,
 AST_Call: AST_Call,
 AST_Case: AST_Case,
 AST_Catch: AST_Catch,
+AST_Chain: AST_Chain,
 AST_Class: AST_Class,
 AST_ClassExpression: AST_ClassExpression,
 AST_ClassProperty: AST_ClassProperty,
@@ -4977,6 +5091,7 @@ AST_Function: AST_Function,
 AST_Hole: AST_Hole,
 AST_If: AST_If,
 AST_Import: AST_Import,
+AST_ImportMeta: AST_ImportMeta,
 AST_Infinity: AST_Infinity,
 AST_IterationStatement: AST_IterationStatement,
 AST_Jump: AST_Jump,
@@ -5632,7 +5747,15 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 start      : my_start_token(M),
                 end        : my_end_token(M),
                 property   : M.computed ? from_moz(M.property) : M.property.name,
-                expression : from_moz(M.object)
+                expression : from_moz(M.object),
+                optional   : M.optional || false
+            });
+        },
+        ChainExpression: function(M) {
+            return new AST_Chain({
+                start      : my_start_token(M),
+                end        : my_end_token(M),
+                expression : from_moz(M.expression)
             });
         },
         SwitchCase: function(M) {
@@ -5759,6 +5882,11 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                     start: my_start_token(M),
                     end: my_end_token(M)
                 });
+            } else if (M.meta.name === "import" && M.property.name === "meta") {
+                return new AST_ImportMeta({
+                    start: my_start_token(M),
+                    end: my_end_token(M)
+                });
             }
         },
         Identifier: function(M) {
@@ -5843,7 +5971,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
     map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
     map("ConditionalExpression", AST_Conditional, "test>condition, consequent>consequent, alternate>alternative");
     map("NewExpression", AST_New, "callee>expression, arguments@args");
-    map("CallExpression", AST_Call, "callee>expression, arguments@args");
+    map("CallExpression", AST_Call, "callee>expression, optional=optional, arguments@args");
 
     def_to_moz(AST_Toplevel, function To_Moz_Program(M) {
         return to_moz_scope("Program", M);
@@ -6050,6 +6178,20 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         };
     });
 
+    def_to_moz(AST_ImportMeta, function To_Moz_MetaProperty() {
+        return {
+            type: "MetaProperty",
+            meta: {
+                type: "Identifier",
+                name: "import"
+            },
+            property: {
+                type: "Identifier",
+                name: "meta"
+            }
+        };
+    });
+
     def_to_moz(AST_Sequence, function To_Moz_SequenceExpression(M) {
         return {
             type: "SequenceExpression",
@@ -6063,7 +6205,15 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             type: "MemberExpression",
             object: to_moz(M.expression),
             computed: isComputed,
-            property: isComputed ? to_moz(M.property) : {type: "Identifier", name: M.property}
+            property: isComputed ? to_moz(M.property) : {type: "Identifier", name: M.property},
+            optional: M.optional
+        };
+    });
+
+    def_to_moz(AST_Chain, function To_Moz_ChainExpression(M) {
+        return {
+            type: "ChainExpression",
+            expression: to_moz(M.expression)
         };
     });
 
@@ -7275,8 +7425,8 @@ function OutputStream(options) {
         return p instanceof AST_PropAccess && p.expression === this;
     });
 
-    // same goes for an object literal, because otherwise it would be
-    // interpreted as a block of code.
+    // same goes for an object literal (as in AST_Function), because
+    // otherwise {...} would be interpreted as a block of code.
     PARENS(AST_Object, function(output) {
         return !output.has_parens() && first_in_statement(output);
     });
@@ -7792,6 +7942,8 @@ function OutputStream(options) {
             || e instanceof AST_PropAccess
             || e instanceof AST_Unary
             || e instanceof AST_Constant
+            || e instanceof AST_Await
+            || e instanceof AST_Object
         );
         if (parens) output.print("(");
         self.expression.print(output);
@@ -7989,6 +8141,9 @@ function OutputStream(options) {
         self.module_name.print(output);
         output.semicolon();
     });
+    DEFPRINT(AST_ImportMeta, function(self, output) {
+        output.print("import.meta");
+    });
 
     DEFPRINT(AST_NameMapping, function(self, output) {
         var is_import = output.parent() instanceof AST_Import;
@@ -8095,6 +8250,7 @@ function OutputStream(options) {
         if (self.expression instanceof AST_Call || self.expression instanceof AST_Lambda) {
             output.add_mapping(self.start);
         }
+        if (self.optional) output.print("?.");
         output.with_parens(function() {
             self.args.forEach(function(expr, i) {
                 if (i) output.comma();
@@ -8138,6 +8294,9 @@ function OutputStream(options) {
         var print_computed = RESERVED_WORDS.has(prop)
             ? output.option("ie8")
             : !is_identifier_string(prop, output.option("ecma") >= 2015);
+
+        if (self.optional) output.print("?.");
+
         if (print_computed) {
             output.print("[");
             output.add_mapping(self.end);
@@ -8149,7 +8308,7 @@ function OutputStream(options) {
                     output.print(".");
                 }
             }
-            output.print(".");
+            if (!self.optional) output.print(".");
             // the name after dot would be mapped about here.
             output.add_mapping(self.end);
             output.print_name(prop);
@@ -8157,10 +8316,14 @@ function OutputStream(options) {
     });
     DEFPRINT(AST_Sub, function(self, output) {
         self.expression.print(output);
+        if (self.optional) output.print("?.");
         output.print("[");
         self.property.print(output);
         output.print("]");
     });
+    DEFPRINT(AST_Chain, function(self, output) {
+        self.expression.print(output);
+    });
     DEFPRINT(AST_UnaryPrefix, function(self, output) {
         var op = self.operator;
         output.print(op);
@@ -8716,6 +8879,8 @@ AST_Import.prototype.shallow_cmp = mkshallow({
     imported_names: "exist"
 });
 
+AST_ImportMeta.prototype.shallow_cmp = pass_through;
+
 AST_Export.prototype.shallow_cmp = mkshallow({
     exported_definition: "exist",
     exported_value: "exist",
@@ -9702,7 +9867,7 @@ const base54 = (() => {
 
 let mangle_options = undefined;
 AST_Node.prototype.size = function (compressor, stack) {
-    mangle_options = undefined; // TODO get mangle_options somehow
+    mangle_options = compressor && compressor.mangle_options;
 
     let size = 0;
     walk_parent(this, (node, info) => {
@@ -9780,7 +9945,7 @@ AST_Arrow.prototype._size = function () {
         args_and_arrow += 2;
     }
 
-    return lambda_modifiers(this) + args_and_arrow + Array.isArray(this.body) ? list_overhead(this.body) : this.body._size();
+    return lambda_modifiers(this) + args_and_arrow + (Array.isArray(this.body) ? list_overhead(this.body) : this.body._size());
 };
 
 AST_Destructuring.prototype._size = () => 2;
@@ -9878,6 +10043,8 @@ AST_Import.prototype._size = function () {
     return size;
 };
 
+AST_ImportMeta.prototype._size = () => 11;
+
 AST_Export.prototype._size = function () {
     let size = 7 + (this.is_default ? 8 : 0);
 
@@ -9899,6 +10066,9 @@ AST_Export.prototype._size = function () {
 };
 
 AST_Call.prototype._size = function () {
+    if (this.optional) {
+        return 4 + list_overhead(this.args);
+    }
     return 2 + list_overhead(this.args);
 };
 
@@ -9911,10 +10081,15 @@ AST_Sequence.prototype._size = function () {
 };
 
 AST_Dot.prototype._size = function () {
+    if (this.optional) {
+        return this.property.length + 2;
+    }
     return this.property.length + 1;
 };
 
-AST_Sub.prototype._size = () => 2;
+AST_Sub.prototype._size = function () {
+    return this.optional ? 4 : 2;
+};
 
 AST_Unary.prototype._size = function () {
     if (this.operator === "typeof") return 7;
@@ -9997,7 +10172,7 @@ AST_ClassProperty.prototype._size = function () {
 AST_Symbol.prototype._size = function () {
     return !mangle_options || this.definition().unmangleable(mangle_options)
         ? this.name.length
-        : 2;
+        : 1;
 };
 
 // TODO take propmangle into account
@@ -10012,7 +10187,7 @@ AST_SymbolRef.prototype._size = AST_SymbolDeclaration.prototype._size = function
 
     if (name === "arguments") return 9;
 
-    return 2;
+    return AST_Symbol.prototype._size.call(this);
 };
 
 AST_NewTarget.prototype._size = () => 10;
@@ -10134,7 +10309,7 @@ const set_flag = (node, flag) => { node.flags |= flag; };
 const clear_flag = (node, flag) => { node.flags &= ~flag; };
 
 class Compressor extends TreeWalker {
-    constructor(options, false_by_default) {
+    constructor(options, { false_by_default = false, mangle_options = false }) {
         super();
         if (options.defaults !== undefined && !options.defaults) false_by_default = true;
         this.options = defaults(options, {
@@ -10192,7 +10367,7 @@ class Compressor extends TreeWalker {
             unsafe_regexp : false,
             unsafe_undefined: false,
             unused        : !false_by_default,
-            warnings      : false,  // legacy
+            warnings      : false  // legacy
         }, true);
         var global_defs = this.options["global_defs"];
         if (typeof global_defs == "object") for (var key in global_defs) {
@@ -10242,6 +10417,7 @@ class Compressor extends TreeWalker {
         this.sequences_limit = sequences == 1 ? 800 : sequences | 0;
         this.evaluated_regexps = new Map();
         this._toplevel = undefined;
+        this.mangle_options = mangle_options;
     }
 
     option(key) {
@@ -10710,13 +10886,53 @@ function is_modified(compressor, tw, node, value, level, immutable) {
         pop(tw);
         return true;
     });
+
+    def_reduce_vars(AST_Chain, function(tw, descend) {
+        // Chains' conditions apply left-to-right, cumulatively.
+        // If we walk normally we don't go in that order because we would pop before pushing again
+        // Solution: AST_PropAccess and AST_Call push when they are optional, and never pop.
+        // Then we pop everything when they are done being walked.
+        const safe_ids = tw.safe_ids;
+
+        descend();
+
+        // Unroll back to start
+        tw.safe_ids = safe_ids;
+        return true;
+    });
+    def_reduce_vars(AST_Call, function (tw) {
+        // TODO this block should just be { return } but
+        // for some reason the _walk function of AST_Call walks the callee last
+
+        this.expression.walk(tw);
+
+        if (this.optional) {
+            // Never pop -- it's popped at AST_Chain above
+            push(tw);
+        }
+
+        for (const arg of this.args) arg.walk(tw);
+
+        return true;
+    });
+    def_reduce_vars(AST_PropAccess, function (tw) {
+        if (!this.optional) return;
+
+        this.expression.walk(tw);
+
+        // Never pop -- it's popped at AST_Chain above
+        push(tw);
+
+        if (this.property instanceof AST_Node) this.property.walk(tw);
+
+        return true;
+    });
     def_reduce_vars(AST_Default, function(tw, descend) {
         push(tw);
         descend();
         pop(tw);
         return true;
     });
-
     function mark_lambda(tw, descend, compressor) {
         clear_flag(this, INLINED);
         push(tw);
@@ -11546,8 +11762,7 @@ function tighten_body(statements, compressor) {
                 extract_candidates(expr.condition);
                 extract_candidates(expr.consequent);
                 extract_candidates(expr.alternative);
-            } else if (expr instanceof AST_Definitions
-                && (compressor.option("unused") || !(expr instanceof AST_Const))) {
+            } else if (expr instanceof AST_Definitions) {
                 var len = expr.definitions.length;
                 // limit number of trailing variable definitions for consideration
                 var i = len - 200;
@@ -11715,7 +11930,9 @@ function tighten_body(statements, compressor) {
                 if (node === expr || node.body === expr) {
                     found = true;
                     if (node instanceof AST_VarDef) {
-                        node.value = null;
+                        node.value = node.name instanceof AST_SymbolConst
+                             ? make_node(AST_Undefined, node.value)  // `const` always needs value.
+                             : null;
                         return node;
                     }
                     return in_list ? MAP.skip : null;
@@ -12031,7 +12248,7 @@ function tighten_body(statements, compressor) {
         statements.length = n;
         CHANGED = n != len;
         if (has_quit) has_quit.forEach(function(stat) {
-            extract_declarations_from_unreachable_code(compressor, stat, statements);
+            trim_unreachable_code(compressor, stat, statements);
         });
     }
 
@@ -12289,7 +12506,7 @@ function tighten_body(statements, compressor) {
     }
 }
 
-function extract_declarations_from_unreachable_code(compressor, stat, target) {
+function trim_unreachable_code(compressor, stat, target) {
     walk(stat, node => {
         if (node instanceof AST_Var) {
             node.remove_initializers();
@@ -12310,6 +12527,10 @@ function extract_declarations_from_unreachable_code(compressor, stat, target) {
             }));
             return true;
         }
+        if (node instanceof AST_Export || node instanceof AST_Import) {
+            target.push(node);
+            return true;
+        }
         if (node instanceof AST_Scope) {
             return true;
         }
@@ -12361,6 +12582,10 @@ function is_undefined(node, compressor) {
             if (this.properties[i]._dot_throw(compressor)) return true;
         return false;
     });
+    // Do not be as strict with classes as we are with objects.
+    // Hopefully the community is not going to abuse static getters and setters.
+    // https://github.com/terser/terser/issues/724#issuecomment-643655656
+    def_may_throw_on_access(AST_Class, return_false);
     def_may_throw_on_access(AST_ObjectProperty, return_false);
     def_may_throw_on_access(AST_ObjectGetter, return_true);
     def_may_throw_on_access(AST_Expansion, function(compressor) {
@@ -12389,11 +12614,15 @@ function is_undefined(node, compressor) {
         if (this.expression instanceof AST_Function && this.property == "prototype") return false;
         return true;
     });
+    def_may_throw_on_access(AST_Chain, function(compressor) {
+        return this.expression._dot_throw(compressor);
+    });
     def_may_throw_on_access(AST_Sequence, function(compressor) {
         return this.tail_node()._dot_throw(compressor);
     });
     def_may_throw_on_access(AST_SymbolRef, function(compressor) {
-        if (is_undefined(this, compressor)) return true;
+        if (this.name === "arguments") return false;
+        if (has_flag(this, UNDEFINED)) return true;
         if (!is_strict(compressor)) return false;
         if (is_undeclared_ref(this) && this.is_declared(compressor)) return false;
         if (this.is_immutable()) return false;
@@ -12538,6 +12767,9 @@ function is_lhs(node, parent) {
         }));
     });
     def_find_defs(AST_Node, noop);
+    def_find_defs(AST_Chain, function(compressor, suffix) {
+        return this.expression._find_defs(compressor, suffix);
+    });
     def_find_defs(AST_Dot, function(compressor, suffix) {
         return this.expression._find_defs(compressor, "." + this.property + suffix);
     });
@@ -12795,13 +13027,33 @@ var static_fns = convert_to_predicate({
         return this;
     });
     var non_converting_binary = makePredicate("&& || ?? === !==");
+    const identity_comparison = makePredicate("== != === !==");
+    const has_identity = value =>
+        typeof value === "object"
+        || typeof value === "function"
+        || typeof value === "symbol";
+
     def_eval(AST_Binary, function(compressor, depth) {
         if (!non_converting_binary.has(this.operator)) depth++;
+
         var left = this.left._eval(compressor, depth);
         if (left === this.left) return this;
         var right = this.right._eval(compressor, depth);
         if (right === this.right) return this;
         var result;
+
+        if (
+            left != null
+            && right != null
+            && identity_comparison.has(this.operator)
+            && has_identity(left)
+            && has_identity(right)
+            && typeof left === typeof right
+        ) {
+            // Do not compare by reference
+            return this;
+        }
+
         switch (this.operator) {
           case "&&"  : result = left &&  right; break;
           case "||"  : result = left ||  right; break;
@@ -12842,34 +13094,29 @@ var static_fns = convert_to_predicate({
         var value = node._eval(compressor, depth);
         return value === node ? this : value;
     });
+
+    // Set of AST_SymbolRef which are currently being evaluated.
+    // Avoids infinite recursion of ._eval()
+    const reentrant_ref_eval = new Set();
     def_eval(AST_SymbolRef, function(compressor, depth) {
+        if (reentrant_ref_eval.has(this)) return this;
+
         var fixed = this.fixed_value();
         if (!fixed) return this;
-        var value;
-        if (HOP(fixed, "_eval")) {
-            value = fixed._eval();
-        } else {
-            this._eval = return_this;
-            value = fixed._eval(compressor, depth);
-            delete this._eval;
-            if (value === fixed) return this;
-            fixed._eval = function() {
-                return value;
-            };
-        }
+
+        reentrant_ref_eval.add(this);
+        const value = fixed._eval(compressor, depth);
+        reentrant_ref_eval.delete(this);
+
+        if (value === fixed) return this;
+
         if (value && typeof value == "object") {
             var escaped = this.definition().escaped;
             if (escaped && depth > escaped) return this;
         }
         return value;
     });
-    var global_objs = {
-        Array: Array,
-        Math: Math,
-        Number: Number,
-        Object: Object,
-        String: String,
-    };
+    var global_objs = { Array, Math, Number, Object, String };
     var static_values = convert_to_predicate({
         Math: [
             "E",
@@ -12890,6 +13137,10 @@ var static_fns = convert_to_predicate({
         ],
     });
     def_eval(AST_PropAccess, function(compressor, depth) {
+        if (this.optional) {
+            const obj = this.expression._eval(compressor, depth);
+            if (obj == null) return undefined;
+        }
         if (compressor.option("unsafe")) {
             var key = this.property;
             if (key instanceof AST_Node) {
@@ -12931,8 +13182,15 @@ var static_fns = convert_to_predicate({
         }
         return this;
     });
+    def_eval(AST_Chain, function(compressor, depth) {
+        return this.expression._eval(compressor, depth);
+    });
     def_eval(AST_Call, function(compressor, depth) {
         var exp = this.expression;
+        if (this.optional) {
+            const callee = this.expression._eval(compressor, depth);
+            if (callee == null) return undefined;
+        }
         if (compressor.option("unsafe") && exp instanceof AST_PropAccess) {
             var key = exp.property;
             if (key instanceof AST_Node) {
@@ -13134,9 +13392,11 @@ const pure_prop_access_globals = new Set([
         return any(this.body, compressor);
     });
     def_has_side_effects(AST_Call, function(compressor) {
-        if (!this.is_expr_pure(compressor)
+        if (
+            !this.is_expr_pure(compressor)
             && (!this.expression.is_call_pure(compressor)
-                || this.expression.has_side_effects(compressor))) {
+                || this.expression.has_side_effects(compressor))
+        ) {
             return true;
         }
         return any(this.args, compressor);
@@ -13219,14 +13479,21 @@ const pure_prop_access_globals = new Set([
         return any(this.elements, compressor);
     });
     def_has_side_effects(AST_Dot, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
+        return !this.optional && this.expression.may_throw_on_access(compressor)
             || this.expression.has_side_effects(compressor);
     });
     def_has_side_effects(AST_Sub, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
+        if (this.optional && is_nullish(this.expression)) {
+            return false;
+        }
+
+        return !this.optional && this.expression.may_throw_on_access(compressor)
             || this.expression.has_side_effects(compressor)
             || this.property.has_side_effects(compressor);
     });
+    def_has_side_effects(AST_Chain, function (compressor) {
+        return this.expression.has_side_effects(compressor);
+    });
     def_has_side_effects(AST_Sequence, function(compressor) {
         return any(this.expressions, compressor);
     });
@@ -13286,6 +13553,7 @@ const pure_prop_access_globals = new Set([
         return any(this.body, compressor);
     });
     def_may_throw(AST_Call, function(compressor) {
+        if (this.optional && is_nullish(this.expression)) return false;
         if (any(this.args, compressor)) return true;
         if (this.is_expr_pure(compressor)) return false;
         if (this.expression.may_throw(compressor)) return true;
@@ -13304,10 +13572,6 @@ const pure_prop_access_globals = new Set([
     def_may_throw(AST_Definitions, function(compressor) {
         return any(this.definitions, compressor);
     });
-    def_may_throw(AST_Dot, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
-            || this.expression.may_throw(compressor);
-    });
     def_may_throw(AST_If, function(compressor) {
         return this.condition.may_throw(compressor)
             || this.body && this.body.may_throw(compressor)
@@ -13347,11 +13611,20 @@ const pure_prop_access_globals = new Set([
     def_may_throw(AST_SimpleStatement, function(compressor) {
         return this.body.may_throw(compressor);
     });
+    def_may_throw(AST_Dot, function(compressor) {
+        return !this.optional && this.expression.may_throw_on_access(compressor)
+            || this.expression.may_throw(compressor);
+    });
     def_may_throw(AST_Sub, function(compressor) {
-        return this.expression.may_throw_on_access(compressor)
+        if (this.optional && is_nullish(this.expression)) return false;
+
+        return !this.optional && this.expression.may_throw_on_access(compressor)
             || this.expression.may_throw(compressor)
             || this.property.may_throw(compressor);
     });
+    def_may_throw(AST_Chain, function(compressor) {
+        return this.expression.may_throw(compressor);
+    });
     def_may_throw(AST_Switch, function(compressor) {
         return this.expression.may_throw(compressor)
             || any(this.body, compressor);
@@ -13509,9 +13782,9 @@ def_optimize(AST_Block, function(self, compressor) {
 
 function can_be_extracted_from_if_block(node) {
     return !(
-        node instanceof AST_Const ||
-        node instanceof AST_Let ||
-        node instanceof AST_Class
+        node instanceof AST_Const
+        || node instanceof AST_Let
+        || node instanceof AST_Class
     );
 }
 
@@ -14145,6 +14418,10 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
     def_drop_side_effect_free(AST_Constant, return_null);
     def_drop_side_effect_free(AST_This, return_null);
     def_drop_side_effect_free(AST_Call, function(compressor, first_in_statement) {
+        if (this.optional && is_nullish(this.expression)) {
+            return make_node(AST_Undefined, this);
+        }
+
         if (!this.is_expr_pure(compressor)) {
             if (this.expression.is_call_pure(compressor)) {
                 var exprs = this.args.slice();
@@ -14285,17 +14562,28 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
         return values && make_sequence(this, values);
     });
     def_drop_side_effect_free(AST_Dot, function(compressor, first_in_statement) {
+        if (this.optional) {
+            return is_nullish(this.expression) ? make_node(AST_Undefined, this) : this;
+        }
         if (this.expression.may_throw_on_access(compressor)) return this;
+
         return this.expression.drop_side_effect_free(compressor, first_in_statement);
     });
     def_drop_side_effect_free(AST_Sub, function(compressor, first_in_statement) {
+        if (this.optional) {
+            return is_nullish(this.expression) ? make_node(AST_Undefined, this): this;
+        }
         if (this.expression.may_throw_on_access(compressor)) return this;
+
         var expression = this.expression.drop_side_effect_free(compressor, first_in_statement);
         if (!expression) return this.property.drop_side_effect_free(compressor, first_in_statement);
         var property = this.property.drop_side_effect_free(compressor);
         if (!property) return expression;
         return make_sequence(this, [ expression, property ]);
     });
+    def_drop_side_effect_free(AST_Chain, function (compressor, first_in_statement) {
+        return this.expression.drop_side_effect_free(compressor, first_in_statement);
+    });
     def_drop_side_effect_free(AST_Sequence, function(compressor) {
         var last = this.tail_node();
         var expr = last.drop_side_effect_free(compressor);
@@ -14395,7 +14683,7 @@ function if_break_in_loop(self, compressor) {
                 body: self.condition
             }));
         }
-        extract_declarations_from_unreachable_code(compressor, self.body, body);
+        trim_unreachable_code(compressor, self.body, body);
         return make_node(AST_BlockStatement, self, {
             body: body
         });
@@ -14466,7 +14754,7 @@ def_optimize(AST_For, function(self, compressor) {
             if (cond instanceof AST_Node) cond = self.condition.tail_node().evaluate(compressor);
             if (!cond) {
                 var body = [];
-                extract_declarations_from_unreachable_code(compressor, self.body, body);
+                trim_unreachable_code(compressor, self.body, body);
                 if (self.init instanceof AST_Statement) {
                     body.push(self.init);
                 } else if (self.init) {
@@ -14502,7 +14790,7 @@ def_optimize(AST_If, function(self, compressor) {
         if (cond instanceof AST_Node) cond = self.condition.tail_node().evaluate(compressor);
         if (!cond) {
             var body = [];
-            extract_declarations_from_unreachable_code(compressor, self.body, body);
+            trim_unreachable_code(compressor, self.body, body);
             body.push(make_node(AST_SimpleStatement, self.condition, {
                 body: self.condition
             }));
@@ -14515,7 +14803,7 @@ def_optimize(AST_If, function(self, compressor) {
             }));
             body.push(self.body);
             if (self.alternative) {
-                extract_declarations_from_unreachable_code(compressor, self.alternative, body);
+                trim_unreachable_code(compressor, self.alternative, body);
             }
             return make_node(AST_BlockStatement, self, { body: body }).optimize(compressor);
         }
@@ -14727,7 +15015,7 @@ def_optimize(AST_Switch, function(self, compressor) {
         if (prev && !aborts(prev)) {
             prev.body = prev.body.concat(branch.body);
         } else {
-            extract_declarations_from_unreachable_code(compressor, branch, decl);
+            trim_unreachable_code(compressor, branch, decl);
         }
     }
 });
@@ -14738,7 +15026,7 @@ def_optimize(AST_Try, function(self, compressor) {
     if (compressor.option("dead_code") && self.body.every(is_empty)) {
         var body = [];
         if (self.bcatch) {
-            extract_declarations_from_unreachable_code(compressor, self.bcatch, body);
+            trim_unreachable_code(compressor, self.bcatch, body);
         }
         if (self.bfinally) body.push(...self.bfinally.body);
         return make_node(AST_BlockStatement, self, {
@@ -14836,6 +15124,10 @@ def_optimize(AST_Call, function(self, compressor) {
         }
     }
 
+    if (self.optional && is_nullish(fn)) {
+        return make_node(AST_Undefined, self);
+    }
+
     var is_func = fn instanceof AST_Lambda;
 
     if (is_func && fn.pinned()) return self;
@@ -15047,6 +15339,7 @@ def_optimize(AST_Call, function(self, compressor) {
                 return make_node(AST_Call, self, {
                     expression: make_node(AST_Dot, exp, {
                         expression: exp.expression,
+                        optional: false,
                         property: "call"
                     }),
                     args: args
@@ -15093,7 +15386,9 @@ def_optimize(AST_Call, function(self, compressor) {
                 var ast = parse(code);
                 var mangle = { ie8: compressor.option("ie8") };
                 ast.figure_out_scope(mangle);
-                var comp = new Compressor(compressor.options);
+                var comp = new Compressor(compressor.options, {
+                    mangle_options: compressor.mangle_options
+                });
                 ast = ast.transform(comp);
                 ast.figure_out_scope(mangle);
                 base54.reset();
@@ -16276,8 +16571,8 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
             }
 
             if (replace) {
-                const name_length = def.name.length;
-                const replace_size = replace.size();
+                const name_length = self.size(compressor);
+                const replace_size = replace.size(compressor);
 
                 let overhead = 0;
                 if (compressor.option("unused") && !compressor.exposed(def)) {
@@ -16482,6 +16777,10 @@ function is_nullish(node) {
             && (fixed = node.definition().fixed) instanceof AST_Node
             && is_nullish(fixed)
         )
+        // Recurse into those optional chains!
+        || node instanceof AST_PropAccess && node.optional && is_nullish(node.expression)
+        || node instanceof AST_Call && node.optional && is_nullish(node.expression)
+        || node instanceof AST_Chain && is_nullish(node.expression)
     );
 }
 
@@ -16864,6 +17163,41 @@ function safe_to_flatten(value, compressor) {
     return compressor.parent() instanceof AST_New;
 }
 
+AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
+    if (!compressor.option("properties")) return;
+    var arrows = compressor.option("unsafe_arrows") && compressor.option("ecma") >= 2015;
+    var expr = this.expression;
+    if (expr instanceof AST_Object) {
+        var props = expr.properties;
+        for (var i = props.length; --i >= 0;) {
+            var prop = props[i];
+            if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
+                if (!props.every((prop) => {
+                    return prop instanceof AST_ObjectKeyVal
+                        || arrows && prop instanceof AST_ConciseMethod && !prop.is_generator;
+                })) break;
+                if (!safe_to_flatten(prop.value, compressor)) break;
+                return make_node(AST_Sub, this, {
+                    expression: make_node(AST_Array, expr, {
+                        elements: props.map(function(prop) {
+                            var v = prop.value;
+                            if (v instanceof AST_Accessor) v = make_node(AST_Function, v, v);
+                            var k = prop.key;
+                            if (k instanceof AST_Node && !(k instanceof AST_SymbolMethod)) {
+                                return make_sequence(prop, [ k, v ]);
+                            }
+                            return v;
+                        })
+                    }),
+                    property: make_node(AST_Number, this, {
+                        value: i
+                    })
+                });
+            }
+        }
+    }
+});
+
 def_optimize(AST_Sub, function(self, compressor) {
     var expr = self.expression;
     var prop = self.property;
@@ -16886,6 +17220,7 @@ def_optimize(AST_Sub, function(self, compressor) {
                 && property.length <= prop.size() + 1) {
                 return make_node(AST_Dot, self, {
                     expression: expr,
+                    optional: self.optional,
                     property: property,
                     quote: prop.quote,
                 }).optimize(compressor);
@@ -16988,6 +17323,14 @@ def_optimize(AST_Sub, function(self, compressor) {
         ev = make_node_from_constant(ev, self).optimize(compressor);
         return best_of(compressor, ev, self);
     }
+    if (self.optional && is_nullish(self.expression)) {
+        return make_node(AST_Undefined, self);
+    }
+    return self;
+});
+
+def_optimize(AST_Chain, function (self, compressor) {
+    self.expression = self.expression.optimize(compressor);
     return self;
 });
 
@@ -17004,41 +17347,6 @@ AST_Lambda.DEFMETHOD("contains_this", function() {
     });
 });
 
-AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
-    if (!compressor.option("properties")) return;
-    var arrows = compressor.option("unsafe_arrows") && compressor.option("ecma") >= 2015;
-    var expr = this.expression;
-    if (expr instanceof AST_Object) {
-        var props = expr.properties;
-        for (var i = props.length; --i >= 0;) {
-            var prop = props[i];
-            if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
-                if (!props.every((prop) => {
-                    return prop instanceof AST_ObjectKeyVal
-                        || arrows && prop instanceof AST_ConciseMethod && !prop.is_generator;
-                })) break;
-                if (!safe_to_flatten(prop.value, compressor)) break;
-                return make_node(AST_Sub, this, {
-                    expression: make_node(AST_Array, expr, {
-                        elements: props.map(function(prop) {
-                            var v = prop.value;
-                            if (v instanceof AST_Accessor) v = make_node(AST_Function, v, v);
-                            var k = prop.key;
-                            if (k instanceof AST_Node && !(k instanceof AST_SymbolMethod)) {
-                                return make_sequence(prop, [ k, v ]);
-                            }
-                            return v;
-                        })
-                    }),
-                    property: make_node(AST_Number, this, {
-                        value: i
-                    })
-                });
-            }
-        }
-    }
-});
-
 def_optimize(AST_Dot, function(self, compressor) {
     const parent = compressor.parent();
     if (is_lhs(self, parent)) return self;
@@ -17089,6 +17397,9 @@ def_optimize(AST_Dot, function(self, compressor) {
         ev = make_node_from_constant(ev, self).optimize(compressor);
         return best_of(compressor, ev, self);
     }
+    if (self.optional && is_nullish(self.expression)) {
+        return make_node(AST_Undefined, self);
+    }
     return self;
 });
 
@@ -17172,10 +17483,10 @@ def_optimize(AST_Function, function(self, compressor) {
         && !self.is_generator
         && !self.uses_arguments
         && !self.pinned()) {
-        const has_special_symbol = walk(self, node => {
+        const uses_this = walk(self, node => {
             if (node instanceof AST_This) return walk_abort;
         });
-        if (!has_special_symbol) return make_node(AST_Arrow, self, self).optimize(compressor);
+        if (!uses_this) return make_node(AST_Arrow, self, self).optimize(compressor);
     }
     return self;
 });
@@ -17267,7 +17578,7 @@ function lift_key(self, compressor) {
     if (!compressor.option("computed_props")) return self;
     // save a comparison in the typical case
     if (!(self.key instanceof AST_Constant)) return self;
-    // whitelist acceptable props as not all AST_Constants are true constants
+    // allow certain acceptable props as not all AST_Constants are true constants
     if (self.key instanceof AST_String || self.key instanceof AST_Number) {
         if (self.key.value === "__proto__") return self;
         if (self.key.value == "constructor"
@@ -23301,6 +23612,8 @@ function mangle_properties(ast, options) {
         } else if (node instanceof AST_Call
             && node.expression.print_to_string() == "Object.defineProperty") {
             addStrings(node.args[1], add);
+        } else if (node instanceof AST_Binary && node.operator === "in") {
+            addStrings(node.left, add);
         }
     }));
 
@@ -23325,6 +23638,8 @@ function mangle_properties(ast, options) {
         } else if (node instanceof AST_Call
             && node.expression.print_to_string() == "Object.defineProperty") {
             node.args[1] = mangleStrings(node.args[1]);
+        } else if (node instanceof AST_Binary && node.operator === "in") {
+            node.left = mangleStrings(node.left);
         }
     }));
 
@@ -23557,7 +23872,11 @@ async function minify(files, options) {
     }
     if (timings) timings.rename = Date.now();
     if (timings) timings.compress = Date.now();
-    if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
+    if (options.compress) {
+        toplevel = new Compressor(options.compress, {
+            mangle_options: options.mangle
+        }).compress(toplevel);
+    }
     if (timings) timings.scope = Date.now();
     if (options.mangle) toplevel.figure_out_scope(options.mangle);
     if (timings) timings.mangle = Date.now();
@@ -23704,6 +24023,7 @@ async function run_cli({ program, packageJson, fs, path }) {
             options[name] = program[name];
         }
     });
+
     if ("ecma" in program) {
         if (program.ecma != (program.ecma | 0)) fatal("ERROR: ecma must be an integer");
         const ecma = program.ecma | 0;
@@ -23933,7 +24253,7 @@ async function run_cli({ program, packageJson, fs, path }) {
             }
         } else if (program.output) {
             fs.writeFileSync(program.output, result.code);
-            if (options.sourceMap.url !== "inline" && result.map) {
+            if (options.sourceMap && options.sourceMap.url !== "inline" && result.map) {
                 fs.writeFileSync(program.output + ".map", result.map);
             }
         } else {