terser 5.6.0-beta → 5.7.1

package/dist/bundle.min.js

@@ -72,10 +72,8 @@ class DefaultsError extends Error {
 function defaults(args, defs, croak) {
     if (args === true) {
         args = {};
-    }
-
-    if (args != null && typeof args === "object") {
-        args = Object.assign({}, args);
+    } else if (args != null && typeof args === "object") {
+        args = {...args};
     }
 
     const ret = args || {};
@@ -204,7 +202,7 @@ function mergeSort(array, cmp) {
 function makePredicate(words) {
     if (!Array.isArray(words)) words = words.split(" ");
 
-    return new Set(words);
+    return new Set(words.sort());
 }
 
 function map_add(map, key, value) {
@@ -243,6 +241,7 @@ function keep_name(keep_setting, name) {
 }
 
 var lineTerminatorEscape = {
+    "\0": "0",
     "\n": "n",
     "\r": "r",
     "\u2028": "u2028",
@@ -250,7 +249,8 @@ var lineTerminatorEscape = {
 };
 function regexp_source_fix(source) {
     // V8 does not escape line terminators in regexp patterns in node 12
-    return source.replace(/[\n\r\u2028\u2029]/g, function (match, offset) {
+    // We'll also remove literal \0
+    return source.replace(/[\0\n\r\u2028\u2029]/g, function (match, offset) {
         var escaped = source[offset - 1] == "\\"
             && (source[offset - 2] != "\\"
             || /(?:^|[^\\])(?:\\{2})*$/.test(source.slice(0, offset - 1)));
@@ -1457,7 +1457,7 @@ function parse($TEXT, options) {
                 if (is_if_body) {
                     croak("classes are not allowed as the body of an if");
                 }
-                return class_(AST_DefClass);
+                return class_(AST_DefClass, is_export_default);
 
               case "function":
                 next();
@@ -2652,7 +2652,7 @@ function parse($TEXT, options) {
         return new AST_Object({ properties: a });
     });
 
-    function class_(KindOfClass) {
+    function class_(KindOfClass, is_export_default) {
         var start, method, class_name, extends_, a = [];
 
         S.input.push_directives_stack(); // Push directive stack, but not scope stack
@@ -2663,7 +2663,11 @@ function parse($TEXT, options) {
         }
 
         if (KindOfClass === AST_DefClass && !class_name) {
-            unexpected();
+            if (is_export_default) {
+                KindOfClass = AST_ClassExpression;
+            } else {
+                unexpected();
+            }
         }
 
         if (S.token.value == "extends") {
@@ -2696,9 +2700,9 @@ function parse($TEXT, options) {
     }
 
     function concise_method_or_getset(name, start, is_class) {
-        var get_method_name_ast = function(name, start) {
+        const get_symbol_ast = (name, SymbolClass = AST_SymbolMethod) => {
             if (typeof name === "string" || typeof name === "number") {
-                return new AST_SymbolMethod({
+                return new SymbolClass({
                     start,
                     name: "" + name,
                     end: prev()
@@ -2708,47 +2712,71 @@ function parse($TEXT, options) {
             }
             return name;
         };
-        const get_class_property_key_ast = (name) => {
-            if (typeof name === "string" || typeof name === "number") {
-                return new AST_SymbolClassProperty({
-                    start: property_token,
-                    end: property_token,
-                    name: "" + name
-                });
-            } else if (name === null) {
-                unexpected();
-            }
-            return name;
-        };
-        var privatename = start.type == "privatename";
+
+        const is_not_method_start = () =>
+            !is("punc", "(") && !is("punc", ",") && !is("punc", "}") && !is("operator", "=");
+
         var is_async = false;
         var is_static = false;
         var is_generator = false;
-        var property_token = start;
-        if (is_class && name === "static" && !is("punc", "(")) {
+        var is_private = false;
+        var accessor_type = null;
+
+        if (is_class && name === "static" && is_not_method_start()) {
             is_static = true;
-            property_token = S.token;
-            privatename = property_token.type == "privatename";
             name = as_property_name();
         }
-        if (name === "async" && !is("punc", "(") && !is("punc", ",") && !is("punc", "}") && !is("operator", "=")) {
+        if (name === "async" && is_not_method_start()) {
             is_async = true;
-            property_token = S.token;
-            privatename = property_token.type == "privatename";
             name = as_property_name();
         }
-        if (name === null) {
+        if (prev().type === "operator" && prev().value === "*") {
             is_generator = true;
-            property_token = S.token;
-            privatename = property_token.type == "privatename";
             name = as_property_name();
-            if (name === null) {
-                unexpected();
+        }
+        if ((name === "get" || name === "set") && is_not_method_start()) {
+            accessor_type = name;
+            name = as_property_name();
+        }
+        if (prev().type === "privatename") {
+            is_private = true;
+        }
+
+        const property_token = prev();
+
+        if (accessor_type != null) {
+            if (!is_private) {
+                const AccessorClass = accessor_type === "get"
+                    ? AST_ObjectGetter
+                    : AST_ObjectSetter;
+
+                name = get_symbol_ast(name);
+                return new AccessorClass({
+                    start,
+                    static: is_static,
+                    key: name,
+                    quote: name instanceof AST_SymbolMethod ? property_token.quote : undefined,
+                    value: create_accessor(),
+                    end: prev()
+                });
+            } else {
+                const AccessorClass = accessor_type === "get"
+                    ? AST_PrivateGetter
+                    : AST_PrivateSetter;
+
+                return new AccessorClass({
+                    start,
+                    static: is_static,
+                    key: get_symbol_ast(name),
+                    value: create_accessor(),
+                    end: prev(),
+                });
             }
         }
+
         if (is("punc", "(")) {
-            name = get_method_name_ast(name, start);
-            const AST_MethodVariant = privatename
+            name = get_symbol_ast(name);
+            const AST_MethodVariant = is_private
                 ? AST_PrivateMethod
                 : AST_ConciseMethod;
             var node = new AST_MethodVariant({
@@ -2764,57 +2792,13 @@ function parse($TEXT, options) {
             });
             return node;
         }
-        const setter_token = S.token;
-        if ((name === "get" || name === "set") && setter_token.type === "privatename") {
-            next();
-
-            const AST_AccessorVariant =
-                name === "get"
-                    ? AST_PrivateGetter
-                    : AST_PrivateSetter;
-
-            return new AST_AccessorVariant({
-                start,
-                static: is_static,
-                key: get_method_name_ast(setter_token.value, start),
-                value: create_accessor(),
-                end: prev(),
-            });
-        }
 
-        if (name == "get") {
-            if (!is("punc") || is("punc", "[")) {
-                name = get_method_name_ast(as_property_name(), start);
-                return new AST_ObjectGetter({
-                    start : start,
-                    static: is_static,
-                    key   : name,
-                    quote : name instanceof AST_SymbolMethod ?
-                            setter_token.quote : undefined,
-                    value : create_accessor(),
-                    end   : prev()
-                });
-            }
-        } else if (name == "set") {
-            if (!is("punc") || is("punc", "[")) {
-                name = get_method_name_ast(as_property_name(), start);
-                return new AST_ObjectSetter({
-                    start : start,
-                    static: is_static,
-                    key   : name,
-                    quote : name instanceof AST_SymbolMethod ?
-                            setter_token.quote : undefined,
-                    value : create_accessor(),
-                    end   : prev()
-                });
-            }
-        }
         if (is_class) {
-            const key = get_class_property_key_ast(name);
+            const key = get_symbol_ast(name, AST_SymbolClassProperty);
             const quote = key instanceof AST_SymbolClassProperty
                 ? property_token.quote
                 : undefined;
-            const AST_ClassPropertyVariant = privatename
+            const AST_ClassPropertyVariant = is_private
                 ? AST_ClassPrivateProperty
                 : AST_ClassProperty;
             if (is("operator", "=")) {
@@ -3036,8 +3020,17 @@ function parse($TEXT, options) {
             semicolon();
         } else if ((node = statement(is_default)) instanceof AST_Definitions && is_default) {
             unexpected(node.start);
-        } else if (node instanceof AST_Definitions || node instanceof AST_Lambda || node instanceof AST_DefClass) {
+        } else if (
+            node instanceof AST_Definitions
+            || node instanceof AST_Defun
+            || node instanceof AST_DefClass
+        ) {
             exported_definition = node;
+        } else if (
+            node instanceof AST_ClassExpression
+            || node instanceof AST_Function
+        ) {
+            exported_value = node;
         } else if (node instanceof AST_SimpleStatement) {
             exported_value = node.body;
         } else {
@@ -3706,8 +3699,6 @@ function walk_body(node, visitor) {
 function clone_block_scope(deep) {
     var clone = this._clone(deep);
     if (this.block_scope) {
-        // TODO this is sometimes undefined during compression.
-        // But it should always have a value!
         clone.block_scope = this.block_scope.clone();
     }
     return clone;
@@ -3891,7 +3882,6 @@ var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent
     $documentation: "Base class for all statements introducing a lexical scope",
     $propdoc: {
         variables: "[Map/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
-        functions: "[Map/S] like `variables`, but only lists function declarations",
         uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
         uses_eval: "[boolean/S] tells whether this scope contains a direct call to the global `eval`",
         parent_scope: "[AST_Scope?/S] link to the parent scope",
@@ -3914,7 +3904,6 @@ var AST_Scope = DEFNODE("Scope", "variables functions uses_with uses_eval parent
             });
         } else {
             if (this.variables) node.variables = new Map(this.variables);
-            if (this.functions) node.functions = new Map(this.functions);
             if (this.enclosed) node.enclosed = this.enclosed.slice();
             if (this._block_scope) node._block_scope = this._block_scope;
         }
@@ -4014,6 +4003,21 @@ var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments is_generator as
 
         if (this.name) push(this.name);
     },
+    is_braceless() {
+        return this.body[0] instanceof AST_Return && this.body[0].value;
+    },
+    // Default args and expansion don't count, so .argnames.length doesn't cut it
+    length_property() {
+        let length = 0;
+
+        for (const arg of this.argnames) {
+            if (arg instanceof AST_SymbolFunarg || arg instanceof AST_Destructuring) {
+                length++;
+            }
+        }
+
+        return length;
+    }
 }, AST_Scope);
 
 var AST_Accessor = DEFNODE("Accessor", null, {
@@ -7087,11 +7091,15 @@ function OutputStream(options) {
     var do_add_mapping = mappings ? function() {
         mappings.forEach(function(mapping) {
             try {
+                let name = !mapping.name && mapping.token.type == "name" ? mapping.token.value : mapping.name;
+                if (name instanceof AST_Symbol) {
+                    name = name.name;
+                }
                 options.source_map.add(
                     mapping.token.file,
                     mapping.line, mapping.col,
                     mapping.token.line, mapping.token.col,
-                    !mapping.name && mapping.token.type == "name" ? mapping.token.value : mapping.name
+                    is_basic_identifier_string(name) ? name : undefined
                 );
             } catch(ex) {
                 // Ignore bad mapping
@@ -7671,6 +7679,7 @@ function OutputStream(options) {
         var p = output.parent();
         return p instanceof AST_PropAccess && p.expression === this
             || p instanceof AST_Call && p.expression === this
+            || p instanceof AST_Binary && p.operator === "**" && p.left === this
             || output.option("safari10") && p instanceof AST_UnaryPrefix;
     });
 
@@ -8888,7 +8897,9 @@ function OutputStream(options) {
         source = regexp_source_fix(source);
         flags = flags ? sort_regexp_flags(flags) : "";
         source = source.replace(r_slash_script, slash_script_replace);
+
         output.print(output.to_utf8(`/${source}/${flags}`));
+
         const parent = output.parent();
         if (
             parent instanceof AST_Binary
@@ -9183,6 +9194,10 @@ AST_Dot.prototype.shallow_cmp = mkshallow({
     property: "eq"
 });
 
+AST_DotHash.prototype.shallow_cmp = mkshallow({
+    property: "eq"
+});
+
 AST_Unary.prototype.shallow_cmp = mkshallow({
     operator: "eq"
 });
@@ -9488,7 +9503,14 @@ AST_Scope.DEFMETHOD("figure_out_scope", function(options, { parent_scope = null,
             // scope when we encounter the AST_Defun node (which is
             // instanceof AST_Scope) but we get to the symbol a bit
             // later.
-            mark_export((node.scope = defun.parent_scope.get_defun_scope()).def_function(node, defun), 1);
+            const closest_scope = defun.parent_scope;
+
+            // In strict mode, function definitions are block-scoped
+            node.scope = tw.directives["use strict"]
+                ? closest_scope
+                : closest_scope.get_defun_scope();
+
+            mark_export(node.scope.def_function(node, defun), 1);
         } else if (node instanceof AST_SymbolClass) {
             mark_export(defun.def_variable(node, defun), 1);
         } else if (node instanceof AST_SymbolImport) {
@@ -9667,7 +9689,6 @@ AST_Toplevel.DEFMETHOD("def_global", function(node) {
 
 AST_Scope.DEFMETHOD("init_scope_vars", function(parent_scope) {
     this.variables = new Map();         // map name to AST_SymbolVar (variables defined in this scope; includes functions)
-    this.functions = new Map();         // map name to AST_SymbolDefun (functions defined in this scope)
     this.uses_with = false;             // will be set to true if this or some nested scope uses the `with` statement
     this.uses_eval = false;             // will be set to true if this or nested scope uses the global `eval`
     this.parent_scope = parent_scope;   // the parent scope
@@ -9830,7 +9851,6 @@ AST_Scope.DEFMETHOD("find_variable", function(name) {
 AST_Scope.DEFMETHOD("def_function", function(symbol, init) {
     var def = this.def_variable(symbol, init);
     if (!def.init || def.init instanceof AST_Defun) def.init = init;
-    this.functions.set(symbol.name, def);
     return def;
 });
 
@@ -10184,6 +10204,12 @@ AST_Node.prototype.size = function (compressor, stack) {
     let size = 0;
     walk_parent(this, (node, info) => {
         size += node._size(info);
+
+        // Braceless arrow functions have fake "return" statements
+        if (node instanceof AST_Arrow && node.is_braceless()) {
+            size += node.body[0].value._size(info);
+            return true;
+        }
     }, stack || (compressor && compressor.stack));
 
     // just to save a bit of memory
@@ -10228,7 +10254,6 @@ AST_With.prototype._size = () => 6;
 
 AST_Expansion.prototype._size = () => 3;
 
-/*#__INLINE__*/
 const lambda_modifiers = func =>
     (func.is_generator ? 1 : 0) + (func.async ? 6 : 0);
 
@@ -10257,7 +10282,9 @@ 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());
+    const body_overhead = this.is_braceless() ? 0 : list_overhead(this.body) + 2;
+
+    return lambda_modifiers(this) + args_and_arrow + body_overhead;
 };
 
 AST_Destructuring.prototype._size = () => 2;
@@ -10632,11 +10659,8 @@ const TOP       = 0b0000010000000000;
 
 const CLEAR_BETWEEN_PASSES = SQUEEZED | OPTIMIZED | TOP;
 
-/*@__INLINE__*/
 const has_flag = (node, flag) => node.flags & flag;
-/*@__INLINE__*/
 const set_flag = (node, flag) => { node.flags |= flag; };
-/*@__INLINE__*/
 const clear_flag = (node, flag) => { node.flags &= ~flag; };
 
 class Compressor extends TreeWalker {
@@ -10679,7 +10703,7 @@ class Compressor extends TreeWalker {
             properties    : !false_by_default,
             pure_getters  : !false_by_default && "strict",
             pure_funcs    : null,
-            reduce_funcs  : null,  // legacy
+            reduce_funcs  : !false_by_default,
             reduce_vars   : !false_by_default,
             sequences     : !false_by_default,
             side_effects  : !false_by_default,
@@ -10979,7 +11003,7 @@ function is_modified(compressor, tw, node, value, level, immutable) {
         && parent.expression === node
         && !(value instanceof AST_Arrow)
         && !(value instanceof AST_Class)
-        && !parent.is_expr_pure(compressor)
+        && !parent.is_callee_pure(compressor)
         && (!(value instanceof AST_Function)
             || !(parent instanceof AST_New) && value.contains_this())) {
         return true;
@@ -11284,9 +11308,6 @@ function is_modified(compressor, tw, node, value, level, immutable) {
         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) {
@@ -11839,8 +11860,11 @@ function tighten_body(statements, compressor) {
                 || node instanceof AST_Debugger
                 || node instanceof AST_Destructuring
                 || node instanceof AST_Expansion
-                   && node.expression instanceof AST_Symbol
-                   && node.expression.definition().references.length > 1
+                    && node.expression instanceof AST_Symbol
+                    && (
+                        node.expression instanceof AST_This
+                        || node.expression.definition().references.length > 1
+                    )
                 || node instanceof AST_IterationStatement && !(node instanceof AST_For)
                 || node instanceof AST_LoopControl
                 || node instanceof AST_Try
@@ -11934,6 +11958,7 @@ function tighten_body(statements, compressor) {
             if (stop_after === node) abort = true;
             if (stop_if_hit === node) stop_if_hit = null;
         });
+
         var multi_replacer = new TreeTransformer(function(node) {
             if (abort) return node;
             // Skip nodes before `candidate` as quickly as possible
@@ -11956,6 +11981,7 @@ function tighten_body(statements, compressor) {
             // Skip (non-executed) functions and (leading) default case in switch statements
             if (node instanceof AST_Default || node instanceof AST_Scope) return node;
         });
+
         while (--stat_index >= 0) {
             // Treat parameters as collapsible in IIFE, i.e.
             //   function(a, b){ ... }(x());
@@ -12131,7 +12157,10 @@ function tighten_body(statements, compressor) {
         function extract_candidates(expr) {
             hit_stack.push(expr);
             if (expr instanceof AST_Assign) {
-                if (!expr.left.has_side_effects(compressor)) {
+                if (
+                    !expr.left.has_side_effects(compressor)
+                    && !(expr.right instanceof AST_Chain)
+                ) {
                     candidates.push(hit_stack.slice());
                 }
                 extract_candidates(expr.right);
@@ -12194,7 +12223,7 @@ function tighten_body(statements, compressor) {
                     candidates.push(hit_stack.slice());
                 }
             } else if (expr instanceof AST_VarDef) {
-                if (expr.value) {
+                if (expr.value && !(expr.value instanceof AST_Chain)) {
                     candidates.push(hit_stack.slice());
                     extract_candidates(expr.value);
                 }
@@ -13009,7 +13038,13 @@ function is_undefined(node, compressor) {
     });
     def_may_throw_on_access(AST_Dot, function(compressor) {
         if (!is_strict(compressor)) return false;
-        if (this.expression instanceof AST_Function && this.property == "prototype") return false;
+
+        if (this.property == "prototype") {
+            return !(
+                this.expression instanceof AST_Function
+                || this.expression instanceof AST_Class
+            );
+        }
         return true;
     });
     def_may_throw_on_access(AST_Chain, function(compressor) {
@@ -13351,9 +13386,7 @@ var static_fns = convert_to_predicate({
         if (compressor.option("unsafe")) {
             var fn = function() {};
             fn.node = this;
-            fn.toString = function() {
-                return this.node.print_to_string();
-            };
+            fn.toString = () => this.print_to_string();
             return fn;
         }
         return this;
@@ -13534,6 +13567,14 @@ var static_fns = convert_to_predicate({
             "POSITIVE_INFINITY",
         ],
     });
+    const regexp_flags = new Set([
+        "dotAll",
+        "global",
+        "ignoreCase",
+        "multiline",
+        "sticky",
+        "unicode",
+    ]);
     def_eval(AST_PropAccess, function(compressor, depth) {
         if (this.optional) {
             const obj = this.expression._eval(compressor, depth);
@@ -13566,12 +13607,19 @@ var static_fns = convert_to_predicate({
                 val = global_objs[exp.name];
             } else {
                 val = exp._eval(compressor, depth + 1);
+                if (val instanceof RegExp) {
+                    if (key == "source") {
+                        return regexp_source_fix(val.source);
+                    } else if (key == "flags" || regexp_flags.has(key)) {
+                        return val[key];
+                    }
+                }
                 if (!val || val === exp || !HOP(val, key)) return this;
                 if (typeof val == "function") switch (key) {
                   case "name":
                     return val.node.name ? val.node.name.name : "";
                   case "length":
-                    return val.node.argnames.length;
+                    return val.node.length_property();
                   default:
                     return this;
                 }
@@ -13623,6 +13671,7 @@ var static_fns = convert_to_predicate({
                 var arg = this.args[i];
                 var value = arg._eval(compressor, depth);
                 if (arg === value) return this;
+                if (arg instanceof AST_Lambda) return this;
                 args.push(value);
             }
             try {
@@ -13722,7 +13771,7 @@ var static_fns = convert_to_predicate({
 });
 
 var global_pure_fns = makePredicate("Boolean decodeURI decodeURIComponent Date encodeURI encodeURIComponent Error escape EvalError isFinite isNaN Number Object parseFloat parseInt RangeError ReferenceError String SyntaxError TypeError unescape URIError");
-AST_Call.DEFMETHOD("is_expr_pure", function(compressor) {
+AST_Call.DEFMETHOD("is_callee_pure", function(compressor) {
     if (compressor.option("unsafe")) {
         var expr = this.expression;
         var first_arg = (this.args && this.args[0] && this.args[0].evaluate(compressor));
@@ -13792,7 +13841,7 @@ const pure_prop_access_globals = new Set([
     });
     def_has_side_effects(AST_Call, function(compressor) {
         if (
-            !this.is_expr_pure(compressor)
+            !this.is_callee_pure(compressor)
             && (!this.expression.is_call_pure(compressor)
                 || this.expression.has_side_effects(compressor))
         ) {
@@ -13882,7 +13931,7 @@ const pure_prop_access_globals = new Set([
             || this.expression.has_side_effects(compressor);
     });
     def_has_side_effects(AST_Sub, function(compressor) {
-        if (this.optional && is_nullish(this.expression)) {
+        if (this.optional && is_nullish(this.expression, compressor)) {
             return false;
         }
 
@@ -13952,9 +14001,9 @@ 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 (this.optional && is_nullish(this.expression, compressor)) return false;
         if (any(this.args, compressor)) return true;
-        if (this.is_expr_pure(compressor)) return false;
+        if (this.is_callee_pure(compressor)) return false;
         if (this.expression.may_throw(compressor)) return true;
         return !(this.expression instanceof AST_Lambda)
             || any(this.expression.body, compressor);
@@ -14015,7 +14064,7 @@ const pure_prop_access_globals = new Set([
             || this.expression.may_throw(compressor);
     });
     def_may_throw(AST_Sub, function(compressor) {
-        if (this.optional && is_nullish(this.expression)) return false;
+        if (this.optional && is_nullish(this.expression, compressor)) return false;
 
         return !this.optional && this.expression.may_throw_on_access(compressor)
             || this.expression.may_throw(compressor)
@@ -14828,11 +14877,11 @@ 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)) {
+        if (this.optional && is_nullish(this.expression, compressor)) {
             return make_node(AST_Undefined, this);
         }
 
-        if (!this.is_expr_pure(compressor)) {
+        if (!this.is_callee_pure(compressor)) {
             if (this.expression.is_call_pure(compressor)) {
                 var exprs = this.args.slice();
                 exprs.unshift(this.expression.expression);
@@ -14975,7 +15024,7 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
     });
     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;
+            return is_nullish(this.expression, compressor) ? make_node(AST_Undefined, this) : this;
         }
         if (this.expression.may_throw_on_access(compressor)) return this;
 
@@ -14983,7 +15032,7 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
     });
     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;
+            return is_nullish(this.expression, compressor) ? make_node(AST_Undefined, this): this;
         }
         if (this.expression.may_throw_on_access(compressor)) return this;
 
@@ -15508,11 +15557,11 @@ def_optimize(AST_Definitions, function(self) {
     return self;
 });
 
-def_optimize(AST_VarDef, function(self) {
+def_optimize(AST_VarDef, function(self, compressor) {
     if (
         self.name instanceof AST_SymbolLet
         && self.value != null
-        && is_undefined(self.value)
+        && is_undefined(self.value, compressor)
     ) {
         self.value = null;
     }
@@ -15550,7 +15599,7 @@ def_optimize(AST_Call, function(self, compressor) {
         }
     }
 
-    if (self.optional && is_nullish(fn)) {
+    if (self.optional && is_nullish(fn, compressor)) {
         return make_node(AST_Undefined, self);
     }
 
@@ -15852,7 +15901,7 @@ def_optimize(AST_Call, function(self, compressor) {
 
     var stat = is_func && fn.body[0];
     var is_regular_func = is_func && !fn.is_generator && !fn.async;
-    var can_inline = is_regular_func && compressor.option("inline") && !self.is_expr_pure(compressor);
+    var can_inline = is_regular_func && compressor.option("inline") && !self.is_callee_pure(compressor);
     if (can_inline && stat instanceof AST_Return) {
         let returned = stat.value;
         if (!returned || returned.is_constant_expression()) {
@@ -16576,7 +16625,7 @@ def_optimize(AST_Binary, function(self, compressor) {
             }
             break;
           case "??":
-            if (is_nullish(self.left)) {
+            if (is_nullish(self.left, compressor)) {
                 return self.right;
             }
 
@@ -16878,19 +16927,26 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
         let fixed = self.fixed_value();
         let single_use = def.single_use
             && !(parent instanceof AST_Call
-                && (parent.is_expr_pure(compressor))
+                && (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))) {
+                    || within_array_or_object_literal(compressor)
+                    || !compressor.option("reduce_funcs"))) {
                 single_use = false;
             } else if (recursive_ref(compressor, def)) {
                 single_use = false;
@@ -16906,6 +16962,7 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
                 }
             }
         }
+
         if (single_use && fixed instanceof AST_Lambda) {
             single_use =
                 def.scope === self.scope
@@ -16915,15 +16972,6 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
                     && !scope_encloses_variables_in_this_scope(nearest_scope, fixed)
                     && !(fixed.name && fixed.name.definition().recursive_refs > 0);
         }
-        if (single_use && fixed instanceof AST_Class) {
-            const extends_inert = !fixed.extends
-                || !fixed.extends.may_throw(compressor)
-                    && !fixed.extends.has_side_effects(compressor);
-            single_use = extends_inert
-                && !fixed.properties.some(prop =>
-                    prop.may_throw(compressor) || prop.has_side_effects(compressor)
-                );
-        }
 
         if (single_use && fixed) {
             if (fixed instanceof AST_DefClass) {
@@ -17000,6 +17048,7 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
             }
         }
     }
+
     return self;
 });
 
@@ -17184,20 +17233,20 @@ def_optimize(AST_DefaultAssign, function(self, compressor) {
     return self;
 });
 
-function is_nullish(node) {
+function is_nullish(node, compressor) {
     let fixed;
     return (
         node instanceof AST_Null
-        || is_undefined(node)
+        || is_undefined(node, compressor)
         || (
             node instanceof AST_SymbolRef
             && (fixed = node.definition().fixed) instanceof AST_Node
-            && is_nullish(fixed)
+            && is_nullish(fixed, compressor)
         )
         // 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)
+        || node instanceof AST_PropAccess && node.optional && is_nullish(node.expression, compressor)
+        || node instanceof AST_Call && node.optional && is_nullish(node.expression, compressor)
+        || node instanceof AST_Chain && is_nullish(node.expression, compressor)
     );
 }
 
@@ -17212,8 +17261,8 @@ function is_nullish_check(check, check_subject, compressor) {
         && check.operator === "=="
         // which side is nullish?
         && (
-            (nullish_side = is_nullish(check.left) && check.left)
-            || (nullish_side = is_nullish(check.right) && check.right)
+            (nullish_side = is_nullish(check.left, compressor) && check.left)
+            || (nullish_side = is_nullish(check.right, compressor) && check.right)
         )
         // is the other side the same as the check_subject
         && (
@@ -17251,12 +17300,12 @@ function is_nullish_check(check, check_subject, compressor) {
                 null_cmp = cmp;
                 defined_side = cmp.left;
             }
-            if (is_undefined(cmp.left)) {
+            if (is_undefined(cmp.left, compressor)) {
                 found++;
                 undefined_cmp = cmp;
                 defined_side = cmp.right;
             }
-            if (is_undefined(cmp.right)) {
+            if (is_undefined(cmp.right, compressor)) {
                 found++;
                 undefined_cmp = cmp;
                 defined_side = cmp.left;
@@ -17586,27 +17635,40 @@ function safe_to_flatten(value, compressor) {
 
 AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
     if (!compressor.option("properties")) return;
+    if (key === "__proto__") 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;
+                const all_props_flattenable = props.every((p) =>
+                    (p instanceof AST_ObjectKeyVal
+                        || arrows && p instanceof AST_ConciseMethod && !p.is_generator
+                    )
+                    && !p.computed_key()
+                );
+
+                if (!all_props_flattenable) return;
+                if (!safe_to_flatten(prop.value, compressor)) return;
+
                 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);
+                            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;
                         })
                     }),
@@ -17744,7 +17806,7 @@ 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)) {
+    if (self.optional && is_nullish(self.expression, compressor)) {
         return make_node(AST_Undefined, self);
     }
     return self;
@@ -17818,7 +17880,7 @@ 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)) {
+    if (self.optional && is_nullish(self.expression, compressor)) {
         return make_node(AST_Undefined, self);
     }
     return self;
@@ -17862,7 +17924,7 @@ def_optimize(AST_Array, function(self, compressor) {
     return self;
 });
 
-function inline_object_prop_spread(props) {
+function inline_object_prop_spread(props, compressor) {
     for (var i = 0; i < props.length; i++) {
         var prop = props[i];
         if (prop instanceof AST_Expansion) {
@@ -17880,6 +17942,9 @@ function inline_object_prop_spread(props) {
                 // non-iterable value silently does nothing; it is thus safe
                 // to remove. AST_String is the only iterable AST_Constant.
                 props.splice(i, 1);
+            } else if (is_nullish(expr, compressor)) {
+                // Likewise, null and undefined can be silently removed.
+                props.splice(i, 1);
             }
         }
     }
@@ -17890,7 +17955,7 @@ def_optimize(AST_Object, function(self, compressor) {
     if (optimized !== self) {
         return optimized;
     }
-    inline_object_prop_spread(self.properties);
+    inline_object_prop_spread(self.properties, compressor);
     return self;
 });
 
@@ -17983,7 +18048,7 @@ def_optimize(AST_TemplateString, function(self, compressor) {
         && (
             segments[1].is_string(compressor)
             || segments[1].is_number(compressor)
-            || is_nullish(segments[1])
+            || is_nullish(segments[1], compressor)
             || compressor.option("unsafe")
         )
     ) {
@@ -22374,6 +22439,7 @@ var domprops = [
     "exponent",
     "exponentialRampToValueAtTime",
     "exportKey",
+    "exports",
     "extend",
     "extensions",
     "extentNode",
@@ -26405,6 +26471,7 @@ async function minify(files, options) {
         rename: undefined,
         safari10: false,
         sourceMap: false,
+        spidermonkey: false,
         timings: false,
         toplevel: false,
         warnings: false,
@@ -26476,20 +26543,32 @@ async function minify(files, options) {
     if (files instanceof AST_Toplevel) {
         toplevel = files;
     } else {
-        if (typeof files == "string") {
+        if (typeof files == "string" || (options.parse.spidermonkey && !Array.isArray(files))) {
             files = [ files ];
         }
         options.parse = options.parse || {};
         options.parse.toplevel = null;
-        for (var name in files) if (HOP(files, name)) {
-            options.parse.filename = name;
-            options.parse.toplevel = parse(files[name], options.parse);
-            if (options.sourceMap && options.sourceMap.content == "inline") {
-                if (Object.keys(files).length > 1)
-                    throw new Error("inline source map only works with singular input");
-                options.sourceMap.content = read_source_map(files[name]);
+
+        if (options.parse.spidermonkey) {
+            options.parse.toplevel = AST_Node.from_mozilla_ast(Object.keys(files).reduce(function(toplevel, name) {
+                if (!toplevel) return files[name];
+                toplevel.body = toplevel.body.concat(files[name].body);
+                return toplevel;
+            }, null));
+        } else {
+            delete options.parse.spidermonkey;
+
+            for (var name in files) if (HOP(files, name)) {
+                options.parse.filename = name;
+                options.parse.toplevel = parse(files[name], options.parse);
+                if (options.sourceMap && options.sourceMap.content == "inline") {
+                    if (Object.keys(files).length > 1)
+                        throw new Error("inline source map only works with singular input");
+                    options.sourceMap.content = read_source_map(files[name]);
+                }
             }
         }
+
         toplevel = options.parse.toplevel;
     }
     if (quoted_props && options.mangle.properties.keep_quoted !== "strict") {
@@ -26525,6 +26604,9 @@ async function minify(files, options) {
     if (options.format.ast) {
         result.ast = toplevel;
     }
+    if (options.format.spidermonkey) {
+        result.ast = toplevel.to_mozilla_ast();
+    }
     if (!HOP(options.format, "code") || options.format.code) {
         if (options.sourceMap) {
             options.format.source_map = await SourceMap({
@@ -26542,6 +26624,7 @@ async function minify(files, options) {
         }
         delete options.format.ast;
         delete options.format.code;
+        delete options.format.spidermonkey;
         var stream = OutputStream(options.format);
         toplevel.print(stream);
         result.code = stream.get();
@@ -26834,7 +26917,6 @@ async function run_cli({ program, packageJson, fs, path }) {
                   case "enclosed":
                     return value.length ? value.map(symdef) : undefined;
                   case "variables":
-                  case "functions":
                   case "globals":
                     return value.size ? collect_from_map(value, symdef) : undefined;
                 }
@@ -26847,7 +26929,6 @@ async function run_cli({ program, packageJson, fs, path }) {
                     };
                     if (value.block_scope) {
                         result.variables = value.block_scope.variables;
-                        result.functions = value.block_scope.functions;
                         result.enclosed = value.block_scope.enclosed;
                     }
                     value.CTOR.PROPS.forEach(function(prop) {