terser 5.4.0 → 5.6.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);
 
 /***********************************************************************
 
@@ -482,12 +484,14 @@ function is_identifier_char(ch) {
     return UNICODE.ID_Continue.test(ch);
 }
 
+const BASIC_IDENT = /^[a-z_$][a-z0-9_$]*$/i;
+
 function is_basic_identifier_string(str) {
-    return /^[a-z_$][a-z0-9_$]*$/i.test(str);
+    return BASIC_IDENT.test(str);
 }
 
 function is_identifier_string(str, allow_surrogates) {
-    if (/^[a-z_$][a-z0-9_$]*$/i.test(str)) {
+    if (BASIC_IDENT.test(str)) {
         return true;
     }
     if (!allow_surrogates && /[\ud800-\udfff]/.test(str)) {
@@ -1033,6 +1037,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 {
@@ -1102,6 +1111,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 + "'");
@@ -1302,6 +1312,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();
@@ -1586,7 +1603,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();
@@ -2083,7 +2100,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);
         }
@@ -2703,6 +2720,7 @@ function parse($TEXT, options) {
             }
             return name;
         };
+        var privatename = start.type == "privatename";
         var is_async = false;
         var is_static = false;
         var is_generator = false;
@@ -2710,16 +2728,19 @@ function parse($TEXT, options) {
         if (is_class && name === "static" && !is("punc", "(")) {
             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", "=")) {
             is_async = true;
             property_token = S.token;
+            privatename = property_token.type == "privatename";
             name = as_property_name();
         }
         if (name === null) {
             is_generator = true;
             property_token = S.token;
+            privatename = property_token.type == "privatename";
             name = as_property_name();
             if (name === null) {
                 unexpected();
@@ -2727,7 +2748,10 @@ function parse($TEXT, options) {
         }
         if (is("punc", "(")) {
             name = get_method_name_ast(name, start);
-            var node = new AST_ConciseMethod({
+            const AST_MethodVariant = privatename
+                ? AST_PrivateMethod
+                : AST_ConciseMethod;
+            var node = new AST_MethodVariant({
                 start       : start,
                 static      : is_static,
                 is_generator: is_generator,
@@ -2741,6 +2765,23 @@ 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);
@@ -2773,9 +2814,12 @@ function parse($TEXT, options) {
             const quote = key instanceof AST_SymbolClassProperty
                 ? property_token.quote
                 : undefined;
+            const AST_ClassPropertyVariant = privatename
+                ? AST_ClassPrivateProperty
+                : AST_ClassProperty;
             if (is("operator", "=")) {
                 next();
-                return new AST_ClassProperty({
+                return new AST_ClassPropertyVariant({
                     start,
                     static: is_static,
                     quote,
@@ -2783,8 +2827,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,
@@ -3023,6 +3073,7 @@ function parse($TEXT, options) {
             }
             /* falls through */
           case "name":
+          case "privatename":
           case "string":
           case "num":
           case "big_int":
@@ -3037,7 +3088,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;
     }
@@ -3108,7 +3159,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,
@@ -3159,8 +3211,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,
@@ -3231,13 +3284,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();
@@ -4450,7 +4499,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 ?.)"
     }
@@ -4471,6 +4520,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) {
@@ -4488,7 +4549,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() {
@@ -4644,6 +4705,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",
@@ -4679,6 +4760,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.",
@@ -4728,6 +4813,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);
@@ -5128,6 +5217,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,
@@ -5144,6 +5234,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,
@@ -5181,6 +5272,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,
@@ -5784,6 +5878,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),
@@ -5972,7 +6083,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
@@ -6271,6 +6382,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 {
@@ -6363,12 +6487,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
             };
         }
@@ -6403,13 +6553,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)
         };
     });
 
@@ -6824,7 +6982,7 @@ function OutputStream(options) {
     let printed_comments = new Set();
 
     var to_utf8 = options.ascii_only ? function(str, identifier) {
-        if (options.ecma >= 2015) {
+        if (options.ecma >= 2015 && !options.safari10) {
             str = str.replace(/[\ud800-\udbff][\udc00-\udfff]/g, function(ch) {
                 var code = get_full_char_code(ch, 0).toString(16);
                 return "\\u{" + code + "}";
@@ -8364,7 +8522,10 @@ function OutputStream(options) {
         var prop = self.property;
         var print_computed = RESERVED_WORDS.has(prop)
             ? output.option("ie8")
-            : !is_identifier_string(prop, output.option("ecma") >= 2015);
+            : !is_identifier_string(
+                prop,
+                output.option("ecma") >= 2015 || output.option("safari10")
+            );
 
         if (self.optional) output.print("?.");
 
@@ -8385,6 +8546,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("?.");
@@ -8534,7 +8704,7 @@ function OutputStream(options) {
         var print_string = RESERVED_WORDS.has(key)
             ? output.option("ie8")
             : (
-                output.option("ecma") < 2015
+                output.option("ecma") < 2015 || output.option("safari10")
                     ? !is_basic_identifier_string(key)
                     : !is_identifier_string(key, true)
             );
@@ -8553,7 +8723,10 @@ function OutputStream(options) {
         var allowShortHand = output.option("shorthand");
         if (allowShortHand &&
             self.value instanceof AST_Symbol &&
-            is_identifier_string(self.key, output.option("ecma") >= 2015) &&
+            is_identifier_string(
+                self.key,
+                output.option("ecma") >= 2015 || output.option("safari10")
+            ) &&
             get_name(self.value) === self.key &&
             !RESERVED_WORDS.has(self.key)
         ) {
@@ -8562,7 +8735,10 @@ function OutputStream(options) {
         } else if (allowShortHand &&
             self.value instanceof AST_DefaultAssign &&
             self.value.left instanceof AST_Symbol &&
-            is_identifier_string(self.key, output.option("ecma") >= 2015) &&
+            is_identifier_string(
+                self.key,
+                output.option("ecma") >= 2015 || output.option("safari10")
+            ) &&
             get_name(self.value.left) === self.key
         ) {
             print_property_name(self.key, self.quote, output);
@@ -8582,6 +8758,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");
@@ -8603,7 +8796,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");
@@ -8614,6 +8807,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() {
@@ -8623,10 +8817,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;
@@ -8637,7 +8848,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();
@@ -9898,7 +10109,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);
@@ -10186,6 +10399,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;
 };
@@ -10253,6 +10473,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)
@@ -10268,6 +10496,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
@@ -13624,7 +13856,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) {
@@ -13752,7 +13984,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 (
@@ -13886,7 +14118,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);
@@ -14713,7 +14945,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]);
         }
@@ -16436,7 +16668,7 @@ def_optimize(AST_Binary, function(self, compressor) {
                 var l = self.left;
                 var r = self.right.evaluate(compressor);
                 if (r != self.right) {
-                    l.segments[l.segments.length - 1].value += r.toString();
+                    l.segments[l.segments.length - 1].value += String(r);
                     return l;
                 }
             }
@@ -16445,7 +16677,7 @@ def_optimize(AST_Binary, function(self, compressor) {
                 var r = self.right;
                 var l = self.left.evaluate(compressor);
                 if (l != self.left) {
-                    r.segments[0].value = l.toString() + r.segments[0].value ;
+                    r.segments[0].value = String(l) + r.segments[0].value;
                     return r;
                 }
             }
@@ -17971,13 +18203,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) {
@@ -25925,7 +26157,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) {
@@ -25948,12 +26183,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);
@@ -25990,7 +26233,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);
@@ -26070,6 +26320,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) {
@@ -26352,7 +26612,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.");
@@ -26403,19 +26663,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 = {};
@@ -26822,4 +27072,3 @@ exports._run_cli = run_cli;
 exports.minify = minify;
 
 })));
-//# sourceMappingURL=bundle.min.js.map