48         Program: function(M) {  argument
50                 start: my_start_token(M),
51                 end: my_end_token(M),
52                 body: normalize_directives(M.body.map(from_moz)),
55         ArrowFunctionExpression: function(M) {  argument
57             M.params.forEach(function(param) {
64             var fn = new (M.async ? AST_AsyncArrow : AST_Arrow)({
65                 start: my_start_token(M),
66                 end: my_end_token(M),
70             var node = from_moz(M.body);
80         FunctionDeclaration: function(M) {  argument
82             if (M.async) {
83                 ctor = M.generator ? AST_AsyncGeneratorDefun : AST_AsyncDefun;
85                 ctor = M.generator ? AST_GeneratorDefun : AST_Defun;
88             M.params.forEach(function(param) {
96                 start: my_start_token(M),
97                 end: my_end_token(M),
98                 name: from_moz(M.id),
101                 body: normalize_directives(from_moz(M.body).body),
104         FunctionExpression: function(M) {  argument
106             if (M.async) {
107                 ctor = M.generator ? AST_AsyncGeneratorFunction : AST_AsyncFunction;
109                 ctor = M.generator ? AST_GeneratorFunction : AST_Function;
112             M.params.forEach(function(param) {
120                 start: my_start_token(M),
121                 end: my_end_token(M),
122                 name: from_moz(M.id),
125                 body: normalize_directives(from_moz(M.body).body),
128         ClassDeclaration: function(M) {  argument
130                 start: my_start_token(M),
131                 end: my_end_token(M),
132                 name: from_moz(M.id),
133                 extends: from_moz(M.superClass),
134                 properties: M.body.body.map(from_moz),
137         ClassExpression: function(M) {  argument
139                 start: my_start_token(M),
140                 end: my_end_token(M),
141                 name: from_moz(M.id),
142                 extends: from_moz(M.superClass),
143                 properties: M.body.body.map(from_moz),
146         MethodDefinition: function(M) {  argument
147             var key = M.key, internal = false;
148             if (M.computed) {
156             var ctor = AST_ClassMethod, value = from_moz(M.value);
157             switch (M.kind) {
168                 start: my_start_token(M),
169                 end: my_end_token(M),
172                 static: M.static,
176         PropertyDefinition: function(M) {  argument
177             var key = M.key, internal = false;
178             if (M.computed) {
187                 start: my_start_token(M),
188                 end: my_end_token(M),
191                 static: M.static,
192                 value: from_moz(M.value),
195         StaticBlock: function(M) {  argument
196             var start = my_start_token(M);
197             var end = my_end_token(M);
204                     body: normalize_directives(M.body.map(from_moz)),
208         ForOfStatement: function(M) {  argument
209             return new (M.await ? AST_ForAwaitOf : AST_ForOf)({
210                 start: my_start_token(M),
211                 end: my_end_token(M),
212                 init: from_moz(M.left),
213                 object: from_moz(M.right),
214                 body: from_moz(M.body),
217         TryStatement: function(M) {  argument
218             var handlers = M.handlers || [M.handler];
219             if (handlers.length > 1 || M.guardedHandlers && M.guardedHandlers.length) {
223                 start    : my_start_token(M),
224                 end      : my_end_token(M),
225                 body     : from_moz(M.block).body,
227                 bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null,
230         Property: function(M) {  argument
231             var key = M.computed ? from_moz(M.key) : read_name(M.key);
233                 start: my_start_token(M),
234                 end: my_end_token(M),
236                 value: from_moz(M.value),
238             if (M.kind == "init") return new (M.method ? AST_ObjectMethod : AST_ObjectKeyVal)(args);
240             if (M.kind == "get") return new AST_ObjectGetter(args);
241             if (M.kind == "set") return new AST_ObjectSetter(args);
243         ArrayExpression: function(M) {  argument
245                 start: my_start_token(M),
246                 end: my_end_token(M),
247                 elements: M.elements.map(function(elem) {
252         ArrayPattern: function(M) {  argument
254             M.elements.forEach(function(el) {
264                 start: my_start_token(M),
265                 end: my_end_token(M),
270         ObjectPattern: function(M) {  argument
272             M.properties.forEach(function(prop) {
280                 start: my_start_token(M),
281                 end: my_end_token(M),
286         MemberExpression: function(M) {  argument
287             return new (M.computed ? AST_Sub : AST_Dot)({
288                 start: my_start_token(M),
289                 end: my_end_token(M),
290                 optional: M.optional,
291                 expression: from_moz(M.object),
292                 property: M.computed ? from_moz(M.property) : M.property.name,
295         MetaProperty: function(M) {  argument
296             var expr = from_moz(M.meta);
297             var prop = read_name(M.property);
299                 start: my_start_token(M),
300                 end: my_end_token(M),
304                 start: my_start_token(M),
305                 end: my_end_token(M),
310         SwitchCase: function(M) {  argument
311             return new (M.test ? AST_Case : AST_Default)({
312                 start      : my_start_token(M),
313                 end        : my_end_token(M),
314                 expression : from_moz(M.test),
315                 body       : M.consequent.map(from_moz),
318         ExportAllDeclaration: function(M) {  argument
319             var start = my_start_token(M);
320             var end = my_end_token(M);
324                 aliases: [ M.exported ? from_moz_alias(M.exported) : new AST_String({
334                 path: from_moz(M.source),
337         ExportDefaultDeclaration: function(M) {  argument
338             var decl = from_moz(M.declaration);
357                 start: my_start_token(M),
358                 end: my_end_token(M),
362         ExportNamedDeclaration: function(M) {  argument
363             if (M.declaration) return new AST_ExportDeclaration({
364                 start: my_start_token(M),
365                 end: my_end_token(M),
366                 body: from_moz(M.declaration),
368             if (M.source) {
370                 M.specifiers.forEach(function(prop) {
375                     start: my_start_token(M),
376                     end: my_end_token(M),
379                     path: from_moz(M.source),
383                 start: my_start_token(M),
384                 end: my_end_token(M),
385                 properties: M.specifiers.map(function(prop) {
392         ImportDeclaration: function(M) {  argument
393             var start = my_start_token(M);
394             var end = my_end_token(M);
396             M.specifiers.forEach(function(prop) {
428                 path: from_moz(M.source),
431         ImportExpression: function(M) {  argument
432             var start = my_start_token(M);
433             var arg = from_moz(M.source);
436                 end: my_end_token(M),
445         VariableDeclaration: function(M) {  argument
449             }[M.kind] || AST_Var)({
450                 start: my_start_token(M),
451                 end: my_end_token(M),
452                 definitions: M.declarations.map(from_moz),
455         Literal: function(M) {  argument
457                 start: my_start_token(M),
458                 end: my_end_token(M),
460             if (M.bigint) {
461                 args.value = M.bigint.toLowerCase() + "n";
464             var val = M.value;
466             var rx = M.regex;
474                 args.value = M.regex && M.raw ? M.raw : val;
502         TemplateLiteral: function(M) {  argument
504                 start: my_start_token(M),
505                 end: my_end_token(M),
506                 expressions: M.expressions.map(from_moz),
507                 strings: M.quasis.map(function(el) {
512         TaggedTemplateExpression: function(M) {  argument
513             var tmpl = from_moz(M.quasi);
514             tmpl.start = my_start_token(M);
515             tmpl.end = my_end_token(M);
516             tmpl.tag = from_moz(M.tag);
519         Identifier: function(M) {  argument
563                 start: my_start_token(M),
564                 end: my_end_token(M),
565                 name: M.name,
568         Super: function(M) {  argument
570                 start: my_start_token(M),
571                 end: my_end_token(M),
575         ThisExpression: function(M) {  argument
577                 start: my_start_token(M),
578                 end: my_end_token(M),
582         ParenthesizedExpression: function(M) {  argument
583             var node = from_moz(M.expression);
585             node.start.parens.push(my_start_token(M));
587             node.end.parens.push(my_end_token(M));
590         ChainExpression: function(M) {  argument
591             var node = from_moz(M.expression);
598     MOZ_TO_ME.UnaryExpression = function To_Moz_Unary(M) {
599         var prefix = "prefix" in M ? M.prefix
600             : M.type == "UnaryExpression" ? true : false;
602             start      : my_start_token(M),
603             end        : my_end_token(M),
604             operator   : M.operator,
605             expression : from_moz(M.argument)
641     def_to_moz(AST_Toplevel, function To_Moz_Program(M) {  argument
642         return to_moz_scope("Program", M);
645     def_to_moz(AST_LambdaDefinition, function To_Moz_FunctionDeclaration(M) {  argument
646         var params = M.argnames.map(to_moz);
647         if (M.rest) params.push({
649             argument: to_moz(M.rest),
653             id: to_moz(M.name),
654             async: is_async(M),
655             generator: is_generator(M),
657             body: to_moz_scope("BlockStatement", M),
661     def_to_moz(AST_Lambda, function To_Moz_FunctionExpression(M) {  argument
662         var params = M.argnames.map(to_moz);
663         if (M.rest) params.push({
665             argument: to_moz(M.rest),
667         if (is_arrow(M)) return {
669             async: is_async(M),
671             body: M.value ? to_moz(M.value) : to_moz_scope("BlockStatement", M),
675             id: to_moz(M.name),
676             async: is_async(M),
677             generator: is_generator(M),
679             body: to_moz_scope("BlockStatement", M),
683     def_to_moz(AST_DefClass, function To_Moz_ClassDeclaration(M) {  argument
686             id: to_moz(M.name),
687             superClass: to_moz(M.extends),
690                 body: M.properties.map(to_moz),
695     def_to_moz(AST_ClassExpression, function To_Moz_ClassExpression(M) {  argument
698             id: to_moz(M.name),
699             superClass: to_moz(M.extends),
702                 body: M.properties.map(to_moz),
708         return function(M) {  argument
709             var computed = M.key instanceof AST_Node;
710             var key = computed ? to_moz(M.key) : M.private ? {
712                 name: M.key.slice(1),
715                 value: M.key,
722                 static: M.static,
723                 value: to_moz(M.value),
731     def_to_moz(AST_ClassField, function To_Moz_PropertyDefinition(M) {  argument
732         var computed = M.key instanceof AST_Node;
733         var key = computed ? to_moz(M.key) : M.private ? {
735             name: M.key.slice(1),
738             value: M.key,
744             static: M.static,
745             value: to_moz(M.value),
749     def_to_moz(AST_ClassInit, function To_Moz_StaticBlock(M) {  argument
750         return to_moz_scope("StaticBlock", M.value);
754         return function(M) {  argument
758                 left: to_moz(M.init),
759                 right: to_moz(M.object),
760                 body: to_moz(M.body),
767     def_to_moz(AST_Directive, function To_Moz_Directive(M) {  argument
770             expression: set_moz_loc(M, {
772                 value: M.value,
777     def_to_moz(AST_SwitchBranch, function To_Moz_SwitchCase(M) {  argument
780             test: to_moz(M.expression),
781             consequent: M.body.map(to_moz),
785     def_to_moz(AST_Try, function To_Moz_TryStatement(M) {  argument
788             block: to_moz_block(M),
789             handler: to_moz(M.bcatch),
791             finalizer: to_moz(M.bfinally),
795     def_to_moz(AST_Catch, function To_Moz_CatchClause(M) {  argument
798             param: to_moz(M.argname),
800             body: to_moz_block(M),
804     def_to_moz(AST_ExportDeclaration, function To_Moz_ExportNamedDeclaration_declaration(M) {  argument
807             declaration: to_moz(M.body),
811     def_to_moz(AST_ExportDefault, function To_Moz_ExportDefaultDeclaration(M) {  argument
814             declaration: to_moz(M.body),
818     def_to_moz(AST_ExportForeign, function To_Moz_ExportAllDeclaration_ExportNamedDeclaration(M) {  argument
819         if (M.keys[0].value == "*") return {
821             exported: M.aliases[0].value == "*" ? null : to_moz_alias(M.aliases[0]),
822             source: to_moz(M.path),
825         for (var i = 0; i < M.aliases.length; i++) {
827                 start: M.keys[i].start,
828                 end: M.aliases[i].end,
831                 local: to_moz_alias(M.keys[i]),
832                 exported: to_moz_alias(M.aliases[i]),
838             source: to_moz(M.path),
842     def_to_moz(AST_ExportReferences, function To_Moz_ExportNamedDeclaration_specifiers(M) {  argument
845             specifiers: M.properties.map(function(prop) {
858     def_to_moz(AST_Import, function To_Moz_ImportDeclaration(M) {  argument
859         var specifiers = M.properties ? M.properties.map(function(prop) {
869         if (M.all) specifiers.unshift(set_moz_loc(M.all, {
871             local: to_moz(M.all),
873         if (M.default) specifiers.unshift(set_moz_loc(M.default, {
875             local: to_moz(M.default),
880             source: to_moz(M.path),
884     def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {  argument
887             kind: M.TYPE.toLowerCase(),
888             declarations: M.definitions.map(to_moz),
892     def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) {  argument
893         var computed = M instanceof AST_Sub;
896             object: to_moz(M.expression),
898             optional: M.optional,
899             property: computed ? to_moz(M.property) : {
901                 name: M.property,
904         return M.terminal ? {
910     def_to_moz(AST_Unary, function To_Moz_Unary(M) {  argument
912             type: M.operator == "++" || M.operator == "--" ? "UpdateExpression" : "UnaryExpression",
913             operator: M.operator,
914             prefix: M instanceof AST_UnaryPrefix,
915             argument: to_moz(M.expression)
919     def_to_moz(AST_Binary, function To_Moz_BinaryExpression(M) {  argument
921 …         type: M.operator == "&&" || M.operator == "||" ? "LogicalExpression" : "BinaryExpression",
922             left: to_moz(M.left),
923             operator: M.operator,
924             right: to_moz(M.right)
928     def_to_moz(AST_Array, function To_Moz_ArrayExpression(M) {  argument
931             elements: M.elements.map(to_moz),
935     def_to_moz(AST_DestructuredArray, function To_Moz_ArrayPattern(M) {  argument
936         var elements = M.elements.map(to_moz);
937         if (M.rest) elements.push({
939             argument: to_moz(M.rest),
947     def_to_moz(AST_DestructuredKeyVal, function To_Moz_Property(M) {  argument
948         var computed = M.key instanceof AST_Node;
949         var key = computed ? to_moz(M.key) : {
951             value: M.key,
958             value: to_moz(M.value),
962     def_to_moz(AST_DestructuredObject, function To_Moz_ObjectPattern(M) {  argument
963         var props = M.properties.map(to_moz);
964         if (M.rest) props.push({
966             argument: to_moz(M.rest),
974     def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) {
975         var computed = M.key instanceof AST_Node;
976         var key = computed ? to_moz(M.key) : {
978             value: M.key,
981         if (M instanceof AST_ObjectKeyVal) {
983         } else if (M instanceof AST_ObjectGetter) {
985         } else if (M instanceof AST_ObjectSetter) {
992             method: M instanceof AST_ObjectMethod,
994             value: to_moz(M.value),
998     def_to_moz(AST_Symbol, function To_Moz_Identifier(M) {  argument
999         var def = M.definition();
1002             name: def && def.mangled_name || M.name,
1028     def_to_moz(AST_RegExp, function To_Moz_RegExpLiteral(M) {  argument
1029         var flags = M.value.toString().match(/\/([gimuy]*)$/)[1];
1030         var value = "/" + M.value.raw_source + "/" + flags;
1036                 pattern: M.value.raw_source,
1042     def_to_moz(AST_BigInt, function To_Moz_BigInt(M) {  argument
1043         var value = M.value;
1051     function To_Moz_Literal(M) {  argument
1052         var value = M.value;
1061                     raw: M.start.raw,
1068             raw: M.start.raw,
1075     def_to_moz(AST_Atom, function To_Moz_Atom(M) {  argument
1078             name: String(M.value),
1082     def_to_moz(AST_Template, function To_Moz_TemplateLiteral_TaggedTemplateExpression(M) {  argument
1083         var last = M.strings.length - 1;
1086             expressions: M.expressions.map(to_moz),
1087             quasis: M.strings.map(function(str, index) {
1095         if (!M.tag) return tmpl;
1098             tag: to_moz(M.tag),
1159     function read_name(M) {  argument
1160         return "" + M[M.type == "Identifier" ? "name" : "value"];
1165             "start: my_start_token(M)",
1166             "end: my_end_token(M)",
1173             var m = /([a-z0-9$_]+)(=|@|>|%)([a-z0-9$_]+)/i.exec(prop);
1174             if (!m) throw new Error("Can't understand property map: " + prop);
1175             var moz = m[1], how = m[2], my = m[3];
1178                 moz_to_me.push(my + ": M." + moz + ".map(from_moz)");
1179                 me_to_moz.push(moz + ": M." +  my + ".map(to_moz)");
1182                 moz_to_me.push(my + ": from_moz(M." + moz + ")");
1183                 me_to_moz.push(moz + ": to_moz(M." + my + ")");
1186                 moz_to_me.push(my + ": M." + moz);
1187                 me_to_moz.push(moz + ": M." + my);
1190                 moz_to_me.push(my + ": from_moz(M." + moz + ").body");
1191                 me_to_moz.push(moz + ": to_moz_block(M)");
1199             "return function From_Moz_" + moztype + "(M) {",
1206             "return function To_Moz_" + moztype + "(M) {",