text: /***********************************************************************
  
    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.
  
   ***********************************************************************/
  
  "use strict";
  
  function DEFNODE(type, props, methods, base) {
      if (arguments.length < 4) base = AST_Node;
      if (!props) props = [];
      else props = props.split(/\s+/);
      var self_props = props;
      if (base && base.PROPS)
          props = props.concat(base.PROPS);
      var code = "return function AST_" + type + "(props){ if (props) { ";
      for (var i = props.length; --i >= 0;) {
          code += "this." + props[i] + " = props." + props[i] + ";";
      }
      var proto = base && new base;
      if (proto && proto.initialize || (methods && methods.initialize))
          code += "this.initialize();";
      code += "}}";
      var ctor = new Function(code)();
      if (proto) {
          ctor.prototype = proto;
          ctor.BASE = base;
      }
      if (base) base.SUBCLASSES.push(ctor);
      ctor.prototype.CTOR = ctor;
      ctor.PROPS = props || null;
      ctor.SELF_PROPS = self_props;
      ctor.SUBCLASSES = [];
      if (type) {
          ctor.prototype.TYPE = ctor.TYPE = type;
      }
      if (methods) for (i in methods) if (methods.hasOwnProperty(i)) {
          if (/^\$/.test(i)) {
              ctor[i.substr(1)] = methods[i];
          } else {
              ctor.prototype[i] = methods[i];
          }
      }
      ctor.DEFMETHOD = function(name, method) {
          this.prototype[name] = method;
      };
      return ctor;
  };
  
  var AST_Token = DEFNODE("Token", "type value line col pos endpos nlb comments_before file", {
  }, null);
  
  var AST_Node = DEFNODE("Node", "start end", {
      clone: function() {
          return new this.CTOR(this);
      },
      $documentation: "Base class of all AST nodes",
      $propdoc: {
          start: "[AST_Token] The first token of this node",
          end: "[AST_Token] The last token of this node"
      },
      _walk: function(visitor) {
          return visitor._visit(this);
      },
      walk: function(visitor) {
          return this._walk(visitor); // not sure the indirection will be any help
      }
  }, null);
  
  AST_Node.warn_function = null;
  AST_Node.warn = function(txt, props) {
      if (AST_Node.warn_function)
          AST_Node.warn_function(string_template(txt, props));
  };
  
  /* -----[ statements ]----- */
  
  var AST_Statement = DEFNODE("Statement", null, {
      $documentation: "Base class of all statements",
  });
  
  var AST_Debugger = DEFNODE("Debugger", null, {
      $documentation: "Represents a debugger statement",
  }, AST_Statement);
  
  var AST_Directive = DEFNODE("Directive", "value scope", {
      $documentation: "Represents a directive, like \"use strict\";",
      $propdoc: {
          value: "[string] The value of this directive as a plain string (it's not an AST_String!)",
          scope: "[AST_Scope/S] The scope that this directive affects"
      },
  }, AST_Statement);
  
  var AST_SimpleStatement = DEFNODE("SimpleStatement", "body", {
      $documentation: "A statement consisting of an expression, i.e. a = 1 + 2",
      $propdoc: {
          body: "[AST_Node] an expression node (should not be instanceof AST_Statement)"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.body._walk(visitor);
          });
      }
  }, AST_Statement);
  
  function walk_body(node, visitor) {
      if (node.body instanceof AST_Statement) {
          node.body._walk(visitor);
      }
      else node.body.forEach(function(stat){
          stat._walk(visitor);
      });
  };
  
  var AST_Block = DEFNODE("Block", "body", {
      $documentation: "A body of statements (usually bracketed)",
      $propdoc: {
          body: "[AST_Statement*] an array of statements"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              walk_body(this, visitor);
          });
      }
  }, AST_Statement);
  
  var AST_BlockStatement = DEFNODE("BlockStatement", null, {
      $documentation: "A block statement",
  }, AST_Block);
  
  var AST_EmptyStatement = DEFNODE("EmptyStatement", null, {
      $documentation: "The empty statement (empty block or simply a semicolon)",
      _walk: function(visitor) {
          return visitor._visit(this);
      }
  }, AST_Statement);
  
  var AST_StatementWithBody = DEFNODE("StatementWithBody", "body", {
      $documentation: "Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With`",
      $propdoc: {
          body: "[AST_Statement] the body; this should always be present, even if it's an AST_EmptyStatement"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.body._walk(visitor);
          });
      }
  }, AST_Statement);
  
  var AST_LabeledStatement = DEFNODE("LabeledStatement", "label", {
      $documentation: "Statement with a label",
      $propdoc: {
          label: "[AST_Label] a label definition"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.label._walk(visitor);
              this.body._walk(visitor);
          });
      }
  }, AST_StatementWithBody);
  
  var AST_IterationStatement = DEFNODE("IterationStatement", null, {
      $documentation: "Internal class.  All loops inherit from it."
  }, AST_StatementWithBody);
  
  var AST_DWLoop = DEFNODE("DWLoop", "condition", {
      $documentation: "Base class for do/while statements",
      $propdoc: {
          condition: "[AST_Node] the loop condition.  Should not be instanceof AST_Statement"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.condition._walk(visitor);
              this.body._walk(visitor);
          });
      }
  }, AST_IterationStatement);
  
  var AST_Do = DEFNODE("Do", null, {
      $documentation: "A `do` statement",
  }, AST_DWLoop);
  
  var AST_While = DEFNODE("While", null, {
      $documentation: "A `while` statement",
  }, AST_DWLoop);
  
  var AST_For = DEFNODE("For", "init condition step", {
      $documentation: "A `for` statement",
      $propdoc: {
          init: "[AST_Node?] the `for` initialization code, or null if empty",
          condition: "[AST_Node?] the `for` termination clause, or null if empty",
          step: "[AST_Node?] the `for` update clause, or null if empty"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              if (this.init) this.init._walk(visitor);
              if (this.condition) this.condition._walk(visitor);
              if (this.step) this.step._walk(visitor);
              this.body._walk(visitor);
          });
      }
  }, AST_IterationStatement);
  
  var AST_ForIn = DEFNODE("ForIn", "init name object", {
      $documentation: "A `for ... in` statement",
      $propdoc: {
          init: "[AST_Node] the `for/in` initialization code",
          name: "[AST_SymbolRef?] the loop variable, only if `init` is AST_Var",
          object: "[AST_Node] the object that we're looping through"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.init._walk(visitor);
              this.object._walk(visitor);
              this.body._walk(visitor);
          });
      }
  }, AST_IterationStatement);
  
  var AST_With = DEFNODE("With", "expression", {
      $documentation: "A `with` statement",
      $propdoc: {
          expression: "[AST_Node] the `with` expression"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.expression._walk(visitor);
              this.body._walk(visitor);
          });
      }
  }, AST_StatementWithBody);
  
  /* -----[ scope and functions ]----- */
  
  var AST_Scope = DEFNODE("Scope", "directives variables functions uses_with uses_eval parent_scope enclosed cname", {
      $documentation: "Base class for all statements introducing a lexical scope",
      $propdoc: {
          directives: "[string*/S] an array of directives declared in this scope",
          variables: "[Object/S] a map of name -> SymbolDef for all variables/functions defined in this scope",
          functions: "[Object/S] like `variables`, but only lists function declarations",
          uses_with: "[boolean/S] tells whether this scope uses the `with` statement",
          uses_eval: "[boolean/S] tells whether this scope contains a direct call to the global `eval`",
          parent_scope: "[AST_Scope?/S] link to the parent scope",
          enclosed: "[SymbolDef*/S] a list of all symbol definitions that are accessed from this scope or any subscopes",
          cname: "[integer/S] current index for mangling variables (used internally by the mangler)",
      },
  }, AST_Block);
  
  var AST_Toplevel = DEFNODE("Toplevel", "globals", {
      $documentation: "The toplevel scope",
      $propdoc: {
          globals: "[Object/S] a map of name -> SymbolDef for all undeclared names",
      },
      wrap_enclose: function(arg_parameter_pairs) {
          var self = this;
          var args = [];
          var parameters = [];
  
          arg_parameter_pairs.forEach(function(pair) {
              var split = pair.split(":");
  
              args.push(split[0]);
              parameters.push(split[1]);
          });
  
          var wrapped_tl = "(function(" + parameters.join(",") + "){ '$ORIG'; })(" + args.join(",") + ")";
          wrapped_tl = parse(wrapped_tl);
          wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node){
              if (node instanceof AST_Directive && node.value == "$ORIG") {
                  return MAP.splice(self.body);
              }
          }));
          return wrapped_tl;
      },
      wrap_commonjs: function(name, export_all) {
          var self = this;
          var to_export = [];
          if (export_all) {
              self.figure_out_scope();
              self.walk(new TreeWalker(function(node){
                  if (node instanceof AST_SymbolDeclaration && node.definition().global) {
                      if (!find_if(function(n){ return n.name == node.name }, to_export))
                          to_export.push(node);
                  }
              }));
          }
          var wrapped_tl = "(function(exports, global){ global['" + name + "'] = exports; '$ORIG'; '$EXPORTS'; }({}, (function(){return this}())))";
          wrapped_tl = parse(wrapped_tl);
          wrapped_tl = wrapped_tl.transform(new TreeTransformer(function before(node){
              if (node instanceof AST_SimpleStatement) {
                  node = node.body;
                  if (node instanceof AST_String) switch (node.getValue()) {
                    case "$ORIG":
                      return MAP.splice(self.body);
                    case "$EXPORTS":
                      var body = [];
                      to_export.forEach(function(sym){
                          body.push(new AST_SimpleStatement({
                              body: new AST_Assign({
                                  left: new AST_Sub({
                                      expression: new AST_SymbolRef({ name: "exports" }),
                                      property: new AST_String({ value: sym.name }),
                                  }),
                                  operator: "=",
                                  right: new AST_SymbolRef(sym),
                              }),
                          }));
                      });
                      return MAP.splice(body);
                  }
              }
          }));
          return wrapped_tl;
      }
  }, AST_Scope);
  
  var AST_Lambda = DEFNODE("Lambda", "name argnames uses_arguments", {
      $documentation: "Base class for functions",
      $propdoc: {
          name: "[AST_SymbolDeclaration?] the name of this function",
          argnames: "[AST_SymbolFunarg*] array of function arguments",
          uses_arguments: "[boolean/S] tells whether this function accesses the arguments array"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              if (this.name) this.name._walk(visitor);
              this.argnames.forEach(function(arg){
                  arg._walk(visitor);
              });
              walk_body(this, visitor);
          });
      }
  }, AST_Scope);
  
  var AST_Accessor = DEFNODE("Accessor", null, {
      $documentation: "A setter/getter function.  The `name` property is always null."
  }, AST_Lambda);
  
  var AST_Function = DEFNODE("Function", null, {
      $documentation: "A function expression"
  }, AST_Lambda);
  
  var AST_Defun = DEFNODE("Defun", null, {
      $documentation: "A function definition"
  }, AST_Lambda);
  
  /* -----[ JUMPS ]----- */
  
  var AST_Jump = DEFNODE("Jump", null, {
      $documentation: "Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`)"
  }, AST_Statement);
  
  var AST_Exit = DEFNODE("Exit", "value", {
      $documentation: "Base class for “exits” (`return` and `throw`)",
      $propdoc: {
          value: "[AST_Node?] the value returned or thrown by this statement; could be null for AST_Return"
      },
      _walk: function(visitor) {
          return visitor._visit(this, this.value && function(){
              this.value._walk(visitor);
          });
      }
  }, AST_Jump);
  
  var AST_Return = DEFNODE("Return", null, {
      $documentation: "A `return` statement"
  }, AST_Exit);
  
  var AST_Throw = DEFNODE("Throw", null, {
      $documentation: "A `throw` statement"
  }, AST_Exit);
  
  var AST_LoopControl = DEFNODE("LoopControl", "label", {
      $documentation: "Base class for loop control statements (`break` and `continue`)",
      $propdoc: {
          label: "[AST_LabelRef?] the label, or null if none",
      },
      _walk: function(visitor) {
          return visitor._visit(this, this.label && function(){
              this.label._walk(visitor);
          });
      }
  }, AST_Jump);
  
  var AST_Break = DEFNODE("Break", null, {
      $documentation: "A `break` statement"
  }, AST_LoopControl);
  
  var AST_Continue = DEFNODE("Continue", null, {
      $documentation: "A `continue` statement"
  }, AST_LoopControl);
  
  /* -----[ IF ]----- */
  
  var AST_If = DEFNODE("If", "condition alternative", {
      $documentation: "A `if` statement",
      $propdoc: {
          condition: "[AST_Node] the `if` condition",
          alternative: "[AST_Statement?] the `else` part, or null if not present"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.condition._walk(visitor);
              this.body._walk(visitor);
              if (this.alternative) this.alternative._walk(visitor);
          });
      }
  }, AST_StatementWithBody);
  
  /* -----[ SWITCH ]----- */
  
  var AST_Switch = DEFNODE("Switch", "expression", {
      $documentation: "A `switch` statement",
      $propdoc: {
          expression: "[AST_Node] the `switch` “discriminant”"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.expression._walk(visitor);
              walk_body(this, visitor);
          });
      }
  }, AST_Block);
  
  var AST_SwitchBranch = DEFNODE("SwitchBranch", null, {
      $documentation: "Base class for `switch` branches",
  }, AST_Block);
  
  var AST_Default = DEFNODE("Default", null, {
      $documentation: "A `default` switch branch",
  }, AST_SwitchBranch);
  
  var AST_Case = DEFNODE("Case", "expression", {
      $documentation: "A `case` switch branch",
      $propdoc: {
          expression: "[AST_Node] the `case` expression"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.expression._walk(visitor);
              walk_body(this, visitor);
          });
      }
  }, AST_SwitchBranch);
  
  /* -----[ EXCEPTIONS ]----- */
  
  var AST_Try = DEFNODE("Try", "bcatch bfinally", {
      $documentation: "A `try` statement",
      $propdoc: {
          bcatch: "[AST_Catch?] the catch block, or null if not present",
          bfinally: "[AST_Finally?] the finally block, or null if not present"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              walk_body(this, visitor);
              if (this.bcatch) this.bcatch._walk(visitor);
              if (this.bfinally) this.bfinally._walk(visitor);
          });
      }
  }, AST_Block);
  
  var AST_Catch = DEFNODE("Catch", "argname", {
      $documentation: "A `catch` node; only makes sense as part of a `try` statement",
      $propdoc: {
          argname: "[AST_SymbolCatch] symbol for the exception"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.argname._walk(visitor);
              walk_body(this, visitor);
          });
      }
  }, AST_Block);
  
  var AST_Finally = DEFNODE("Finally", null, {
      $documentation: "A `finally` node; only makes sense as part of a `try` statement"
  }, AST_Block);
  
  /* -----[ VAR/CONST ]----- */
  
  var AST_Definitions = DEFNODE("Definitions", "definitions", {
      $documentation: "Base class for `var` or `const` nodes (variable declarations/initializations)",
      $propdoc: {
          definitions: "[AST_VarDef*] array of variable definitions"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.definitions.forEach(function(def){
                  def._walk(visitor);
              });
          });
      }
  }, AST_Statement);
  
  var AST_Var = DEFNODE("Var", null, {
      $documentation: "A `var` statement"
  }, AST_Definitions);
  
  var AST_Const = DEFNODE("Const", null, {
      $documentation: "A `const` statement"
  }, AST_Definitions);
  
  var AST_VarDef = DEFNODE("VarDef", "name value", {
      $documentation: "A variable declaration; only appears in a AST_Definitions node",
      $propdoc: {
          name: "[AST_SymbolVar|AST_SymbolConst] name of the variable",
          value: "[AST_Node?] initializer, or null of there's no initializer"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.name._walk(visitor);
              if (this.value) this.value._walk(visitor);
          });
      }
  });
  
  /* -----[ OTHER ]----- */
  
  var AST_Call = DEFNODE("Call", "expression args", {
      $documentation: "A function call expression",
      $propdoc: {
          expression: "[AST_Node] expression to invoke as function",
          args: "[AST_Node*] array of arguments"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.expression._walk(visitor);
              this.args.forEach(function(arg){
                  arg._walk(visitor);
              });
          });
      }
  });
  
  var AST_New = DEFNODE("New", null, {
      $documentation: "An object instantiation.  Derives from a function call since it has exactly the same properties"
  }, AST_Call);
  
  var AST_Seq = DEFNODE("Seq", "car cdr", {
      $documentation: "A sequence expression (two comma-separated expressions)",
      $propdoc: {
          car: "[AST_Node] first element in sequence",
          cdr: "[AST_Node] second element in sequence"
      },
      $cons: function(x, y) {
          var seq = new AST_Seq(x);
          seq.car = x;
          seq.cdr = y;
          return seq;
      },
      $from_array: function(array) {
          if (array.length == 0) return null;
          if (array.length == 1) return array[0].clone();
          var list = null;
          for (var i = array.length; --i >= 0;) {
              list = AST_Seq.cons(array[i], list);
          }
          var p = list;
          while (p) {
              if (p.cdr && !p.cdr.cdr) {
                  p.cdr = p.cdr.car;
                  break;
              }
              p = p.cdr;
          }
          return list;
      },
      to_array: function() {
          var p = this, a = [];
          while (p) {
              a.push(p.car);
              if (p.cdr && !(p.cdr instanceof AST_Seq)) {
                  a.push(p.cdr);
                  break;
              }
              p = p.cdr;
          }
          return a;
      },
      add: function(node) {
          var p = this;
          while (p) {
              if (!(p.cdr instanceof AST_Seq)) {
                  var cell = AST_Seq.cons(p.cdr, node);
                  return p.cdr = cell;
              }
              p = p.cdr;
          }
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.car._walk(visitor);
              if (this.cdr) this.cdr._walk(visitor);
          });
      }
  });
  
  var AST_PropAccess = DEFNODE("PropAccess", "expression property", {
      $documentation: "Base class for property access expressions, i.e. `a.foo` or `a[\"foo\"]`",
      $propdoc: {
          expression: "[AST_Node] the “container” expression",
          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"
      }
  });
  
  var AST_Dot = DEFNODE("Dot", null, {
      $documentation: "A dotted property access expression",
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.expression._walk(visitor);
          });
      }
  }, AST_PropAccess);
  
  var AST_Sub = DEFNODE("Sub", null, {
      $documentation: "Index-style property access, i.e. `a[\"foo\"]`",
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.expression._walk(visitor);
              this.property._walk(visitor);
          });
      }
  }, AST_PropAccess);
  
  var AST_Unary = DEFNODE("Unary", "operator expression", {
      $documentation: "Base class for unary expressions",
      $propdoc: {
          operator: "[string] the operator",
          expression: "[AST_Node] expression that this unary operator applies to"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.expression._walk(visitor);
          });
      }
  });
  
  var AST_UnaryPrefix = DEFNODE("UnaryPrefix", null, {
      $documentation: "Unary prefix expression, i.e. `typeof i` or `++i`"
  }, AST_Unary);
  
  var AST_UnaryPostfix = DEFNODE("UnaryPostfix", null, {
      $documentation: "Unary postfix expression, i.e. `i++`"
  }, AST_Unary);
  
  var AST_Binary = DEFNODE("Binary", "left operator right", {
      $documentation: "Binary expression, i.e. `a + b`",
      $propdoc: {
          left: "[AST_Node] left-hand side expression",
          operator: "[string] the operator",
          right: "[AST_Node] right-hand side expression"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.left._walk(visitor);
              this.right._walk(visitor);
          });
      }
  });
  
  var AST_Conditional = DEFNODE("Conditional", "condition consequent alternative", {
      $documentation: "Conditional expression using the ternary operator, i.e. `a ? b : c`",
      $propdoc: {
          condition: "[AST_Node]",
          consequent: "[AST_Node]",
          alternative: "[AST_Node]"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.condition._walk(visitor);
              this.consequent._walk(visitor);
              this.alternative._walk(visitor);
          });
      }
  });
  
  var AST_Assign = DEFNODE("Assign", null, {
      $documentation: "An assignment expression — `a = b + 5`",
  }, AST_Binary);
  
  /* -----[ LITERALS ]----- */
  
  var AST_Array = DEFNODE("Array", "elements", {
      $documentation: "An array literal",
      $propdoc: {
          elements: "[AST_Node*] array of elements"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.elements.forEach(function(el){
                  el._walk(visitor);
              });
          });
      }
  });
  
  var AST_Object = DEFNODE("Object", "properties", {
      $documentation: "An object literal",
      $propdoc: {
          properties: "[AST_ObjectProperty*] array of properties"
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.properties.forEach(function(prop){
                  prop._walk(visitor);
              });
          });
      }
  });
  
  var AST_ObjectProperty = DEFNODE("ObjectProperty", "key value", {
      $documentation: "Base class for literal object properties",
      $propdoc: {
          key: "[string] the property name converted to a string for ObjectKeyVal.  For setters and getters this is an arbitrary AST_Node.",
          value: "[AST_Node] property value.  For setters and getters this is an AST_Function."
      },
      _walk: function(visitor) {
          return visitor._visit(this, function(){
              this.value._walk(visitor);
          });
      }
  });
  
  var AST_ObjectKeyVal = DEFNODE("ObjectKeyVal", null, {
      $documentation: "A key: value object property",
  }, AST_ObjectProperty);
  
  var AST_ObjectSetter = DEFNODE("ObjectSetter", null, {
      $documentation: "An object setter property",
  }, AST_ObjectProperty);
  
  var AST_ObjectGetter = DEFNODE("ObjectGetter", null, {
      $documentation: "An object getter property",
  }, AST_ObjectProperty);
  
  var AST_Symbol = DEFNODE("Symbol", "scope name thedef", {
      $propdoc: {
          name: "[string] name of this symbol",
          scope: "[AST_Scope/S] the current scope (not necessarily the definition scope)",
          thedef: "[SymbolDef/S] the definition of this symbol"
      },
      $documentation: "Base class for all symbols",
  });
  
  var AST_SymbolAccessor = DEFNODE("SymbolAccessor", null, {
      $documentation: "The name of a property accessor (setter/getter function)"
  }, AST_Symbol);
  
  var AST_SymbolDeclaration = DEFNODE("SymbolDeclaration", "init", {
      $documentation: "A declaration symbol (symbol in var/const, function name or argument, symbol in catch)",
      $propdoc: {
          init: "[AST_Node*/S] array of initializers for this declaration."
      }
  }, AST_Symbol);
  
  var AST_SymbolVar = DEFNODE("SymbolVar", null, {
      $documentation: "Symbol defining a variable",
  }, AST_SymbolDeclaration);
  
  var AST_SymbolConst = DEFNODE("SymbolConst", null, {
      $documentation: "A constant declaration"
  }, AST_SymbolDeclaration);
  
  var AST_SymbolFunarg = DEFNODE("SymbolFunarg", null, {
      $documentation: "Symbol naming a function argument",
  }, AST_SymbolVar);
  
  var AST_SymbolDefun = DEFNODE("SymbolDefun", null, {
      $documentation: "Symbol defining a function",
  }, AST_SymbolDeclaration);
  
  var AST_SymbolLambda = DEFNODE("SymbolLambda", null, {
      $documentation: "Symbol naming a function expression",
  }, AST_SymbolDeclaration);
  
  var AST_SymbolCatch = DEFNODE("SymbolCatch", null, {
      $documentation: "Symbol naming the exception in catch",
  }, AST_SymbolDeclaration);
  
  var AST_Label = DEFNODE("Label", "references", {
      $documentation: "Symbol naming a label (declaration)",
      $propdoc: {
          references: "[AST_LoopControl*] a list of nodes referring to this label"
      },
      initialize: function() {
          this.references = [];
          this.thedef = this;
      }
  }, AST_Symbol);
  
  var AST_SymbolRef = DEFNODE("SymbolRef", null, {
      $documentation: "Reference to some symbol (not definition/declaration)",
  }, AST_Symbol);
  
  var AST_LabelRef = DEFNODE("LabelRef", null, {
      $documentation: "Reference to a label symbol",
  }, AST_Symbol);
  
  var AST_This = DEFNODE("This", null, {
      $documentation: "The `this` symbol",
  }, AST_Symbol);
  
  var AST_Constant = DEFNODE("Constant", null, {
      $documentation: "Base class for all constants",
      getValue: function() {
          return this.value;
      }
  });
  
  var AST_String = DEFNODE("String", "value", {
      $documentation: "A string literal",
      $propdoc: {
          value: "[string] the contents of this string"
      }
  }, AST_Constant);
  
  var AST_Number = DEFNODE("Number", "value", {
      $documentation: "A number literal",
      $propdoc: {
          value: "[number] the numeric value"
      }
  }, AST_Constant);
  
  var AST_RegExp = DEFNODE("RegExp", "value", {
      $documentation: "A regexp literal",
      $propdoc: {
          value: "[RegExp] the actual regexp"
      }
  }, AST_Constant);
  
  var AST_Atom = DEFNODE("Atom", null, {
      $documentation: "Base class for atoms",
  }, AST_Constant);
  
  var AST_Null = DEFNODE("Null", null, {
      $documentation: "The `null` atom",
      value: null
  }, AST_Atom);
  
  var AST_NaN = DEFNODE("NaN", null, {
      $documentation: "The impossible value",
      value: 0/0
  }, AST_Atom);
  
  var AST_Undefined = DEFNODE("Undefined", null, {
      $documentation: "The `undefined` value",
      value: (function(){}())
  }, AST_Atom);
  
  var AST_Hole = DEFNODE("Hole", null, {
      $documentation: "A hole in an array",
      value: (function(){}())
  }, AST_Atom);
  
  var AST_Infinity = DEFNODE("Infinity", null, {
      $documentation: "The `Infinity` value",
      value: 1/0
  }, AST_Atom);
  
  var AST_Boolean = DEFNODE("Boolean", null, {
      $documentation: "Base class for booleans",
  }, AST_Atom);
  
  var AST_False = DEFNODE("False", null, {
      $documentation: "The `false` atom",
      value: false
  }, AST_Boolean);
  
  var AST_True = DEFNODE("True", null, {
      $documentation: "The `true` atom",
      value: true
  }, AST_Boolean);
  
  /* -----[ TreeWalker ]----- */
  
  function TreeWalker(callback) {
      this.visit = callback;
      this.stack = [];
  };
  TreeWalker.prototype = {
      _visit: function(node, descend) {
          this.stack.push(node);
          var ret = this.visit(node, descend ? function(){
              descend.call(node);
          } : noop);
          if (!ret && descend) {
              descend.call(node);
          }
          this.stack.pop();
          return ret;
      },
      parent: function(n) {
          return this.stack[this.stack.length - 2 - (n || 0)];
      },
      push: function (node) {
          this.stack.push(node);
      },
      pop: function() {
          return this.stack.pop();
      },
      self: function() {
          return this.stack[this.stack.length - 1];
      },
      find_parent: function(type) {
          var stack = this.stack;
          for (var i = stack.length; --i >= 0;) {
              var x = stack[i];
              if (x instanceof type) return x;
          }
      },
      has_directive: function(type) {
          return this.find_parent(AST_Scope).has_directive(type);
      },
      in_boolean_context: function() {
          var stack = this.stack;
          var i = stack.length, self = stack[--i];
          while (i > 0) {
              var p = stack[--i];
              if ((p instanceof AST_If           && p.condition === self) ||
                  (p instanceof AST_Conditional  && p.condition === self) ||
                  (p instanceof AST_DWLoop       && p.condition === self) ||
                  (p instanceof AST_For          && p.condition === self) ||
                  (p instanceof AST_UnaryPrefix  && p.operator == "!" && p.expression === self))
              {
                  return true;
              }
              if (!(p instanceof AST_Binary && (p.operator == "&&" || p.operator == "||")))
                  return false;
              self = p;
          }
      },
      loopcontrol_target: function(label) {
          var stack = this.stack;
          if (label) for (var i = stack.length; --i >= 0;) {
              var x = stack[i];
              if (x instanceof AST_LabeledStatement && x.label.name == label.name) {
                  return x.body;
              }
          } else for (var i = stack.length; --i >= 0;) {
              var x = stack[i];
              if (x instanceof AST_Switch || x instanceof AST_IterationStatement)
                  return x;
          }
      }
  };
  