html-minifier-next 1.1.5 → 1.2.0

package/dist/htmlminifier.umd.bundle.js

@@ -15,7 +15,11 @@
 	  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);
@@ -26515,7 +26519,6 @@
 
 	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;
@@ -26880,15 +26883,16 @@
 	                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;
 
@@ -26905,7 +26909,7 @@
 	            }
 	            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);
@@ -27080,7 +27084,24 @@
 	        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;
@@ -27871,24 +27892,19 @@
 
 	        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();
 	        }
 
@@ -27905,7 +27921,7 @@
 	            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,
@@ -28537,7 +28553,12 @@
 	            });
 	            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({
@@ -28801,7 +28822,7 @@
 
 	            // 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;
@@ -28836,7 +28857,7 @@
 	            const kv = new AST_ObjectKeyVal({
 	                start: start,
 	                quote: start.quote,
-	                key: name instanceof AST_Node ? name : "" + name,
+	                key: name,
 	                value: value,
 	                end: prev()
 	            });
@@ -28847,7 +28868,7 @@
 	    });
 
 	    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");
@@ -28876,9 +28897,9 @@
 	        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,
@@ -28892,19 +28913,15 @@
 	            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();
 	            }
@@ -28952,7 +28969,7 @@
 	                    ? AST_ObjectGetter
 	                    : AST_ObjectSetter;
 
-	                name = get_symbol_ast(name);
+	                name = get_symbol_ast(name, AST_SymbolMethod);
 	                return annotate(new AccessorClass({
 	                    start,
 	                    static: is_static,
@@ -28969,7 +28986,7 @@
 	                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(),
 	                }));
@@ -28977,15 +28994,13 @@
 	        }
 
 	        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,
@@ -28996,13 +29011,17 @@
 	        }
 
 	        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(
@@ -29022,6 +29041,9 @@
 	                || is("operator", "*")
 	                || is("punc", ";")
 	                || is("punc", "}")
+	                || is("string")
+	                || is("num")
+	                || is("big_int")
 	            ) {
 	                return annotate(
 	                    new AST_ClassPropertyVariant({
@@ -29146,10 +29168,12 @@
 	            } 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({
@@ -29320,12 +29344,14 @@
 	          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);
 	        }
@@ -31955,12 +31981,10 @@
 	    }
 	}, 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;
@@ -31973,8 +31997,6 @@
 	    $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() {
@@ -31982,12 +32004,9 @@
 	    }
 	}, 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;
@@ -31997,6 +32016,9 @@
 	    this.flags = 0;
 	}, {
 	    $documentation: "A private class method inside a class",
+	    $propdoc: {
+	        static: "[boolean] is this a static private method",
+	    },
 	    computed_key() {
 	        return false;
 	    },
@@ -32145,7 +32167,6 @@
 	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;
@@ -32505,12 +32526,12 @@
 	    $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;
 	    }
@@ -32557,12 +32578,12 @@
 	    $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;
 	    }
@@ -32572,12 +32593,12 @@
 	    $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;
 	    }
@@ -32692,9 +32713,10 @@
 	    }
 	}, 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;
 	    }
@@ -32703,7 +32725,8 @@
 	}, {
 	    $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);
 
@@ -32986,6 +33009,28 @@
 	        }
 	    }
 
+	    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;) {
@@ -33363,6 +33408,7 @@
 	                body[i] = new AST_Directive({
 	                    start: body[i].start,
 	                    end: body[i].end,
+	                    quote: '"',
 	                    value: body[i].body.value
 	                });
 	            } else {
@@ -33486,8 +33532,8 @@
 	            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)
@@ -33495,15 +33541,7 @@
 	        },
 
 	        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) {
@@ -33513,7 +33551,7 @@
 	            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,
 	            });
@@ -33542,57 +33580,48 @@
 	        },
 
 	        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") {
@@ -33601,8 +33630,6 @@
 	            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);
 	        },
 
@@ -33617,6 +33644,7 @@
 	            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,
@@ -33636,15 +33664,13 @@
 	                    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,
@@ -33736,11 +33762,30 @@
 	        },
 
 	        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,
 	            });
 	        },
 
@@ -33769,13 +33814,13 @@
 	            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) {
@@ -33783,7 +33828,7 @@
 	                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)
 	            });
 	        },
 
@@ -33805,15 +33850,17 @@
 	        },
 
 	        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
 	                    })
 	                ],
@@ -33823,14 +33870,26 @@
 	        },
 
 	        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) {
@@ -33844,8 +33903,10 @@
 
 	        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"),
 	            });
 	        },
 
@@ -33874,27 +33935,13 @@
 	            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":
@@ -33921,26 +33968,11 @@
 	        },
 
 	        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) {
@@ -33969,19 +34001,28 @@
 	        },
 
 	        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),
 	            });
 	        },
 
@@ -33989,7 +34030,7 @@
 	            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),
 	            });
 	        },
 
@@ -34101,20 +34142,11 @@
 	            });
 	        },
 
-	        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
 	            });
 	        },
@@ -34122,6 +34154,7 @@
 	        ThisExpression: function(M) {
 	            return new AST_This({
 	                start: my_start_token(M),
+	                name: "this",
 	                end: my_end_token(M)
 	            });
 	        },
@@ -34129,7 +34162,8 @@
 	        Super: function(M) {
 	            return new AST_Super({
 	                start: my_start_token(M),
-	                end: my_end_token(M)
+	                end: my_end_token(M),
+	                name: "super",
 	            });
 	        },
 
@@ -34170,6 +34204,7 @@
 	                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)
 	            });
@@ -34222,7 +34257,7 @@
 	        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)
 	        });
@@ -34357,13 +34392,6 @@
 	            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 {
@@ -34375,30 +34403,6 @@
 	            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",
@@ -34420,7 +34424,7 @@
 	            return {
 	                type: "ImportExpression",
 	                source,
-	                options
+	                options: options || null
 	            };
 	        }
 
@@ -34479,36 +34483,36 @@
 	        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,
 	        };
 	    });
 
@@ -34516,12 +34520,39 @@
 	        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),
 	        };
 	    });
 
@@ -34565,8 +34596,7 @@
 	    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)
 	        };
 	    });
@@ -34601,8 +34631,7 @@
 	    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
@@ -34628,10 +34657,20 @@
 	                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) {
@@ -34749,6 +34788,15 @@
 	        };
 	    });
 
+	    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",
@@ -34773,29 +34821,10 @@
 	    });
 
 	    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
@@ -34850,31 +34879,51 @@
 	        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,
 	        };
 	    });
@@ -34980,6 +35029,7 @@
 	        // `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);
@@ -35023,20 +35073,133 @@
 	        );
 	    }
 
-	    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;
 	    };
 
@@ -35078,6 +35241,52 @@
 	        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--) {
@@ -35311,7 +35520,7 @@
 	        webkit               : false,
 	        width                : 80,
 	        wrap_iife            : false,
-	        wrap_func_args       : true,
+	        wrap_func_args       : false,
 
 	        _destroy_ast         : false
 	    }, true);
@@ -36835,11 +37044,11 @@
 	            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) {
@@ -36848,7 +37057,7 @@
 	                    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);
@@ -36868,7 +37077,7 @@
 	                }
 	            }
 	        } else {
-	            if (self.name.quote == null) {
+	            if (!self.name.quote) {
 	                self.name.print(output);
 	            } else {
 	                output.print_string(self.name.name, self.name.quote);
@@ -37257,7 +37466,7 @@
 
 	        output.print("#");
 	        
-	        print_property_name(self.key.name, self.quote, output);
+	        print_property_name(self.key.name, undefined, output);
 
 	        if (self.value) {
 	            output.print("=");
@@ -37322,22 +37531,22 @@
 	    });
 	    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);
@@ -37385,7 +37594,11 @@
 	        }
 	    });
 	    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;
@@ -37673,13 +37886,13 @@
 	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;
@@ -37706,6 +37919,8 @@
 	    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;
@@ -37715,7 +37930,7 @@
 	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) {
@@ -37727,11 +37942,11 @@
 	};
 
 	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) {
@@ -39068,7 +39283,7 @@
 	};
 
 	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 () {
@@ -41042,7 +41257,7 @@
 	            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;
@@ -43818,7 +44033,7 @@
 	                    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
@@ -43838,7 +44053,7 @@
 	                    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
@@ -43943,7 +44158,7 @@
 	                || 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) {
@@ -43961,6 +44176,9 @@
 	                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
@@ -44420,6 +44638,8 @@
 	        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))
@@ -44573,6 +44793,11 @@
 	        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];
@@ -44901,6 +45126,14 @@
 	    }
 	}
 
+	/** 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) {
@@ -48328,7 +48561,7 @@
 	            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()
 	                );
@@ -48814,7 +49047,7 @@
 	    // 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
@@ -48822,8 +49055,8 @@
 	        && 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,
@@ -48851,8 +49084,6 @@
 	            && !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,
 	                }),
@@ -60154,9 +60385,7 @@
 	  }
 	}
 
-	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:
@@ -60208,14 +60437,14 @@
 	  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);
@@ -61015,6 +61244,7 @@
 	  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.
@@ -61146,7 +61376,7 @@
 	      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;
 	      }
 	    }
@@ -61357,7 +61587,7 @@
 	            }
 	          }
 	          if (prevTag || nextTag) {
-	            text = collapseWhitespaceSmart(text, prevTag, nextTag, options);
+	            text = collapseWhitespaceSmart(text, prevTag, nextTag, options, inlineTags);
 	          } else {
 	            text = collapseWhitespace(text, options, true, true);
 	          }