terser 5.40.0 → 5.42.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;
@@ -1718,7 +1735,7 @@ function parse($TEXT, options) {
         return new ctor({
             start : args.start,
             end   : body.end,
-            is_generator: is_generator,
+            is_generator: is_generator || is_generator_property,
             async : is_async,
             name  : name,
             argnames: args,
@@ -2346,7 +2363,12 @@ function parse($TEXT, options) {
             });
             break;
           case "big_int":
-            ret = new AST_BigInt({ start: tok, end: tok, value: tok.value });
+            ret = new AST_BigInt({
+                start: tok,
+                end: tok,
+                value: tok.value,
+                raw: LATEST_RAW,
+            });
             break;
           case "string":
             ret = new AST_String({
@@ -2610,7 +2632,7 @@ function parse($TEXT, options) {
 
             // Check property and fetch value
             if (!is("punc", ":")) {
-                var concise = concise_method_or_getset(name, start);
+                var concise = object_or_class_property(name, start);
                 if (concise) {
                     a.push(concise);
                     continue;
@@ -2645,7 +2667,7 @@ function parse($TEXT, options) {
             const kv = new AST_ObjectKeyVal({
                 start: start,
                 quote: start.quote,
-                key: name instanceof AST_Node ? name : "" + name,
+                key: name,
                 value: value,
                 end: prev()
             });
@@ -2656,7 +2678,7 @@ function parse($TEXT, options) {
     });
 
     function class_(KindOfClass, is_export_default) {
-        var start, method, class_name, extends_, a = [];
+        var start, method, class_name, extends_, properties = [];
 
         S.input.push_directives_stack(); // Push directive stack, but not scope stack
         S.input.add_directive("use strict");
@@ -2685,9 +2707,9 @@ function parse($TEXT, options) {
         while (is("punc", ";")) { next(); }  // Leading semicolons are okay in class bodies.
         while (!is("punc", "}")) {
             start = S.token;
-            method = concise_method_or_getset(as_property_name(), start, true);
+            method = object_or_class_property(as_property_name(), start, true);
             if (!method) { unexpected(); }
-            a.push(method);
+            properties.push(method);
             while (is("punc", ";")) { next(); }
         }
         // mark in class feild,
@@ -2701,19 +2723,15 @@ function parse($TEXT, options) {
             start: start,
             name: class_name,
             extends: extends_,
-            properties: a,
+            properties: properties,
             end: prev(),
         });
     }
 
-    function concise_method_or_getset(name, start, is_class) {
-        const get_symbol_ast = (name, SymbolClass = AST_SymbolMethod) => {
-            if (typeof name === "string" || typeof name === "number") {
-                return new SymbolClass({
-                    start,
-                    name: "" + name,
-                    end: prev()
-                });
+    function object_or_class_property(name, start, is_class) {
+        const get_symbol_ast = (name, SymbolClass) => {
+            if (typeof name === "string") {
+                return new SymbolClass({ start, name, end: prev() });
             } else if (name === null) {
                 unexpected();
             }
@@ -2761,7 +2779,7 @@ function parse($TEXT, options) {
                     ? AST_ObjectGetter
                     : AST_ObjectSetter;
 
-                name = get_symbol_ast(name);
+                name = get_symbol_ast(name, AST_SymbolMethod);
                 return annotate(new AccessorClass({
                     start,
                     static: is_static,
@@ -2778,7 +2796,7 @@ function parse($TEXT, options) {
                 return annotate(new AccessorClass({
                     start,
                     static: is_static,
-                    key: get_symbol_ast(name),
+                    key: get_symbol_ast(name, AST_SymbolMethod),
                     value: create_accessor(),
                     end: prev(),
                 }));
@@ -2786,7 +2804,7 @@ function parse($TEXT, options) {
         }
 
         if (is("punc", "(")) {
-            name = get_symbol_ast(name);
+            name = get_symbol_ast(name, AST_SymbolMethod);
             const AST_MethodVariant = is_private
                 ? AST_PrivateMethod
                 : AST_ConciseMethod;
@@ -2805,13 +2823,17 @@ function parse($TEXT, options) {
         }
 
         if (is_class) {
-            const key = get_symbol_ast(name, AST_SymbolClassProperty);
-            const quote = key instanceof AST_SymbolClassProperty
-                ? property_token.quote
-                : undefined;
+            const AST_SymbolVariant = is_private
+                ? AST_SymbolPrivateProperty
+                : AST_SymbolClassProperty;
             const AST_ClassPropertyVariant = is_private
                 ? AST_ClassPrivateProperty
                 : AST_ClassProperty;
+
+            const key = get_symbol_ast(name, AST_SymbolVariant);
+            const quote = key instanceof AST_SymbolClassProperty
+                ? property_token.quote
+                : undefined;
             if (is("operator", "=")) {
                 next();
                 return annotate(
@@ -2831,6 +2853,9 @@ function parse($TEXT, options) {
                 || is("operator", "*")
                 || is("punc", ";")
                 || is("punc", "}")
+                || is("string")
+                || is("num")
+                || is("big_int")
             ) {
                 return annotate(
                     new AST_ClassPropertyVariant({
@@ -2955,10 +2980,12 @@ function parse($TEXT, options) {
             } else {
                 foreign_name = make_symbol(foreign_type, S.token.quote);
             }
-        } else if (is_import) {
-            name = new type(foreign_name);
         } else {
-            foreign_name = new foreign_type(name);
+            if (is_import) {
+                name = new type(foreign_name);
+            } else {
+                foreign_name = new foreign_type(name);
+            }
         }
 
         return new AST_NameMapping({
@@ -3129,12 +3156,14 @@ function parse($TEXT, options) {
           case "name":
           case "privatename":
           case "string":
-          case "num":
-          case "big_int":
           case "keyword":
           case "atom":
             next();
             return tmp.value;
+          case "num":
+          case "big_int":
+            next();
+            return "" + tmp.value;
           default:
             unexpected(tmp);
         }
@@ -5792,7 +5821,6 @@ var AST_ConciseMethod = DEFNODE("ConciseMethod", "quote static is_generator asyn
 
 var AST_PrivateMethod = DEFNODE("PrivateMethod", "", function AST_PrivateMethod(props) {
     if (props) {
-        this.quote = props.quote;
         this.static = props.static;
         this.is_generator = props.is_generator;
         this.async = props.async;
@@ -5953,7 +5981,6 @@ var AST_ClassProperty = DEFNODE("ClassProperty", "static quote", function AST_Cl
 var AST_ClassPrivateProperty = DEFNODE("ClassPrivateProperty", "", function AST_ClassPrivateProperty(props) {
     if (props) {
         this.static = props.static;
-        this.quote = props.quote;
         this.key = props.key;
         this.value = props.value;
         this.start = props.start;
@@ -6313,12 +6340,12 @@ var AST_SymbolImport = DEFNODE("SymbolImport", null, function AST_SymbolImport(p
     $documentation: "Symbol referring to an imported name",
 }, AST_SymbolBlockDeclaration);
 
-var AST_SymbolImportForeign = DEFNODE("SymbolImportForeign", null, function AST_SymbolImportForeign(props) {
+var AST_SymbolImportForeign = DEFNODE("SymbolImportForeign", "quote", function AST_SymbolImportForeign(props) {
     if (props) {
+        this.quote = props.quote;
         this.scope = props.scope;
         this.name = props.name;
         this.thedef = props.thedef;
-        this.quote = props.quote;
         this.start = props.start;
         this.end = props.end;
     }
@@ -6365,12 +6392,12 @@ var AST_SymbolRef = DEFNODE("SymbolRef", null, function AST_SymbolRef(props) {
     $documentation: "Reference to some symbol (not definition/declaration)",
 }, AST_Symbol);
 
-var AST_SymbolExport = DEFNODE("SymbolExport", null, function AST_SymbolExport(props) {
+var AST_SymbolExport = DEFNODE("SymbolExport", "quote", function AST_SymbolExport(props) {
     if (props) {
+        this.quote = props.quote;
         this.scope = props.scope;
         this.name = props.name;
         this.thedef = props.thedef;
-        this.quote = props.quote;
         this.start = props.start;
         this.end = props.end;
     }
@@ -6380,12 +6407,12 @@ var AST_SymbolExport = DEFNODE("SymbolExport", null, function AST_SymbolExport(p
     $documentation: "Symbol referring to a name to export",
 }, AST_SymbolRef);
 
-var AST_SymbolExportForeign = DEFNODE("SymbolExportForeign", null, function AST_SymbolExportForeign(props) {
+var AST_SymbolExportForeign = DEFNODE("SymbolExportForeign", "quote", function AST_SymbolExportForeign(props) {
     if (props) {
+        this.quote = props.quote;
         this.scope = props.scope;
         this.name = props.name;
         this.thedef = props.thedef;
-        this.quote = props.quote;
         this.start = props.start;
         this.end = props.end;
     }
@@ -6500,9 +6527,10 @@ var AST_Number = DEFNODE("Number", "value raw", function AST_Number(props) {
     }
 }, AST_Constant);
 
-var AST_BigInt = DEFNODE("BigInt", "value", function AST_BigInt(props) {
+var AST_BigInt = DEFNODE("BigInt", "value raw", function AST_BigInt(props) {
     if (props) {
         this.value = props.value;
+        this.raw = props.raw;
         this.start = props.start;
         this.end = props.end;
     }
@@ -6511,7 +6539,8 @@ var AST_BigInt = DEFNODE("BigInt", "value", function AST_BigInt(props) {
 }, {
     $documentation: "A big int literal",
     $propdoc: {
-        value: "[string] big int value"
+        value: "[string] big int value, represented as a string",
+        raw: "[string] the original format preserved"
     }
 }, AST_Constant);
 
@@ -7169,6 +7198,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 {
@@ -7292,8 +7322,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)
@@ -7301,15 +7331,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) {
@@ -7319,7 +7341,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,
             });
@@ -7348,59 +7370,50 @@ 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),
+                    is_generator: value.is_generator,
+                    async    : value.async,
+                    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") {
@@ -7425,6 +7438,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,
@@ -7444,15 +7458,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,
@@ -7544,11 +7556,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,
             });
         },
 
@@ -7577,13 +7608,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) {
@@ -7591,7 +7622,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)
             });
         },
 
@@ -7613,15 +7644,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
                     })
                 ],
@@ -7664,8 +7697,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"),
             });
         },
 
@@ -7694,27 +7729,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":
@@ -7741,27 +7762,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) {
@@ -7790,19 +7795,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),
             });
         },
 
@@ -7810,7 +7824,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),
             });
         },
 
@@ -7922,20 +7936,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
             });
         },
@@ -7943,6 +7948,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)
             });
         },
@@ -7950,7 +7956,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",
             });
         },
 
@@ -7991,6 +7998,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)
             });
@@ -8043,7 +8051,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)
         });
@@ -8178,13 +8186,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 {
@@ -8217,7 +8218,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             return {
                 type: "ImportExpression",
                 source,
-                options
+                options: options || null
             };
         }
 
@@ -8276,7 +8277,7 @@ 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)
@@ -8284,28 +8285,31 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
     });
 
     def_to_moz(AST_Function, function To_Moz_FunctionExpression(M, parent) {
-        var is_generator = parent.is_generator !== undefined ?
-            parent.is_generator : M.is_generator;
+        var is_generator = parent.is_generator !== undefined
+            ? parent.is_generator
+            : M.is_generator;
         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: 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,
         };
     });
 
@@ -8313,19 +8317,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),
         };
     });
@@ -8370,8 +8393,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)
         };
     });
@@ -8432,10 +8454,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) {
@@ -8586,35 +8618,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
@@ -8669,31 +8676,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,
         };
     });
@@ -8799,6 +8826,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);
@@ -8842,20 +8870,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;
     };
 
@@ -8897,6 +9038,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--) {
@@ -10653,11 +10840,11 @@ function OutputStream(options) {
             foreign_name.name;
         if (!names_are_different &&
             foreign_name.name === "*" &&
-            foreign_name.quote != self.name.quote) {
+            !!foreign_name.quote != !!self.name.quote) {
                 // export * as "*"
             names_are_different = true;
         }
-        var foreign_name_is_name = foreign_name.quote == null;
+        var foreign_name_is_name = !foreign_name.quote;
         if (names_are_different) {
             if (is_import) {
                 if (foreign_name_is_name) {
@@ -10666,7 +10853,7 @@ function OutputStream(options) {
                     output.print_string(foreign_name.name, foreign_name.quote);
                 }
             } else {
-                if (self.name.quote == null) {
+                if (!self.name.quote) {
                     self.name.print(output);
                 } else {
                     output.print_string(self.name.name, self.name.quote);
@@ -10686,7 +10873,7 @@ function OutputStream(options) {
                 }
             }
         } else {
-            if (self.name.quote == null) {
+            if (!self.name.quote) {
                 self.name.print(output);
             } else {
                 output.print_string(self.name.name, self.name.quote);
@@ -11075,7 +11262,7 @@ function OutputStream(options) {
 
         output.print("#");
         
-        print_property_name(self.key.name, self.quote, output);
+        print_property_name(self.key.name, undefined, output);
 
         if (self.value) {
             output.print("=");
@@ -11203,7 +11390,11 @@ function OutputStream(options) {
         }
     });
     DEFPRINT(AST_BigInt, function(self, output) {
-        output.print(self.getValue() + "n");
+        if (output.option("keep_numbers") && self.raw) {
+            output.print(self.raw);
+        } else {
+            output.print(self.getValue() + "n");
+        }
     });
 
     const r_slash_script = /(<\s*\/\s*script)/i;
@@ -11491,13 +11682,13 @@ AST_VarDef.prototype.shallow_cmp = function(other) {
 AST_NameMapping.prototype.shallow_cmp = pass_through;
 
 AST_Import.prototype.shallow_cmp = function(other) {
-    return (this.imported_name == null ? other.imported_name == null : this.imported_name === other.imported_name) && (this.imported_names == null ? other.imported_names == null : this.imported_names === other.imported_names);
+    return (this.imported_name == null ? other.imported_name == null : this.imported_name === other.imported_name) && (this.imported_names == null ? other.imported_names == null : this.imported_names === other.imported_names) && (this.attributes == null ? other.attributes == null : this.attributes === other.attributes);
 };
 
 AST_ImportMeta.prototype.shallow_cmp = pass_through;
 
 AST_Export.prototype.shallow_cmp = function(other) {
-    return (this.exported_definition == null ? other.exported_definition == null : this.exported_definition === other.exported_definition) && (this.exported_value == null ? other.exported_value == null : this.exported_value === other.exported_value) && (this.exported_names == null ? other.exported_names == null : this.exported_names === other.exported_names) && this.module_name === other.module_name && this.is_default === other.is_default;
+    return (this.exported_definition == null ? other.exported_definition == null : this.exported_definition === other.exported_definition) && (this.exported_value == null ? other.exported_value == null : this.exported_value === other.exported_value) && (this.exported_names == null ? other.exported_names == null : this.exported_names === other.exported_names) && (this.attributes == null ? other.attributes == null : this.attributes === other.attributes) && this.module_name === other.module_name && this.is_default === other.is_default;
 };
 
 AST_Call.prototype.shallow_cmp = pass_through;
@@ -11524,6 +11715,8 @@ AST_Binary.prototype.shallow_cmp = function(other) {
     return this.operator === other.operator;
 };
 
+AST_PrivateIn.prototype.shallow_cmp = pass_through;
+
 AST_Conditional.prototype.shallow_cmp = pass_through;
 
 AST_Array.prototype.shallow_cmp = pass_through;
@@ -11533,7 +11726,7 @@ AST_Object.prototype.shallow_cmp = pass_through;
 AST_ObjectProperty.prototype.shallow_cmp = pass_through;
 
 AST_ObjectKeyVal.prototype.shallow_cmp = function(other) {
-    return this.key === other.key;
+    return this.key === other.key && this.quote === other.quote;
 };
 
 AST_ObjectSetter.prototype.shallow_cmp = function(other) {