terser 5.41.0 → 5.43.0

package/dist/bundle.min.js

@@ -329,7 +329,6 @@ ALL_RESERVED_WORDS = makePredicate(ALL_RESERVED_WORDS);
 
 var OPERATOR_CHARS = makePredicate(characters("+-*&%=<>!?|~^"));
 
-var RE_NUM_LITERAL = /[0-9a-f]/i;
 var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;
 var RE_OCT_NUMBER = /^0[0-7]+$/;
 var RE_ES6_OCT_NUMBER = /^0o[0-7]+$/i;
@@ -694,15 +693,16 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
                 return after_e;
               case (after_e = false, 46): // .
                 return (!has_dot && !has_x && !has_e) ? (has_dot = true) : false;
-            }
-
-            if (ch === "n") {
+              case 110: // n
                 is_big_int = true;
-
                 return true;
             }
 
-            return RE_NUM_LITERAL.test(ch);
+            return (
+                code >= 48 && code <= 57 // 0-9
+                || code >= 97 && code <= 102 // a-f
+                || code >= 65 && code <= 70 // A-F
+            );
         });
         if (prefix) num = prefix + num;
 
@@ -719,7 +719,7 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
             }
             num = num.replace(/_/g, "");
         }
-        if (num.endsWith("n")) {
+        if (is_big_int) {
             const without_n = num.slice(0, -1);
             const allow_e = RE_HEX_NUMBER.test(without_n);
             const valid = parse_js_number(without_n, allow_e);
@@ -894,7 +894,24 @@ function tokenizer($TEXT, filename, html5_comments, shebang) {
         return next_token;
     });
 
-    var read_name = with_eof_error("Unterminated identifier name", function() {
+    var read_name = function () {
+        let start = S.pos, end = start - 1, ch = "c";
+
+        while (
+            (ch = S.text.charAt(++end))
+            && (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z")
+        );
+
+        if (end > start + 1 && ch && ch !== "\\" && !is_identifier_char(ch)) {
+            S.pos += end - start;
+            S.col += end - start;
+            return S.text.slice(start, S.pos);
+        }
+
+        return read_name_hard();
+    };
+
+    var read_name_hard = with_eof_error("Unterminated identifier name", function() {
         var name = [], ch, escaped = false;
         var read_escaped_identifier_char = function() {
             escaped = true;
@@ -1694,10 +1711,10 @@ function parse($TEXT, options) {
         });
     };
 
-    var function_ = function(ctor, is_generator_property, is_async, is_export_default) {
+    var function_ = function(ctor, is_generator, is_async, is_export_default) {
         var in_statement = ctor === AST_Defun;
-        var is_generator = is("operator", "*");
-        if (is_generator) {
+        if (is("operator", "*")) {
+            is_generator = true;
             next();
         }
 
@@ -1714,11 +1731,11 @@ function parse($TEXT, options) {
             unexpected(prev());
 
         var args = [];
-        var body = _function_body(true, is_generator || is_generator_property, is_async, name, args);
+        var body = _function_body(true, is_generator, is_async, name, args);
         return new ctor({
             start : args.start,
             end   : body.end,
-            is_generator: is_generator || is_generator_property,
+            is_generator: is_generator,
             async : is_async,
             name  : name,
             argnames: args,
@@ -2794,8 +2811,6 @@ function parse($TEXT, options) {
             var node = new AST_MethodVariant({
                 start       : start,
                 static      : is_static,
-                is_generator: is_generator,
-                async       : is_async,
                 key         : name,
                 quote       : name instanceof AST_SymbolMethod ?
                               property_token.quote : undefined,
@@ -5775,12 +5790,10 @@ var AST_ObjectGetter = DEFNODE("ObjectGetter", "quote static", function AST_Obje
     }
 }, AST_ObjectProperty);
 
-var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator async", function AST_ConciseMethod(props) {
+var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static", function AST_ConciseMethod(props) {
     if (props) {
         this.quote = props.quote;
         this.static = props.static;
-        this.is_generator = props.is_generator;
-        this.async = props.async;
         this.key = props.key;
         this.value = props.value;
         this.start = props.start;
@@ -5793,8 +5806,6 @@ var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator asyn
     $propdoc: {
         quote: "[string|undefined] the original quote character, if any",
         static: "[boolean] is this method static (classes only)",
-        is_generator: "[boolean] is this a generator method",
-        async: "[boolean] is this method async",
     },
     $documentation: "An ES6 concise method inside an object or class",
     computed_key() {
@@ -5802,11 +5813,9 @@ var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator asyn
     }
 }, AST_ObjectProperty);
 
-var AST_PrivateMethod = DEFNODE("PrivateMethod", "", function AST_PrivateMethod(props) {
+var AST_PrivateMethod = DEFNODE("PrivateMethod", "static", function AST_PrivateMethod(props) {
     if (props) {
         this.static = props.static;
-        this.is_generator = props.is_generator;
-        this.async = props.async;
         this.key = props.key;
         this.value = props.value;
         this.start = props.start;
@@ -5816,6 +5825,9 @@ var AST_PrivateMethod = DEFNODE("PrivateMethod", "", function AST_PrivateMethod(
     this.flags = 0;
 }, {
     $documentation: "A private class method inside a class",
+    $propdoc: {
+        static: "[boolean] is this a static private method",
+    },
     computed_key() {
         return false;
     },
@@ -6806,6 +6818,28 @@ class TreeWalker {
         }
     }
 
+    is_within_loop() {
+        let i = this.stack.length - 1;
+        let child = this.stack[i];
+        while (i--) {
+            const node = this.stack[i];
+
+            if (node instanceof AST_Lambda) return false;
+            if (
+                node instanceof AST_IterationStatement
+                // exclude for-loop bits that only run once
+                && !((node instanceof AST_For) && child === node.init)
+                && !((node instanceof AST_ForIn || node instanceof AST_ForOf) && child === node.object)
+            ) {
+                return true;
+            }
+
+            child = node;
+        }
+
+        return false;
+    }
+
     find_scope() {
         var stack = this.stack;
         for (var i = stack.length; --i >= 0;) {
@@ -7181,6 +7215,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 body[i] = new AST_Directive({
                     start: body[i].start,
                     end: body[i].end,
+                    quote: '"',
                     value: body[i].body.value
                 });
             } else {
@@ -7304,8 +7339,8 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             return new AST_Defun({
                 start: my_start_token(M),
                 end: my_end_token(M),
-                name: from_moz(M.id),
-                argnames: M.params.map(from_moz),
+                name: M.id && from_moz_symbol(AST_SymbolDefun, M.id),
+                argnames: M.params.map(M => from_moz_pattern(M, AST_SymbolFunarg)),
                 is_generator: M.generator,
                 async: M.async,
                 body: normalize_directives(from_moz(M.body).body)
@@ -7313,15 +7348,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         },
 
         FunctionExpression: function(M) {
-            return new AST_Function({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                name: from_moz(M.id),
-                argnames: M.params.map(from_moz),
-                is_generator: M.generator,
-                async: M.async,
-                body: normalize_directives(from_moz(M.body).body)
-            });
+            return from_moz_lambda(M, /*is_method=*/false);
         },
 
         ArrowFunctionExpression: function(M) {
@@ -7331,7 +7358,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             return new AST_Arrow({
                 start: my_start_token(M),
                 end: my_end_token(M),
-                argnames: M.params.map(from_moz),
+                argnames: M.params.map(p => from_moz_pattern(p, AST_SymbolFunarg)),
                 body,
                 async: M.async,
             });
@@ -7360,59 +7387,48 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         },
 
         Property: function(M) {
-            var key = M.key;
-            var args = {
-                start    : my_start_token(key || M.value),
-                end      : my_end_token(M.value),
-                key      : key.type == "Identifier" ? key.name : key.value,
-                quote    : !key.computed && key.type === "Literal" && typeof key.value === "string"
-                            ? '"'
-                            : null,
-                value    : from_moz(M.value)
-            };
-            if (M.computed) {
-                args.key = from_moz(M.key);
-            }
-            if (M.method) {
-                args.is_generator = M.value.generator;
-                args.async = M.value.async;
-                if (!M.computed) {
-                    args.key = new AST_SymbolMethod({ name: args.key });
-                } else {
-                    args.key = from_moz(M.key);
-                }
-                return new AST_ConciseMethod(args);
-            }
-            if (M.kind == "init") {
-                if (key.type != "Identifier" && key.type != "Literal") {
-                    args.key = from_moz(key);
-                }
+            if (M.kind == "init" && !M.method) {
+                var args = {
+                    start    : my_start_token(M.key || M.value),
+                    end      : my_end_token(M.value),
+                    key      : M.computed
+                                ? from_moz(M.key)
+                                : M.key.name || String(M.key.value),
+                    quote    : from_moz_quote(M.key, M.computed),
+                    static   : false, // always an object
+                    value    : from_moz(M.value)
+                };
+
                 return new AST_ObjectKeyVal(args);
-            }
-            if (typeof args.key === "string" || typeof args.key === "number") {
-                args.key = new AST_SymbolMethod({
-                    name: args.key
-                });
-            }
-            args.value = new AST_Accessor(args.value);
-            if (M.kind == "get") return new AST_ObjectGetter(args);
-            if (M.kind == "set") return new AST_ObjectSetter(args);
-            if (M.kind == "method") {
-                args.async = M.value.async;
-                args.is_generator = M.value.generator;
-                return new AST_ConciseMethod(args);
+            } else {
+                var value = from_moz_lambda(M.value, /*is_method=*/true);
+                var args = {
+                    start    : my_start_token(M.key || M.value),
+                    end      : my_end_token(M.value),
+                    key      : M.computed
+                                ? from_moz(M.key)
+                                : from_moz_symbol(AST_SymbolMethod, M.key),
+                    quote    : from_moz_quote(M.key, M.computed),
+                    static   : false, // always an object
+                    value,
+                };
+
+                if (M.kind == "get") return new AST_ObjectGetter(args);
+                if (M.kind == "set") return new AST_ObjectSetter(args);
+                if (M.method) return new AST_ConciseMethod(args);
             }
         },
 
         MethodDefinition: function(M) {
             const is_private = M.key.type === "PrivateIdentifier";
-            const key = M.computed ? from_moz(M.key) : new AST_SymbolMethod({ name: M.key.name || M.key.value });
+            const key = M.computed ? from_moz(M.key) : new AST_SymbolMethod({ name: M.key.name || String(M.key.value) });
 
             var args = {
                 start    : my_start_token(M),
                 end      : my_end_token(M),
                 key,
-                value    : from_moz(M.value),
+                quote    : from_moz_quote(M.key, M.computed),
+                value    : from_moz_lambda(M.value, /*is_method=*/true),
                 static   : M.static,
             };
             if (M.kind == "get") {
@@ -7421,8 +7437,6 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             if (M.kind == "set") {
                 return new (is_private ? AST_PrivateSetter : AST_ObjectSetter)(args);
             }
-            args.is_generator = M.value.generator;
-            args.async = M.value.async;
             return new (is_private ? AST_PrivateMethod : AST_ConciseMethod)(args);
         },
 
@@ -7437,6 +7451,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             return new AST_ClassProperty({
                 start    : my_start_token(M),
                 end      : my_end_token(M),
+                quote    : from_moz_quote(M.key, M.computed),
                 key,
                 value    : from_moz(M.value),
                 static   : M.static,
@@ -7456,15 +7471,13 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                     static   : M.static,
                 });
             } else {
-                if (M.key.type !== "Identifier") {
-                    throw new Error("Non-Identifier key in PropertyDefinition");
-                }
-                key = from_moz(M.key);
+                key = from_moz_symbol(AST_SymbolClassProperty, M.key);
             }
 
             return new AST_ClassProperty({
                 start    : my_start_token(M),
                 end      : my_end_token(M),
+                quote    : from_moz_quote(M.key, M.computed),
                 key,
                 value    : from_moz(M.value),
                 static   : M.static,
@@ -7556,11 +7569,30 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         },
 
         VariableDeclaration: function(M) {
-            return new (M.kind === "const" ? AST_Const :
-                        M.kind === "let" ? AST_Let : AST_Var)({
+            let decl_type;
+            let sym_type;
+            if (M.kind === "const") {
+                decl_type = AST_Const;
+                sym_type = AST_SymbolConst;
+            } else if (M.kind === "let") {
+                decl_type = AST_Let;
+                sym_type = AST_SymbolLet;
+            } else {
+                decl_type = AST_Var;
+                sym_type = AST_SymbolVar;
+            }
+            const definitions = M.declarations.map(M => {
+                return new AST_VarDef({
+                    start: my_start_token(M),
+                    end: my_end_token(M),
+                    name: from_moz_pattern(M.id, sym_type),
+                    value: from_moz(M.init),
+                });
+            });
+            return new decl_type({
                 start       : my_start_token(M),
                 end         : my_end_token(M),
-                definitions : M.declarations.map(from_moz)
+                definitions : definitions,
             });
         },
 
@@ -7589,13 +7621,13 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             return new AST_NameMapping({
                 start: my_start_token(M),
                 end: my_end_token(M),
-                foreign_name: from_moz(M.imported),
-                name: from_moz(M.local)
+                foreign_name: from_moz_symbol(AST_SymbolImportForeign, M.imported, M.imported.type === "Literal"),
+                name: from_moz_symbol(AST_SymbolImport, M.local)
             });
         },
 
         ImportDefaultSpecifier: function(M) {
-            return from_moz(M.local);
+            return from_moz_symbol(AST_SymbolImport, M.local);
         },
 
         ImportNamespaceSpecifier: function(M) {
@@ -7603,7 +7635,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 start: my_start_token(M),
                 end: my_end_token(M),
                 foreign_name: new AST_SymbolImportForeign({ name: "*" }),
-                name: from_moz(M.local)
+                name: from_moz_symbol(AST_SymbolImport, M.local)
             });
         },
 
@@ -7625,15 +7657,17 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         },
 
         ExportAllDeclaration: function(M) {
-            var foreign_name = M.exported == null ? 
+            var foreign_name = M.exported == null ?
                 new AST_SymbolExportForeign({ name: "*" }) :
-                from_moz(M.exported);
+                from_moz_symbol(AST_SymbolExportForeign, M.exported, M.exported.type === "Literal");
             return new AST_Export({
                 start: my_start_token(M),
                 end: my_end_token(M),
                 exported_names: [
                     new AST_NameMapping({
-                        name: new AST_SymbolExportForeign({ name: "*" }),
+                        start: my_start_token(M),
+                        end: my_end_token(M),
+                        name: new AST_SymbolExport({ name: "*" }),
                         foreign_name: foreign_name
                     })
                 ],
@@ -7676,8 +7710,10 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
 
         ExportSpecifier: function(M) {
             return new AST_NameMapping({
-                foreign_name: from_moz(M.exported),
-                name: from_moz(M.local)
+                start: my_start_token(M),
+                end: my_end_token(M),
+                foreign_name: from_moz_symbol(AST_SymbolExportForeign, M.exported, M.exported.type === "Literal"),
+                name: from_moz_symbol(AST_SymbolExport, M.local, M.local.type === "Literal"),
             });
         },
 
@@ -7706,27 +7742,13 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             const bi = typeof M.value === "bigint" ? M.value.toString() : M.bigint;
             if (typeof bi === "string") {
                 args.value = bi;
+                args.raw = M.raw;
                 return new AST_BigInt(args);
             }
             if (val === null) return new AST_Null(args);
             switch (typeof val) {
               case "string":
                 args.quote = "\"";
-                var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
-                if (p.type == "ImportSpecifier") {
-                    args.name = val;
-                    return new AST_SymbolImportForeign(args);
-                } else if (p.type == "ExportSpecifier") {
-                    args.name = val;
-                    if (M == p.exported) {
-                        return new AST_SymbolExportForeign(args);
-                    } else {
-                        return new AST_SymbolExport(args);
-                    }
-                } else if (p.type == "ExportAllDeclaration" && M == p.exported) {
-                    args.name = val;
-                    return new AST_SymbolExportForeign(args);
-                }
                 args.value = val;
                 return new AST_String(args);
               case "number":
@@ -7753,27 +7775,11 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         },
 
         Identifier: function(M) {
-            var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
-            var q = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 3];
-            return new (  p.type == "LabeledStatement" ? AST_Label
-                        : p.type == "VariableDeclarator" && p.id === M ? (q.kind == "const" ? AST_SymbolConst : q.kind == "let" ? AST_SymbolLet : AST_SymbolVar)
-                        : /Import.*Specifier/.test(p.type) ? (p.local === M ? AST_SymbolImport : AST_SymbolImportForeign)
-                        : p.type == "ExportSpecifier" ? (p.local === M ? AST_SymbolExport : AST_SymbolExportForeign)
-                        : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
-                        : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
-                        : 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 == "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
-                        : p.type == "BreakStatement" || p.type == "ContinueStatement" ? AST_LabelRef
-                        : AST_SymbolRef)({
-                            start : my_start_token(M),
-                            end   : my_end_token(M),
-                            name  : M.name
-                        });
+            return new AST_SymbolRef({
+                start : my_start_token(M),
+                end   : my_end_token(M),
+                name  : M.name
+            });
         },
 
         EmptyStatement: function(M) {
@@ -7802,19 +7808,28 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         },
 
         LabeledStatement: function(M) {
-            return new AST_LabeledStatement({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                label: from_moz(M.label),
-                body: from_moz(M.body)
-            });
+            try {
+                const label = from_moz_symbol(AST_Label, M.label);
+                FROM_MOZ_LABELS.push(label);
+
+                const stat = new AST_LabeledStatement({
+                    start: my_start_token(M),
+                    end: my_end_token(M),
+                    label,
+                    body: from_moz(M.body)
+                });
+
+                return stat;
+            } finally {
+                FROM_MOZ_LABELS.pop();
+            }
         },
 
         BreakStatement: function(M) {
             return new AST_Break({
                 start: my_start_token(M),
                 end: my_end_token(M),
-                label: from_moz(M.label)
+                label: from_moz_label_ref(M.label),
             });
         },
 
@@ -7822,7 +7837,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             return new AST_Continue({
                 start: my_start_token(M),
                 end: my_end_token(M),
-                label: from_moz(M.label)
+                label: from_moz_label_ref(M.label),
             });
         },
 
@@ -7934,20 +7949,11 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             });
         },
 
-        VariableDeclarator: function(M) {
-            return new AST_VarDef({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                name: from_moz(M.id),
-                value: from_moz(M.init)
-            });
-        },
-
         CatchClause: function(M) {
             return new AST_Catch({
                 start: my_start_token(M),
                 end: my_end_token(M),
-                argname: from_moz(M.param),
+                argname: M.param ? from_moz_pattern(M.param, AST_SymbolCatch) : null,
                 body: from_moz(M.body).body
             });
         },
@@ -7955,6 +7961,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         ThisExpression: function(M) {
             return new AST_This({
                 start: my_start_token(M),
+                name: "this",
                 end: my_end_token(M)
             });
         },
@@ -7962,7 +7969,8 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         Super: function(M) {
             return new AST_Super({
                 start: my_start_token(M),
-                end: my_end_token(M)
+                end: my_end_token(M),
+                name: "super",
             });
         },
 
@@ -8003,6 +8011,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 start: my_start_token(M),
                 end: my_end_token(M),
                 operator: M.operator,
+                logical: M.operator === "??=" || M.operator === "&&=" || M.operator === "||=",
                 left: from_moz(M.left),
                 right: from_moz(M.right)
             });
@@ -8055,7 +8064,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         return new (M.type === "ClassDeclaration" ? AST_DefClass : AST_ClassExpression)({
             start    : my_start_token(M),
             end      : my_end_token(M),
-            name     : from_moz(M.id),
+            name     : M.id && from_moz_symbol(M.type === "ClassDeclaration" ? AST_SymbolDefClass : AST_SymbolClass, M.id),
             extends  : from_moz(M.superClass),
             properties: M.body.body.map(from_moz)
         });
@@ -8190,13 +8199,6 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             init: to_moz(M.value)
         };
     });
-    def_to_moz(AST_Catch, function To_Moz_CatchClause(M) {
-        return {
-            type: "CatchClause",
-            param: to_moz(M.argname),
-            body: to_moz_block(M)
-        };
-    });
 
     def_to_moz(AST_This, function To_Moz_ThisExpression() {
         return {
@@ -8229,7 +8231,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             return {
                 type: "ImportExpression",
                 source,
-                options
+                options: options || null
             };
         }
 
@@ -8288,36 +8290,36 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         return {
             type: "FunctionDeclaration",
             id: to_moz(M.name),
-            params: M.argnames.map(to_moz),
+            params: M.argnames.map(to_moz_pattern),
             generator: M.is_generator,
             async: M.async,
             body: to_moz_scope("BlockStatement", M)
         };
     });
 
-    def_to_moz(AST_Function, function To_Moz_FunctionExpression(M, parent) {
-        var is_generator = parent.is_generator !== undefined ?
-            parent.is_generator : M.is_generator;
+    def_to_moz(AST_Function, function To_Moz_FunctionExpression(M) {
         return {
             type: "FunctionExpression",
             id: to_moz(M.name),
-            params: M.argnames.map(to_moz),
-            generator: is_generator,
-            async: M.async,
+            params: M.argnames.map(to_moz_pattern),
+            generator: M.is_generator || false,
+            async: M.async || false,
             body: to_moz_scope("BlockStatement", M)
         };
     });
 
     def_to_moz(AST_Arrow, function To_Moz_ArrowFunctionExpression(M) {
-        var body = {
-            type: "BlockStatement",
-            body: M.body.map(to_moz)
-        };
+        var body = M.body.length === 1 && M.body[0] instanceof AST_Return && M.body[0].value
+            ? to_moz(M.body[0].value)
+            : {
+                type: "BlockStatement",
+                body: M.body.map(to_moz)
+            };
         return {
             type: "ArrowFunctionExpression",
-            params: M.argnames.map(to_moz),
+            params: M.argnames.map(to_moz_pattern),
             async: M.async,
-            body: body
+            body: body,
         };
     });
 
@@ -8325,19 +8327,38 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         if (M.is_array) {
             return {
                 type: "ArrayPattern",
-                elements: M.names.map(to_moz)
+                elements: M.names.map(
+                    M => M instanceof AST_Hole ? null : to_moz_pattern(M)
+                ),
             };
         }
         return {
             type: "ObjectPattern",
-            properties: M.names.map(to_moz)
+            properties: M.names.map(M => {
+                if (M instanceof AST_ObjectKeyVal) {
+                    var computed = M.computed_key();
+                    const [shorthand, key] = to_moz_property_key(M.key, computed, M.quote, M.value);
+
+                    return {
+                        type: "Property",
+                        computed,
+                        kind: "init",
+                        key: key,
+                        method: false,
+                        shorthand,
+                        value: to_moz_pattern(M.value)
+                    };
+                } else {
+                    return to_moz_pattern(M);
+                }
+            }),
         };
     });
 
     def_to_moz(AST_DefaultAssign, function To_Moz_AssignmentExpression(M) {
         return {
             type: "AssignmentPattern",
-            left: to_moz(M.left),
+            left: to_moz_pattern(M.left),
             right: to_moz(M.right),
         };
     });
@@ -8382,8 +8403,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
     def_to_moz(AST_Catch, function To_Moz_CatchClause(M) {
         return {
             type: "CatchClause",
-            param: to_moz(M.argname),
-            guard: null,
+            param: M.argname != null ? to_moz_pattern(M.argname) : null,
             body: to_moz_block(M)
         };
     });
@@ -8444,10 +8464,20 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
                 attributes: import_attributes_to_moz(M.attributes)
             };
         }
-        return {
-            type: M.is_default ? "ExportDefaultDeclaration" : "ExportNamedDeclaration",
-            declaration: to_moz(M.exported_value || M.exported_definition)
-        };
+
+        if (M.is_default) {
+            return {
+                type: "ExportDefaultDeclaration",
+                declaration: to_moz(M.exported_value || M.exported_definition),
+            };
+        } else {
+            return {
+                type: "ExportNamedDeclaration",
+                declaration: to_moz(M.exported_value || M.exported_definition),
+                specifiers: [],
+                source: null,
+            };
+        }
     });
 
     def_to_moz(AST_Import, function To_Moz_ImportDeclaration(M) {
@@ -8598,35 +8628,10 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
     });
 
     def_to_moz(AST_ObjectProperty, function To_Moz_Property(M, parent) {
-        var key = M.key instanceof AST_Node ? to_moz(M.key) : {
-            type: "Identifier",
-            value: M.key,
-        };
-        if (typeof M.key === "number") {
-            key = {
-                type: "Literal",
-                value: Number(M.key)
-            };
-        }
-        if (typeof M.key === "string") {
-            key = M.quote
-                ? {
-                    type: "Literal",
-                    value: M.key,
-                    raw: JSON.stringify(M.key),
-                }
-                : {
-                    type: "Identifier",
-                    name: M.key,
-                };
-        }
+        var computed = M.computed_key();
+        const [shorthand, key] = to_moz_property_key(M.key, computed, M.quote, M.value);
+
         var kind;
-        var string_or_num = typeof M.key === "string" || typeof M.key === "number";
-        var computed = string_or_num ? false : !(M.key instanceof AST_Symbol) || M.key instanceof AST_SymbolRef;
-        if (M instanceof AST_ObjectKeyVal) {
-            kind = "init";
-            computed = !string_or_num;
-        } else
         if (M instanceof AST_ObjectGetter) {
             kind = "get";
         } else
@@ -8681,31 +8686,51 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         return {
             type: "Property",
             computed: computed,
+            method: false,
+            shorthand,
             kind: kind,
             key: key,
             value: to_moz(M.value)
         };
     });
 
+    def_to_moz(AST_ObjectKeyVal, function To_Moz_Property(M) {
+        var computed = M.computed_key();
+        const [shorthand, key] = to_moz_property_key(M.key, computed, M.quote, M.value);
+
+        return {
+            type: "Property",
+            computed: computed,
+            shorthand: shorthand,
+            method: false,
+            kind: "init",
+            key: key,
+            value: to_moz(M.value)
+        };
+    });
+
     def_to_moz(AST_ConciseMethod, function To_Moz_MethodDefinition(M, parent) {
+        const computed = M.computed_key();
+        const [_always_false, key] = to_moz_property_key(M.key, computed, M.quote, M.value);
+
         if (parent instanceof AST_Object) {
             return {
                 type: "Property",
-                computed: !(M.key instanceof AST_Symbol) || M.key instanceof AST_SymbolRef,
                 kind: "init",
+                computed,
                 method: true,
                 shorthand: false,
-                key: to_moz(M.key),
-                value: to_moz(M.value)
+                key,
+                value: to_moz(M.value),
             };
         }
 
         return {
             type: "MethodDefinition",
-            kind: M.key === "constructor" ? "constructor" : "method",
-            key: to_moz(M.key),
+            kind: !computed && M.key.name === "constructor" ? "constructor" : "method",
+            computed,
+            key,
             value: to_moz(M.value),
-            computed: !(M.key instanceof AST_Symbol) || M.key instanceof AST_SymbolRef,
             static: M.static,
         };
     });
@@ -8811,6 +8836,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         // `M.value` is a string that may be a hex number representation.
         // but "bigint" property should have only decimal digits
         bigint: typeof BigInt === "function" ? BigInt(M.value).toString() : M.value,
+        raw: M.raw,
     }));
 
     AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
@@ -8854,20 +8880,133 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         );
     }
 
-    var FROM_MOZ_STACK = null;
+    var FROM_MOZ_LABELS = null;
 
     function from_moz(node) {
-        FROM_MOZ_STACK.push(node);
-        var ret = node != null ? MOZ_TO_ME[node.type](node) : null;
-        FROM_MOZ_STACK.pop();
-        return ret;
+        if (node == null) return null;
+        return MOZ_TO_ME[node.type](node);
+    }
+
+    function from_moz_quote(moz_key, computed) {
+        if (!computed && moz_key.type === "Literal" && typeof moz_key.value === "string") {
+            return '"';
+        } else {
+            return "";
+        }
+    }
+
+    function from_moz_symbol(symbol_type, M, has_quote) {
+        return new symbol_type({
+            start: my_start_token(M),
+            quote: has_quote ? '"' : undefined,
+            name: M.type === "Identifier" ? M.name : String(M.value),
+            end: my_end_token(M),
+        });
+    }
+
+    function from_moz_lambda(M, is_method) {
+        return new (is_method ? AST_Accessor : AST_Function)({
+            start: my_start_token(M),
+            end: my_end_token(M),
+            name: M.id && from_moz_symbol(is_method ? AST_SymbolMethod : AST_SymbolLambda, M.id),
+            argnames: M.params.map(M => from_moz_pattern(M, AST_SymbolFunarg)),
+            is_generator: M.generator,
+            async: M.async,
+            body: normalize_directives(from_moz(M.body).body)
+        });
+    }
+
+    function from_moz_pattern(M, sym_type) {
+        switch (M.type) {
+            case "ObjectPattern":
+                return new AST_Destructuring({
+                    start: my_start_token(M),
+                    end: my_end_token(M),
+                    names: M.properties.map(p => from_moz_pattern(p, sym_type)),
+                    is_array: false
+                });
+
+            case "Property":
+                var key = M.key;
+                var args = {
+                    start    : my_start_token(key || M.value),
+                    end      : my_end_token(M.value),
+                    key      : key.type == "Identifier" ? key.name : String(key.value),
+                    quote    : !M.computed && key.type === "Literal" && typeof key.value === "string"
+                                ? '"'
+                                : "",
+                    value    : from_moz_pattern(M.value, sym_type)
+                };
+                if (M.computed) {
+                    args.key = from_moz(M.key);
+                }
+                return new AST_ObjectKeyVal(args);
+
+            case "ArrayPattern":
+                return new AST_Destructuring({
+                    start: my_start_token(M),
+                    end: my_end_token(M),
+                    names: M.elements.map(function(elm) {
+                        if (elm === null) {
+                            return new AST_Hole();
+                        }
+                        return from_moz_pattern(elm, sym_type);
+                    }),
+                    is_array: true
+                });
+
+            case "SpreadElement":
+            case "RestElement":
+                return new AST_Expansion({
+                    start: my_start_token(M),
+                    end: my_end_token(M),
+                    expression: from_moz_pattern(M.argument, sym_type),
+                });
+
+            case "AssignmentPattern":
+                return new AST_DefaultAssign({
+                    start : my_start_token(M),
+                    end   : my_end_token(M),
+                    left  : from_moz_pattern(M.left, sym_type),
+                    operator: "=",
+                    right : from_moz(M.right),
+                });
+
+            case "Identifier":
+                return new sym_type({
+                    start : my_start_token(M),
+                    end   : my_end_token(M),
+                    name  : M.name,
+                });
+
+            default:
+                throw new Error("Invalid node type for destructuring: " + M.type);
+        }
+    }
+
+    function from_moz_label_ref(m_label) {
+        if (!m_label) return null;
+
+        const label = from_moz_symbol(AST_LabelRef, m_label);
+
+        let i = FROM_MOZ_LABELS.length;
+        while (i--) {
+            const label_origin = FROM_MOZ_LABELS[i];
+
+            if (label.name === label_origin.name) {
+                label.thedef = label_origin;
+                break;
+            }
+        }
+
+        return label;
     }
 
     AST_Node.from_mozilla_ast = function(node) {
-        var save_stack = FROM_MOZ_STACK;
-        FROM_MOZ_STACK = [];
+        var save_labels = FROM_MOZ_LABELS;
+        FROM_MOZ_LABELS = [];
         var ast = from_moz(node);
-        FROM_MOZ_STACK = save_stack;
+        FROM_MOZ_LABELS = save_labels;
         return ast;
     };
 
@@ -8909,6 +9048,52 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         return ast;
     }
 
+    /** Object property keys can be number literals, string literals, or raw names. Additionally they can be shorthand. We decide that here. */
+    function to_moz_property_key(key, computed = false, quote = false, value = null) {
+        if (computed) {
+            return [false, to_moz(key)];
+        }
+
+        const key_name = typeof key === "string" ? key : key.name;
+        let moz_key;
+        if (quote) {
+            moz_key = { type: "Literal", value: key_name, raw: JSON.stringify(key_name) };
+        } else if ("" + +key_name === key_name && +key_name >= 0) {
+            // representable as a number
+            moz_key = { type: "Literal", value: +key_name, raw: JSON.stringify(+key_name) };
+        } else {
+            moz_key = { type: "Identifier", name: key_name };
+        }
+
+        const shorthand =
+            moz_key.type === "Identifier"
+            && moz_key.name === key_name
+            && (value instanceof AST_Symbol && value.name === key_name
+                || value instanceof AST_DefaultAssign && value.left.name === key_name);
+        return [shorthand, moz_key];
+    }
+
+    function to_moz_pattern(node) {
+        if (node instanceof AST_Expansion) {
+            return {
+                type: "RestElement",
+                argument: to_moz_pattern(node.expression),
+            };
+        }
+
+        if ((
+            node instanceof AST_Symbol
+            || node instanceof AST_Destructuring
+            || node instanceof AST_DefaultAssign
+            || node instanceof AST_PropAccess
+        )) {
+            // Plain translation
+            return to_moz(node);
+        }
+
+        throw new Error(node.TYPE);
+    }
+
     function to_moz_in_destructuring() {
         var i = TO_MOZ_STACK.length;
         while (i--) {
@@ -9141,7 +9326,7 @@ function OutputStream(options) {
         webkit               : false,
         width                : 80,
         wrap_iife            : false,
-        wrap_func_args       : true,
+        wrap_func_args       : false,
 
         _destroy_ast         : false
     }, true);
@@ -11152,22 +11337,22 @@ function OutputStream(options) {
     });
     DEFPRINT(AST_ConciseMethod, function(self, output) {
         var type;
-        if (self.is_generator && self.async) {
+        if (self.value.is_generator && self.value.async) {
             type = "async*";
-        } else if (self.is_generator) {
+        } else if (self.value.is_generator) {
             type = "*";
-        } else if (self.async) {
+        } else if (self.value.async) {
             type = "async";
         }
         self._print_getter_setter(type, false, output);
     });
     DEFPRINT(AST_PrivateMethod, function(self, output) {
         var type;
-        if (self.is_generator && self.async) {
+        if (self.value.is_generator && self.value.async) {
             type = "async*";
-        } else if (self.is_generator) {
+        } else if (self.value.is_generator) {
             type = "*";
-        } else if (self.async) {
+        } else if (self.value.async) {
             type = "async";
         }
         self._print_getter_setter(type, true, output);
@@ -11563,11 +11748,11 @@ AST_ObjectGetter.prototype.shallow_cmp = function(other) {
 };
 
 AST_ConciseMethod.prototype.shallow_cmp = function(other) {
-    return this.static === other.static && this.is_generator === other.is_generator && this.async === other.async;
+    return this.static === other.static;
 };
 
 AST_PrivateMethod.prototype.shallow_cmp = function(other) {
-    return this.static === other.static && this.is_generator === other.is_generator && this.async === other.async;
+    return this.static === other.static;
 };
 
 AST_Class.prototype.shallow_cmp = function(other) {
@@ -12903,7 +13088,7 @@ AST_ObjectSetter.prototype._size = function () {
 };
 
 AST_ConciseMethod.prototype._size = function () {
-    return static_size(this.static) + key_size(this.key) + lambda_modifiers(this);
+    return static_size(this.static) + key_size(this.key);
 };
 
 AST_PrivateMethod.prototype._size = function () {
@@ -18246,6 +18431,8 @@ function inline_into_symbolref(self, compressor) {
         return self;
     }
 
+    if (dont_inline_lambda_in_loop(compressor, fixed)) return self;
+
     let single_use = def.single_use
         && !(parent instanceof AST_Call
             && (parent.is_callee_pure(compressor))
@@ -18399,6 +18586,11 @@ function inline_into_call(self, compressor) {
         fn = fixed;
     }
 
+    if (
+        dont_inline_lambda_in_loop(compressor, fn)
+        && !has_annotation(self, _INLINE)
+    ) return self;
+
     var is_func = fn instanceof AST_Lambda;
 
     var stat = is_func && fn.body[0];
@@ -18727,6 +18919,14 @@ function inline_into_call(self, compressor) {
     }
 }
 
+/** prevent inlining functions into loops, for performance reasons */
+function dont_inline_lambda_in_loop(compressor, maybe_lambda) {
+    return (
+        (maybe_lambda instanceof AST_Lambda || maybe_lambda instanceof AST_Class)
+        && !!compressor.is_within_loop()
+    );
+}
+
 (function(def_find_defs) {
     function to_node(value, orig) {
         if (value instanceof AST_Node) {
@@ -22153,7 +22353,7 @@ AST_PropAccess.DEFMETHOD("flatten_object", function(key, compressor) {
             if ("" + (prop instanceof AST_ConciseMethod ? prop.key.name : prop.key) == key) {
                 const all_props_flattenable = props.every((p) =>
                     (p instanceof AST_ObjectKeyVal
-                        || arrows && p instanceof AST_ConciseMethod && !p.is_generator
+                        || arrows && p instanceof AST_ConciseMethod && !p.value.is_generator
                     )
                     && !p.computed_key()
                 );
@@ -22639,7 +22839,7 @@ def_optimize(AST_ConciseMethod, function(self, compressor) {
     // p(){return x;} ---> p:()=>x
     if (compressor.option("arrows")
         && compressor.parent() instanceof AST_Object
-        && !self.is_generator
+        && !self.value.is_generator
         && !self.value.uses_arguments
         && !self.value.pinned()
         && self.value.body.length == 1
@@ -22647,8 +22847,8 @@ def_optimize(AST_ConciseMethod, function(self, compressor) {
         && self.value.body[0].value
         && !self.value.contains_this()) {
         var arrow = make_node(AST_Arrow, self.value, self.value);
-        arrow.async = self.async;
-        arrow.is_generator = self.is_generator;
+        arrow.async = self.value.async;
+        arrow.is_generator = self.value.is_generator;
         return make_node(AST_ObjectKeyVal, self, {
             key: self.key instanceof AST_SymbolMethod ? self.key.name : self.key,
             value: arrow,
@@ -22676,8 +22876,6 @@ def_optimize(AST_ObjectKeyVal, function(self, compressor) {
             && !value.contains_this();
         if ((is_arrow_with_block || value instanceof AST_Function) && !value.name) {
             return make_node(AST_ConciseMethod, self, {
-                async: value.async,
-                is_generator: value.is_generator,
                 key: key instanceof AST_Node ? key : make_node(AST_SymbolMethod, self, {
                     name: key,
                 }),