terser 5.41.0 → 5.43.0

package/lib/mozilla-ast.js

@@ -171,6 +171,7 @@ import { is_basic_identifier_string } from "./parse.js";
                 body[i] = new AST_Directive({
                     start: body[i].start,
                     end: body[i].end,
+                    quote: '"',
                     value: body[i].body.value
                 });
             } else {
@@ -294,8 +295,8 @@ import { is_basic_identifier_string } from "./parse.js";
             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)
@@ -303,15 +304,7 @@ import { is_basic_identifier_string } from "./parse.js";
         },
 
         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) {
@@ -321,7 +314,7 @@ import { is_basic_identifier_string } from "./parse.js";
             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,
             });
@@ -350,59 +343,48 @@ import { is_basic_identifier_string } from "./parse.js";
         },
 
         Property: function(M) {
-            var key = M.key;
-            var args = {
-                start    : my_start_token(key || M.value),
-                end      : my_end_token(M.value),
-                key      : key.type == "Identifier" ? key.name : key.value,
-                quote    : !key.computed && key.type === "Literal" && typeof key.value === "string"
-                            ? '"'
-                            : null,
-                value    : from_moz(M.value)
-            };
-            if (M.computed) {
-                args.key = from_moz(M.key);
-            }
-            if (M.method) {
-                args.is_generator = M.value.generator;
-                args.async = M.value.async;
-                if (!M.computed) {
-                    args.key = new AST_SymbolMethod({ name: args.key });
-                } else {
-                    args.key = from_moz(M.key);
-                }
-                return new AST_ConciseMethod(args);
-            }
-            if (M.kind == "init") {
-                if (key.type != "Identifier" && key.type != "Literal") {
-                    args.key = from_moz(key);
-                }
+            if (M.kind == "init" && !M.method) {
+                var args = {
+                    start    : my_start_token(M.key || M.value),
+                    end      : my_end_token(M.value),
+                    key      : M.computed
+                                ? from_moz(M.key)
+                                : M.key.name || String(M.key.value),
+                    quote    : from_moz_quote(M.key, M.computed),
+                    static   : false, // always an object
+                    value    : from_moz(M.value)
+                };
+
                 return new AST_ObjectKeyVal(args);
-            }
-            if (typeof args.key === "string" || typeof args.key === "number") {
-                args.key = new AST_SymbolMethod({
-                    name: args.key
-                });
-            }
-            args.value = new AST_Accessor(args.value);
-            if (M.kind == "get") return new AST_ObjectGetter(args);
-            if (M.kind == "set") return new AST_ObjectSetter(args);
-            if (M.kind == "method") {
-                args.async = M.value.async;
-                args.is_generator = M.value.generator;
-                return new AST_ConciseMethod(args);
+            } else {
+                var value = from_moz_lambda(M.value, /*is_method=*/true);
+                var args = {
+                    start    : my_start_token(M.key || M.value),
+                    end      : my_end_token(M.value),
+                    key      : M.computed
+                                ? from_moz(M.key)
+                                : from_moz_symbol(AST_SymbolMethod, M.key),
+                    quote    : from_moz_quote(M.key, M.computed),
+                    static   : false, // always an object
+                    value,
+                };
+
+                if (M.kind == "get") return new AST_ObjectGetter(args);
+                if (M.kind == "set") return new AST_ObjectSetter(args);
+                if (M.method) return new AST_ConciseMethod(args);
             }
         },
 
         MethodDefinition: function(M) {
             const is_private = M.key.type === "PrivateIdentifier";
-            const key = M.computed ? from_moz(M.key) : new AST_SymbolMethod({ name: M.key.name || M.key.value });
+            const key = M.computed ? from_moz(M.key) : new AST_SymbolMethod({ name: M.key.name || String(M.key.value) });
 
             var args = {
                 start    : my_start_token(M),
                 end      : my_end_token(M),
                 key,
-                value    : from_moz(M.value),
+                quote    : from_moz_quote(M.key, M.computed),
+                value    : from_moz_lambda(M.value, /*is_method=*/true),
                 static   : M.static,
             };
             if (M.kind == "get") {
@@ -411,8 +393,6 @@ import { is_basic_identifier_string } from "./parse.js";
             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);
         },
 
@@ -427,6 +407,7 @@ import { is_basic_identifier_string } from "./parse.js";
             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,
@@ -446,15 +427,13 @@ import { is_basic_identifier_string } from "./parse.js";
                     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,
@@ -546,11 +525,30 @@ import { is_basic_identifier_string } from "./parse.js";
         },
 
         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,
             });
         },
 
@@ -579,13 +577,13 @@ import { is_basic_identifier_string } from "./parse.js";
             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) {
@@ -593,7 +591,7 @@ import { is_basic_identifier_string } from "./parse.js";
                 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)
             });
         },
 
@@ -615,15 +613,17 @@ import { is_basic_identifier_string } from "./parse.js";
         },
 
         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
                     })
                 ],
@@ -666,8 +666,10 @@ import { is_basic_identifier_string } from "./parse.js";
 
         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"),
             });
         },
 
@@ -696,27 +698,13 @@ import { is_basic_identifier_string } from "./parse.js";
             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":
@@ -743,27 +731,11 @@ import { is_basic_identifier_string } from "./parse.js";
         },
 
         Identifier: function(M) {
-            var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
-            var q = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 3];
-            return new (  p.type == "LabeledStatement" ? AST_Label
-                        : p.type == "VariableDeclarator" && p.id === M ? (q.kind == "const" ? AST_SymbolConst : q.kind == "let" ? AST_SymbolLet : AST_SymbolVar)
-                        : /Import.*Specifier/.test(p.type) ? (p.local === M ? AST_SymbolImport : AST_SymbolImportForeign)
-                        : p.type == "ExportSpecifier" ? (p.local === M ? AST_SymbolExport : AST_SymbolExportForeign)
-                        : p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
-                        : p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
-                        : p.type == "ArrowFunctionExpression" ? (p.params.includes(M)) ? AST_SymbolFunarg : AST_SymbolRef
-                        : p.type == "ClassExpression" ? (p.id === M ? AST_SymbolClass : AST_SymbolRef)
-                        : p.type == "Property" ? (p.key === M && p.computed || p.value === M ? AST_SymbolRef : AST_SymbolMethod)
-                        : p.type == "PropertyDefinition" || p.type === "FieldDefinition" ? (p.key === M && p.computed || p.value === M ? AST_SymbolRef : AST_SymbolClassProperty)
-                        : p.type == "ClassDeclaration" ? (p.id === M ? AST_SymbolDefClass : AST_SymbolRef)
-                        : p.type == "MethodDefinition" ? (p.computed ? AST_SymbolRef : AST_SymbolMethod)
-                        : p.type == "CatchClause" ? AST_SymbolCatch
-                        : p.type == "BreakStatement" || p.type == "ContinueStatement" ? AST_LabelRef
-                        : AST_SymbolRef)({
-                            start : my_start_token(M),
-                            end   : my_end_token(M),
-                            name  : M.name
-                        });
+            return new AST_SymbolRef({
+                start : my_start_token(M),
+                end   : my_end_token(M),
+                name  : M.name
+            });
         },
 
         EmptyStatement: function(M) {
@@ -792,19 +764,28 @@ import { is_basic_identifier_string } from "./parse.js";
         },
 
         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),
             });
         },
 
@@ -812,7 +793,7 @@ import { is_basic_identifier_string } from "./parse.js";
             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),
             });
         },
 
@@ -924,20 +905,11 @@ import { is_basic_identifier_string } from "./parse.js";
             });
         },
 
-        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
             });
         },
@@ -945,6 +917,7 @@ import { is_basic_identifier_string } from "./parse.js";
         ThisExpression: function(M) {
             return new AST_This({
                 start: my_start_token(M),
+                name: "this",
                 end: my_end_token(M)
             });
         },
@@ -952,7 +925,8 @@ import { is_basic_identifier_string } from "./parse.js";
         Super: function(M) {
             return new AST_Super({
                 start: my_start_token(M),
-                end: my_end_token(M)
+                end: my_end_token(M),
+                name: "super",
             });
         },
 
@@ -993,6 +967,7 @@ import { is_basic_identifier_string } from "./parse.js";
                 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)
             });
@@ -1045,7 +1020,7 @@ import { is_basic_identifier_string } from "./parse.js";
         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)
         });
@@ -1180,13 +1155,6 @@ import { is_basic_identifier_string } from "./parse.js";
             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 {
@@ -1219,7 +1187,7 @@ import { is_basic_identifier_string } from "./parse.js";
             return {
                 type: "ImportExpression",
                 source,
-                options
+                options: options || null
             };
         }
 
@@ -1278,36 +1246,36 @@ import { is_basic_identifier_string } from "./parse.js";
         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,
         };
     });
 
@@ -1315,19 +1283,38 @@ import { is_basic_identifier_string } from "./parse.js";
         if (M.is_array) {
             return {
                 type: "ArrayPattern",
-                elements: M.names.map(to_moz)
+                elements: M.names.map(
+                    M => M instanceof AST_Hole ? null : to_moz_pattern(M)
+                ),
             };
         }
         return {
             type: "ObjectPattern",
-            properties: M.names.map(to_moz)
+            properties: M.names.map(M => {
+                if (M instanceof AST_ObjectKeyVal) {
+                    var computed = M.computed_key();
+                    const [shorthand, key] = to_moz_property_key(M.key, computed, M.quote, M.value);
+
+                    return {
+                        type: "Property",
+                        computed,
+                        kind: "init",
+                        key: key,
+                        method: false,
+                        shorthand,
+                        value: to_moz_pattern(M.value)
+                    };
+                } else {
+                    return to_moz_pattern(M);
+                }
+            }),
         };
     });
 
     def_to_moz(AST_DefaultAssign, function To_Moz_AssignmentExpression(M) {
         return {
             type: "AssignmentPattern",
-            left: to_moz(M.left),
+            left: to_moz_pattern(M.left),
             right: to_moz(M.right),
         };
     });
@@ -1372,8 +1359,7 @@ import { is_basic_identifier_string } from "./parse.js";
     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)
         };
     });
@@ -1434,10 +1420,20 @@ import { is_basic_identifier_string } from "./parse.js";
                 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) {
@@ -1588,35 +1584,10 @@ import { is_basic_identifier_string } from "./parse.js";
     });
 
     def_to_moz(AST_ObjectProperty, function To_Moz_Property(M, parent) {
-        var key = M.key instanceof AST_Node ? to_moz(M.key) : {
-            type: "Identifier",
-            value: M.key,
-        };
-        if (typeof M.key === "number") {
-            key = {
-                type: "Literal",
-                value: Number(M.key)
-            };
-        }
-        if (typeof M.key === "string") {
-            key = M.quote
-                ? {
-                    type: "Literal",
-                    value: M.key,
-                    raw: JSON.stringify(M.key),
-                }
-                : {
-                    type: "Identifier",
-                    name: M.key,
-                };
-        }
+        var computed = M.computed_key();
+        const [shorthand, key] = to_moz_property_key(M.key, computed, M.quote, M.value);
+
         var kind;
-        var string_or_num = typeof M.key === "string" || typeof M.key === "number";
-        var computed = string_or_num ? false : !(M.key instanceof AST_Symbol) || M.key instanceof AST_SymbolRef;
-        if (M instanceof AST_ObjectKeyVal) {
-            kind = "init";
-            computed = !string_or_num;
-        } else
         if (M instanceof AST_ObjectGetter) {
             kind = "get";
         } else
@@ -1671,31 +1642,51 @@ import { is_basic_identifier_string } from "./parse.js";
         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,
         };
     });
@@ -1801,6 +1792,7 @@ import { is_basic_identifier_string } from "./parse.js";
         // `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);
@@ -1844,20 +1836,133 @@ import { is_basic_identifier_string } from "./parse.js";
         );
     }
 
-    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;
     };
 
@@ -1899,6 +2004,52 @@ import { is_basic_identifier_string } from "./parse.js";
         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--) {