astexplorer.app/vendor/astexplorer/out/77.js

https://astexplorer.net with ES Modules support and Hot Reloading

(window.webpackJsonp=window.webpackJsonp||[]).push([[77],{"./node_modules/raw-loader/dist/cjs.js?esModule=false!./node_modules/uglify-es/lib/ast.js":function(module,exports){eval('module.exports = "/***********************************************************************\\n\\n  A JavaScript tokenizer / parser / beautifier / compressor.\\n  https://github.com/mishoo/UglifyJS2\\n\\n  -------------------------------- (C) ---------------------------------\\n\\n                           Author: Mihai Bazon\\n                         <mihai.bazon@gmail.com>\\n                       http://mihai.bazon.net/blog\\n\\n  Distributed under the BSD license:\\n\\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\\n\\n    Redistribution and use in source and binary forms, with or without\\n    modification, are permitted provided that the following conditions\\n    are met:\\n\\n        * Redistributions of source code must retain the above\\n          copyright notice, this list of conditions and the following\\n          disclaimer.\\n\\n        * Redistributions in binary form must reproduce the above\\n          copyright notice, this list of conditions and the following\\n          disclaimer in the documentation and/or other materials\\n          provided with the distribution.\\n\\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\\n    SUCH DAMAGE.\\n\\n ***********************************************************************/\\n\\n\\"use strict\\";\\n\\nfunction DEFNODE(type, props, methods, base) {\\n    if (arguments.length < 4) base = AST_Node;\\n    if (!props) props = [];\\n    else props = props.split(/\\\\s+/);\\n    var self_props = props;\\n    if (base && base.PROPS)\\n        props = props.concat(base.PROPS);\\n    var code = \\"return function AST_\\" + type + \\"(props){ if (props) { \\";\\n    for (var i = props.length; --i >= 0;) {\\n        code += \\"this.\\" + props[i] + \\" = props.\\" + props[i] + \\";\\";\\n    }\\n    var proto = base && new base;\\n    if (proto && proto.initialize || (methods && methods.initialize))\\n        code += \\"this.initialize();\\";\\n    code += \\"}}\\";\\n    var ctor = new Function(code)();\\n    if (proto) {\\n        ctor.prototype = proto;\\n        ctor.BASE = base;\\n    }\\n    if (base) base.SUBCLASSES.push(ctor);\\n    ctor.prototype.CTOR = ctor;\\n    ctor.PROPS = props || null;\\n    ctor.SELF_PROPS = self_props;\\n    ctor.SUBCLASSES = [];\\n    if (type) {\\n        ctor.prototype.TYPE = ctor.TYPE = type;\\n    }\\n    if (methods) for (i in methods) if (HOP(methods, i)) {\\n        if (/^\\\\$/.test(i)) {\\n            ctor[i.substr(1)] = methods[i];\\n        } else {\\n            ctor.prototype[i] = methods[i];\\n        }\\n    }\\n    ctor.DEFMETHOD = function(name, method) {\\n        this.prototype[name] = method;\\n    };\\n    if (typeof exports !== \\"undefined\\") {\\n        exports[\\"AST_\\" + type] = ctor;\\n    }\\n    return ctor;\\n};\\n\\nvar AST_Token = DEFNODE(\\"Token\\", \\"type value line col pos endline endcol endpos nlb comments_before comments_after file raw\\", {\\n}, null);\\n\\nvar AST_Node = DEFNODE(\\"Node\\", \\"start end\\", {\\n    _clone: function(deep) {\\n        if (deep) {\\n            var self = this.clone();\\n            return self.transform(new TreeTransformer(function(node) {\\n                if (node !== self) {\\n                    return node.clone(true);\\n                }\\n            }));\\n        }\\n        return new this.CTOR(this);\\n    },\\n    clone: function(deep) {\\n        return this._clone(deep);\\n    },\\n    $documentation: \\"Base class of all AST nodes\\",\\n    $propdoc: {\\n        start: \\"[AST_Token] The first token of this node\\",\\n        end: \\"[AST_Token] The last token of this node\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this);\\n    },\\n    walk: function(visitor) {\\n        return this._walk(visitor); // not sure the indirection will be any help\\n    }\\n}, null);\\n\\nAST_Node.warn_function = null;\\nAST_Node.warn = function(txt, props) {\\n    if (AST_Node.warn_function)\\n        AST_Node.warn_function(string_template(txt, props));\\n};\\n\\n/* -----[ statements ]----- */\\n\\nvar AST_Statement = DEFNODE(\\"Statement\\", null, {\\n    $documentation: \\"Base class of all statements\\",\\n});\\n\\nvar AST_Debugger = DEFNODE(\\"Debugger\\", null, {\\n    $documentation: \\"Represents a debugger statement\\",\\n}, AST_Statement);\\n\\nvar AST_Directive = DEFNODE(\\"Directive\\", \\"value quote\\", {\\n    $documentation: \\"Represents a directive, like \\\\\\"use strict\\\\\\";\\",\\n    $propdoc: {\\n        value: \\"[string] The value of this directive as a plain string (it\'s not an AST_String!)\\",\\n        quote: \\"[string] the original quote character\\"\\n    },\\n}, AST_Statement);\\n\\nvar AST_SimpleStatement = DEFNODE(\\"SimpleStatement\\", \\"body\\", {\\n    $documentation: \\"A statement consisting of an expression, i.e. a = 1 + 2\\",\\n    $propdoc: {\\n        body: \\"[AST_Node] an expression node (should not be instanceof AST_Statement)\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.body._walk(visitor);\\n        });\\n    }\\n}, AST_Statement);\\n\\nfunction walk_body(node, visitor) {\\n    var body = node.body;\\n    if (body instanceof AST_Node) {\\n        body._walk(visitor);\\n    }\\n    else for (var i = 0, len = body.length; i < len; i++) {\\n        body[i]._walk(visitor);\\n    }\\n};\\n\\nvar AST_Block = DEFNODE(\\"Block\\", \\"body\\", {\\n    $documentation: \\"A body of statements (usually bracketed)\\",\\n    $propdoc: {\\n        body: \\"[AST_Statement*] an array of statements\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            walk_body(this, visitor);\\n        });\\n    }\\n}, AST_Statement);\\n\\nvar AST_BlockStatement = DEFNODE(\\"BlockStatement\\", null, {\\n    $documentation: \\"A block statement\\",\\n}, AST_Block);\\n\\nvar AST_EmptyStatement = DEFNODE(\\"EmptyStatement\\", null, {\\n    $documentation: \\"The empty statement (empty block or simply a semicolon)\\"\\n}, AST_Statement);\\n\\nvar AST_StatementWithBody = DEFNODE(\\"StatementWithBody\\", \\"body\\", {\\n    $documentation: \\"Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`\\",\\n    $propdoc: {\\n        body: \\"[AST_Statement] the body; this should always be present, even if it\'s an AST_EmptyStatement\\"\\n    }\\n}, AST_Statement);\\n\\nvar AST_LabeledStatement = DEFNODE(\\"LabeledStatement\\", \\"label\\", {\\n    $documentation: \\"Statement with a label\\",\\n    $propdoc: {\\n        label: \\"[AST_Label] a label definition\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.label._walk(visitor);\\n            this.body._walk(visitor);\\n        });\\n    },\\n    clone: function(deep) {\\n        var node = this._clone(deep);\\n        if (deep) {\\n            var label = node.label;\\n            var def = this.label;\\n            node.walk(new TreeWalker(function(node) {\\n                if (node instanceof AST_LoopControl\\n                    && node.label && node.label.thedef === def) {\\n                    node.label.thedef = label;\\n                    label.references.push(node);\\n                }\\n            }));\\n        }\\n        return node;\\n    }\\n}, AST_StatementWithBody);\\n\\nvar AST_IterationStatement = DEFNODE(\\"IterationStatement\\", null, {\\n    $documentation: \\"Internal class.  All loops inherit from it.\\"\\n}, AST_StatementWithBody);\\n\\nvar AST_DWLoop = DEFNODE(\\"DWLoop\\", \\"condition\\", {\\n    $documentation: \\"Base class for do/while statements\\",\\n    $propdoc: {\\n        condition: \\"[AST_Node] the loop condition.  Should not be instanceof AST_Statement\\"\\n    }\\n}, AST_IterationStatement);\\n\\nvar AST_Do = DEFNODE(\\"Do\\", null, {\\n    $documentation: \\"A `do` statement\\",\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.body._walk(visitor);\\n            this.condition._walk(visitor);\\n        });\\n    }\\n}, AST_DWLoop);\\n\\nvar AST_While = DEFNODE(\\"While\\", null, {\\n    $documentation: \\"A `while` statement\\",\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.condition._walk(visitor);\\n            this.body._walk(visitor);\\n        });\\n    }\\n}, AST_DWLoop);\\n\\nvar AST_For = DEFNODE(\\"For\\", \\"init condition step\\", {\\n    $documentation: \\"A `for` statement\\",\\n    $propdoc: {\\n        init: \\"[AST_Node?] the `for` initialization code, or null if empty\\",\\n        condition: \\"[AST_Node?] the `for` termination clause, or null if empty\\",\\n        step: \\"[AST_Node?] the `for` update clause, or null if empty\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            if (this.init) this.init._walk(visitor);\\n            if (this.condition) this.condition._walk(visitor);\\n            if (this.step) this.step._walk(visitor);\\n            this.body._walk(visitor);\\n        });\\n    }\\n}, AST_IterationStatement);\\n\\nvar AST_ForIn = DEFNODE(\\"ForIn\\", \\"init object\\", {\\n    $documentation: \\"A `for ... in` statement\\",\\n    $propdoc: {\\n        init: \\"[AST_Node] the `for/in` initialization code\\",\\n        object: \\"[AST_Node] the object that we\'re looping through\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.init._walk(visitor);\\n            this.object._walk(visitor);\\n            this.body._walk(visitor);\\n        });\\n    }\\n}, AST_IterationStatement);\\n\\nvar AST_ForOf = DEFNODE(\\"ForOf\\", null, {\\n    $documentation: \\"A `for ... of` statement\\",\\n}, AST_ForIn);\\n\\nvar AST_With = DEFNODE(\\"With\\", \\"expression\\", {\\n    $documentation: \\"A `with` statement\\",\\n    $propdoc: {\\n        expression: \\"[AST_Node] the `with` expression\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.expression._walk(visitor);\\n            this.body._walk(visitor);\\n        });\\n    }\\n}, AST_StatementWithBody);\\n\\n/* -----[ scope and functions ]----- */\\n\\nvar AST_Scope = DEFNODE(\\"Scope\\", \\"variables functions uses_with uses_eval parent_scope enclosed cname\\", {\\n    $documentation: \\"Base class for all statements introducing a lexical scope\\",\\n    $propdoc: {\\n        variables: \\"[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope\\",\\n        functions: \\"[Object/S] like `variables`, but only lists function declarations\\",\\n        uses_with: \\"[boolean/S] tells whether this scope uses the `with` statement\\",\\n        uses_eval: \\"[boolean/S] tells whether this scope contains a direct call to the global `eval`\\",\\n        parent_scope: \\"[AST_Scope?/S] link to the parent scope\\",\\n        enclosed: \\"[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes\\",\\n        cname: \\"[integer/S] current index for mangling variables (used internally by the mangler)\\",\\n    },\\n    get_defun_scope: function() {\\n        var self = this;\\n        while (self.is_block_scope()) {\\n            self = self.parent_scope;\\n        }\\n        return self;\\n    },\\n    clone: function(deep) {\\n        var node = this._clone(deep);\\n        if (this.variables) node.variables = this.variables.clone();\\n        if (this.functions) node.functions = this.functions.clone();\\n        if (this.enclosed) node.enclosed = this.enclosed.slice();\\n        return node;\\n    }\\n}, AST_Block);\\n\\nvar AST_Toplevel = DEFNODE(\\"Toplevel\\", \\"globals\\", {\\n    $documentation: \\"The toplevel scope\\",\\n    $propdoc: {\\n        globals: \\"[Object/S] a map of name -> SymbolDef for all undeclared names\\",\\n    },\\n    wrap_commonjs: function(name) {\\n        var body = this.body;\\n        var wrapped_tl = \\"(function(exports){\'$ORIG\';})(typeof \\" + name + \\"==\'undefined\'?(\\" + name + \\"={}):\\" + name + \\");\\";\\n        wrapped_tl = parse(wrapped_tl);\\n        wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node){\\n            if (node instanceof AST_Directive && node.value == \\"$ORIG\\") {\\n                return MAP.splice(body);\\n            }\\n        }));\\n        return wrapped_tl;\\n    }\\n}, AST_Scope);\\n\\nvar AST_Expansion = DEFNODE(\\"Expansion\\", \\"expression\\", {\\n    $documentation: \\"An expandible argument, such as ...rest, a splat, such as [1,2,...all], or an expansion in a variable declaration, such as var [first, ...rest] = list\\",\\n    $propdoc: {\\n        expression: \\"[AST_Node] the thing to be expanded\\"\\n    },\\n    _walk: function(visitor) {\\n        var self = this;\\n        return visitor._visit(this, function(){\\n            self.expression.walk(visitor);\\n        });\\n    }\\n});\\n\\nvar AST_Lambda = DEFNODE(\\"Lambda\\", \\"name argnames uses_arguments is_generator async\\", {\\n    $documentation: \\"Base class for functions\\",\\n    $propdoc: {\\n        name: \\"[AST_SymbolDeclaration?] the name of this function\\",\\n        argnames: \\"[AST_SymbolFunarg|AST_Destructuring|AST_Expansion|AST_DefaultAssign*] array of function arguments, destructurings, or expanding arguments\\",\\n        uses_arguments: \\"[boolean/S] tells whether this function accesses the arguments array\\",\\n        is_generator: \\"[boolean] is this a generator method\\",\\n        async: \\"[boolean] is this method async\\",\\n    },\\n    args_as_names: function () {\\n        var out = [];\\n        for (var i = 0; i < this.argnames.length; i++) {\\n            if (this.argnames[i] instanceof AST_Destructuring) {\\n                out = out.concat(this.argnames[i].all_symbols());\\n            } else {\\n                out.push(this.argnames[i]);\\n            }\\n        }\\n        return out;\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            if (this.name) this.name._walk(visitor);\\n            var argnames = this.argnames;\\n            for (var i = 0, len = argnames.length; i < len; i++) {\\n                argnames[i]._walk(visitor);\\n            }\\n            walk_body(this, visitor);\\n        });\\n    }\\n}, AST_Scope);\\n\\nvar AST_Accessor = DEFNODE(\\"Accessor\\", null, {\\n    $documentation: \\"A setter/getter function.  The `name` property is always null.\\"\\n}, AST_Lambda);\\n\\nvar AST_Function = DEFNODE(\\"Function\\", \\"inlined\\", {\\n    $documentation: \\"A function expression\\"\\n}, AST_Lambda);\\n\\nvar AST_Arrow = DEFNODE(\\"Arrow\\", \\"inlined\\", {\\n    $documentation: \\"An ES6 Arrow function ((a) => b)\\"\\n}, AST_Lambda);\\n\\nvar AST_Defun = DEFNODE(\\"Defun\\", \\"inlined\\", {\\n    $documentation: \\"A function definition\\"\\n}, AST_Lambda);\\n\\n/* -----[ DESTRUCTURING ]----- */\\nvar AST_Destructuring = DEFNODE(\\"Destructuring\\", \\"names is_array\\", {\\n    $documentation: \\"A destructuring of several names. Used in destructuring assignment and with destructuring function argument names\\",\\n    $propdoc: {\\n        \\"names\\": \\"[AST_Node*] Array of properties or elements\\",\\n        \\"is_array\\": \\"[Boolean] Whether the destructuring represents an object or array\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.names.forEach(function(name){\\n                name._walk(visitor);\\n            });\\n        });\\n    },\\n    all_symbols: function() {\\n        var out = [];\\n        this.walk(new TreeWalker(function (node) {\\n            if (node instanceof AST_Symbol) {\\n                out.push(node);\\n            }\\n            if (node instanceof AST_Expansion) {\\n                out.push(node.expression);\\n            }\\n        }));\\n        return out;\\n    }\\n});\\n\\nvar AST_PrefixedTemplateString = DEFNODE(\\"PrefixedTemplateString\\", \\"template_string prefix\\", {\\n    $documentation: \\"A templatestring with a prefix, such as String.raw`foobarbaz`\\",\\n    $propdoc: {\\n        template_string: \\"[AST_TemplateString] The template string\\",\\n        prefix: \\"[AST_SymbolRef|AST_PropAccess] The prefix, which can be a symbol such as `foo` or a dotted expression such as `String.raw`.\\"\\n    },\\n    _walk: function(visitor) {\\n        this.prefix._walk(visitor);\\n        this.template_string._walk(visitor);\\n    }\\n})\\n\\nvar AST_TemplateString = DEFNODE(\\"TemplateString\\", \\"segments\\", {\\n    $documentation: \\"A template string literal\\",\\n    $propdoc: {\\n        segments: \\"[AST_Node*] One or more segments, starting with AST_TemplateSegment. AST_Node may follow AST_TemplateSegment, but each AST_Node must be followed by AST_TemplateSegment.\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.segments.forEach(function(seg){\\n                seg._walk(visitor);\\n            });\\n        });\\n    }\\n});\\n\\nvar AST_TemplateSegment = DEFNODE(\\"TemplateSegment\\", \\"value raw\\", {\\n    $documentation: \\"A segment of a template string literal\\",\\n    $propdoc: {\\n        value: \\"Content of the segment\\",\\n        raw: \\"Raw content of the segment\\"\\n    }\\n});\\n\\n/* -----[ JUMPS ]----- */\\n\\nvar AST_Jump = DEFNODE(\\"Jump\\", null, {\\n    $documentation: \\"Base class for “jumps” (for now that\'s `return`, `throw`, `break` and `continue`)\\"\\n}, AST_Statement);\\n\\nvar AST_Exit = DEFNODE(\\"Exit\\", \\"value\\", {\\n    $documentation: \\"Base class for “exits” (`return` and `throw`)\\",\\n    $propdoc: {\\n        value: \\"[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, this.value && function(){\\n            this.value._walk(visitor);\\n        });\\n    }\\n}, AST_Jump);\\n\\nvar AST_Return = DEFNODE(\\"Return\\", null, {\\n    $documentation: \\"A `return` statement\\"\\n}, AST_Exit);\\n\\nvar AST_Throw = DEFNODE(\\"Throw\\", null, {\\n    $documentation: \\"A `throw` statement\\"\\n}, AST_Exit);\\n\\nvar AST_LoopControl = DEFNODE(\\"LoopControl\\", \\"label\\", {\\n    $documentation: \\"Base class for loop control statements (`break` and `continue`)\\",\\n    $propdoc: {\\n        label: \\"[AST_LabelRef?] the label, or null if none\\",\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, this.label && function(){\\n            this.label._walk(visitor);\\n        });\\n    }\\n}, AST_Jump);\\n\\nvar AST_Break = DEFNODE(\\"Break\\", null, {\\n    $documentation: \\"A `break` statement\\"\\n}, AST_LoopControl);\\n\\nvar AST_Continue = DEFNODE(\\"Continue\\", null, {\\n    $documentation: \\"A `continue` statement\\"\\n}, AST_LoopControl);\\n\\n/* -----[ IF ]----- */\\n\\nvar AST_If = DEFNODE(\\"If\\", \\"condition alternative\\", {\\n    $documentation: \\"A `if` statement\\",\\n    $propdoc: {\\n        condition: \\"[AST_Node] the `if` condition\\",\\n        alternative: \\"[AST_Statement?] the `else` part, or null if not present\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.condition._walk(visitor);\\n            this.body._walk(visitor);\\n            if (this.alternative) this.alternative._walk(visitor);\\n        });\\n    }\\n}, AST_StatementWithBody);\\n\\n/* -----[ SWITCH ]----- */\\n\\nvar AST_Switch = DEFNODE(\\"Switch\\", \\"expression\\", {\\n    $documentation: \\"A `switch` statement\\",\\n    $propdoc: {\\n        expression: \\"[AST_Node] the `switch` “discriminant”\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.expression._walk(visitor);\\n            walk_body(this, visitor);\\n        });\\n    }\\n}, AST_Block);\\n\\nvar AST_SwitchBranch = DEFNODE(\\"SwitchBranch\\", null, {\\n    $documentation: \\"Base class for `switch` branches\\",\\n}, AST_Block);\\n\\nvar AST_Default = DEFNODE(\\"Default\\", null, {\\n    $documentation: \\"A `default` switch branch\\",\\n}, AST_SwitchBranch);\\n\\nvar AST_Case = DEFNODE(\\"Case\\", \\"expression\\", {\\n    $documentation: \\"A `case` switch branch\\",\\n    $propdoc: {\\n        expression: \\"[AST_Node] the `case` expression\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.expression._walk(visitor);\\n            walk_body(this, visitor);\\n        });\\n    }\\n}, AST_SwitchBranch);\\n\\n/* -----[ EXCEPTIONS ]----- */\\n\\nvar AST_Try = DEFNODE(\\"Try\\", \\"bcatch bfinally\\", {\\n    $documentation: \\"A `try` statement\\",\\n    $propdoc: {\\n        bcatch: \\"[AST_Catch?] the catch block, or null if not present\\",\\n        bfinally: \\"[AST_Finally?] the finally block, or null if not present\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            walk_body(this, visitor);\\n            if (this.bcatch) this.bcatch._walk(visitor);\\n            if (this.bfinally) this.bfinally._walk(visitor);\\n        });\\n    }\\n}, AST_Block);\\n\\nvar AST_Catch = DEFNODE(\\"Catch\\", \\"argname\\", {\\n    $documentation: \\"A `catch` node; only makes sense as part of a `try` statement\\",\\n    $propdoc: {\\n        argname: \\"[AST_SymbolCatch|AST_Destructuring|AST_Expansion|AST_DefaultAssign] symbol for the exception\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.argname._walk(visitor);\\n            walk_body(this, visitor);\\n        });\\n    }\\n}, AST_Block);\\n\\nvar AST_Finally = DEFNODE(\\"Finally\\", null, {\\n    $documentation: \\"A `finally` node; only makes sense as part of a `try` statement\\"\\n}, AST_Block);\\n\\n/* -----[ VAR/CONST ]----- */\\n\\nvar AST_Definitions = DEFNODE(\\"Definitions\\", \\"definitions\\", {\\n    $documentation: \\"Base class for `var` or `const` nodes (variable declarations/initializations)\\",\\n    $propdoc: {\\n        definitions: \\"[AST_VarDef*] array of variable definitions\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            var definitions = this.definitions;\\n            for (var i = 0, len = definitions.length; i < len; i++) {\\n                definitions[i]._walk(visitor);\\n            }\\n        });\\n    }\\n}, AST_Statement);\\n\\nvar AST_Var = DEFNODE(\\"Var\\", null, {\\n    $documentation: \\"A `var` statement\\"\\n}, AST_Definitions);\\n\\nvar AST_Let = DEFNODE(\\"Let\\", null, {\\n    $documentation: \\"A `let` statement\\"\\n}, AST_Definitions);\\n\\nvar AST_Const = DEFNODE(\\"Const\\", null, {\\n    $documentation: \\"A `const` statement\\"\\n}, AST_Definitions);\\n\\nvar AST_NameMapping = DEFNODE(\\"NameMapping\\", \\"foreign_name name\\", {\\n    $documentation: \\"The part of the export/import statement that declare names from a module.\\",\\n    $propdoc: {\\n        foreign_name: \\"[AST_SymbolExportForeign|AST_SymbolImportForeign] The name being exported/imported (as specified in the module)\\",\\n        name: \\"[AST_SymbolExport|AST_SymbolImport] The name as it is visible to this module.\\"\\n    },\\n    _walk: function (visitor) {\\n        return visitor._visit(this, function() {\\n            this.foreign_name._walk(visitor);\\n            this.name._walk(visitor);\\n        });\\n    }\\n})\\n\\nvar AST_Import = DEFNODE(\\"Import\\", \\"imported_name imported_names module_name\\", {\\n    $documentation: \\"An `import` statement\\",\\n    $propdoc: {\\n        imported_name: \\"[AST_SymbolImport] The name of the variable holding the module\'s default export.\\",\\n        imported_names: \\"[AST_NameMapping*] The names of non-default imported variables\\",\\n        module_name: \\"[AST_String] String literal describing where this module came from\\",\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function() {\\n            if (this.imported_name) {\\n                this.imported_name._walk(visitor);\\n            }\\n            if (this.imported_names) {\\n                this.imported_names.forEach(function(name_import) {\\n                    name_import._walk(visitor);\\n                });\\n            }\\n            this.module_name._walk(visitor);\\n        });\\n    }\\n});\\n\\nvar AST_Export = DEFNODE(\\"Export\\", \\"exported_definition exported_value is_default exported_names module_name\\", {\\n    $documentation: \\"An `export` statement\\",\\n    $propdoc: {\\n        exported_definition: \\"[AST_Defun|AST_Definitions|AST_DefClass?] An exported definition\\",\\n        exported_value: \\"[AST_Node?] An exported value\\",\\n        exported_names: \\"[AST_NameMapping*?] List of exported names\\",\\n        module_name: \\"[AST_String?] Name of the file to load exports from\\",\\n        is_default: \\"[Boolean] Whether this is the default exported value of this module\\"\\n    },\\n    _walk: function (visitor) {\\n        visitor._visit(this, function () {\\n            if (this.exported_definition) {\\n                this.exported_definition._walk(visitor);\\n            }\\n            if (this.exported_value) {\\n                this.exported_value._walk(visitor);\\n            }\\n            if (this.exported_names) {\\n                this.exported_names.forEach(function(name_export) {\\n                    name_export._walk(visitor);\\n                });\\n            }\\n            if (this.module_name) {\\n                this.module_name._walk(visitor);\\n            }\\n        });\\n    }\\n}, AST_Statement);\\n\\nvar AST_VarDef = DEFNODE(\\"VarDef\\", \\"name value\\", {\\n    $documentation: \\"A variable declaration; only appears in a AST_Definitions node\\",\\n    $propdoc: {\\n        name: \\"[AST_Destructuring|AST_SymbolConst|AST_SymbolLet|AST_SymbolVar] name of the variable\\",\\n        value: \\"[AST_Node?] initializer, or null of there\'s no initializer\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.name._walk(visitor);\\n            if (this.value) this.value._walk(visitor);\\n        });\\n    }\\n});\\n\\n/* -----[ OTHER ]----- */\\n\\nvar AST_Call = DEFNODE(\\"Call\\", \\"expression args\\", {\\n    $documentation: \\"A function call expression\\",\\n    $propdoc: {\\n        expression: \\"[AST_Node] expression to invoke as function\\",\\n        args: \\"[AST_Node*] array of arguments\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            var args = this.args;\\n            for (var i = 0, len = args.length; i < len; i++) {\\n                args[i]._walk(visitor);\\n            }\\n            this.expression._walk(visitor);\\n        });\\n    }\\n});\\n\\nvar AST_New = DEFNODE(\\"New\\", null, {\\n    $documentation: \\"An object instantiation.  Derives from a function call since it has exactly the same properties\\"\\n}, AST_Call);\\n\\nvar AST_Sequence = DEFNODE(\\"Sequence\\", \\"expressions\\", {\\n    $documentation: \\"A sequence expression (comma-separated expressions)\\",\\n    $propdoc: {\\n        expressions: \\"[AST_Node*] array of expressions (at least two)\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.expressions.forEach(function(node) {\\n                node._walk(visitor);\\n            });\\n        });\\n    }\\n});\\n\\nvar AST_PropAccess = DEFNODE(\\"PropAccess\\", \\"expression property\\", {\\n    $documentation: \\"Base class for property access expressions, i.e. `a.foo` or `a[\\\\\\"foo\\\\\\"]`\\",\\n    $propdoc: {\\n        expression: \\"[AST_Node] the “container” expression\\",\\n        property: \\"[AST_Node|string] the property to access.  For AST_Dot this is always a plain string, while for AST_Sub it\'s an arbitrary AST_Node\\"\\n    }\\n});\\n\\nvar AST_Dot = DEFNODE(\\"Dot\\", null, {\\n    $documentation: \\"A dotted property access expression\\",\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.expression._walk(visitor);\\n        });\\n    }\\n}, AST_PropAccess);\\n\\nvar AST_Sub = DEFNODE(\\"Sub\\", null, {\\n    $documentation: \\"Index-style property access, i.e. `a[\\\\\\"foo\\\\\\"]`\\",\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.expression._walk(visitor);\\n            this.property._walk(visitor);\\n        });\\n    }\\n}, AST_PropAccess);\\n\\nvar AST_Unary = DEFNODE(\\"Unary\\", \\"operator expression\\", {\\n    $documentation: \\"Base class for unary expressions\\",\\n    $propdoc: {\\n        operator: \\"[string] the operator\\",\\n        expression: \\"[AST_Node] expression that this unary operator applies to\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.expression._walk(visitor);\\n        });\\n    }\\n});\\n\\nvar AST_UnaryPrefix = DEFNODE(\\"UnaryPrefix\\", null, {\\n    $documentation: \\"Unary prefix expression, i.e. `typeof i` or `++i`\\"\\n}, AST_Unary);\\n\\nvar AST_UnaryPostfix = DEFNODE(\\"UnaryPostfix\\", null, {\\n    $documentation: \\"Unary postfix expression, i.e. `i++`\\"\\n}, AST_Unary);\\n\\nvar AST_Binary = DEFNODE(\\"Binary\\", \\"operator left right\\", {\\n    $documentation: \\"Binary expression, i.e. `a + b`\\",\\n    $propdoc: {\\n        left: \\"[AST_Node] left-hand side expression\\",\\n        operator: \\"[string] the operator\\",\\n        right: \\"[AST_Node] right-hand side expression\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.left._walk(visitor);\\n            this.right._walk(visitor);\\n        });\\n    }\\n});\\n\\nvar AST_Conditional = DEFNODE(\\"Conditional\\", \\"condition consequent alternative\\", {\\n    $documentation: \\"Conditional expression using the ternary operator, i.e. `a ? b : c`\\",\\n    $propdoc: {\\n        condition: \\"[AST_Node]\\",\\n        consequent: \\"[AST_Node]\\",\\n        alternative: \\"[AST_Node]\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.condition._walk(visitor);\\n            this.consequent._walk(visitor);\\n            this.alternative._walk(visitor);\\n        });\\n    }\\n});\\n\\nvar AST_Assign = DEFNODE(\\"Assign\\", null, {\\n    $documentation: \\"An assignment expression — `a = b + 5`\\",\\n}, AST_Binary);\\n\\nvar AST_DefaultAssign = DEFNODE(\\"DefaultAssign\\", null, {\\n    $documentation: \\"A default assignment expression like in `(a = 3) => a`\\"\\n}, AST_Binary);\\n\\n/* -----[ LITERALS ]----- */\\n\\nvar AST_Array = DEFNODE(\\"Array\\", \\"elements\\", {\\n    $documentation: \\"An array literal\\",\\n    $propdoc: {\\n        elements: \\"[AST_Node*] array of elements\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            var elements = this.elements;\\n            for (var i = 0, len = elements.length; i < len; i++) {\\n                elements[i]._walk(visitor);\\n            }\\n        });\\n    }\\n});\\n\\nvar AST_Object = DEFNODE(\\"Object\\", \\"properties\\", {\\n    $documentation: \\"An object literal\\",\\n    $propdoc: {\\n        properties: \\"[AST_ObjectProperty*] array of properties\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            var properties = this.properties;\\n            for (var i = 0, len = properties.length; i < len; i++) {\\n                properties[i]._walk(visitor);\\n            }\\n        });\\n    }\\n});\\n\\nvar AST_ObjectProperty = DEFNODE(\\"ObjectProperty\\", \\"key value\\", {\\n    $documentation: \\"Base class for literal object properties\\",\\n    $propdoc: {\\n        key: \\"[string|AST_Node] property name. For ObjectKeyVal this is a string. For getters, setters and computed property this is an AST_Node.\\",\\n        value: \\"[AST_Node] property value.  For getters and setters this is an AST_Accessor.\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            if (this.key instanceof AST_Node)\\n                this.key._walk(visitor);\\n            this.value._walk(visitor);\\n        });\\n    }\\n});\\n\\nvar AST_ObjectKeyVal = DEFNODE(\\"ObjectKeyVal\\", \\"quote\\", {\\n    $documentation: \\"A key: value object property\\",\\n    $propdoc: {\\n        quote: \\"[string] the original quote character\\"\\n    }\\n}, AST_ObjectProperty);\\n\\nvar AST_ObjectSetter = DEFNODE(\\"ObjectSetter\\", \\"quote static\\", {\\n    $propdoc: {\\n        quote: \\"[string|undefined] the original quote character, if any\\",\\n        static: \\"[boolean] whether this is a static setter (classes only)\\"\\n    },\\n    $documentation: \\"An object setter property\\",\\n}, AST_ObjectProperty);\\n\\nvar AST_ObjectGetter = DEFNODE(\\"ObjectGetter\\", \\"quote static\\", {\\n    $propdoc: {\\n        quote: \\"[string|undefined] the original quote character, if any\\",\\n        static: \\"[boolean] whether this is a static getter (classes only)\\"\\n    },\\n    $documentation: \\"An object getter property\\",\\n}, AST_ObjectProperty);\\n\\nvar AST_ConciseMethod = DEFNODE(\\"ConciseMethod\\", \\"quote static is_generator async\\", {\\n    $propdoc: {\\n        quote: \\"[string|undefined] the original quote character, if any\\",\\n        static: \\"[boolean] is this method static (classes only)\\",\\n        is_generator: \\"[boolean] is this a generator method\\",\\n        async: \\"[boolean] is this method async\\",\\n    },\\n    $documentation: \\"An ES6 concise method inside an object or class\\"\\n}, AST_ObjectProperty);\\n\\nvar AST_Class = DEFNODE(\\"Class\\", \\"name extends properties inlined\\", {\\n    $propdoc: {\\n        name: \\"[AST_SymbolClass|AST_SymbolDefClass?] optional class name.\\",\\n        extends: \\"[AST_Node]? optional parent class\\",\\n        properties: \\"[AST_ObjectProperty*] array of properties\\"\\n    },\\n    $documentation: \\"An ES6 class\\",\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            if (this.name) {\\n                this.name._walk(visitor);\\n            }\\n            if (this.extends) {\\n                this.extends._walk(visitor);\\n            }\\n            this.properties.forEach(function(prop){\\n                prop._walk(visitor);\\n            });\\n        });\\n    },\\n}, AST_Scope);\\n\\nvar AST_DefClass = DEFNODE(\\"DefClass\\", null, {\\n    $documentation: \\"A class definition\\",\\n}, AST_Class);\\n\\nvar AST_ClassExpression = DEFNODE(\\"ClassExpression\\", null, {\\n    $documentation: \\"A class expression.\\"\\n}, AST_Class);\\n\\nvar AST_Symbol = DEFNODE(\\"Symbol\\", \\"scope name thedef\\", {\\n    $propdoc: {\\n        name: \\"[string] name of this symbol\\",\\n        scope: \\"[AST_Scope/S] the current scope (not necessarily the definition scope)\\",\\n        thedef: \\"[SymbolDef/S] the definition of this symbol\\"\\n    },\\n    $documentation: \\"Base class for all symbols\\"\\n});\\n\\nvar AST_NewTarget = DEFNODE(\\"NewTarget\\", null, {\\n    $documentation: \\"A reference to new.target\\"\\n});\\n\\nvar AST_SymbolDeclaration = DEFNODE(\\"SymbolDeclaration\\", \\"init\\", {\\n    $documentation: \\"A declaration symbol (symbol in var/const, function name or argument, symbol in catch)\\",\\n}, AST_Symbol);\\n\\nvar AST_SymbolVar = DEFNODE(\\"SymbolVar\\", null, {\\n    $documentation: \\"Symbol defining a variable\\",\\n}, AST_SymbolDeclaration);\\n\\nvar AST_SymbolBlockDeclaration = DEFNODE(\\"SymbolBlockDeclaration\\", null, {\\n    $documentation: \\"Base class for block-scoped declaration symbols\\"\\n}, AST_SymbolDeclaration);\\n\\nvar AST_SymbolConst = DEFNODE(\\"SymbolConst\\", null, {\\n    $documentation: \\"A constant declaration\\"\\n}, AST_SymbolBlockDeclaration);\\n\\nvar AST_SymbolLet = DEFNODE(\\"SymbolLet\\", null, {\\n    $documentation: \\"A block-scoped `let` declaration\\"\\n}, AST_SymbolBlockDeclaration);\\n\\nvar AST_SymbolFunarg = DEFNODE(\\"SymbolFunarg\\", null, {\\n    $documentation: \\"Symbol naming a function argument\\",\\n}, AST_SymbolVar);\\n\\nvar AST_SymbolDefun = DEFNODE(\\"SymbolDefun\\", null, {\\n    $documentation: \\"Symbol defining a function\\",\\n}, AST_SymbolDeclaration);\\n\\nvar AST_SymbolMethod = DEFNODE(\\"SymbolMethod\\", null, {\\n    $documentation: \\"Symbol in an object defining a method\\",\\n}, AST_Symbol);\\n\\nvar AST_SymbolLambda = DEFNODE(\\"SymbolLambda\\", null, {\\n    $documentation: \\"Symbol naming a function expression\\",\\n}, AST_SymbolDeclaration);\\n\\nvar AST_SymbolDefClass = DEFNODE(\\"SymbolDefClass\\", null, {\\n    $documentation: \\"Symbol naming a class\'s name in a class declaration. Lexically scoped to its containing scope, and accessible within the class.\\"\\n}, AST_SymbolBlockDeclaration);\\n\\nvar AST_SymbolClass = DEFNODE(\\"SymbolClass\\", null, {\\n    $documentation: \\"Symbol naming a class\'s name. Lexically scoped to the class.\\"\\n}, AST_SymbolDeclaration);\\n\\nvar AST_SymbolCatch = DEFNODE(\\"SymbolCatch\\", null, {\\n    $documentation: \\"Symbol naming the exception in catch\\",\\n}, AST_SymbolBlockDeclaration);\\n\\nvar AST_SymbolImport = DEFNODE(\\"SymbolImport\\", null, {\\n    $documentation: \\"Symbol referring to an imported name\\",\\n}, AST_SymbolBlockDeclaration);\\n\\nvar AST_SymbolImportForeign = DEFNODE(\\"SymbolImportForeign\\", null, {\\n    $documentation: \\"A symbol imported from a module, but it is defined in the other module, and its real name is irrelevant for this module\'s purposes\\",\\n}, AST_Symbol);\\n\\nvar AST_Label = DEFNODE(\\"Label\\", \\"references\\", {\\n    $documentation: \\"Symbol naming a label (declaration)\\",\\n    $propdoc: {\\n        references: \\"[AST_LoopControl*] a list of nodes referring to this label\\"\\n    },\\n    initialize: function() {\\n        this.references = [];\\n        this.thedef = this;\\n    }\\n}, AST_Symbol);\\n\\nvar AST_SymbolRef = DEFNODE(\\"SymbolRef\\", null, {\\n    $documentation: \\"Reference to some symbol (not definition/declaration)\\",\\n}, AST_Symbol);\\n\\nvar AST_SymbolExport = DEFNODE(\\"SymbolExport\\", null, {\\n    $documentation: \\"Symbol referring to a name to export\\",\\n}, AST_SymbolRef);\\n\\nvar AST_SymbolExportForeign = DEFNODE(\\"SymbolExportForeign\\", null, {\\n    $documentation: \\"A symbol exported from this module, but it is used in the other module, and its real name is irrelevant for this module\'s purposes\\",\\n}, AST_Symbol);\\n\\nvar AST_LabelRef = DEFNODE(\\"LabelRef\\", null, {\\n    $documentation: \\"Reference to a label symbol\\",\\n}, AST_Symbol);\\n\\nvar AST_This = DEFNODE(\\"This\\", null, {\\n    $documentation: \\"The `this` symbol\\",\\n}, AST_Symbol);\\n\\nvar AST_Super = DEFNODE(\\"Super\\", null, {\\n    $documentation: \\"The `super` symbol\\",\\n}, AST_This);\\n\\nvar AST_Constant = DEFNODE(\\"Constant\\", null, {\\n    $documentation: \\"Base class for all constants\\",\\n    getValue: function() {\\n        return this.value;\\n    }\\n});\\n\\nvar AST_String = DEFNODE(\\"String\\", \\"value quote\\", {\\n    $documentation: \\"A string literal\\",\\n    $propdoc: {\\n        value: \\"[string] the contents of this string\\",\\n        quote: \\"[string] the original quote character\\"\\n    }\\n}, AST_Constant);\\n\\nvar AST_Number = DEFNODE(\\"Number\\", \\"value literal\\", {\\n    $documentation: \\"A number literal\\",\\n    $propdoc: {\\n        value: \\"[number] the numeric value\\",\\n        literal: \\"[string] numeric value as string (optional)\\"\\n    }\\n}, AST_Constant);\\n\\nvar AST_RegExp = DEFNODE(\\"RegExp\\", \\"value\\", {\\n    $documentation: \\"A regexp literal\\",\\n    $propdoc: {\\n        value: \\"[RegExp] the actual regexp\\"\\n    }\\n}, AST_Constant);\\n\\nvar AST_Atom = DEFNODE(\\"Atom\\", null, {\\n    $documentation: \\"Base class for atoms\\",\\n}, AST_Constant);\\n\\nvar AST_Null = DEFNODE(\\"Null\\", null, {\\n    $documentation: \\"The `null` atom\\",\\n    value: null\\n}, AST_Atom);\\n\\nvar AST_NaN = DEFNODE(\\"NaN\\", null, {\\n    $documentation: \\"The impossible value\\",\\n    value: 0/0\\n}, AST_Atom);\\n\\nvar AST_Undefined = DEFNODE(\\"Undefined\\", null, {\\n    $documentation: \\"The `undefined` value\\",\\n    value: (function(){}())\\n}, AST_Atom);\\n\\nvar AST_Hole = DEFNODE(\\"Hole\\", null, {\\n    $documentation: \\"A hole in an array\\",\\n    value: (function(){}())\\n}, AST_Atom);\\n\\nvar AST_Infinity = DEFNODE(\\"Infinity\\", null, {\\n    $documentation: \\"The `Infinity` value\\",\\n    value: 1/0\\n}, AST_Atom);\\n\\nvar AST_Boolean = DEFNODE(\\"Boolean\\", null, {\\n    $documentation: \\"Base class for booleans\\",\\n}, AST_Atom);\\n\\nvar AST_False = DEFNODE(\\"False\\", null, {\\n    $documentation: \\"The `false` atom\\",\\n    value: false\\n}, AST_Boolean);\\n\\nvar AST_True = DEFNODE(\\"True\\", null, {\\n    $documentation: \\"The `true` atom\\",\\n    value: true\\n}, AST_Boolean);\\n\\nvar AST_Await = DEFNODE(\\"Await\\", \\"expression\\", {\\n    $documentation: \\"An `await` statement\\",\\n    $propdoc: {\\n        expression: \\"[AST_Node] the mandatory expression being awaited\\",\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, function(){\\n            this.expression._walk(visitor);\\n        });\\n    }\\n});\\n\\nvar AST_Yield = DEFNODE(\\"Yield\\", \\"expression is_star\\", {\\n    $documentation: \\"A `yield` statement\\",\\n    $propdoc: {\\n        expression: \\"[AST_Node?] the value returned or thrown by this statement; could be null (representing undefined) but only when is_star is set to false\\",\\n        is_star: \\"[Boolean] Whether this is a yield or yield* statement\\"\\n    },\\n    _walk: function(visitor) {\\n        return visitor._visit(this, this.expression && function(){\\n            this.expression._walk(visitor);\\n        });\\n    }\\n});\\n\\n/* -----[ TreeWalker ]----- */\\n\\nfunction TreeWalker(callback) {\\n    this.visit = callback;\\n    this.stack = [];\\n    this.directives = Object.create(null);\\n};\\nTreeWalker.prototype = {\\n    _visit: function(node, descend) {\\n        this.push(node);\\n        var ret = this.visit(node, descend ? function(){\\n            descend.call(node);\\n        } : noop);\\n        if (!ret && descend) {\\n            descend.call(node);\\n        }\\n        this.pop();\\n        return ret;\\n    },\\n    parent: function(n) {\\n        return this.stack[this.stack.length - 2 - (n || 0)];\\n    },\\n    push: function(node) {\\n        if (node instanceof AST_Lambda) {\\n            this.directives = Object.create(this.directives);\\n        } else if (node instanceof AST_Directive && !this.directives[node.value]) {\\n            this.directives[node.value] = node;\\n        } else if (node instanceof AST_Class) {\\n            this.directives = Object.create(this.directives);\\n            if (!this.directives[\\"use strict\\"]) {\\n                this.directives[\\"use strict\\"] = node;\\n            }\\n        }\\n        this.stack.push(node);\\n    },\\n    pop: function() {\\n        var node = this.stack.pop();\\n        if (node instanceof AST_Lambda || node instanceof AST_Class) {\\n            this.directives = Object.getPrototypeOf(this.directives);\\n        }\\n    },\\n    self: function() {\\n        return this.stack[this.stack.length - 1];\\n    },\\n    find_parent: function(type) {\\n        var stack = this.stack;\\n        for (var i = stack.length; --i >= 0;) {\\n            var x = stack[i];\\n            if (x instanceof type) return x;\\n        }\\n    },\\n    has_directive: function(type) {\\n        var dir = this.directives[type];\\n        if (dir) return dir;\\n        var node = this.stack[this.stack.length - 1];\\n        if (node instanceof AST_Scope && node.body) {\\n            for (var i = 0; i < node.body.length; ++i) {\\n                var st = node.body[i];\\n                if (!(st instanceof AST_Directive)) break;\\n                if (st.value == type) return st;\\n            }\\n        }\\n    },\\n    loopcontrol_target: function(node) {\\n        var stack = this.stack;\\n        if (node.label) for (var i = stack.length; --i >= 0;) {\\n            var x = stack[i];\\n            if (x instanceof AST_LabeledStatement && x.label.name == node.label.name)\\n                return x.body;\\n        } else for (var i = stack.length; --i >= 0;) {\\n            var x = stack[i];\\n            if (x instanceof AST_IterationStatement\\n                || node instanceof AST_Break && x instanceof AST_Switch)\\n                return x;\\n        }\\n    }\\n};\\n";\n\n//# sourceURL=webpack:///./node_modules/uglify-es/lib/ast.js?./node_modules/raw-loader/dist/cjs.js?esModule=false')},"./node_modules/raw-loader/dist/cjs.js?esModule=false!./node_modules/uglify-es/lib/parse.js":function(module,exports){eval('module.exports = "/***********************************************************************\\n\\n  A JavaScript tokenizer / parser / beautifier / compressor.\\n  https://github.com/mishoo/UglifyJS2\\n\\n  -------------------------------- (C) ---------------------------------\\n\\n                           Author: Mihai Bazon\\n                         <mihai.bazon@gmail.com>\\n                       http://mihai.bazon.net/blog\\n\\n  Distributed under the BSD license:\\n\\n    Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>\\n    Parser based on parse-js (http://marijn.haverbeke.nl/parse-js/).\\n\\n    Redistribution and use in source and binary forms, with or without\\n    modification, are permitted provided that the following conditions\\n    are met:\\n\\n        * Redistributions of source code must retain the above\\n          copyright notice, this list of conditions and the following\\n          disclaimer.\\n\\n        * Redistributions in binary form must reproduce the above\\n          copyright notice, this list of conditions and the following\\n          disclaimer in the documentation and/or other materials\\n          provided with the distribution.\\n\\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY\\n    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\\n    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\\n    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE\\n    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,\\n    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\\n    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\\n    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR\\n    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF\\n    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\\n    SUCH DAMAGE.\\n\\n ***********************************************************************/\\n\\n\\"use strict\\";\\n\\nvar KEYWORDS = \'break case catch class const continue debugger default delete do else export extends finally for function if in instanceof let new return switch throw try typeof var void while with\';\\nvar KEYWORDS_ATOM = \'false null true\';\\nvar RESERVED_WORDS = \'enum implements import interface package private protected public static super this \' + KEYWORDS_ATOM + \\" \\" + KEYWORDS;\\nvar KEYWORDS_BEFORE_EXPRESSION = \'return new delete throw else case yield await\';\\n\\nKEYWORDS = makePredicate(KEYWORDS);\\nRESERVED_WORDS = makePredicate(RESERVED_WORDS);\\nKEYWORDS_BEFORE_EXPRESSION = makePredicate(KEYWORDS_BEFORE_EXPRESSION);\\nKEYWORDS_ATOM = makePredicate(KEYWORDS_ATOM);\\n\\nvar OPERATOR_CHARS = makePredicate(characters(\\"+-*&%=<>!?|~^\\"));\\n\\nvar RE_NUM_LITERAL = /[0-9a-f]/i;\\nvar RE_HEX_NUMBER = /^0x[0-9a-f]+$/i;\\nvar RE_OCT_NUMBER = /^0[0-7]+$/;\\nvar RE_ES6_OCT_NUMBER = /^0o[0-7]+$/i;\\nvar RE_BIN_NUMBER = /^0b[01]+$/i;\\nvar RE_DEC_NUMBER = /^\\\\d*\\\\.?\\\\d*(?:e[+-]?\\\\d*(?:\\\\d\\\\.?|\\\\.?\\\\d)\\\\d*)?$/i;\\n\\nvar OPERATORS = makePredicate([\\n    \\"in\\",\\n    \\"instanceof\\",\\n    \\"typeof\\",\\n    \\"new\\",\\n    \\"void\\",\\n    \\"delete\\",\\n    \\"++\\",\\n    \\"--\\",\\n    \\"+\\",\\n    \\"-\\",\\n    \\"!\\",\\n    \\"~\\",\\n    \\"&\\",\\n    \\"|\\",\\n    \\"^\\",\\n    \\"*\\",\\