html-minifier-next 1.1.5 → 1.2.0

package/dist/htmlminifier.esm.bundle.js

@@ -9,7 +9,11 @@ function getAugmentedNamespace(n) {
   var f = n.default;
 	if (typeof f == "function") {
 		var a = function a () {
-			if (this instanceof a) {
+			var isInstance = false;
+      try {
+        isInstance = this instanceof a;
+      } catch {}
+			if (isInstance) {
         return Reflect.construct(f, arguments, this.constructor);
 			}
 			return f.apply(this, arguments);
@@ -26509,7 +26513,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;
@@ -26874,15 +26877,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;
 
@@ -26899,7 +26903,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);
@@ -27074,7 +27078,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;
@@ -27865,24 +27886,19 @@ function parse($TEXT, options) {
 
         var body = _function_body(is("punc", "{"), false, is_async);
 
-        var end =
-            body instanceof Array && body.length ? body[body.length - 1].end :
-            body instanceof Array ? start :
-                body.end;
-
         return new AST_Arrow({
             start    : start,
-            end      : end,
+            end      : body.end,
             async    : is_async,
             argnames : argnames,
             body     : body
         });
     };
 
-    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();
         }
 
@@ -27899,7 +27915,7 @@ 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,
@@ -28531,7 +28547,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({
@@ -28795,7 +28816,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;
@@ -28830,7 +28851,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()
             });
@@ -28841,7 +28862,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");
@@ -28870,9 +28891,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,
@@ -28886,19 +28907,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();
             }
@@ -28946,7 +28963,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,
@@ -28963,7 +28980,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(),
                 }));
@@ -28971,15 +28988,13 @@ 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;
             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,
@@ -28990,13 +29005,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(
@@ -29016,6 +29035,9 @@ function parse($TEXT, options) {
                 || is("operator", "*")
                 || is("punc", ";")
                 || is("punc", "}")
+                || is("string")
+                || is("num")
+                || is("big_int")
             ) {
                 return annotate(
                     new AST_ClassPropertyVariant({
@@ -29140,10 +29162,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({
@@ -29314,12 +29338,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);
         }
@@ -31949,12 +31975,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;
@@ -31967,8 +31991,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() {
@@ -31976,12 +31998,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.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;
@@ -31991,6 +32010,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;
     },
@@ -32139,7 +32161,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;
@@ -32499,12 +32520,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;
     }
@@ -32551,12 +32572,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;
     }
@@ -32566,12 +32587,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;
     }
@@ -32686,9 +32707,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;
     }
@@ -32697,7 +32719,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);
 
@@ -32980,6 +33003,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;) {
@@ -33357,6 +33402,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 {
@@ -33480,8 +33526,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)
@@ -33489,15 +33535,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) {
@@ -33507,7 +33545,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,
             });
@@ -33536,57 +33574,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,
-                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;
-                args.quote = M.computed ? "\"" : null;
-                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") {
@@ -33595,8 +33624,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);
         },
 
@@ -33611,6 +33638,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,
@@ -33630,15 +33658,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,
@@ -33730,11 +33756,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,
             });
         },
 
@@ -33763,13 +33808,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) {
@@ -33777,7 +33822,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)
             });
         },
 
@@ -33799,15 +33844,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
                     })
                 ],
@@ -33817,14 +33864,26 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         },
 
         ExportNamedDeclaration: function(M) {
-            return new AST_Export({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                exported_definition: from_moz(M.declaration),
-                exported_names: M.specifiers && M.specifiers.length ? M.specifiers.map(from_moz) : null,
-                module_name: from_moz(M.source),
-                attributes: import_attributes_from_moz(M.attributes || M.assertions)
-            });
+            if (M.declaration) {
+                // export const, export function, ...
+                return new AST_Export({
+                    start: my_start_token(M),
+                    end: my_end_token(M),
+                    exported_definition: from_moz(M.declaration),
+                    exported_names: null,
+                    module_name: null,
+                    attributes: null,
+                });
+            } else {
+                return new AST_Export({
+                    start: my_start_token(M),
+                    end: my_end_token(M),
+                    exported_definition: null,
+                    exported_names: M.specifiers && M.specifiers.length ? M.specifiers.map(from_moz) : [],
+                    module_name: from_moz(M.source),
+                    attributes: import_attributes_from_moz(M.attributes || M.assertions),
+                });
+            }
         },
 
         ExportDefaultDeclaration: function(M) {
@@ -33838,8 +33897,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"),
             });
         },
 
@@ -33868,27 +33929,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":
@@ -33915,26 +33962,11 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         },
 
         Identifier: function(M) {
-            var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
-            return new (  p.type == "LabeledStatement" ? AST_Label
-                        : p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : p.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) {
@@ -33963,19 +33995,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),
             });
         },
 
@@ -33983,7 +34024,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),
             });
         },
 
@@ -34095,20 +34136,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
             });
         },
@@ -34116,6 +34148,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)
             });
         },
@@ -34123,7 +34156,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",
             });
         },
 
@@ -34164,6 +34198,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)
             });
@@ -34216,7 +34251,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)
         });
@@ -34351,13 +34386,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 {
@@ -34369,30 +34397,6 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             type: "Super"
         };
     });
-    def_to_moz(AST_Binary, function To_Moz_BinaryExpression(M) {
-        return {
-            type: "BinaryExpression",
-            operator: M.operator,
-            left: to_moz(M.left),
-            right: to_moz(M.right)
-        };
-    });
-    def_to_moz(AST_Binary, function To_Moz_LogicalExpression(M) {
-        return {
-            type: "LogicalExpression",
-            operator: M.operator,
-            left: to_moz(M.left),
-            right: to_moz(M.right)
-        };
-    });
-    def_to_moz(AST_Assign, function To_Moz_AssignmentExpression(M) {
-        return {
-            type: "AssignmentExpression",
-            operator: M.operator,
-            left: to_moz(M.left),
-            right: to_moz(M.right)
-        };
-    });
     def_to_moz(AST_Conditional, function To_Moz_ConditionalExpression(M) {
         return {
             type: "ConditionalExpression",
@@ -34414,7 +34418,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
             return {
                 type: "ImportExpression",
                 source,
-                options
+                options: options || null
             };
         }
 
@@ -34473,36 +34477,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,
         };
     });
 
@@ -34510,12 +34514,39 @@ 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_pattern(M.left),
+            right: to_moz(M.right),
         };
     });
 
@@ -34559,8 +34590,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)
         };
     });
@@ -34595,8 +34625,7 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
     def_to_moz(AST_Export, function To_Moz_ExportDeclaration(M) {
         if (M.exported_names) {
             var first_exported = M.exported_names[0];
-            var first_exported_name = first_exported.name;
-            if (first_exported_name.name === "*" && !first_exported_name.quote) {
+            if (first_exported && first_exported.name.name === "*" && !first_exported.name.quote) {
                 var foreign_name = first_exported.foreign_name;
                 var exported = foreign_name.name === "*" && !foreign_name.quote
                     ? null
@@ -34622,10 +34651,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) {
@@ -34743,6 +34782,15 @@ def_transform(AST_PrefixedTemplateString, function(self, tw) {
         };
     });
 
+    def_to_moz(AST_Assign, function To_Moz_AssignmentExpression(M) {
+        return {
+            type: "AssignmentExpression",
+            operator: M.operator,
+            left: to_moz(M.left),
+            right: to_moz(M.right)
+        };
+    });
+
     def_to_moz(AST_PrivateIn, function To_Moz_BinaryExpression_PrivateIn(M) {
         return {
             type: "BinaryExpression",
@@ -34767,29 +34815,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 = {
-                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
@@ -34844,31 +34873,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,
         };
     });
@@ -34974,6 +35023,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);
@@ -35017,20 +35067,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;
     };
 
@@ -35072,6 +35235,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--) {
@@ -35305,7 +35514,7 @@ function OutputStream(options) {
         webkit               : false,
         width                : 80,
         wrap_iife            : false,
-        wrap_func_args       : true,
+        wrap_func_args       : false,
 
         _destroy_ast         : false
     }, true);
@@ -36829,11 +37038,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) {
@@ -36842,7 +37051,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);
@@ -36862,7 +37071,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);
@@ -37251,7 +37460,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("=");
@@ -37316,22 +37525,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);
@@ -37379,7 +37588,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;
@@ -37667,13 +37880,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;
@@ -37700,6 +37913,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;
@@ -37709,7 +37924,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) {
@@ -37721,11 +37936,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) {
@@ -39062,7 +39277,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 () {
@@ -41036,7 +41251,7 @@ def_eval(AST_UnaryPrefix, function (compressor, depth) {
             if (e instanceof RegExp)
                 return this;
             return typeof e;
-        case "void": return void 0;
+        case "void": return void e;
         case "~": return ~e;
         case "-": return -e;
         case "+": return +e;
@@ -43812,7 +44027,7 @@ function tighten_body(statements, compressor) {
                     stat = stat.clone();
                     stat.condition = stat.condition.negate(compressor);
                     stat.body = make_node(AST_BlockStatement, stat, {
-                        body: as_statement_array(stat.alternative).concat(extract_functions())
+                        body: as_statement_array(stat.alternative).concat(extract_defuns())
                     });
                     stat.alternative = make_node(AST_BlockStatement, stat, {
                         body: new_else
@@ -43832,7 +44047,7 @@ function tighten_body(statements, compressor) {
                     CHANGED = true;
                     stat = stat.clone();
                     stat.body = make_node(AST_BlockStatement, stat.body, {
-                        body: as_statement_array(stat.body).concat(extract_functions())
+                        body: as_statement_array(stat.body).concat(extract_defuns())
                     });
                     stat.alternative = make_node(AST_BlockStatement, stat.alternative, {
                         body: new_else
@@ -43937,7 +44152,7 @@ function tighten_body(statements, compressor) {
                 || ab instanceof AST_Break && lct instanceof AST_BlockStatement && self === lct;
         }
 
-        function extract_functions() {
+        function extract_defuns() {
             var tail = statements.slice(i + 1);
             statements.length = i + 1;
             return tail.filter(function (stat) {
@@ -43955,6 +44170,9 @@ function tighten_body(statements, compressor) {
                 return undefined;
             }
             body = body.slice(0, -1);
+            if (!body.every(stat => can_be_evicted_from_block(stat))) {
+                return undefined;
+            }
             if (ab.value) {
                 body.push(make_node(AST_SimpleStatement, ab.value, {
                     body: ab.value.expression
@@ -44414,6 +44632,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))
@@ -44567,6 +44787,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];
@@ -44895,6 +45120,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) {
@@ -48322,7 +48555,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()
                 );
@@ -48808,7 +49041,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
@@ -48816,8 +49049,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,
@@ -48845,8 +49078,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,
                 }),
@@ -60148,9 +60379,7 @@ class TokenChain {
   }
 }
 
-function trimWhitespace(str) {
-  return str && str.replace(/^[ \n\r\t\f]+/, '').replace(/[ \n\r\t\f]+$/, '');
-}
+const trimWhitespace = str => str && str.replace(/^[ \n\r\t\f]+/, '').replace(/[ \n\r\t\f]+$/, '');
 
 function collapseWhitespaceAll(str) {
   // Non-breaking space is specifically handled inside the replacer function here:
@@ -60202,14 +60431,14 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
   return lineBreakBefore + str + lineBreakAfter;
 }
 
-// non-empty tags that will maintain whitespace around them
-const inlineTags = new Set(['a', 'abbr', 'acronym', 'b', 'bdi', 'bdo', 'big', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'ins', 'kbd', 'label', 'mark', 'math', 'nobr', 'object', 'q', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'time', 'tt', 'u', 'var']);
-// non-empty tags that will maintain whitespace within them
+// non-empty elements that will maintain whitespace around them
+const inlineHtmlElements = ['a', 'abbr', 'acronym', 'b', 'bdi', 'bdo', 'big', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'mark', 'math', 'meter', 'nobr', 'object', 'output', 'progress', 'q', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'time', 'tt', 'u', 'var', 'wbr'];
+// non-empty elements that will maintain whitespace within them
 const inlineTextTags = new Set(['a', 'abbr', 'acronym', 'b', 'big', 'del', 'em', 'font', 'i', 'ins', 'kbd', 'mark', 'nobr', 'rp', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'time', 'tt', 'u', 'var']);
-// self-closing tags that will maintain whitespace around them
+// self-closing elements that will maintain whitespace around them
 const selfClosingInlineTags = new Set(['comment', 'img', 'input', 'wbr']);
 
-function collapseWhitespaceSmart(str, prevTag, nextTag, options) {
+function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineTags) {
   let trimLeft = prevTag && !selfClosingInlineTags.has(prevTag);
   if (trimLeft && !options.collapseInlineTagWhitespace) {
     trimLeft = prevTag.charAt(0) === '/' ? !inlineTags.has(prevTag.slice(1)) : !inlineTextTags.has(prevTag);
@@ -61009,6 +61238,7 @@ async function minifyHTML(value, options, partialMarkup) {
   let uidIgnore;
   let uidAttr;
   let uidPattern;
+  let inlineTags = new Set([...inlineHtmlElements, ...(options.inlineCustomElements ?? [])]);
 
   // temporarily replace ignored chunks with comments,
   // so that we don't have to worry what's there.
@@ -61140,7 +61370,7 @@ async function minifyHTML(value, options, partialMarkup) {
       const match = str.match(/^<\/([\w:-]+)>$/);
       if (match) {
         endTag = match[1];
-      } else if (/>$/.test(str) || (buffer[index] = collapseWhitespaceSmart(str, null, nextTag, options))) {
+      } else if (/>$/.test(str) || (buffer[index] = collapseWhitespaceSmart(str, null, nextTag, options, inlineTags))) {
         break;
       }
     }
@@ -61351,7 +61581,7 @@ async function minifyHTML(value, options, partialMarkup) {
             }
           }
           if (prevTag || nextTag) {
-            text = collapseWhitespaceSmart(text, prevTag, nextTag, options);
+            text = collapseWhitespaceSmart(text, prevTag, nextTag, options, inlineTags);
           } else {
             text = collapseWhitespace(text, options, true, true);
           }