terser 5.5.1 → 5.7.0

package/dist/bundle.min.js

@@ -1,10 +1,12 @@
 (function (global, factory) {
 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('source-map')) :
 typeof define === 'function' && define.amd ? define(['exports', 'source-map'], factory) :
-(global = global || self, factory(global.Terser = {}, global.sourceMap));
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Terser = {}, global.sourceMap));
 }(this, (function (exports, MOZ_SourceMap) { 'use strict';
 
-MOZ_SourceMap = MOZ_SourceMap && Object.prototype.hasOwnProperty.call(MOZ_SourceMap, 'default') ? MOZ_SourceMap['default'] : MOZ_SourceMap;
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var MOZ_SourceMap__default = /*#__PURE__*/_interopDefaultLegacy(MOZ_SourceMap);
 
 /***********************************************************************
 
@@ -202,7 +204,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) {
@@ -241,6 +243,7 @@ function keep_name(keep_setting, name) {
 }
 
 var lineTerminatorEscape = {
+    "\0": "0",
     "\n": "n",
     "\r": "r",
     "\u2028": "u2028",
@@ -248,7 +251,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)));
@@ -1035,6 +1039,11 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             : token("keyword", word);
     }
 
+    function read_private_word() {
+        next();
+        return token("privatename", read_name());
+    }
+
     function with_eof_error(eof_error, cont) {
         return function(x) {
             try {
@@ -1104,6 +1113,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             if (PUNC_CHARS.has(ch)) return token("punc", next());
             if (OPERATOR_CHARS.has(ch)) return read_operator();
             if (code == 92 || is_identifier_start(ch)) return read_word();
+            if (code == 35) return read_private_word();
             break;
         }
         parse_error("Unexpected character '" + ch + "'");
@@ -1304,6 +1314,13 @@ function parse($TEXT, options) {
         return S.in_async === S.in_function;
     }
 
+    function can_await() {
+        return (
+            S.in_async === S.in_function
+            || S.in_function === 0 && S.input.has_directive("use strict")
+        );
+    }
+
     function semicolon(optional) {
         if (is("punc", ";")) next();
         else if (!optional && !can_insert_semicolon()) unexpected();
@@ -1442,7 +1459,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();
@@ -1588,7 +1605,7 @@ function parse($TEXT, options) {
         var for_await_error = "`for await` invalid in this context";
         var await_tok = S.token;
         if (await_tok.type == "name" && await_tok.value == "await") {
-            if (!is_in_async()) {
+            if (!can_await()) {
                 token_error(await_tok, for_await_error);
             }
             next();
@@ -2085,7 +2102,7 @@ function parse($TEXT, options) {
 
     function _await_expression() {
         // Previous token must be "await" and not be interpreted as an identifier
-        if (!is_in_async()) {
+        if (!can_await()) {
             croak("Unexpected await expression outside async function",
                 S.prev.line, S.prev.col, S.prev.pos);
         }
@@ -2637,7 +2654,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
@@ -2648,7 +2665,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") {
@@ -2681,9 +2702,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()
@@ -2693,43 +2714,74 @@ 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;
-        };
+
+        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;
             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;
             name = as_property_name();
         }
-        if (name === null) {
+        if (prev().type === "operator" && prev().value === "*") {
             is_generator = true;
-            property_token = S.token;
             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);
-            var node = new AST_ConciseMethod({
+            name = get_symbol_ast(name);
+            const AST_MethodVariant = is_private
+                ? AST_PrivateMethod
+                : AST_ConciseMethod;
+            var node = new AST_MethodVariant({
                 start       : start,
                 static      : is_static,
                 is_generator: is_generator,
@@ -2742,42 +2794,18 @@ function parse($TEXT, options) {
             });
             return node;
         }
-        const setter_token = S.token;
-        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 = is_private
+                ? AST_ClassPrivateProperty
+                : AST_ClassProperty;
             if (is("operator", "=")) {
                 next();
-                return new AST_ClassProperty({
+                return new AST_ClassPropertyVariant({
                     start,
                     static: is_static,
                     quote,
@@ -2785,8 +2813,14 @@ function parse($TEXT, options) {
                     value: expression(false),
                     end: prev()
                 });
-            } else if (is("name") || is("punc", ";") || is("punc", "}")) {
-                return new AST_ClassProperty({
+            } else if (
+                is("name")
+                || is("privatename")
+                || is("operator", "*")
+                || is("punc", ";")
+                || is("punc", "}")
+            ) {
+                return new AST_ClassPropertyVariant({
                     start,
                     static: is_static,
                     quote,
@@ -2988,8 +3022,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 {
@@ -3025,6 +3068,7 @@ function parse($TEXT, options) {
             }
             /* falls through */
           case "name":
+          case "privatename":
           case "string":
           case "num":
           case "big_int":
@@ -3039,7 +3083,7 @@ function parse($TEXT, options) {
 
     function as_name() {
         var tmp = S.token;
-        if (tmp.type != "name") unexpected();
+        if (tmp.type != "name" && tmp.type != "privatename") unexpected();
         next();
         return tmp.value;
     }
@@ -3110,7 +3154,8 @@ function parse($TEXT, options) {
         var start = expr.start;
         if (is("punc", ".")) {
             next();
-            return subscripts(new AST_Dot({
+            const AST_DotVariant = is("privatename") ? AST_DotHash : AST_Dot;
+            return subscripts(new AST_DotVariant({
                 start      : start,
                 expression : expr,
                 optional   : false,
@@ -3161,8 +3206,9 @@ function parse($TEXT, options) {
                 annotate(call);
 
                 chain_contents = subscripts(call, true, true);
-            } else if (is("name")) {
-                chain_contents = subscripts(new AST_Dot({
+            } else if (is("name") || is("privatename")) {
+                const AST_DotVariant = is("privatename") ? AST_DotHash : AST_Dot;
+                chain_contents = subscripts(new AST_DotVariant({
                     start,
                     expression: expr,
                     optional: true,
@@ -3233,13 +3279,9 @@ function parse($TEXT, options) {
 
     var maybe_unary = function(allow_calls, allow_arrows) {
         var start = S.token;
-        if (start.type == "name" && start.value == "await") {
-            if (is_in_async()) {
-                next();
-                return _await_expression();
-            } else if (S.input.has_directive("use strict")) {
-                token_error(S.token, "Unexpected await identifier inside strict mode");
-            }
+        if (start.type == "name" && start.value == "await" && can_await()) {
+            next();
+            return _await_expression();
         }
         if (is("operator") && UNARY_PREFIX.has(start.value)) {
             next();
@@ -3967,6 +4009,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, {
@@ -4452,7 +4509,7 @@ 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 & AST_DotHash 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 ?.)"
     }
@@ -4473,6 +4530,18 @@ var AST_Dot = DEFNODE("Dot", "quote", {
     },
 }, AST_PropAccess);
 
+var AST_DotHash = DEFNODE("DotHash", "", {
+    $documentation: "A dotted property access to a private property",
+    _walk: function(visitor) {
+        return visitor._visit(this, function() {
+            this.expression._walk(visitor);
+        });
+    },
+    _children_backwards(push) {
+        push(this.expression);
+    },
+}, AST_PropAccess);
+
 var AST_Sub = DEFNODE("Sub", null, {
     $documentation: "Index-style property access, i.e. `a[\"foo\"]`",
     _walk: function(visitor) {
@@ -4490,7 +4559,7 @@ var AST_Sub = DEFNODE("Sub", null, {
 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."
+        expression: "[AST_Call|AST_Dot|AST_DotHash|AST_Sub] chain element."
     },
     _walk: function (visitor) {
         return visitor._visit(this, function() {
@@ -4646,6 +4715,26 @@ var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", "quote", {
     }
 }, AST_ObjectProperty);
 
+var AST_PrivateSetter = DEFNODE("PrivateSetter", "static", {
+    $propdoc: {
+        static: "[boolean] whether this is a static private setter"
+    },
+    $documentation: "A private setter property",
+    computed_key() {
+        return false;
+    }
+}, AST_ObjectProperty);
+
+var AST_PrivateGetter = DEFNODE("PrivateGetter", "static", {
+    $propdoc: {
+        static: "[boolean] whether this is a static private getter"
+    },
+    $documentation: "A private getter property",
+    computed_key() {
+        return false;
+    }
+}, AST_ObjectProperty);
+
 var AST_ObjectSetter = DEFNODE("ObjectSetter", "quote static", {
     $propdoc: {
         quote: "[string|undefined] the original quote character, if any",
@@ -4681,6 +4770,10 @@ var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator asyn
     }
 }, AST_ObjectProperty);
 
+var AST_PrivateMethod = DEFNODE("PrivateMethod", "", {
+    $documentation: "A private class method inside a class",
+}, AST_ConciseMethod);
+
 var AST_Class = DEFNODE("Class", "name extends properties", {
     $propdoc: {
         name: "[AST_SymbolClass|AST_SymbolDefClass?] optional class name.",
@@ -4730,6 +4823,10 @@ var AST_ClassProperty = DEFNODE("ClassProperty", "static quote", {
     }
 }, AST_ObjectProperty);
 
+var AST_ClassPrivateProperty = DEFNODE("ClassProperty", "", {
+    $documentation: "A class property for a private property",
+}, AST_ClassProperty);
+
 var AST_DefClass = DEFNODE("DefClass", null, {
     $documentation: "A class definition",
 }, AST_Class);
@@ -5130,6 +5227,7 @@ AST_Catch: AST_Catch,
 AST_Chain: AST_Chain,
 AST_Class: AST_Class,
 AST_ClassExpression: AST_ClassExpression,
+AST_ClassPrivateProperty: AST_ClassPrivateProperty,
 AST_ClassProperty: AST_ClassProperty,
 AST_ConciseMethod: AST_ConciseMethod,
 AST_Conditional: AST_Conditional,
@@ -5146,6 +5244,7 @@ AST_Destructuring: AST_Destructuring,
 AST_Directive: AST_Directive,
 AST_Do: AST_Do,
 AST_Dot: AST_Dot,
+AST_DotHash: AST_DotHash,
 AST_DWLoop: AST_DWLoop,
 AST_EmptyStatement: AST_EmptyStatement,
 AST_Exit: AST_Exit,
@@ -5183,6 +5282,9 @@ AST_ObjectKeyVal: AST_ObjectKeyVal,
 AST_ObjectProperty: AST_ObjectProperty,
 AST_ObjectSetter: AST_ObjectSetter,
 AST_PrefixedTemplateString: AST_PrefixedTemplateString,
+AST_PrivateGetter: AST_PrivateGetter,
+AST_PrivateMethod: AST_PrivateMethod,
+AST_PrivateSetter: AST_PrivateSetter,
 AST_PropAccess: AST_PropAccess,
 AST_RegExp: AST_RegExp,
 AST_Return: AST_Return,
@@ -5786,6 +5888,23 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 static   : M.static,
             });
         },
+        PropertyDefinition: function(M) {
+            let key;
+            if (M.computed) {
+                key = from_moz(M.key);
+            } else {
+                if (M.key.type !== "Identifier") throw new Error("Non-Identifier key in PropertyDefinition");
+                key = from_moz(M.key);
+            }
+
+            return new AST_ClassProperty({
+                start    : my_start_token(M),
+                end      : my_end_token(M),
+                key,
+                value    : from_moz(M.value),
+                static   : M.static,
+            });
+        },
         ArrayExpression: function(M) {
             return new AST_Array({
                 start    : my_start_token(M),
@@ -5974,7 +6093,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                         : p.type == "ArrowFunctionExpression" ? (p.params.includes(M)) ? AST_SymbolFunarg : AST_SymbolRef
                         : p.type == "ClassExpression" ? (p.id === M ? AST_SymbolClass : AST_SymbolRef)
                         : p.type == "Property" ? (p.key === M && p.computed || p.value === M ? AST_SymbolRef : AST_SymbolMethod)
-                        : p.type == "FieldDefinition" ? (p.key === M && p.computed || p.value === M ? AST_SymbolRef : AST_SymbolClassProperty)
+                        : p.type == "PropertyDefinition" || p.type === "FieldDefinition" ? (p.key === M && p.computed || p.value === M ? AST_SymbolRef : AST_SymbolClassProperty)
                         : p.type == "ClassDeclaration" ? (p.id === M ? AST_SymbolDefClass : AST_SymbolRef)
                         : p.type == "MethodDefinition" ? (p.computed ? AST_SymbolRef : AST_SymbolMethod)
                         : p.type == "CatchClause" ? AST_SymbolCatch
@@ -6273,6 +6392,19 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         };
     });
 
+    def_to_moz(AST_DotHash, function To_Moz_PrivateMemberExpression(M) {
+        return {
+            type: "MemberExpression",
+            object: to_moz(M.expression),
+            computed: false,
+            property: {
+                type: "PrivateIdentifier",
+                name: M.property
+            },
+            optional: M.optional
+        };
+    });
+
     def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) {
         var isComputed = M instanceof AST_Sub;
         return {
@@ -6365,12 +6497,38 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         if (M instanceof AST_ObjectSetter) {
             kind = "set";
         }
+        if (M instanceof AST_PrivateGetter || M instanceof AST_PrivateSetter) {
+            const kind = M instanceof AST_PrivateGetter ? "get" : "set";
+            return {
+                type: "MethodDefinition",
+                computed: false,
+                kind: kind,
+                static: M.static,
+                key: {
+                    type: "PrivateIdentifier",
+                    name: M.key.name
+                },
+                value: to_moz(M.value)
+            };
+        }
+        if (M instanceof AST_ClassPrivateProperty) {
+            return {
+                type: "PropertyDefinition",
+                key: {
+                    type: "PrivateIdentifier",
+                    name: M.key.name
+                },
+                value: to_moz(M.value),
+                computed: false,
+                static: M.static
+            };
+        }
         if (M instanceof AST_ClassProperty) {
             return {
-                type: "FieldDefinition",
-                computed,
+                type: "PropertyDefinition",
                 key,
                 value: to_moz(M.value),
+                computed,
                 static: M.static
             };
         }
@@ -6405,13 +6563,21 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 value: to_moz(M.value)
             };
         }
+
+        const key = M instanceof AST_PrivateMethod
+            ? {
+                type: "PrivateIdentifier",
+                name: M.key.name
+            }
+            : to_moz(M.key);
+
         return {
             type: "MethodDefinition",
-            computed: !(M.key instanceof AST_Symbol) || M.key instanceof AST_SymbolRef,
             kind: M.key === "constructor" ? "constructor" : "method",
+            key,
+            value: to_moz(M.value),
+            computed: !(M.key instanceof AST_Symbol) || M.key instanceof AST_SymbolRef,
             static: M.static,
-            key: to_moz(M.key),
-            value: to_moz(M.value)
         };
     });
 
@@ -7515,6 +7681,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;
     });
 
@@ -8390,6 +8557,15 @@ function OutputStream(options) {
             output.print_name(prop);
         }
     });
+    DEFPRINT(AST_DotHash, function(self, output) {
+        var expr = self.expression;
+        expr.print(output);
+        var prop = self.property;
+
+        if (self.optional) output.print("?");
+        output.print(".#");
+        output.print_name(prop);
+    });
     DEFPRINT(AST_Sub, function(self, output) {
         self.expression.print(output);
         if (self.optional) output.print("?.");
@@ -8593,6 +8769,23 @@ function OutputStream(options) {
             self.value.print(output);
         }
     });
+    DEFPRINT(AST_ClassPrivateProperty, (self, output) => {
+        if (self.static) {
+            output.print("static");
+            output.space();
+        }
+
+        output.print("#");
+        
+        print_property_name(self.key.name, self.quote, output);
+
+        if (self.value) {
+            output.print("=");
+            self.value.print(output);
+        }
+
+        output.semicolon();
+    });
     DEFPRINT(AST_ClassProperty, (self, output) => {
         if (self.static) {
             output.print("static");
@@ -8614,7 +8807,7 @@ function OutputStream(options) {
 
         output.semicolon();
     });
-    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, output) {
+    AST_ObjectProperty.DEFMETHOD("_print_getter_setter", function(type, is_private, output) {
         var self = this;
         if (self.static) {
             output.print("static");
@@ -8625,6 +8818,7 @@ function OutputStream(options) {
             output.space();
         }
         if (self.key instanceof AST_SymbolMethod) {
+            if (is_private) output.print("#");
             print_property_name(self.key.name, self.quote, output);
         } else {
             output.with_square(function() {
@@ -8634,10 +8828,27 @@ function OutputStream(options) {
         self.value._do_print(output, true);
     });
     DEFPRINT(AST_ObjectSetter, function(self, output) {
-        self._print_getter_setter("set", output);
+        self._print_getter_setter("set", false, output);
     });
     DEFPRINT(AST_ObjectGetter, function(self, output) {
-        self._print_getter_setter("get", output);
+        self._print_getter_setter("get", false, output);
+    });
+    DEFPRINT(AST_PrivateSetter, function(self, output) {
+        self._print_getter_setter("set", true, output);
+    });
+    DEFPRINT(AST_PrivateGetter, function(self, output) {
+        self._print_getter_setter("get", true, output);
+    });
+    DEFPRINT(AST_PrivateMethod, function(self, output) {
+        var type;
+        if (self.is_generator && self.async) {
+            type = "async*";
+        } else if (self.is_generator) {
+            type = "*";
+        } else if (self.async) {
+            type = "async";
+        }
+        self._print_getter_setter(type, true, output);
     });
     DEFPRINT(AST_ConciseMethod, function(self, output) {
         var type;
@@ -8648,7 +8859,7 @@ function OutputStream(options) {
         } else if (self.async) {
             type = "async";
         }
-        self._print_getter_setter(type, output);
+        self._print_getter_setter(type, false, output);
     });
     AST_Symbol.DEFMETHOD("_do_print", function(output) {
         var def = this.definition();
@@ -8688,7 +8899,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
@@ -9909,7 +10122,9 @@ AST_Toplevel.DEFMETHOD("compute_char_frequency", function(options) {
             if (this instanceof AST_Symbol && !this.unmangleable(options)) {
                 base54.consider(this.name, -1);
             } else if (options.properties) {
-                if (this instanceof AST_Dot) {
+                if (this instanceof AST_DotHash) {
+                    base54.consider("#" + this.property, -1);
+                } else if (this instanceof AST_Dot) {
                     base54.consider(this.property, -1);
                 } else if (this instanceof AST_Sub) {
                     skip_string(this.property);
@@ -9982,6 +10197,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
@@ -10026,7 +10247,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);
 
@@ -10055,7 +10275,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;
@@ -10197,6 +10419,13 @@ AST_Dot.prototype._size = function () {
     return this.property.length + 1;
 };
 
+AST_DotHash.prototype._size = function () {
+    if (this.optional) {
+        return this.property.length + 3;
+    }
+    return this.property.length + 2;
+};
+
 AST_Sub.prototype._size = function () {
     return this.optional ? 4 : 2;
 };
@@ -10264,6 +10493,14 @@ AST_ConciseMethod.prototype._size = function () {
     return static_size(this.static) + key_size(this.key) + lambda_modifiers(this);
 };
 
+AST_PrivateMethod.prototype._size = function () {
+    return AST_ConciseMethod.prototype._size.call(this) + 1;
+};
+
+AST_PrivateGetter.prototype._size = AST_PrivateSetter.prototype._size = function () {
+    return AST_ConciseMethod.prototype._size.call(this) + 4;
+};
+
 AST_Class.prototype._size = function () {
     return (
         (this.name ? 8 : 7)
@@ -10279,6 +10516,10 @@ AST_ClassProperty.prototype._size = function () {
     );
 };
 
+AST_ClassPrivateProperty.prototype._size = function () {
+    return AST_ClassProperty.prototype._size.call(this) + 1;
+};
+
 AST_Symbol.prototype._size = function () {
     return !mangle_options || this.definition().unmangleable(mangle_options)
         ? this.name.length
@@ -10411,11 +10652,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 {
@@ -10458,7 +10696,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,
@@ -10758,7 +10996,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;
@@ -11063,9 +11301,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) {
@@ -11618,8 +11853,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
@@ -12788,7 +13026,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) {
@@ -13130,9 +13374,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;
@@ -13313,6 +13555,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);
@@ -13345,12 +13595,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;
                 }
@@ -13402,6 +13659,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 {
@@ -13501,7 +13759,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));
@@ -13571,7 +13829,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))
         ) {
@@ -13635,7 +13893,7 @@ const pure_prop_access_globals = new Set([
     def_has_side_effects(AST_ObjectProperty, function(compressor) {
         return (
             this.computed_key() && this.key.has_side_effects(compressor)
-            || this.value.has_side_effects(compressor)
+            || this.value && this.value.has_side_effects(compressor)
         );
     });
     def_has_side_effects(AST_ClassProperty, function(compressor) {
@@ -13733,7 +13991,7 @@ const pure_prop_access_globals = new Set([
     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.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);
@@ -13763,7 +14021,7 @@ const pure_prop_access_globals = new Set([
     });
     def_may_throw(AST_ObjectProperty, function(compressor) {
         // TODO key may throw too
-        return this.value.may_throw(compressor);
+        return this.value ? this.value.may_throw(compressor) : false;
     });
     def_may_throw(AST_ClassProperty, function(compressor) {
         return (
@@ -13897,7 +14155,7 @@ const pure_prop_access_globals = new Set([
         return this.properties.every((l) => l.is_constant_expression());
     });
     def_is_constant_expression(AST_ObjectProperty, function() {
-        return !(this.key instanceof AST_Node) && this.value.is_constant_expression();
+        return !!(!(this.key instanceof AST_Node) && this.value && this.value.is_constant_expression());
     });
 })(function(node, func) {
     node.DEFMETHOD("is_constant_expression", func);
@@ -14611,7 +14869,7 @@ AST_Scope.DEFMETHOD("hoist_properties", function(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);
@@ -14724,7 +14982,7 @@ AST_Scope.DEFMETHOD("hoist_properties", function(compressor) {
     def_drop_side_effect_free(AST_ObjectProperty, function(compressor, first_in_statement) {
         const computed_key = this instanceof AST_ObjectKeyVal && this.key instanceof AST_Node;
         const key = computed_key && this.key.drop_side_effect_free(compressor, first_in_statement);
-        const value = this.value.drop_side_effect_free(compressor, first_in_statement);
+        const value = this.value && this.value.drop_side_effect_free(compressor, first_in_statement);
         if (key && value) {
             return make_sequence(this, [key, value]);
         }
@@ -15631,7 +15889,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()) {
@@ -16657,19 +16915,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;
@@ -16685,6 +16950,7 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
                 }
             }
         }
+
         if (single_use && fixed instanceof AST_Lambda) {
             single_use =
                 def.scope === self.scope
@@ -16694,15 +16960,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) {
@@ -16779,6 +17036,7 @@ def_optimize(AST_SymbolRef, function(self, compressor) {
             }
         }
     }
+
     return self;
 });
 
@@ -17365,27 +17623,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;
                         })
                     }),
@@ -17982,13 +18253,13 @@ async function SourceMap(options) {
     });
 
     var orig_map;
-    var generator = new MOZ_SourceMap.SourceMapGenerator({
+    var generator = new MOZ_SourceMap__default['default'].SourceMapGenerator({
         file       : options.file,
         sourceRoot : options.root
     });
 
     if (options.orig) {
-        orig_map = await new MOZ_SourceMap.SourceMapConsumer(options.orig);
+        orig_map = await new MOZ_SourceMap__default['default'].SourceMapConsumer(options.orig);
         orig_map.sources.forEach(function(source) {
             var sourceContent = orig_map.sourceContentFor(source, true);
             if (sourceContent) {
@@ -22153,6 +22424,7 @@ var domprops = [
     "exponent",
     "exponentialRampToValueAtTime",
     "exportKey",
+    "exports",
     "extend",
     "extensions",
     "extentNode",
@@ -25936,7 +26208,10 @@ function mangle_properties(ast, options) {
     if (!options.builtins) find_builtins(reserved);
 
     var cname = -1;
+    var cprivate = -1;
+
     var cache;
+    var private_cache = new Map();
     if (options.cache) {
         cache = options.cache.props;
         cache.forEach(function(mangled_name) {
@@ -25959,12 +26234,20 @@ function mangle_properties(ast, options) {
 
     var names_to_mangle = new Set();
     var unmangleable = new Set();
+    var private_properties = new Set();
 
     var keep_quoted_strict = options.keep_quoted === "strict";
 
     // step 1: find candidates to mangle
     ast.walk(new TreeWalker(function(node) {
-        if (node instanceof AST_ObjectKeyVal) {
+        if (
+            node instanceof AST_ClassPrivateProperty
+            || node instanceof AST_PrivateMethod
+        ) {
+            private_properties.add(node.key.name);
+        } else if (node instanceof AST_DotHash) {
+            private_properties.add(node.property);
+        } else if (node instanceof AST_ObjectKeyVal) {
             if (typeof node.key == "string" &&
                 (!keep_quoted_strict || !node.quote)) {
                 add(node.key);
@@ -26001,7 +26284,14 @@ function mangle_properties(ast, options) {
 
     // step 2: transform the tree, renaming properties
     return ast.transform(new TreeTransformer(function(node) {
-        if (node instanceof AST_ObjectKeyVal) {
+        if (
+            node instanceof AST_ClassPrivateProperty
+            || node instanceof AST_PrivateMethod
+        ) {
+            node.key.name = mangle_private(node.key.name);
+        } else if (node instanceof AST_DotHash) {
+            node.property = mangle_private(node.property);
+        } else if (node instanceof AST_ObjectKeyVal) {
             if (typeof node.key == "string" &&
                 (!keep_quoted_strict || !node.quote)) {
                 node.key = mangle(node.key);
@@ -26081,6 +26371,16 @@ function mangle_properties(ast, options) {
         return mangled;
     }
 
+    function mangle_private(name) {
+        let mangled = private_cache.get(name);
+        if (!mangled) {
+            mangled = base54(++cprivate);
+            private_cache.set(name, mangled);
+        }
+
+        return mangled;
+    }
+
     function mangleStrings(node) {
         return node.transform(new TreeTransformer(function(node) {
             if (node instanceof AST_Sequence) {
@@ -26156,6 +26456,7 @@ async function minify(files, options) {
         rename: undefined,
         safari10: false,
         sourceMap: false,
+        spidermonkey: false,
         timings: false,
         toplevel: false,
         warnings: false,
@@ -26227,20 +26528,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") {
@@ -26276,6 +26589,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({
@@ -26293,6 +26609,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();
@@ -26363,7 +26680,7 @@ async function run_cli({ program, packageJson, fs, path }) {
     program.option("-m, --mangle [options]", "Mangle names/specify mangler options.", parse_js());
     program.option("--mangle-props [options]", "Mangle properties/specify mangler options.", parse_js());
     program.option("-f, --format [options]", "Format options.", parse_js());
-    program.option("-b, --beautify [options]", "Alias for --format beautify=true.", parse_js());
+    program.option("-b, --beautify [options]", "Alias for --format.", parse_js());
     program.option("-o, --output <file>", "Output file (default STDOUT).");
     program.option("--comments [filter]", "Preserve copyright comments in the output.");
     program.option("--config-file <file>", "Read minify() options from JSON file.");
@@ -26414,19 +26731,9 @@ async function run_cli({ program, packageJson, fs, path }) {
         else
             options.ecma = ecma;
     }
-    if (program.beautify || program.format) {
-        if (program.beautify && program.format) {
-            fatal("Please only specify one of --beautify or --format");
-        }
-        if (program.beautify) {
-            options.format = typeof program.beautify == "object" ? program.beautify : {};
-            if (!("beautify" in options.format)) {
-                options.format.beautify = true;
-            }
-        }
-        if (program.format) {
-            options.format = typeof program.format == "object" ? program.format : {};
-        }
+    if (program.format || program.beautify) {
+        const chosenOption = program.format || program.beautify;
+        options.format = typeof chosenOption === "object" ? chosenOption : {};
     }
     if (program.comments) {
         if (typeof options.format != "object") options.format = {};