terser 5.5.1 → 5.7.0

package/lib/mozilla-ast.js

@@ -63,6 +63,7 @@ import {
     AST_Class,
     AST_ClassExpression,
     AST_ClassProperty,
+    AST_ClassPrivateProperty,
     AST_ConciseMethod,
     AST_Conditional,
     AST_Const,
@@ -78,6 +79,7 @@ import {
     AST_Directive,
     AST_Do,
     AST_Dot,
+    AST_DotHash,
     AST_EmptyStatement,
     AST_Expansion,
     AST_Export,
@@ -108,6 +110,9 @@ import {
     AST_ObjectProperty,
     AST_ObjectSetter,
     AST_PrefixedTemplateString,
+    AST_PrivateGetter,
+    AST_PrivateMethod,
+    AST_PrivateSetter,
     AST_PropAccess,
     AST_RegExp,
     AST_Return,
@@ -386,6 +391,23 @@ import {
                 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),
@@ -574,7 +596,7 @@ import {
                         : 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
@@ -873,6 +895,19 @@ import {
         };
     });
 
+    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 {
@@ -965,12 +1000,38 @@ import {
         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
             };
         }
@@ -1005,13 +1066,21 @@ import {
                 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)
         };
     });
 

package/lib/output.js

@@ -68,8 +68,12 @@ import {
     AST_Chain,
     AST_Class,
     AST_ClassExpression,
+    AST_ClassPrivateProperty,
     AST_ClassProperty,
     AST_ConciseMethod,
+    AST_PrivateGetter,
+    AST_PrivateMethod,
+    AST_PrivateSetter,
     AST_Conditional,
     AST_Const,
     AST_Constant,
@@ -83,6 +87,7 @@ import {
     AST_Directive,
     AST_Do,
     AST_Dot,
+    AST_DotHash,
     AST_EmptyStatement,
     AST_Exit,
     AST_Expansion,
@@ -928,6 +933,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;
     });
 
@@ -1803,6 +1809,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("?.");
@@ -2006,6 +2021,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");
@@ -2027,7 +2059,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");
@@ -2038,6 +2070,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() {
@@ -2047,10 +2080,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;
@@ -2061,7 +2111,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();
@@ -2101,7 +2151,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

package/lib/parse.js

@@ -65,8 +65,12 @@ import {
     AST_Catch,
     AST_Chain,
     AST_ClassExpression,
+    AST_ClassPrivateProperty,
     AST_ClassProperty,
     AST_ConciseMethod,
+    AST_PrivateGetter,
+    AST_PrivateMethod,
+    AST_PrivateSetter,
     AST_Conditional,
     AST_Const,
     AST_Continue,
@@ -80,6 +84,7 @@ import {
     AST_Directive,
     AST_Do,
     AST_Dot,
+    AST_DotHash,
     AST_EmptyStatement,
     AST_Expansion,
     AST_Export,
@@ -97,7 +102,6 @@ import {
     AST_Label,
     AST_LabeledStatement,
     AST_LabelRef,
-    AST_Lambda,
     AST_Let,
     AST_NameMapping,
     AST_New,
@@ -868,6 +872,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 {
@@ -937,6 +946,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 + "'");
@@ -1137,6 +1147,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();
@@ -1275,7 +1292,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();
@@ -1421,7 +1438,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();
@@ -1918,7 +1935,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);
         }
@@ -2470,7 +2487,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
@@ -2481,7 +2498,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") {
@@ -2514,9 +2535,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()
@@ -2526,43 +2547,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,
@@ -2575,42 +2627,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, property_token);
+            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,
@@ -2618,8 +2646,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,
@@ -2821,8 +2855,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 {
@@ -2858,6 +2901,7 @@ function parse($TEXT, options) {
             }
             /* falls through */
           case "name":
+          case "privatename":
           case "string":
           case "num":
           case "big_int":
@@ -2872,7 +2916,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;
     }
@@ -2943,7 +2987,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,
@@ -2994,8 +3039,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,
@@ -3066,13 +3112,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();