mathjs 10.4.3 → 10.5.2

package/examples/node_modules/terser/lib/mozilla-ast.js

@@ -1,1376 +0,0 @@
-/***********************************************************************
-
-  A JavaScript tokenizer / parser / beautifier / compressor.
-  https://github.com/mishoo/UglifyJS2
-
-  -------------------------------- (C) ---------------------------------
-
-                           Author: Mihai Bazon
-                         <mihai.bazon@gmail.com>
-                       http://mihai.bazon.net/blog
-
-  Distributed under the BSD license:
-
-    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions
-    are met:
-
-        * Redistributions of source code must retain the above
-          copyright notice, this list of conditions and the following
-          disclaimer.
-
-        * Redistributions in binary form must reproduce the above
-          copyright notice, this list of conditions and the following
-          disclaimer in the documentation and/or other materials
-          provided with the distribution.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
-    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
-    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
-    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
-    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-    SUCH DAMAGE.
-
- ***********************************************************************/
-
-import * as ast from "./ast.js";
-import { make_node } from "./utils/index.js";
-import {
-    AST_Accessor,
-    AST_Array,
-    AST_Arrow,
-    AST_Assign,
-    AST_Atom,
-    AST_Await,
-    AST_BigInt,
-    AST_Binary,
-    AST_Block,
-    AST_BlockStatement,
-    AST_Boolean,
-    AST_Break,
-    AST_Call,
-    AST_Case,
-    AST_Catch,
-    AST_Chain,
-    AST_Class,
-    AST_ClassExpression,
-    AST_ClassProperty,
-    AST_ClassPrivateProperty,
-    AST_ConciseMethod,
-    AST_Conditional,
-    AST_Const,
-    AST_Constant,
-    AST_Continue,
-    AST_Debugger,
-    AST_Default,
-    AST_DefaultAssign,
-    AST_DefClass,
-    AST_Definitions,
-    AST_Defun,
-    AST_Destructuring,
-    AST_Directive,
-    AST_Do,
-    AST_Dot,
-    AST_DotHash,
-    AST_EmptyStatement,
-    AST_Expansion,
-    AST_Export,
-    AST_False,
-    AST_Finally,
-    AST_For,
-    AST_ForIn,
-    AST_ForOf,
-    AST_Function,
-    AST_Hole,
-    AST_If,
-    AST_Import,
-    AST_ImportMeta,
-    AST_Label,
-    AST_LabeledStatement,
-    AST_LabelRef,
-    AST_Lambda,
-    AST_Let,
-    AST_NameMapping,
-    AST_New,
-    AST_NewTarget,
-    AST_Node,
-    AST_Null,
-    AST_Number,
-    AST_Object,
-    AST_ObjectGetter,
-    AST_ObjectKeyVal,
-    AST_ObjectProperty,
-    AST_ObjectSetter,
-    AST_PrefixedTemplateString,
-    AST_PrivateGetter,
-    AST_PrivateMethod,
-    AST_PrivateSetter,
-    AST_PropAccess,
-    AST_RegExp,
-    AST_Return,
-    AST_Sequence,
-    AST_SimpleStatement,
-    AST_Statement,
-    AST_String,
-    AST_Sub,
-    AST_Super,
-    AST_Switch,
-    AST_SwitchBranch,
-    AST_Symbol,
-    AST_SymbolCatch,
-    AST_SymbolClass,
-    AST_SymbolClassProperty,
-    AST_SymbolConst,
-    AST_SymbolDefClass,
-    AST_SymbolDefun,
-    AST_SymbolExport,
-    AST_SymbolExportForeign,
-    AST_SymbolFunarg,
-    AST_SymbolImport,
-    AST_SymbolImportForeign,
-    AST_SymbolLambda,
-    AST_SymbolLet,
-    AST_SymbolMethod,
-    AST_SymbolRef,
-    AST_SymbolVar,
-    AST_TemplateSegment,
-    AST_TemplateString,
-    AST_This,
-    AST_Throw,
-    AST_Token,
-    AST_Toplevel,
-    AST_True,
-    AST_Try,
-    AST_Unary,
-    AST_UnaryPostfix,
-    AST_UnaryPrefix,
-    AST_Var,
-    AST_VarDef,
-    AST_While,
-    AST_With,
-    AST_Yield,
-} from "./ast.js";
-import { is_basic_identifier_string } from "./parse.js";
-
-(function() {
-
-    var normalize_directives = function(body) {
-        var in_directive = true;
-
-        for (var i = 0; i < body.length; i++) {
-            if (in_directive && body[i] instanceof AST_Statement && body[i].body instanceof AST_String) {
-                body[i] = new AST_Directive({
-                    start: body[i].start,
-                    end: body[i].end,
-                    value: body[i].body.value
-                });
-            } else if (in_directive && !(body[i] instanceof AST_Statement && body[i].body instanceof AST_String)) {
-                in_directive = false;
-            }
-        }
-
-        return body;
-    };
-
-    const assert_clause_from_moz = (assertions) => {
-        if (assertions && assertions.length > 0) {
-            return new AST_Object({
-                start: my_start_token(assertions),
-                end: my_end_token(assertions),
-                properties: assertions.map((assertion_kv) =>
-                    new AST_ObjectKeyVal({
-                        start: my_start_token(assertion_kv),
-                        end: my_end_token(assertion_kv),
-                        key: assertion_kv.key.name || assertion_kv.key.value,
-                        value: from_moz(assertion_kv.value)
-                    })
-                )
-            });
-        }
-        return null;
-    };
-
-    var MOZ_TO_ME = {
-        Program: function(M) {
-            return new AST_Toplevel({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                body: normalize_directives(M.body.map(from_moz))
-            });
-        },
-        ArrayPattern: function(M) {
-            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(elm);
-                }),
-                is_array: true
-            });
-        },
-        ObjectPattern: function(M) {
-            return new AST_Destructuring({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                names: M.properties.map(from_moz),
-                is_array: false
-            });
-        },
-        AssignmentPattern: function(M) {
-            return new AST_DefaultAssign({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                left: from_moz(M.left),
-                operator: "=",
-                right: from_moz(M.right)
-            });
-        },
-        SpreadElement: function(M) {
-            return new AST_Expansion({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                expression: from_moz(M.argument)
-            });
-        },
-        RestElement: function(M) {
-            return new AST_Expansion({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                expression: from_moz(M.argument)
-            });
-        },
-        TemplateElement: function(M) {
-            return new AST_TemplateSegment({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                value: M.value.cooked,
-                raw: M.value.raw
-            });
-        },
-        TemplateLiteral: function(M) {
-            var segments = [];
-            for (var i = 0; i < M.quasis.length; i++) {
-                segments.push(from_moz(M.quasis[i]));
-                if (M.expressions[i]) {
-                    segments.push(from_moz(M.expressions[i]));
-                }
-            }
-            return new AST_TemplateString({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                segments: segments
-            });
-        },
-        TaggedTemplateExpression: function(M) {
-            return new AST_PrefixedTemplateString({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                template_string: from_moz(M.quasi),
-                prefix: from_moz(M.tag)
-            });
-        },
-        FunctionDeclaration: function(M) {
-            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),
-                is_generator: M.generator,
-                async: M.async,
-                body: normalize_directives(from_moz(M.body).body)
-            });
-        },
-        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)
-            });
-        },
-        ArrowFunctionExpression: function(M) {
-            const body = M.body.type === "BlockStatement"
-                ? from_moz(M.body).body
-                : [make_node(AST_Return, {}, { value: from_moz(M.body) })];
-            return new AST_Arrow({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                argnames: M.params.map(from_moz),
-                body,
-                async: M.async,
-            });
-        },
-        ExpressionStatement: function(M) {
-            return new AST_SimpleStatement({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                body: from_moz(M.expression)
-            });
-        },
-        TryStatement: function(M) {
-            var handlers = M.handlers || [M.handler];
-            if (handlers.length > 1 || M.guardedHandlers && M.guardedHandlers.length) {
-                throw new Error("Multiple catch clauses are not supported.");
-            }
-            return new AST_Try({
-                start    : my_start_token(M),
-                end      : my_end_token(M),
-                body     : from_moz(M.block).body,
-                bcatch   : from_moz(handlers[0]),
-                bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null
-            });
-        },
-        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);
-                }
-                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);
-            }
-        },
-        MethodDefinition: function(M) {
-            var args = {
-                start    : my_start_token(M),
-                end      : my_end_token(M),
-                key      : M.computed ? from_moz(M.key) : new AST_SymbolMethod({ name: M.key.name || M.key.value }),
-                value    : from_moz(M.value),
-                static   : M.static,
-            };
-            if (M.kind == "get") {
-                return new AST_ObjectGetter(args);
-            }
-            if (M.kind == "set") {
-                return new AST_ObjectSetter(args);
-            }
-            args.is_generator = M.value.generator;
-            args.async = M.value.async;
-            return new AST_ConciseMethod(args);
-        },
-        FieldDefinition: function(M) {
-            let key;
-            if (M.computed) {
-                key = from_moz(M.key);
-            } else {
-                if (M.key.type !== "Identifier") throw new Error("Non-Identifier key in FieldDefinition");
-                key = from_moz(M.key);
-            }
-            return new AST_ClassProperty({
-                start    : my_start_token(M),
-                end      : my_end_token(M),
-                key,
-                value    : from_moz(M.value),
-                static   : M.static,
-            });
-        },
-        PropertyDefinition: function(M) {
-            let key;
-            if (M.computed) {
-                key = from_moz(M.key);
-            } else {
-                if (M.key.type !== "Identifier") throw new Error("Non-Identifier key in PropertyDefinition");
-                key = from_moz(M.key);
-            }
-
-            return new AST_ClassProperty({
-                start    : my_start_token(M),
-                end      : my_end_token(M),
-                key,
-                value    : from_moz(M.value),
-                static   : M.static,
-            });
-        },
-        ArrayExpression: function(M) {
-            return new AST_Array({
-                start    : my_start_token(M),
-                end      : my_end_token(M),
-                elements : M.elements.map(function(elem) {
-                    return elem === null ? new AST_Hole() : from_moz(elem);
-                })
-            });
-        },
-        ObjectExpression: function(M) {
-            return new AST_Object({
-                start      : my_start_token(M),
-                end        : my_end_token(M),
-                properties : M.properties.map(function(prop) {
-                    if (prop.type === "SpreadElement") {
-                        return from_moz(prop);
-                    }
-                    prop.type = "Property";
-                    return from_moz(prop);
-                })
-            });
-        },
-        SequenceExpression: function(M) {
-            return new AST_Sequence({
-                start      : my_start_token(M),
-                end        : my_end_token(M),
-                expressions: M.expressions.map(from_moz)
-            });
-        },
-        MemberExpression: function(M) {
-            return new (M.computed ? AST_Sub : AST_Dot)({
-                start      : my_start_token(M),
-                end        : my_end_token(M),
-                property   : M.computed ? from_moz(M.property) : M.property.name,
-                expression : from_moz(M.object),
-                optional   : M.optional || false
-            });
-        },
-        ChainExpression: function(M) {
-            return new AST_Chain({
-                start      : my_start_token(M),
-                end        : my_end_token(M),
-                expression : from_moz(M.expression)
-            });
-        },
-        SwitchCase: function(M) {
-            return new (M.test ? AST_Case : AST_Default)({
-                start      : my_start_token(M),
-                end        : my_end_token(M),
-                expression : from_moz(M.test),
-                body       : M.consequent.map(from_moz)
-            });
-        },
-        VariableDeclaration: function(M) {
-            return new (M.kind === "const" ? AST_Const :
-                        M.kind === "let" ? AST_Let : AST_Var)({
-                start       : my_start_token(M),
-                end         : my_end_token(M),
-                definitions : M.declarations.map(from_moz)
-            });
-        },
-
-        ImportDeclaration: function(M) {
-            var imported_name = null;
-            var imported_names = null;
-            M.specifiers.forEach(function (specifier) {
-                if (specifier.type === "ImportSpecifier") {
-                    if (!imported_names) { imported_names = []; }
-                    imported_names.push(new AST_NameMapping({
-                        start: my_start_token(specifier),
-                        end: my_end_token(specifier),
-                        foreign_name: from_moz(specifier.imported),
-                        name: from_moz(specifier.local)
-                    }));
-                } else if (specifier.type === "ImportDefaultSpecifier") {
-                    imported_name = from_moz(specifier.local);
-                } else if (specifier.type === "ImportNamespaceSpecifier") {
-                    if (!imported_names) { imported_names = []; }
-                    imported_names.push(new AST_NameMapping({
-                        start: my_start_token(specifier),
-                        end: my_end_token(specifier),
-                        foreign_name: new AST_SymbolImportForeign({ name: "*" }),
-                        name: from_moz(specifier.local)
-                    }));
-                }
-            });
-            return new AST_Import({
-                start       : my_start_token(M),
-                end         : my_end_token(M),
-                imported_name: imported_name,
-                imported_names : imported_names,
-                module_name : from_moz(M.source),
-                assert_clause: assert_clause_from_moz(M.assertions)
-            });
-        },
-        ExportAllDeclaration: function(M) {
-            return new AST_Export({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                exported_names: [
-                    new AST_NameMapping({
-                        name: new AST_SymbolExportForeign({ name: "*" }),
-                        foreign_name: new AST_SymbolExportForeign({ name: "*" })
-                    })
-                ],
-                module_name: from_moz(M.source),
-                assert_clause: assert_clause_from_moz(M.assertions)
-            });
-        },
-        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(function (specifier) {
-                    return new AST_NameMapping({
-                        foreign_name: from_moz(specifier.exported),
-                        name: from_moz(specifier.local)
-                    });
-                }) : null,
-                module_name: from_moz(M.source),
-                assert_clause: assert_clause_from_moz(M.assertions)
-            });
-        },
-        ExportDefaultDeclaration: function(M) {
-            return new AST_Export({
-                start: my_start_token(M),
-                end: my_end_token(M),
-                exported_value: from_moz(M.declaration),
-                is_default: true
-            });
-        },
-        Literal: function(M) {
-            var val = M.value, args = {
-                start  : my_start_token(M),
-                end    : my_end_token(M)
-            };
-            var rx = M.regex;
-            if (rx && rx.pattern) {
-                // RegExpLiteral as per ESTree AST spec
-                args.value = {
-                    source: rx.pattern,
-                    flags: rx.flags
-                };
-                return new AST_RegExp(args);
-            } else if (rx) {
-                // support legacy RegExp
-                const rx_source = M.raw || val;
-                const match = rx_source.match(/^\/(.*)\/(\w*)$/);
-                if (!match) throw new Error("Invalid regex source " + rx_source);
-                const [_, source, flags] = match;
-                args.value = { source, flags };
-                return new AST_RegExp(args);
-            }
-            if (val === null) return new AST_Null(args);
-            switch (typeof val) {
-              case "string":
-                args.value = val;
-                return new AST_String(args);
-              case "number":
-                args.value = val;
-                args.raw = M.raw || val.toString();
-                return new AST_Number(args);
-              case "boolean":
-                return new (val ? AST_True : AST_False)(args);
-            }
-        },
-        MetaProperty: function(M) {
-            if (M.meta.name === "new" && M.property.name === "target") {
-                return new AST_NewTarget({
-                    start: my_start_token(M),
-                    end: my_end_token(M)
-                });
-            } else if (M.meta.name === "import" && M.property.name === "meta") {
-                return new AST_ImportMeta({
-                    start: my_start_token(M),
-                    end: my_end_token(M)
-                });
-            }
-        },
-        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
-                        });
-        },
-        BigIntLiteral(M) {
-            return new AST_BigInt({
-                start : my_start_token(M),
-                end   : my_end_token(M),
-                value : M.value
-            });
-        }
-    };
-
-    MOZ_TO_ME.UpdateExpression =
-    MOZ_TO_ME.UnaryExpression = function To_Moz_Unary(M) {
-        var prefix = "prefix" in M ? M.prefix
-            : M.type == "UnaryExpression" ? true : false;
-        return new (prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({
-            start      : my_start_token(M),
-            end        : my_end_token(M),
-            operator   : M.operator,
-            expression : from_moz(M.argument)
-        });
-    };
-
-    MOZ_TO_ME.ClassDeclaration =
-    MOZ_TO_ME.ClassExpression = function From_Moz_Class(M) {
-        return new (M.type === "ClassDeclaration" ? AST_DefClass : AST_ClassExpression)({
-            start    : my_start_token(M),
-            end      : my_end_token(M),
-            name     : from_moz(M.id),
-            extends  : from_moz(M.superClass),
-            properties: M.body.body.map(from_moz)
-        });
-    };
-
-    map("EmptyStatement", AST_EmptyStatement);
-    map("BlockStatement", AST_BlockStatement, "body@body");
-    map("IfStatement", AST_If, "test>condition, consequent>body, alternate>alternative");
-    map("LabeledStatement", AST_LabeledStatement, "label>label, body>body");
-    map("BreakStatement", AST_Break, "label>label");
-    map("ContinueStatement", AST_Continue, "label>label");
-    map("WithStatement", AST_With, "object>expression, body>body");
-    map("SwitchStatement", AST_Switch, "discriminant>expression, cases@body");
-    map("ReturnStatement", AST_Return, "argument>value");
-    map("ThrowStatement", AST_Throw, "argument>value");
-    map("WhileStatement", AST_While, "test>condition, body>body");
-    map("DoWhileStatement", AST_Do, "test>condition, body>body");
-    map("ForStatement", AST_For, "init>init, test>condition, update>step, body>body");
-    map("ForInStatement", AST_ForIn, "left>init, right>object, body>body");
-    map("ForOfStatement", AST_ForOf, "left>init, right>object, body>body, await=await");
-    map("AwaitExpression", AST_Await, "argument>expression");
-    map("YieldExpression", AST_Yield, "argument>expression, delegate=is_star");
-    map("DebuggerStatement", AST_Debugger);
-    map("VariableDeclarator", AST_VarDef, "id>name, init>value");
-    map("CatchClause", AST_Catch, "param>argname, body%body");
-
-    map("ThisExpression", AST_This);
-    map("Super", AST_Super);
-    map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right");
-    map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right");
-    map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
-    map("ConditionalExpression", AST_Conditional, "test>condition, consequent>consequent, alternate>alternative");
-    map("NewExpression", AST_New, "callee>expression, arguments@args");
-    map("CallExpression", AST_Call, "callee>expression, optional=optional, arguments@args");
-
-    def_to_moz(AST_Toplevel, function To_Moz_Program(M) {
-        return to_moz_scope("Program", M);
-    });
-
-    def_to_moz(AST_Expansion, function To_Moz_Spread(M) {
-        return {
-            type: to_moz_in_destructuring() ? "RestElement" : "SpreadElement",
-            argument: to_moz(M.expression)
-        };
-    });
-
-    def_to_moz(AST_PrefixedTemplateString, function To_Moz_TaggedTemplateExpression(M) {
-        return {
-            type: "TaggedTemplateExpression",
-            tag: to_moz(M.prefix),
-            quasi: to_moz(M.template_string)
-        };
-    });
-
-    def_to_moz(AST_TemplateString, function To_Moz_TemplateLiteral(M) {
-        var quasis = [];
-        var expressions = [];
-        for (var i = 0; i < M.segments.length; i++) {
-            if (i % 2 !== 0) {
-                expressions.push(to_moz(M.segments[i]));
-            } else {
-                quasis.push({
-                    type: "TemplateElement",
-                    value: {
-                        raw: M.segments[i].raw,
-                        cooked: M.segments[i].value
-                    },
-                    tail: i === M.segments.length - 1
-                });
-            }
-        }
-        return {
-            type: "TemplateLiteral",
-            quasis: quasis,
-            expressions: expressions
-        };
-    });
-
-    def_to_moz(AST_Defun, function To_Moz_FunctionDeclaration(M) {
-        return {
-            type: "FunctionDeclaration",
-            id: to_moz(M.name),
-            params: M.argnames.map(to_moz),
-            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;
-        return {
-            type: "FunctionExpression",
-            id: to_moz(M.name),
-            params: M.argnames.map(to_moz),
-            generator: is_generator,
-            async: M.async,
-            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)
-        };
-        return {
-            type: "ArrowFunctionExpression",
-            params: M.argnames.map(to_moz),
-            async: M.async,
-            body: body
-        };
-    });
-
-    def_to_moz(AST_Destructuring, function To_Moz_ObjectPattern(M) {
-        if (M.is_array) {
-            return {
-                type: "ArrayPattern",
-                elements: M.names.map(to_moz)
-            };
-        }
-        return {
-            type: "ObjectPattern",
-            properties: M.names.map(to_moz)
-        };
-    });
-
-    def_to_moz(AST_Directive, function To_Moz_Directive(M) {
-        return {
-            type: "ExpressionStatement",
-            expression: {
-                type: "Literal",
-                value: M.value,
-                raw: M.print_to_string()
-            },
-            directive: M.value
-        };
-    });
-
-    def_to_moz(AST_SimpleStatement, function To_Moz_ExpressionStatement(M) {
-        return {
-            type: "ExpressionStatement",
-            expression: to_moz(M.body)
-        };
-    });
-
-    def_to_moz(AST_SwitchBranch, function To_Moz_SwitchCase(M) {
-        return {
-            type: "SwitchCase",
-            test: to_moz(M.expression),
-            consequent: M.body.map(to_moz)
-        };
-    });
-
-    def_to_moz(AST_Try, function To_Moz_TryStatement(M) {
-        return {
-            type: "TryStatement",
-            block: to_moz_block(M),
-            handler: to_moz(M.bcatch),
-            guardedHandlers: [],
-            finalizer: to_moz(M.bfinally)
-        };
-    });
-
-    def_to_moz(AST_Catch, function To_Moz_CatchClause(M) {
-        return {
-            type: "CatchClause",
-            param: to_moz(M.argname),
-            guard: null,
-            body: to_moz_block(M)
-        };
-    });
-
-    def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) {
-        return {
-            type: "VariableDeclaration",
-            kind:
-                M instanceof AST_Const ? "const" :
-                M instanceof AST_Let ? "let" : "var",
-            declarations: M.definitions.map(to_moz)
-        };
-    });
-
-    const assert_clause_to_moz = assert_clause => {
-        const assertions = [];
-        if (assert_clause) {
-            for (const { key, value } of assert_clause.properties) {
-                const key_moz = is_basic_identifier_string(key)
-                    ? { type: "Identifier", name: key }
-                    : { type: "Literal", value: key, raw: JSON.stringify(key) };
-                assertions.push({
-                    type: "ImportAttribute",
-                    key: key_moz,
-                    value: to_moz(value)
-                });
-            }
-        }
-        return assertions;
-    };
-
-    def_to_moz(AST_Export, function To_Moz_ExportDeclaration(M) {
-        if (M.exported_names) {
-            if (M.exported_names[0].name.name === "*") {
-                return {
-                    type: "ExportAllDeclaration",
-                    source: to_moz(M.module_name),
-                    assertions: assert_clause_to_moz(M.assert_clause)
-                };
-            }
-            return {
-                type: "ExportNamedDeclaration",
-                specifiers: M.exported_names.map(function (name_mapping) {
-                    return {
-                        type: "ExportSpecifier",
-                        exported: to_moz(name_mapping.foreign_name),
-                        local: to_moz(name_mapping.name)
-                    };
-                }),
-                declaration: to_moz(M.exported_definition),
-                source: to_moz(M.module_name),
-                assertions: assert_clause_to_moz(M.assert_clause)
-            };
-        }
-        return {
-            type: M.is_default ? "ExportDefaultDeclaration" : "ExportNamedDeclaration",
-            declaration: to_moz(M.exported_value || M.exported_definition)
-        };
-    });
-
-    def_to_moz(AST_Import, function To_Moz_ImportDeclaration(M) {
-        var specifiers = [];
-        if (M.imported_name) {
-            specifiers.push({
-                type: "ImportDefaultSpecifier",
-                local: to_moz(M.imported_name)
-            });
-        }
-        if (M.imported_names && M.imported_names[0].foreign_name.name === "*") {
-            specifiers.push({
-                type: "ImportNamespaceSpecifier",
-                local: to_moz(M.imported_names[0].name)
-            });
-        } else if (M.imported_names) {
-            M.imported_names.forEach(function(name_mapping) {
-                specifiers.push({
-                    type: "ImportSpecifier",
-                    local: to_moz(name_mapping.name),
-                    imported: to_moz(name_mapping.foreign_name)
-                });
-            });
-        }
-        return {
-            type: "ImportDeclaration",
-            specifiers: specifiers,
-            source: to_moz(M.module_name),
-            assertions: assert_clause_to_moz(M.assert_clause)
-        };
-    });
-
-    def_to_moz(AST_ImportMeta, function To_Moz_MetaProperty() {
-        return {
-            type: "MetaProperty",
-            meta: {
-                type: "Identifier",
-                name: "import"
-            },
-            property: {
-                type: "Identifier",
-                name: "meta"
-            }
-        };
-    });
-
-    def_to_moz(AST_Sequence, function To_Moz_SequenceExpression(M) {
-        return {
-            type: "SequenceExpression",
-            expressions: M.expressions.map(to_moz)
-        };
-    });
-
-    def_to_moz(AST_DotHash, function To_Moz_PrivateMemberExpression(M) {
-        return {
-            type: "MemberExpression",
-            object: to_moz(M.expression),
-            computed: false,
-            property: {
-                type: "PrivateIdentifier",
-                name: M.property
-            },
-            optional: M.optional
-        };
-    });
-
-    def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) {
-        var isComputed = M instanceof AST_Sub;
-        return {
-            type: "MemberExpression",
-            object: to_moz(M.expression),
-            computed: isComputed,
-            property: isComputed ? to_moz(M.property) : {type: "Identifier", name: M.property},
-            optional: M.optional
-        };
-    });
-
-    def_to_moz(AST_Chain, function To_Moz_ChainExpression(M) {
-        return {
-            type: "ChainExpression",
-            expression: to_moz(M.expression)
-        };
-    });
-
-    def_to_moz(AST_Unary, function To_Moz_Unary(M) {
-        return {
-            type: M.operator == "++" || M.operator == "--" ? "UpdateExpression" : "UnaryExpression",
-            operator: M.operator,
-            prefix: M instanceof AST_UnaryPrefix,
-            argument: to_moz(M.expression)
-        };
-    });
-
-    def_to_moz(AST_Binary, function To_Moz_BinaryExpression(M) {
-        if (M.operator == "=" && to_moz_in_destructuring()) {
-            return {
-                type: "AssignmentPattern",
-                left: to_moz(M.left),
-                right: to_moz(M.right)
-            };
-        }
-
-        const type = M.operator == "&&" || M.operator == "||" || M.operator === "??"
-            ? "LogicalExpression"
-            : "BinaryExpression";
-
-        return {
-            type,
-            left: to_moz(M.left),
-            operator: M.operator,
-            right: to_moz(M.right)
-        };
-    });
-
-    def_to_moz(AST_Array, function To_Moz_ArrayExpression(M) {
-        return {
-            type: "ArrayExpression",
-            elements: M.elements.map(to_moz)
-        };
-    });
-
-    def_to_moz(AST_Object, function To_Moz_ObjectExpression(M) {
-        return {
-            type: "ObjectExpression",
-            properties: M.properties.map(to_moz)
-        };
-    });
-
-    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 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
-        if (M instanceof AST_ObjectSetter) {
-            kind = "set";
-        }
-        if (M instanceof AST_PrivateGetter || M instanceof AST_PrivateSetter) {
-            const kind = M instanceof AST_PrivateGetter ? "get" : "set";
-            return {
-                type: "MethodDefinition",
-                computed: false,
-                kind: kind,
-                static: M.static,
-                key: {
-                    type: "PrivateIdentifier",
-                    name: M.key.name
-                },
-                value: to_moz(M.value)
-            };
-        }
-        if (M instanceof AST_ClassPrivateProperty) {
-            return {
-                type: "PropertyDefinition",
-                key: {
-                    type: "PrivateIdentifier",
-                    name: M.key.name
-                },
-                value: to_moz(M.value),
-                computed: false,
-                static: M.static
-            };
-        }
-        if (M instanceof AST_ClassProperty) {
-            return {
-                type: "PropertyDefinition",
-                key,
-                value: to_moz(M.value),
-                computed,
-                static: M.static
-            };
-        }
-        if (parent instanceof AST_Class) {
-            return {
-                type: "MethodDefinition",
-                computed: computed,
-                kind: kind,
-                static: M.static,
-                key: to_moz(M.key),
-                value: to_moz(M.value)
-            };
-        }
-        return {
-            type: "Property",
-            computed: computed,
-            kind: kind,
-            key: key,
-            value: to_moz(M.value)
-        };
-    });
-
-    def_to_moz(AST_ConciseMethod, function To_Moz_MethodDefinition(M, parent) {
-        if (parent instanceof AST_Object) {
-            return {
-                type: "Property",
-                computed: !(M.key instanceof AST_Symbol) || M.key instanceof AST_SymbolRef,
-                kind: "init",
-                method: true,
-                shorthand: false,
-                key: to_moz(M.key),
-                value: to_moz(M.value)
-            };
-        }
-
-        const key = M instanceof AST_PrivateMethod
-            ? {
-                type: "PrivateIdentifier",
-                name: M.key.name
-            }
-            : to_moz(M.key);
-
-        return {
-            type: "MethodDefinition",
-            kind: M.key === "constructor" ? "constructor" : "method",
-            key,
-            value: to_moz(M.value),
-            computed: !(M.key instanceof AST_Symbol) || M.key instanceof AST_SymbolRef,
-            static: M.static,
-        };
-    });
-
-    def_to_moz(AST_Class, function To_Moz_Class(M) {
-        var type = M instanceof AST_ClassExpression ? "ClassExpression" : "ClassDeclaration";
-        return {
-            type: type,
-            superClass: to_moz(M.extends),
-            id: M.name ? to_moz(M.name) : null,
-            body: {
-                type: "ClassBody",
-                body: M.properties.map(to_moz)
-            }
-        };
-    });
-
-    def_to_moz(AST_NewTarget, function To_Moz_MetaProperty() {
-        return {
-            type: "MetaProperty",
-            meta: {
-                type: "Identifier",
-                name: "new"
-            },
-            property: {
-                type: "Identifier",
-                name: "target"
-            }
-        };
-    });
-
-    def_to_moz(AST_Symbol, function To_Moz_Identifier(M, parent) {
-        if (M instanceof AST_SymbolMethod && parent.quote) {
-            return {
-                type: "Literal",
-                value: M.name
-            };
-        }
-        var def = M.definition();
-        return {
-            type: "Identifier",
-            name: def ? def.mangled_name || def.name : M.name
-        };
-    });
-
-    def_to_moz(AST_RegExp, function To_Moz_RegExpLiteral(M) {
-        const pattern = M.value.source;
-        const flags = M.value.flags;
-        return {
-            type: "Literal",
-            value: null,
-            raw: M.print_to_string(),
-            regex: { pattern, flags }
-        };
-    });
-
-    def_to_moz(AST_Constant, function To_Moz_Literal(M) {
-        var value = M.value;
-        return {
-            type: "Literal",
-            value: value,
-            raw: M.raw || M.print_to_string()
-        };
-    });
-
-    def_to_moz(AST_Atom, function To_Moz_Atom(M) {
-        return {
-            type: "Identifier",
-            name: String(M.value)
-        };
-    });
-
-    def_to_moz(AST_BigInt, M => ({
-        type: "BigIntLiteral",
-        value: M.value
-    }));
-
-    AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
-    AST_Null.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast);
-    AST_Hole.DEFMETHOD("to_mozilla_ast", function To_Moz_ArrayHole() { return null; });
-
-    AST_Block.DEFMETHOD("to_mozilla_ast", AST_BlockStatement.prototype.to_mozilla_ast);
-    AST_Lambda.DEFMETHOD("to_mozilla_ast", AST_Function.prototype.to_mozilla_ast);
-
-    /* -----[ tools ]----- */
-
-    function my_start_token(moznode) {
-        var loc = moznode.loc, start = loc && loc.start;
-        var range = moznode.range;
-        return new AST_Token(
-            "",
-            "",
-            start && start.line || 0,
-            start && start.column || 0,
-            range ? range [0] : moznode.start,
-            false,
-            [],
-            [],
-            loc && loc.source,
-        );
-    }
-
-    function my_end_token(moznode) {
-        var loc = moznode.loc, end = loc && loc.end;
-        var range = moznode.range;
-        return new AST_Token(
-            "",
-            "",
-            end && end.line || 0,
-            end && end.column || 0,
-            range ? range [0] : moznode.end,
-            false,
-            [],
-            [],
-            loc && loc.source,
-        );
-    }
-
-    function map(moztype, mytype, propmap) {
-        var moz_to_me = "function From_Moz_" + moztype + "(M){\n";
-        moz_to_me += "return new U2." + mytype.name + "({\n" +
-            "start: my_start_token(M),\n" +
-            "end: my_end_token(M)";
-
-        var me_to_moz = "function To_Moz_" + moztype + "(M){\n";
-        me_to_moz += "return {\n" +
-            "type: " + JSON.stringify(moztype);
-
-        if (propmap) propmap.split(/\s*,\s*/).forEach(function(prop) {
-            var m = /([a-z0-9$_]+)([=@>%])([a-z0-9$_]+)/i.exec(prop);
-            if (!m) throw new Error("Can't understand property map: " + prop);
-            var moz = m[1], how = m[2], my = m[3];
-            moz_to_me += ",\n" + my + ": ";
-            me_to_moz += ",\n" + moz + ": ";
-            switch (how) {
-                case "@":
-                    moz_to_me += "M." + moz + ".map(from_moz)";
-                    me_to_moz += "M." +  my + ".map(to_moz)";
-                    break;
-                case ">":
-                    moz_to_me += "from_moz(M." + moz + ")";
-                    me_to_moz += "to_moz(M." + my + ")";
-                    break;
-                case "=":
-                    moz_to_me += "M." + moz;
-                    me_to_moz += "M." + my;
-                    break;
-                case "%":
-                    moz_to_me += "from_moz(M." + moz + ").body";
-                    me_to_moz += "to_moz_block(M)";
-                    break;
-                default:
-                    throw new Error("Can't understand operator in propmap: " + prop);
-            }
-        });
-
-        moz_to_me += "\n})\n}";
-        me_to_moz += "\n}\n}";
-
-        moz_to_me = new Function("U2", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
-            ast, my_start_token, my_end_token, from_moz
-        );
-        me_to_moz = new Function("to_moz", "to_moz_block", "to_moz_scope", "return(" + me_to_moz + ")")(
-            to_moz, to_moz_block, to_moz_scope
-        );
-        MOZ_TO_ME[moztype] = moz_to_me;
-        def_to_moz(mytype, me_to_moz);
-    }
-
-    var FROM_MOZ_STACK = 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;
-    }
-
-    AST_Node.from_mozilla_ast = function(node) {
-        var save_stack = FROM_MOZ_STACK;
-        FROM_MOZ_STACK = [];
-        var ast = from_moz(node);
-        FROM_MOZ_STACK = save_stack;
-        return ast;
-    };
-
-    function set_moz_loc(mynode, moznode) {
-        var start = mynode.start;
-        var end = mynode.end;
-        if (!(start && end)) {
-            return moznode;
-        }
-        if (start.pos != null && end.endpos != null) {
-            moznode.range = [start.pos, end.endpos];
-        }
-        if (start.line) {
-            moznode.loc = {
-                start: {line: start.line, column: start.col},
-                end: end.endline ? {line: end.endline, column: end.endcol} : null
-            };
-            if (start.file) {
-                moznode.loc.source = start.file;
-            }
-        }
-        return moznode;
-    }
-
-    function def_to_moz(mytype, handler) {
-        mytype.DEFMETHOD("to_mozilla_ast", function(parent) {
-            return set_moz_loc(this, handler(this, parent));
-        });
-    }
-
-    var TO_MOZ_STACK = null;
-
-    function to_moz(node) {
-        if (TO_MOZ_STACK === null) { TO_MOZ_STACK = []; }
-        TO_MOZ_STACK.push(node);
-        var ast = node != null ? node.to_mozilla_ast(TO_MOZ_STACK[TO_MOZ_STACK.length - 2]) : null;
-        TO_MOZ_STACK.pop();
-        if (TO_MOZ_STACK.length === 0) { TO_MOZ_STACK = null; }
-        return ast;
-    }
-
-    function to_moz_in_destructuring() {
-        var i = TO_MOZ_STACK.length;
-        while (i--) {
-            if (TO_MOZ_STACK[i] instanceof AST_Destructuring) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    function to_moz_block(node) {
-        return {
-            type: "BlockStatement",
-            body: node.body.map(to_moz)
-        };
-    }
-
-    function to_moz_scope(type, node) {
-        var body = node.body.map(to_moz);
-        if (node.body[0] instanceof AST_SimpleStatement && node.body[0].body instanceof AST_String) {
-            body.unshift(to_moz(new AST_EmptyStatement(node.body[0])));
-        }
-        return {
-            type: type,
-            body: body
-        };
-    }
-})();