text: (function(f) {
    if (typeof exports === "object" && typeof module !== "undefined") {
      module.exports = f()
    } else if (typeof define === "function" && define.amd) {
      define([], f)
    } else {
      var g;
      if (typeof window !== "undefined") {
        g = window
      } else if (typeof global !== "undefined") {
        g = global
      } else if (typeof self !== "undefined") {
        g = self
      } else {
        g = this
      }
      g.acorn = f()
    }
  })(function() {
    var define, module, exports;
    return (function e(t, n, r) {
      function s(o, u) {
        if (!n[o]) {
          if (!t[o]) {
            var a = typeof require == "function" && require;
            if (!u && a) return a(o, !0);
            if (i) return i(o, !0);
            var f = new Error("Cannot find module '" + o + "'");
            throw f.code = "MODULE_NOT_FOUND", f
          }
          var l = n[o] = {
            exports: {}
          };
          t[o][0].call(l.exports, function(e) {
            var n = t[o][1][e];
            return s(n ? n : e)
          }, l, l.exports, e, t, n, r)
        }
        return n[o].exports
      }
      var i = typeof require == "function" && require;
      for (var o = 0; o < r.length; o++) s(r[o]);
      return s
    })({
      1: [function(_dereq_, module, exports) {
  
  
        // The main exported interface (under `self.acorn` when in the
        // browser) is a `parse` function that takes a code string and
        // returns an abstract syntax tree as specified by [Mozilla parser
        // API][api].
        //
        // [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
  
        "use strict";
  
        exports.parse = parse;
  
        // This function tries to parse a single expression at a given
        // offset in a string. Useful for parsing mixed-language formats
        // that embed JavaScript expressions.
  
        exports.parseExpressionAt = parseExpressionAt;
  
        // Acorn is organized as a tokenizer and a recursive-descent parser.
        // The `tokenize` export provides an interface to the tokenizer.
  
        exports.tokenizer = tokenizer;
        exports.__esModule = true;
        // Acorn is a tiny, fast JavaScript parser written in JavaScript.
        //
        // Acorn was written by Marijn Haverbeke, Ingvar Stepanyan, and
        // various contributors and released under an MIT license.
        //
        // Git repositories for Acorn are available at
        //
        //     http://marijnhaverbeke.nl/git/acorn
        //     https://github.com/marijnh/acorn.git
        //
        // Please use the [github bug tracker][ghbt] to report issues.
        //
        // [ghbt]: https://github.com/marijnh/acorn/issues
        //
        // This file defines the main parser interface. The library also comes
        // with a [error-tolerant parser][dammit] and an
        // [abstract syntax tree walker][walk], defined in other files.
        //
        // [dammit]: acorn_loose.js
        // [walk]: util/walk.js
  
        var _state = _dereq_("./state");
  
        var Parser = _state.Parser;
  
        var _options = _dereq_("./options");
  
        var getOptions = _options.getOptions;
  
        _dereq_("./parseutil");
  
        _dereq_("./statement");
  
        _dereq_("./lval");
  
        _dereq_("./expression");
  
        exports.Parser = _state.Parser;
        exports.plugins = _state.plugins;
        exports.defaultOptions = _options.defaultOptions;
  
        var _location = _dereq_("./location");
  
        exports.SourceLocation = _location.SourceLocation;
        exports.getLineInfo = _location.getLineInfo;
        exports.Node = _dereq_("./node").Node;
  
        var _tokentype = _dereq_("./tokentype");
  
        exports.TokenType = _tokentype.TokenType;
        exports.tokTypes = _tokentype.types;
  
        var _tokencontext = _dereq_("./tokencontext");
  
        exports.TokContext = _tokencontext.TokContext;
        exports.tokContexts = _tokencontext.types;
  
        var _identifier = _dereq_("./identifier");
  
        exports.isIdentifierChar = _identifier.isIdentifierChar;
        exports.isIdentifierStart = _identifier.isIdentifierStart;
        exports.Token = _dereq_("./tokenize").Token;
  
        var _whitespace = _dereq_("./whitespace");
  
        exports.isNewLine = _whitespace.isNewLine;
        exports.lineBreak = _whitespace.lineBreak;
        exports.lineBreakG = _whitespace.lineBreakG;
        var version = "1.2.2";
        exports.version = version;
  
        function parse(input, options) {
          var p = parser(options, input);
          var startPos = p.pos,
            startLoc = p.options.locations && p.curPosition();
          p.nextToken();
          return p.parseTopLevel(p.options.program || p.startNodeAt(startPos, startLoc));
        }
  
        function parseExpressionAt(input, pos, options) {
          var p = parser(options, input, pos);
          p.nextToken();
          return p.parseExpression();
        }
  
        function tokenizer(input, options) {
          return parser(options, input);
        }
  
        function parser(options, input) {
          return new Parser(getOptions(options), String(input));
        }
  
      }, {
        "./expression": 6,
        "./identifier": 7,
        "./location": 8,
        "./lval": 9,
        "./node": 10,
        "./options": 11,
        "./parseutil": 12,
        "./state": 13,
        "./statement": 14,
        "./tokencontext": 15,
        "./tokenize": 16,
        "./tokentype": 17,
        "./whitespace": 19
      }],
      2: [function(_dereq_, module, exports) {
        if (typeof Object.create === 'function') {
          // implementation from standard node.js 'util' module
          module.exports = function inherits(ctor, superCtor) {
            ctor.super_ = superCtor
            ctor.prototype = Object.create(superCtor.prototype, {
              constructor: {
                value: ctor,
                enumerable: false,
                writable: true,
                configurable: true
              }
            });
          };
        } else {
          // old school shim for old browsers
          module.exports = function inherits(ctor, superCtor) {
            ctor.super_ = superCtor
            var TempCtor = function() {}
            TempCtor.prototype = superCtor.prototype
            ctor.prototype = new TempCtor()
            ctor.prototype.constructor = ctor
          }
        }
  
      }, {}],
      3: [function(_dereq_, module, exports) {
        // shim for using process in browser
  
        var process = module.exports = {};
        var queue = [];
        var draining = false;
  
        function drainQueue() {
          if (draining) {
            return;
          }
          draining = true;
          var currentQueue;
          var len = queue.length;
          while (len) {
            currentQueue = queue;
            queue = [];
            var i = -1;
            while (++i < len) {
              currentQueue[i]();
            }
            len = queue.length;
          }
          draining = false;
        }
        process.nextTick = function(fun) {
          queue.push(fun);
          if (!draining) {
            setTimeout(drainQueue, 0);
          }
        };
  
        process.title = 'browser';
        process.browser = true;
        process.env = {};
        process.argv = [];
        process.version = ''; // empty string to avoid regexp issues
        process.versions = {};
  
        function noop() {}
  
        process.on = noop;
        process.addListener = noop;
        process.once = noop;
        process.off = noop;
        process.removeListener = noop;
        process.removeAllListeners = noop;
        process.emit = noop;
  
        process.binding = function(name) {
          throw new Error('process.binding is not supported');
        };
  
        // TODO(shtylman)
        process.cwd = function() {
          return '/'
        };
        process.chdir = function(dir) {
          throw new Error('process.chdir is not supported');
        };
        process.umask = function() {
          return 0;
        };
  
      }, {}],
      4: [function(_dereq_, module, exports) {
        module.exports = function isBuffer(arg) {
          return arg && typeof arg === 'object' && typeof arg.copy === 'function' && typeof arg.fill === 'function' && typeof arg.readUInt8 === 'function';
        }
      }, {}],
      5: [function(_dereq_, module, exports) {
        (function(process, global) {
          // Copyright Joyent, Inc. and other Node contributors.
          //
          // Permission is hereby granted, free of charge, to any person obtaining a
          // copy of this software and associated documentation files (the
          // "Software"), to deal in the Software without restriction, including
          // without limitation the rights to use, copy, modify, merge, publish,
          // distribute, sublicense, and/or sell copies of the Software, and to permit
          // persons to whom the Software is furnished to do so, subject to the
          // following conditions:
          //
          // The above copyright notice and this permission notice shall be included
          // in all copies or substantial portions of the Software.
          //
          // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
          // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
          // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
          // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
          // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
          // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
          // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
          var formatRegExp = /%[sdj%]/g;
          exports.format = function(f) {
            if (!isString(f)) {
              var objects = [];
              for (var i = 0; i < arguments.length; i++) {
                objects.push(inspect(arguments[i]));
              }
              return objects.join(' ');
            }
  
            var i = 1;
            var args = arguments;
            var len = args.length;
            var str = String(f).replace(formatRegExp, function(x) {
              if (x === '%%') return '%';
              if (i >= len) return x;
              switch (x) {
                case '%s':
                  return String(args[i++]);
                case '%d':
                  return Number(args[i++]);
                case '%j':
                  try {
                    return JSON.stringify(args[i++]);
                  } catch (_) {
                    return '[Circular]';
                  }
                default:
                  return x;
              }
            });
            for (var x = args[i]; i < len; x = args[++i]) {
              if (isNull(x) || !isObject(x)) {
                str += ' ' + x;
              } else {
                str += ' ' + inspect(x);
              }
            }
            return str;
          };
  
  
          // Mark that a method should not be used.
          // Returns a modified function which warns once by default.
          // If --no-deprecation is set, then it is a no-op.
          exports.deprecate = function(fn, msg) {
            // Allow for deprecating things in the process of starting up.
            if (isUndefined(global.process)) {
              return function() {
                return exports.deprecate(fn, msg).apply(this, arguments);
              };
            }
  
            if (process.noDeprecation === true) {
              return fn;
            }
  
            var warned = false;
  
            function deprecated() {
              if (!warned) {
                if (process.throwDeprecation) {
                  throw new Error(msg);
                } else if (process.traceDeprecation) {
                  console.trace(msg);
                } else {
                  console.error(msg);
                }
                warned = true;
              }
              return fn.apply(this, arguments);
            }
  
            return deprecated;
          };
  
  
          var debugs = {};
          var debugEnviron;
          exports.debuglog = function(set) {
            if (isUndefined(debugEnviron))
              debugEnviron = process.env.NODE_DEBUG || '';
            set = set.toUpperCase();
            if (!debugs[set]) {
              if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
                var pid = process.pid;
                debugs[set] = function() {
                  var msg = exports.format.apply(exports, arguments);
                  console.error('%s %d: %s', set, pid, msg);
                };
              } else {
                debugs[set] = function() {};
              }
            }
            return debugs[set];
          };
  
  
          /**
           * Echos the value of a value. Trys to print the value out
           * in the best way possible given the different types.
           *
           * @param {Object} obj The object to print out.
           * @param {Object} opts Optional options object that alters the output.
           */
          /* legacy: obj, showHidden, depth, colors*/
          function inspect(obj, opts) {
            // default options
            var ctx = {
              seen: [],
              stylize: stylizeNoColor
            };
            // legacy...
            if (arguments.length >= 3) ctx.depth = arguments[2];
            if (arguments.length >= 4) ctx.colors = arguments[3];
            if (isBoolean(opts)) {
              // legacy...
              ctx.showHidden = opts;
            } else if (opts) {
              // got an "options" object
              exports._extend(ctx, opts);
            }
            // set default options
            if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
            if (isUndefined(ctx.depth)) ctx.depth = 2;
            if (isUndefined(ctx.colors)) ctx.colors = false;
            if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
            if (ctx.colors) ctx.stylize = stylizeWithColor;
            return formatValue(ctx, obj, ctx.depth);
          }
          exports.inspect = inspect;
  
  
          // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
          inspect.colors = {
            'bold': [1, 22],
            'italic': [3, 23],
            'underline': [4, 24],
            'inverse': [7, 27],
            'white': [37, 39],
            'grey': [90, 39],
            'black': [30, 39],
            'blue': [34, 39],
            'cyan': [36, 39],
            'green': [32, 39],
            'magenta': [35, 39],
            'red': [31, 39],
            'yellow': [33, 39]
          };
  
          // Don't use 'blue' not visible on cmd.exe
          inspect.styles = {
            'special': 'cyan',
            'number': 'yellow',
            'boolean': 'yellow',
            'undefined': 'grey',
            'null': 'bold',
            'string': 'green',
            'date': 'magenta',
            // "name": Internionally not styling
            'regexp': 'red'
          };
  
  
          function stylizeWithColor(str, styleType) {
            var style = inspect.styles[styleType];
  
            if (style) {
              return '\u001b[' + inspect.colors[style][0] + 'm' + str +
                '\u001b[' + inspect.colors[style][1] + 'm';
            } else {
              return str;
            }
          }
  
  
          function stylizeNoColor(str, styleType) {
            return str;
          }
  
  
          function arrayToHash(array) {
            var hash = {};
  
            array.forEach(function(val, idx) {
              hash[val] = true;
            });
  
            return hash;
          }
  
  
          function formatValue(ctx, value, recurseTimes) {
            // Provide a hook for user-specified inspect functions.
            // Check that value is an object with an inspect function on it
            if (ctx.customInspect &&
              value &&
              isFunction(value.inspect) &&
              // Filter out the util module, it's inspect function is special
              value.inspect !== exports.inspect &&
              // Also filter out any prototype objects using the circular check.
              !(value.constructor && value.constructor.prototype === value)) {
              var ret = value.inspect(recurseTimes, ctx);
              if (!isString(ret)) {
                ret = formatValue(ctx, ret, recurseTimes);
              }
              return ret;
            }
  
            // Primitive types cannot have properties
            var primitive = formatPrimitive(ctx, value);
            if (primitive) {
              return primitive;
            }
  
            // Look up the keys of the object.
            var keys = Object.keys(value);
            var visibleKeys = arrayToHash(keys);
  
            if (ctx.showHidden) {
              keys = Object.getOwnPropertyNames(value);
            }
  
            // IE doesn't make error fields non-enumerable
            // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
            if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
              return formatError(value);
            }
  
            // Some type of object without properties can be shortcutted.
            if (keys.length === 0) {
              if (isFunction(value)) {
                var name = value.name ? ': ' + value.name : '';
                return ctx.stylize('[Function' + name + ']', 'special');
              }
              if (isRegExp(value)) {
                return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
              }
              if (isDate(value)) {
                return ctx.stylize(Date.prototype.toString.call(value), 'date');
              }
              if (isError(value)) {
                return formatError(value);
              }
            }
  
            var base = '',
              array = false,
              braces = ['{', '}'];
  
            // Make Array say that they are Array
            if (isArray(value)) {
              array = true;
              braces = ['[', ']'];
            }
  
            // Make functions say that they are functions
            if (isFunction(value)) {
              var n = value.name ? ': ' + value.name : '';
              base = ' [Function' + n + ']';
            }
  
            // Make RegExps say that they are RegExps
            if (isRegExp(value)) {
              base = ' ' + RegExp.prototype.toString.call(value);
            }
  
            // Make dates with properties first say the date
            if (isDate(value)) {
              base = ' ' + Date.prototype.toUTCString.call(value);
            }
  
            // Make error with message first say the error
            if (isError(value)) {
              base = ' ' + formatError(value);
            }
  
            if (keys.length === 0 && (!array || value.length == 0)) {
              return braces[0] + base + braces[1];
            }
  
            if (recurseTimes < 0) {
              if (isRegExp(value)) {
                return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
              } else {
                return ctx.stylize('[Object]', 'special');
              }
            }
  
            ctx.seen.push(value);
  
            var output;
            if (array) {
              output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
            } else {
              output = keys.map(function(key) {
                return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
              });
            }
  
            ctx.seen.pop();
  
            return reduceToSingleString(output, base, braces);
          }
  
  
          function formatPrimitive(ctx, value) {
            if (isUndefined(value))
              return ctx.stylize('undefined', 'undefined');
            if (isString(value)) {
              var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
                .replace(/'/g, "\\'")
                .replace(/\\"/g, '"') + '\'';
              return ctx.stylize(simple, 'string');
            }
            if (isNumber(value))
              return ctx.stylize('' + value, 'number');
            if (isBoolean(value))
              return ctx.stylize('' + value, 'boolean');
            // For some reason typeof null is "object", so special case here.
            if (isNull(value))
              return ctx.stylize('null', 'null');
          }
  
  
          function formatError(value) {
            return '[' + Error.prototype.toString.call(value) + ']';
          }
  
  
          function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
            var output = [];
            for (var i = 0, l = value.length; i < l; ++i) {
              if (hasOwnProperty(value, String(i))) {
                output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
                  String(i), true));
              } else {
                output.push('');
              }
            }
            keys.forEach(function(key) {
              if (!key.match(/^\d+$/)) {
                output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
                  key, true));
              }
            });
            return output;
          }
  
  
          function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
            var name, str, desc;
            desc = Object.getOwnPropertyDescriptor(value, key) || {
              value: value[key]
            };
            if (desc.get) {
              if (desc.set) {
                str = ctx.stylize('[Getter/Setter]', 'special');
              } else {
                str = ctx.stylize('[Getter]', 'special');
              }
            } else {
              if (desc.set) {
                str = ctx.stylize('[Setter]', 'special');
              }
            }
            if (!hasOwnProperty(visibleKeys, key)) {
              name = '[' + key + ']';
            }
            if (!str) {
              if (ctx.seen.indexOf(desc.value) < 0) {
                if (isNull(recurseTimes)) {
                  str = formatValue(ctx, desc.value, null);
                } else {
                  str = formatValue(ctx, desc.value, recurseTimes - 1);
                }
                if (str.indexOf('\n') > -1) {
                  if (array) {
                    str = str.split('\n').map(function(line) {
                      return '  ' + line;
                    }).join('\n').substr(2);
                  } else {
                    str = '\n' + str.split('\n').map(function(line) {
                      return '   ' + line;
                    }).join('\n');
                  }
                }
              } else {
                str = ctx.stylize('[Circular]', 'special');
              }
            }
            if (isUndefined(name)) {
              if (array && key.match(/^\d+$/)) {
                return str;
              }
              name = JSON.stringify('' + key);
              if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
                name = name.substr(1, name.length - 2);
                name = ctx.stylize(name, 'name');
              } else {
                name = name.replace(/'/g, "\\'")
                  .replace(/\\"/g, '"')
                  .replace(/(^"|"$)/g, "'");
                name = ctx.stylize(name, 'string');
              }
            }
  
            return name + ': ' + str;
          }
  
  
          function reduceToSingleString(output, base, braces) {
            var numLinesEst = 0;
            var length = output.reduce(function(prev, cur) {
              numLinesEst++;
              if (cur.indexOf('\n') >= 0) numLinesEst++;
              return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
            }, 0);
  
            if (length > 60) {
              return braces[0] +
                (base === '' ? '' : base + '\n ') +
                ' ' +
                output.join(',\n  ') +
                ' ' +
                braces[1];
            }
  
            return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
          }
  
  
          // NOTE: These type checking functions Internionally don't use `instanceof`
          // because it is fragile and can be easily faked with `Object.create()`.
          function isArray(ar) {
            return Array.isArray(ar);
          }
          exports.isArray = isArray;
  
          function isBoolean(arg) {
            return typeof arg === 'boolean';
          }
          exports.isBoolean = isBoolean;
  
          function isNull(arg) {
            return arg === null;
          }
          exports.isNull = isNull;
  
          function isNullOrUndefined(arg) {
            return arg == null;
          }
          exports.isNullOrUndefined = isNullOrUndefined;
  
          function isNumber(arg) {
            return typeof arg === 'number';
          }
          exports.isNumber = isNumber;
  
          function isString(arg) {
            return typeof arg === 'string';
          }
          exports.isString = isString;
  
          function isSymbol(arg) {
            return typeof arg === 'symbol';
          }
          exports.isSymbol = isSymbol;
  
          function isUndefined(arg) {
            return arg === void 0;
          }
          exports.isUndefined = isUndefined;
  
          function isRegExp(re) {
            return isObject(re) && objectToString(re) === '[object RegExp]';
          }
          exports.isRegExp = isRegExp;
  
          function isObject(arg) {
            return typeof arg === 'object' && arg !== null;
          }
          exports.isObject = isObject;
  
          function isDate(d) {
            return isObject(d) && objectToString(d) === '[object Date]';
          }
          exports.isDate = isDate;
  
          function isError(e) {
            return isObject(e) &&
              (objectToString(e) === '[object Error]' || e instanceof Error);
          }
          exports.isError = isError;
  
          function isFunction(arg) {
            return typeof arg === 'function';
          }
          exports.isFunction = isFunction;
  
          function isPrimitive(arg) {
            return arg === null ||
              typeof arg === 'boolean' ||
              typeof arg === 'number' ||
              typeof arg === 'string' ||
              typeof arg === 'symbol' || // ES6 symbol
              typeof arg === 'undefined';
          }
          exports.isPrimitive = isPrimitive;
  
          exports.isBuffer = _dereq_('./support/isBuffer');
  
          function objectToString(o) {
            return Object.prototype.toString.call(o);
          }
  
  
          function pad(n) {
            return n < 10 ? '0' + n.toString(10) : n.toString(10);
          }
  
  
          var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
            'Oct', 'Nov', 'Dec'
          ];
  
          // 26 Feb 16:19:34
          function timestamp() {
            var d = new Date();
            var time = [pad(d.getHours()),
              pad(d.getMinutes()),
              pad(d.getSeconds())
            ].join(':');
            return [d.getDate(), months[d.getMonth()], time].join(' ');
          }
  
  
          // log is just a thin wrapper to console.log that prepends a timestamp
          exports.log = function() {
            console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
          };
  
  
          /**
           * Inherit the prototype methods from one constructor into another.
           *
           * The Function.prototype.inherits from lang.js rewritten as a standalone
           * function (not on Function.prototype). NOTE: If this file is to be loaded
           * during bootstrapping this function needs to be rewritten using some native
           * functions as prototype setup using normal JavaScript does not work as
           * expected during bootstrapping (see mirror.js in r114903).
           *
           * @param {function} ctor Constructor function which needs to inherit the
           *     prototype.
           * @param {function} superCtor Constructor function to inherit prototype from.
           */
          exports.inherits = _dereq_('inherits');
  
          exports._extend = function(origin, add) {
            // Don't do anything if add isn't an object
            if (!add || !isObject(add)) return origin;
  
            var keys = Object.keys(add);
            var i = keys.length;
            while (i--) {
              origin[keys[i]] = add[keys[i]];
            }
            return origin;
          };
  
          function hasOwnProperty(obj, prop) {
            return Object.prototype.hasOwnProperty.call(obj, prop);
          }
  
        }).call(this, _dereq_('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
      }, {
        "./support/isBuffer": 4,
        "_process": 3,
        "inherits": 2
      }],
      6: [function(_dereq_, module, exports) {
        // A recursive descent parser operates by defining functions for all
        // syntactic elements, and recursively calling those, each function
        // advancing the input stream and returning an AST node. Precedence
        // of constructs (for example, the fact that `!x[1]` means `!(x[1])`
        // instead of `(!x)[1]` is handled by the fact that the parser
        // function that parses unary prefix operators is called first, and
        // in turn calls the function that parses `[]` subscripts — that
        // way, it'll receive the node for `x[1]` already parsed, and wraps
        // *that* in the unary operator node.
        //
        // Acorn uses an [operator precedence parser][opp] to handle binary
        // operator precedence, because it is much more compact than using
        // the technique outlined above, which uses different, nesting
        // functions to specify precedence, for all of the ten binary
        // precedence levels that JavaScript defines.
        //
        // [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
  
        "use strict";
  
        var tt = _dereq_("./tokentype").types;
  
        var Parser = _dereq_("./state").Parser;
  
        var reservedWords = _dereq_("./identifier").reservedWords;
  
        var has = _dereq_("./util").has;
  
        var pp = Parser.prototype;
  
        // Check if property name clashes with already added.
        // Object/class getters and setters are not allowed to clash —
        // either with each other or with an init property — and in
        // strict mode, init properties are also not allowed to be repeated.
  
        pp.checkPropClash = function(prop, propHash) {
          if (this.options.ecmaVersion >= 6) return;
          var key = prop.key,
            name = undefined;
          switch (key.type) {
            case "Identifier":
              name = key.name;
              break;
            case "Literal":
              name = String(key.value);
              break;
            default:
              return;
          }
          var kind = prop.kind || "init",
            other = undefined;
          if (has(propHash, name)) {
            other = propHash[name];
            var isGetSet = kind !== "init";
            if ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init)) this.raise(key.start, "Redefinition of property");
          } else {
            other = propHash[name] = {
              init: false,
              get: false,
              set: false
            };
          }
          other[kind] = true;
        };
  
        // ### Expression parsing
  
        // These nest, from the most general expression type at the top to
        // 'atomic', nondivisible expression types at the bottom. Most of
        // the functions will simply let the function(s) below them parse,
        // and, *if* the syntactic construct they handle is present, wrap
        // the AST node that the inner parser gave them in another node.
  
        // Parse a full expression. The optional arguments are used to
        // forbid the `in` operator (in for loops initalization expressions)
        // and provide reference for storing '=' operator inside shorthand
        // property assignment in contexts where both object expression
        // and object pattern might appear (so it's possible to raise
        // delayed syntax error at correct position).
  
        pp.parseExpression = function(noIn, refShorthandDefaultPos) {
          var startPos = this.start,
            startLoc = this.startLoc;
          var expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos);
          if (this.type === tt.comma) {
            var node = this.startNodeAt(startPos, startLoc);
            node.expressions = [expr];
            while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refShorthandDefaultPos));
            return this.finishNode(node, "SequenceExpression");
          }
          return expr;
        };
  
        // Parse an assignment expression. This includes applications of
        // operators like `+=`.
  
        pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos, afterLeftParse) {
          if (this.type == tt._yield && this.inGenerator) return this.parseYield();
  
          var failOnShorthandAssign = undefined;
          if (!refShorthandDefaultPos) {
            refShorthandDefaultPos = {
              start: 0
            };
            failOnShorthandAssign = true;
          } else {
            failOnShorthandAssign = false;
          }
          var startPos = this.start,
            startLoc = this.startLoc;
          if (this.type == tt.parenL || this.type == tt.name) this.potentialArrowAt = this.start;
          var left = this.parseMaybeConditional(noIn, refShorthandDefaultPos);
          if (afterLeftParse) left = afterLeftParse.call(this, left, startPos, startLoc);
          if (this.type.isAssign) {
            var node = this.startNodeAt(startPos, startLoc);
            node.operator = this.value;
            node.left = this.type === tt.eq ? this.toAssignable(left) : left;
            refShorthandDefaultPos.start = 0; // reset because shorthand default was used correctly
            this.checkLVal(left);
            this.next();
            node.right = this.parseMaybeAssign(noIn);
            return this.finishNode(node, "AssignmentExpression");
          } else if (failOnShorthandAssign && refShorthandDefaultPos.start) {
            this.unexpected(refShorthandDefaultPos.start);
          }
          return left;
        };
  
        // Parse a ternary conditional (`?:`) operator.
  
        pp.parseMaybeConditional = function(noIn, refShorthandDefaultPos) {
          var startPos = this.start,
            startLoc = this.startLoc;
          var expr = this.parseExprOps(noIn, refShorthandDefaultPos);
          if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
          if (this.eat(tt.question)) {
            var node = this.startNodeAt(startPos, startLoc);
            node.test = expr;
            node.consequent = this.parseMaybeAssign();
            this.expect(tt.colon);
            node.alternate = this.parseMaybeAssign(noIn);
            return this.finishNode(node, "ConditionalExpression");
          }
          return expr;
        };
  
        // Start the precedence parser.
  
        pp.parseExprOps = function(noIn, refShorthandDefaultPos) {
          var startPos = this.start,
            startLoc = this.startLoc;
          var expr = this.parseMaybeUnary(refShorthandDefaultPos);
          if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
          return this.parseExprOp(expr, startPos, startLoc, -1, noIn);
        };
  
        // Parse binary operators with the operator precedence parsing
        // algorithm. `left` is the left-hand side of the operator.
        // `minPrec` provides context that allows the function to stop and
        // defer further parser to one of its callers when it encounters an
        // operator that has a lower precedence than the set it is parsing.
  
        pp.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
          var prec = this.type.binop;
          if (Array.isArray(leftStartPos)) {
            if (this.options.locations && noIn === undefined) {
              // shift arguments to left by one
              noIn = minPrec;
              minPrec = leftStartLoc;
              // flatten leftStartPos
              leftStartLoc = leftStartPos[1];
              leftStartPos = leftStartPos[0];
            }
          }
          if (prec != null && (!noIn || this.type !== tt._in)) {
            if (prec > minPrec) {
              var node = this.startNodeAt(leftStartPos, leftStartLoc);
              node.left = left;
              node.operator = this.value;
              var op = this.type;
              this.next();
              var startPos = this.start,
                startLoc = this.startLoc;
              node.right = this.parseExprOp(this.parseMaybeUnary(), startPos, startLoc, prec, noIn);
              this.finishNode(node, op === tt.logicalOR || op === tt.logicalAND ? "LogicalExpression" : "BinaryExpression");
              return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn);
            }
          }
          return left;
        };
  
        // Parse unary operators, both prefix and postfix.
  
        pp.parseMaybeUnary = function(refShorthandDefaultPos) {
          if (this.type.prefix) {
            var node = this.startNode(),
              update = this.type === tt.incDec;
            node.operator = this.value;
            node.prefix = true;
            this.next();
            node.argument = this.parseMaybeUnary();
            if (refShorthandDefaultPos && refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
            if (update) this.checkLVal(node.argument);
            else if (this.strict && node.operator === "delete" && node.argument.type === "Identifier") this.raise(node.start, "Deleting local variable in strict mode");
            return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
          }
          var startPos = this.start,
            startLoc = this.startLoc;
          var expr = this.parseExprSubscripts(refShorthandDefaultPos);
          if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
          while (this.type.postfix && !this.canInsertSemicolon()) {
            var node = this.startNodeAt(startPos, startLoc);
            node.operator = this.value;
            node.prefix = false;
            node.argument = expr;
            this.checkLVal(expr);
            this.next();
            expr = this.finishNode(node, "UpdateExpression");
          }
          return expr;
        };
  
        // Parse call, dot, and `[]`-subscript expressions.
  
        pp.parseExprSubscripts = function(refShorthandDefaultPos) {
          var startPos = this.start,
            startLoc = this.startLoc;
          var expr = this.parseExprAtom(refShorthandDefaultPos);
          if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
          return this.parseSubscripts(expr, startPos, startLoc);
        };
  
        pp.parseSubscripts = function(base, startPos, startLoc, noCalls) {
          if (Array.isArray(startPos)) {
            if (this.options.locations && noCalls === undefined) {
              // shift arguments to left by one
              noCalls = startLoc;
              // flatten startPos
              startLoc = startPos[1];
              startPos = startPos[0];
            }
          }
          for (;;) {
            if (this.eat(tt.dot)) {
              var node = this.startNodeAt(startPos, startLoc);
              node.object = base;
              node.property = this.parseIdent(true);
              node.computed = false;
              base = this.finishNode(node, "MemberExpression");
            } else if (this.eat(tt.bracketL)) {
              var node = this.startNodeAt(startPos, startLoc);
              node.object = base;
              node.property = this.parseExpression();
              node.computed = true;
              this.expect(tt.bracketR);
              base = this.finishNode(node, "MemberExpression");
            } else if (!noCalls && this.eat(tt.parenL)) {
              var node = this.startNodeAt(startPos, startLoc);
              node.callee = base;
              node.arguments = this.parseExprList(tt.parenR, false);
              base = this.finishNode(node, "CallExpression");
            } else if (this.type === tt.backQuote) {
              var node = this.startNodeAt(startPos, startLoc);
              node.tag = base;
              node.quasi = this.parseTemplate();
              base = this.finishNode(node, "TaggedTemplateExpression");
            } else {
              return base;
            }
          }
        };
  
        // Parse an atomic expression — either a single token that is an
        // expression, an expression started by a keyword like `function` or
        // `new`, or an expression wrapped in punctuation like `()`, `[]`,
        // or `{}`.
  
        pp.parseExprAtom = function(refShorthandDefaultPos) {
          var node = undefined,
            canBeArrow = this.potentialArrowAt == this.start;
          switch (this.type) {
            case tt._this:
            case tt._super:
              var type = this.type === tt._this ? "ThisExpression" : "Super";
              node = this.startNode();
              this.next();
              return this.finishNode(node, type);
  
            case tt._yield:
              if (this.inGenerator) this.unexpected();
  
            case tt.name:
              var startPos = this.start,
                startLoc = this.startLoc;
              var id = this.parseIdent(this.type !== tt.name);
              if (canBeArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id]);
              return id;
  
            case tt.regexp:
              var value = this.value;
              node = this.parseLiteral(value.value);
              node.regex = {
                pattern: value.pattern,
                flags: value.flags
              };
              return node;
  
            case tt.num:
            case tt.string:
              return this.parseLiteral(this.value);
  
            case tt._null:
            case tt._true:
            case tt._false:
              node = this.startNode();
              node.value = this.type === tt._null ? null : this.type === tt._true;
              node.raw = this.type.keyword;
              this.next();
              return this.finishNode(node, "Literal");
  
            case tt.parenL:
              return this.parseParenAndDistinguishExpression(canBeArrow);
  
            case tt.bracketL:
              node = this.startNode();
              this.next();
              // check whether this is array comprehension or regular array
              if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
                return this.parseComprehension(node, false);
              }
              node.elements = this.parseExprList(tt.bracketR, true, true, refShorthandDefaultPos);
              return this.finishNode(node, "ArrayExpression");
  
            case tt.braceL:
              return this.parseObj(false, refShorthandDefaultPos);
  
            case tt._function:
              node = this.startNode();
              this.next();
              return this.parseFunction(node, false);
  
            case tt._class:
              return this.parseClass(this.startNode(), false);
  
            case tt._new:
              return this.parseNew();
  
            case tt.backQuote:
              return this.parseTemplate();
  
            default:
              this.unexpected();
          }
        };
  
        pp.parseLiteral = function(value) {
          var node = this.startNode();
          node.value = value;
          node.raw = this.input.slice(this.start, this.end);
          this.next();
          return this.finishNode(node, "Literal");
        };
  
        pp.parseParenExpression = function() {
          this.expect(tt.parenL);
          var val = this.parseExpression();
          this.expect(tt.parenR);
          return val;
        };
  
        pp.parseParenAndDistinguishExpression = function(canBeArrow) {
          var startPos = this.start,
            startLoc = this.startLoc,
            val = undefined;
          if (this.options.ecmaVersion >= 6) {
            this.next();
  
            if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
              return this.parseComprehension(this.startNodeAt(startPos, startLoc), true);
            }
  
            var innerStartPos = this.start,
              innerStartLoc = this.startLoc;
            var exprList = [],
              first = true;
            var refShorthandDefaultPos = {
                start: 0
              },
              spreadStart = undefined,
              innerParenStart = undefined;
            while (this.type !== tt.parenR) {
              first ? first = false : this.expect(tt.comma);
              if (this.type === tt.ellipsis) {
                spreadStart = this.start;
                exprList.push(this.parseParenItem(this.parseRest()));
                break;
              } else {
                if (this.type === tt.parenL && !innerParenStart) {
                  innerParenStart = this.start;
                }
                exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos, this.parseParenItem));
              }
            }
            var innerEndPos = this.start,
              innerEndLoc = this.startLoc;
            this.expect(tt.parenR);
  
            if (canBeArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) {
              if (innerParenStart) this.unexpected(innerParenStart);
              return this.parseParenArrowList(startPos, startLoc, exprList);
            }
  
            if (!exprList.length) this.unexpected(this.lastTokStart);
            if (spreadStart) this.unexpected(spreadStart);
            if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
  
            if (exprList.length > 1) {
              val = this.startNodeAt(innerStartPos, innerStartLoc);
              val.expressions = exprList;
              this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);
            } else {
              val = exprList[0];
            }
          } else {
            val = this.parseParenExpression();
          }
  
          if (this.options.preserveParens) {
            var par = this.startNodeAt(startPos, startLoc);
            par.expression = val;
            return this.finishNode(par, "ParenthesizedExpression");
          } else {
            return val;
          }
        };
  
        pp.parseParenItem = function(item) {
          return item;
        };
  
        pp.parseParenArrowList = function(startPos, startLoc, exprList) {
          return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList);
        };
  
        // New's precedence is slightly tricky. It must allow its argument
        // to be a `[]` or dot subscript expression, but not a call — at
        // least, not without wrapping it in parentheses. Thus, it uses the
  
        var empty = [];
  
        pp.parseNew = function() {
          var node = this.startNode();
          var meta = this.parseIdent(true);
          if (this.options.ecmaVersion >= 6 && this.eat(tt.dot)) {
            node.meta = meta;
            node.property = this.parseIdent(true);
            if (node.property.name !== "target") this.raise(node.property.start, "The only valid meta property for new is new.target");
            return this.finishNode(node, "MetaProperty");
          }
          var startPos = this.start,
            startLoc = this.startLoc;
          node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);
          if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false);
          else node.arguments = empty;
          return this.finishNode(node, "NewExpression");
        };
  
        // Parse template expression.
  
        pp.parseTemplateElement = function() {
          var elem = this.startNode();
          elem.value = {
            raw: this.input.slice(this.start, this.end),
            cooked: this.value
          };
          this.next();
          elem.tail = this.type === tt.backQuote;
          return this.finishNode(elem, "TemplateElement");
        };
  
        pp.parseTemplate = function() {
          var node = this.startNode();
          this.next();
          node.expressions = [];
          var curElt = this.parseTemplateElement();
          node.quasis = [curElt];
          while (!curElt.tail) {
            this.expect(tt.dollarBraceL);
            node.expressions.push(this.parseExpression());
            this.expect(tt.braceR);
            node.quasis.push(curElt = this.parseTemplateElement());
          }
          this.next();
          return this.finishNode(node, "TemplateLiteral");
        };
  
        // Parse an object literal or binding pattern.
  
        pp.parseObj = function(isPattern, refShorthandDefaultPos) {
          var node = this.startNode(),
            first = true,
            propHash = {};
          node.properties = [];
          this.next();
          while (!this.eat(tt.braceR)) {
            if (!first) {
              this.expect(tt.comma);
              if (this.afterTrailingComma(tt.braceR)) break;
            } else first = false;
  
            var prop = this.startNode(),
              isGenerator = undefined,
              startPos = undefined,
              startLoc = undefined;
            if (this.options.ecmaVersion >= 6) {
              prop.method = false;
              prop.shorthand = false;
              if (isPattern || refShorthandDefaultPos) {
                startPos = this.start;
                startLoc = this.startLoc;
              }
              if (!isPattern) isGenerator = this.eat(tt.star);
            }
            this.parsePropertyName(prop);
            this.parsePropertyValue(prop, isPattern, isGenerator, startPos, startLoc, refShorthandDefaultPos);
            this.checkPropClash(prop, propHash);
            node.properties.push(this.finishNode(prop, "Property"));
          }
          return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
        };
  
        pp.parsePropertyValue = function(prop, isPattern, isGenerator, startPos, startLoc, refShorthandDefaultPos) {
          if (this.eat(tt.colon)) {
            prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refShorthandDefaultPos);
            prop.kind = "init";
          } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) {
            if (isPattern) this.unexpected();
            prop.kind = "init";
            prop.method = true;
            prop.value = this.parseMethod(isGenerator);
          } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" && (prop.key.name === "get" || prop.key.name === "set") && (this.type != tt.comma && this.type != tt.braceR)) {
            if (isGenerator || isPattern) this.unexpected();
            prop.kind = prop.key.name;
            this.parsePropertyName(prop);
            prop.value = this.parseMethod(false);
          } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
            prop.kind = "init";
            if (isPattern) {
              if (this.isKeyword(prop.key.name) || this.strict && (reservedWords.strictBind(prop.key.name) || reservedWords.strict(prop.key.name)) || !this.options.allowReserved && this.isReservedWord(prop.key.name)) this.raise(prop.key.start, "Binding " + prop.key.name);
              prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
            } else if (this.type === tt.eq && refShorthandDefaultPos) {
              if (!refShorthandDefaultPos.start) refShorthandDefaultPos.start = this.start;
              prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);
            } else {
              prop.value = prop.key;
            }
            prop.shorthand = true;
          } else this.unexpected();
        };
  
        pp.parsePropertyName = function(prop) {
          if (this.options.ecmaVersion >= 6) {
            if (this.eat(tt.bracketL)) {
              prop.computed = true;
              prop.key = this.parseMaybeAssign();
              this.expect(tt.bracketR);
              return prop.key;
            } else {
              prop.computed = false;
            }
          }
          return prop.key = this.type === tt.num || this.type === tt.string ? this.parseExprAtom() : this.parseIdent(true);
        };
  
        // Initialize empty function node.
  
        pp.initFunction = function(node) {
          node.id = null;
          if (this.options.ecmaVersion >= 6) {
            node.generator = false;
            node.expression = false;
          }
        };
  
        // Parse object or class method.
  
        pp.parseMethod = function(isGenerator) {
          var node = this.startNode();
          this.initFunction(node);
          this.expect(tt.parenL);
          node.params = this.parseBindingList(tt.parenR, false, false);
          var allowExpressionBody = undefined;
          if (this.options.ecmaVersion >= 6) {
            node.generator = isGenerator;
            allowExpressionBody = true;
          } else {
            allowExpressionBody = false;
          }
          this.parseFunctionBody(node, allowExpressionBody);
          return this.finishNode(node, "FunctionExpression");
        };
  
        // Parse arrow function expression with given parameters.
  
        pp.parseArrowExpression = function(node, params) {
          this.initFunction(node);
          node.params = this.toAssignableList(params, true);
          this.parseFunctionBody(node, true);
          return this.finishNode(node, "ArrowFunctionExpression");
        };
  
        // Parse function body and check parameters.
  
        pp.parseFunctionBody = function(node, allowExpression) {
          var isExpression = allowExpression && this.type !== tt.braceL;
  
          if (isExpression) {
            node.body = this.parseMaybeAssign();
            node.expression = true;
          } else {
            // Start a new scope with regard to labels and the `inFunction`
            // flag (restore them to their old value afterwards).
            var oldInFunc = this.inFunction,
              oldInGen = this.inGenerator,
              oldLabels = this.labels;
            this.inFunction = true;
            this.inGenerator = node.generator;
            this.labels = [];
            node.body = this.parseBlock(true);
            node.expression = false;
            this.inFunction = oldInFunc;
            this.inGenerator = oldInGen;
            this.labels = oldLabels;
          }
  
          // If this is a strict mode function, verify that argument names
          // are not repeated, and it does not try to bind the words `eval`
          // or `arguments`.
          if (this.strict || !isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) {
            var nameHash = {},
              oldStrict = this.strict;
            this.strict = true;
            if (node.id) this.checkLVal(node.id, true);
            for (var i = 0; i < node.params.length; i++) {
              this.checkLVal(node.params[i], true, nameHash);
            }
            this.strict = oldStrict;
          }
        };
  
        // Parses a comma-separated list of expressions, and returns them as
        // an array. `close` is the token type that ends the list, and
        // `allowEmpty` can be turned on to allow subsequent commas with
        // nothing in between them to be parsed as `null` (which is needed
        // for array literals).
  
        pp.parseExprList = function(close, allowTrailingComma, allowEmpty, refShorthandDefaultPos) {
          var elts = [],
            first = true;
          while (!this.eat(close)) {
            if (!first) {
              this.expect(tt.comma);
              if (allowTrailingComma && this.afterTrailingComma(close)) break;
            } else first = false;
  
            if (allowEmpty && this.type === tt.comma) {
              elts.push(null);
            } else {
              if (this.type === tt.ellipsis) elts.push(this.parseSpread(refShorthandDefaultPos));
              else elts.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
            }
          }
          return elts;
        };
  
        // Parse the next token as an identifier. If `liberal` is true (used
        // when parsing properties), it will also convert keywords into
        // identifiers.
  
        pp.parseIdent = function(liberal) {
          var node = this.startNode();
          if (liberal && this.options.allowReserved == "never") liberal = false;
          if (this.type === tt.name) {
            if (!liberal && (!this.options.allowReserved && this.isReservedWord(this.value) || this.strict && reservedWords.strict(this.value) && (this.options.ecmaVersion >= 6 || this.input.slice(this.start, this.end).indexOf("\\") == -1))) this.raise(this.start, "The keyword '" + this.value + "' is reserved");
            node.name = this.value;
          } else if (liberal && this.type.keyword) {
            node.name = this.type.keyword;
          } else {
            this.unexpected();
          }
          this.next();
          return this.finishNode(node, "Identifier");
        };
  
        // Parses yield expression inside generator.
  
        pp.parseYield = function() {
          var node = this.startNode();
          this.next();
          if (this.type == tt.semi || this.canInsertSemicolon() || this.type != tt.star && !this.type.startsExpr) {
            node.delegate = false;
            node.argument = null;
          } else {
            node.delegate = this.eat(tt.star);
            node.argument = this.parseMaybeAssign();
          }
          return this.finishNode(node, "YieldExpression");
        };
  
        // Parses array and generator comprehensions.
  
        pp.parseComprehension = function(node, isGenerator) {
          node.blocks = [];
          while (this.type === tt._for) {
            var block = this.startNode();
            this.next();
            this.expect(tt.parenL);
            block.left = this.parseBindingAtom();
            this.checkLVal(block.left, true);
            this.expectContextual("of");
            block.right = this.parseExpression();
            this.expect(tt.parenR);
            node.blocks.push(this.finishNode(block, "ComprehensionBlock"));
          }
          node.filter = this.eat(tt._if) ? this.parseParenExpression() : null;
          node.body = this.parseExpression();
          this.expect(isGenerator ? tt.parenR : tt.bracketR);
          node.generator = isGenerator;
          return this.finishNode(node, "ComprehensionExpression");
        };
  
      }, {
        "./identifier": 7,
        "./state": 13,
        "./tokentype": 17,
        "./util": 18
      }],
      7: [function(_dereq_, module, exports) {
  
  
        // Test whether a given character code starts an identifier.
  
        "use strict";
  
        exports.isIdentifierStart = isIdentifierStart;
  
        // Test whether a given character is part of an identifier.
  
        exports.isIdentifierChar = isIdentifierChar;
        exports.__esModule = true;
        // This is a trick taken from Esprima. It turns out that, on
        // non-Chrome browsers, to check whether a string is in a set, a
        // predicate containing a big ugly `switch` statement is faster than
        // a regular expression, and on Chrome the two are about on par.
        // This function uses `eval` (non-lexical) to produce such a
        // predicate from a space-separated string of words.
        //
        // It starts by sorting the words by length.
  
        // Removed to create an eval-free library
  
        // Reserved word lists for various dialects of the language
  
        var reservedWords = {
          3: function anonymous(str) {
            switch (str.length) {
              case 6:
                switch (str) {
                  case "double":
                  case "export":
                  case "import":
                  case "native":
                  case "public":
                  case "static":
                  case "throws":
                    return true
                }
                return false;
              case 4:
                switch (str) {
                  case "byte":
                  case "char":
                  case "enum":
                  case "goto":
                  case "long":
                    return true
                }
                return false;
              case 5:
                switch (str) {
                  case "class":
                  case "final":
                  case "float":
                  case "short":
                  case "super":
                    return true
                }
                return false;
              case 7:
                switch (str) {
                  case "boolean":
                  case "extends":
                  case "package":
                  case "private":
                    return true
                }
                return false;
              case 9:
                switch (str) {
                  case "interface":
                  case "protected":
                  case "transient":
                    return true
                }
                return false;
              case 8:
                switch (str) {
                  case "abstract":
                  case "volatile":
                    return true
                }
                return false;
              case 10:
                return str === "implements";
              case 3:
                return str === "int";
              case 12:
                return str === "synchronized";
            }
          },
          5: function anonymous(str) {
            switch (str.length) {
              case 5:
                switch (str) {
                  case "class":
                  case "super":
                  case "const":
                    return true
                }
                return false;
              case 6:
                switch (str) {
                  case "export":
                  case "import":
                    return true
                }
                return false;
              case 4:
                return str === "enum";
              case 7:
                return str === "extends";
            }
          },
          6: function anonymous(str) {
            switch (str) {
              case "enum":
              case "await":
                return true
            }
            return false;
          },
          strict: function anonymous(str) {
            switch (str.length) {
              case 9:
                switch (str) {
                  case "interface":
                  case "protected":
                    return true
                }
                return false;
              case 7:
                switch (str) {
                  case "package":
                  case "private":
                    return true
                }
                return false;
              case 6:
                switch (str) {
                  case "public":
                  case "static":
                    return true
                }
                return false;
              case 10:
                return str === "implements";
              case 3:
                return str === "let";
              case 5:
                return str === "yield";
            }
          },
          strictBind: function anonymous(str) {
            switch (str) {
              case "eval":
              case "arguments":
                return true
            }
            return false;
          }
        };
  
        exports.reservedWords = reservedWords;
        // And the keywords
  
        var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";
  
        var keywords = {
          5: function anonymous(str) {
            switch (str.length) {
              case 4:
                switch (str) {
                  case "case":
                  case "else":
                  case "with":
                  case "null":
                  case "true":
                  case "void":
                  case "this":
                    return true
                }
                return false;
              case 5:
                switch (str) {
                  case "break":
                  case "catch":
                  case "throw":
                  case "while":
                  case "false":
                    return true
                }
                return false;
              case 3:
                switch (str) {
                  case "for":
                  case "try":
                  case "var":
                  case "new":
                    return true
                }
                return false;
              case 6:
                switch (str) {
                  case "return":
                  case "switch":
                  case "typeof":
                  case "delete":
                    return true
                }
                return false;
              case 8:
                switch (str) {
                  case "continue":
                  case "debugger":
                  case "function":
                    return true
                }
                return false;
              case 2:
                switch (str) {
                  case "do":
                  case "if":
                  case "in":
                    return true
                }
                return false;
              case 7:
                switch (str) {
                  case "default":
                  case "finally":
                    return true
                }
                return false;
              case 10:
                return str === "instanceof";
            }
          },
          6: function anonymous(str) {
            switch (str.length) {
              case 5:
                switch (str) {
                  case "break":
                  case "catch":
                  case "throw":
                  case "while":
                  case "false":
                  case "const":
                  case "class":
                  case "yield":
                  case "super":
                    return true
                }
                return false;
              case 4:
                switch (str) {
                  case "case":
                  case "else":
                  case "with":
                  case "null":
                  case "true":
                  case "void":
                  case "this":
                    return true
                }
                return false;
              case 6:
                switch (str) {
                  case "return":
                  case "switch":
                  case "typeof":
                  case "delete":
                  case "export":
                  case "import":
                    return true
                }
                return false;
              case 3:
                switch (str) {
                  case "for":
                  case "try":
                  case "var":
                  case "new":
                  case "let":
                    return true
                }
                return false;
              case 8:
                switch (str) {
                  case "continue":
                  case "debugger":
                  case "function":
                    return true
                }
                return false;
              case 7:
                switch (str) {
                  case "default":
                  case "finally":
                  case "extends":
                    return true
                }
                return false;
              case 2:
                switch (str) {
                  case "do":
                  case "if":
                  case "in":
                    return true
                }
                return false;
              case 10:
                return str === "instanceof";
            }
          }
        };
  
        exports.keywords = keywords;
        // ## Character categories
  
        // Big ugly regular expressions that match characters in the
        // whitespace, identifier, and identifier-start categories. These
        // are only applied when a character is found to actually have a
        // code point above 128.
        // Generated by `tools/generate-identifier-regex.js`.
  
        var nonASCIIidentifierStartChars = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠ-ࢲऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘౙౠౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൠൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏼᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᧁ-ᧇᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿌ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞎꞐ-ꞭꞰꞱꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭟꭤꭥꯀ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ﬀ-ﬆﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
        var nonASCIIidentifierChars = "‌‍·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࣤ-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఃా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ഁ-ഃാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ංඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ູົຼ່-ໍ໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜔ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠐-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏ᦰ-ᧀᧈᧉ᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭ᳲ-᳴᳸᳹᷀-᷵᷼-᷿‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯꘠-꘩꙯ꙴ-꙽ꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧꢀꢁꢴ-꣄꣐-꣙꣠-꣱꤀-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︭︳︴﹍-﹏０-９＿";
  
        var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
        var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
  
        nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
  
        // These are a run-length and offset encoded representation of the
        // >0xffff code points that are a valid part of identifiers. The
        // offset starts at 0x10000, and each pair of numbers represents an
        // offset to the next range, and then a size of the range. They were
        // generated by tools/generate-identifier-regex.js
        var astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 17, 26, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 99, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 98, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 26, 45, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 955, 52, 76, 44, 33, 24, 27, 35, 42, 34, 4, 0, 13, 47, 15, 3, 22, 0, 38, 17, 2, 24, 133, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 32, 4, 287, 47, 21, 1, 2, 0, 185, 46, 82, 47, 21, 0, 60, 42, 502, 63, 32, 0, 449, 56, 1288, 920, 104, 110, 2962, 1070, 13266, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 881, 68, 12, 0, 67, 12, 16481, 1, 3071, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 4149, 196, 1340, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42710, 42, 4148, 12, 221, 16355, 541];
        var astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 1306, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 52, 0, 13, 2, 49, 13, 16, 9, 83, 11, 168, 11, 6, 9, 8, 2, 57, 0, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 316, 19, 13, 9, 214, 6, 3, 8, 112, 16, 16, 9, 82, 12, 9, 9, 535, 9, 20855, 9, 135, 4, 60, 6, 26, 9, 1016, 45, 17, 3, 19723, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 4305, 6, 792618, 239];
  
        // This has a complexity linear to the value of the code. The
        // assumption is that looking up astral identifier characters is
        // rare.
        function isInAstralSet(code, set) {
          var pos = 65536;
          for (var i = 0; i < set.length; i += 2) {
            pos += set[i];
            if (pos > code) {
              return false;
            }
            pos += set[i + 1];
            if (pos >= code) {
              return true;
            }
          }
        }
  
        function isIdentifierStart(code, astral) {
          if (code < 65) {
            return code === 36;
          }
          if (code < 91) {
            return true;
          }
          if (code < 97) {
            return code === 95;
          }
          if (code < 123) {
            return true;
          }
          if (code <= 65535) {
            return code >= 170 && nonASCIIidentifierStart.test(String.fromCharCode(code));
          }
          if (astral === false) {
            return false;
          }
          return isInAstralSet(code, astralIdentifierStartCodes);
        }
  
        function isIdentifierChar(code, astral) {
          if (code < 48) {
            return code === 36;
          }
          if (code < 58) {
            return true;
          }
          if (code < 65) {
            return false;
          }
          if (code < 91) {
            return true;
          }
          if (code < 97) {
            return code === 95;
          }
          if (code < 123) {
            return true;
          }
          if (code <= 65535) {
            return code >= 170 && nonASCIIidentifier.test(String.fromCharCode(code));
          }
          if (astral === false) {
            return false;
          }
          return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
        }
  
      }, {}],
      8: [function(_dereq_, module, exports) {
        "use strict";
  
        var _classCallCheck = function(instance, Constructor) {
          if (!(instance instanceof Constructor)) {
            throw new TypeError("Cannot call a class as a function");
          }
        };
  
        // The `getLineInfo` function is mostly useful when the
        // `locations` option is off (for performance reasons) and you
        // want to find the line/column position for a given character
        // offset. `input` should be the code string that the offset refers
        // into.
  
        exports.getLineInfo = getLineInfo;
        exports.__esModule = true;
  
        var Parser = _dereq_("./state").Parser;
  
        var lineBreakG = _dereq_("./whitespace").lineBreakG;
  
        var deprecate = _dereq_("util").deprecate;
  
        // These are used when `options.locations` is on, for the
        // `startLoc` and `endLoc` properties.
  
        var Position = exports.Position = (function() {
          function Position(line, col) {
            _classCallCheck(this, Position);
  
            this.line = line;
            this.column = col;
          }
  
          Position.prototype.offset = function offset(n) {
            return new Position(this.line, this.column + n);
          };
  
          return Position;
        })();
  
        var SourceLocation = exports.SourceLocation = function SourceLocation(p, start, end) {
          _classCallCheck(this, SourceLocation);
  
          this.start = start;
          this.end = end;
          if (p.sourceFile !== null) this.source = p.sourceFile;
        };
  
        function getLineInfo(input, offset) {
          for (var line = 1, cur = 0;;) {
            lineBreakG.lastIndex = cur;
            var match = lineBreakG.exec(input);
            if (match && match.index < offset) {
              ++line;
              cur = match.index + match[0].length;
            } else {
              return new Position(line, offset - cur);
            }
          }
        }
  
        var pp = Parser.prototype;
  
        // This function is used to raise exceptions on parse errors. It
        // takes an offset integer (into the current `input`) to indicate
        // the location of the error, attaches the position to the end
        // of the error message, and then raises a `SyntaxError` with that
        // message.
  
        pp.raise = function(pos, message) {
          var loc = getLineInfo(this.input, pos);
          message += " (" + loc.line + ":" + loc.column + ")";
          var err = new SyntaxError(message);
          err.pos = pos;
          err.loc = loc;
          err.raisedAt = this.pos;
          throw err;
        };
  
        pp.curPosition = function() {
          return new Position(this.curLine, this.pos - this.lineStart);
        };
  
        pp.markPosition = function() {
          return this.options.locations ? [this.start, this.startLoc] : this.start;
        };
  
      }, {
        "./state": 13,
        "./whitespace": 19,
        "util": 5
      }],
      9: [function(_dereq_, module, exports) {
        "use strict";
  
        var tt = _dereq_("./tokentype").types;
  
        var Parser = _dereq_("./state").Parser;
  
        var reservedWords = _dereq_("./identifier").reservedWords;
  
        var has = _dereq_("./util").has;
  
        var pp = Parser.prototype;
  
        // Convert existing expression atom to assignable pattern
        // if possible.
  
        pp.toAssignable = function(node, isBinding) {
          if (this.options.ecmaVersion >= 6 && node) {
            switch (node.type) {
              case "Identifier":
              case "ObjectPattern":
              case "ArrayPattern":
              case "AssignmentPattern":
                break;
  
              case "ObjectExpression":
                node.type = "ObjectPattern";
                for (var i = 0; i < node.properties.length; i++) {
                  var prop = node.properties[i];
                  if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter");
                  this.toAssignable(prop.value, isBinding);
                }
                break;
  
              case "ArrayExpression":
                node.type = "ArrayPattern";
                this.toAssignableList(node.elements, isBinding);
                break;
  
              case "AssignmentExpression":
                if (node.operator === "=") {
                  node.type = "AssignmentPattern";
                } else {
                  this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
                }
                break;
  
              case "ParenthesizedExpression":
                node.expression = this.toAssignable(node.expression, isBinding);
                break;
  
              case "MemberExpression":
                if (!isBinding) break;
  
              default:
                this.raise(node.start, "Assigning to rvalue");
            }
          }
          return node;
        };
  
        // Convert list of expression atoms to binding list.
  
        pp.toAssignableList = function(exprList, isBinding) {
          var end = exprList.length;
          if (end) {
            var last = exprList[end - 1];
            if (last && last.type == "RestElement") {
              --end;
            } else if (last && last.type == "SpreadElement") {
              last.type = "RestElement";
              var arg = last.argument;
              this.toAssignable(arg, isBinding);
              if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern") this.unexpected(arg.start);
              --end;
            }
          }
          for (var i = 0; i < end; i++) {
            var elt = exprList[i];
            if (elt) this.toAssignable(elt, isBinding);
          }
          return exprList;
        };
  
        // Parses spread element.
  
        pp.parseSpread = function(refShorthandDefaultPos) {
          var node = this.startNode();
          this.next();
          node.argument = this.parseMaybeAssign(refShorthandDefaultPos);
          return this.finishNode(node, "SpreadElement");
        };
  
        pp.parseRest = function() {
          var node = this.startNode();
          this.next();
          node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected();
          return this.finishNode(node, "RestElement");
        };
  
        // Parses lvalue (assignable) atom.
  
        pp.parseBindingAtom = function() {
          if (this.options.ecmaVersion < 6) return this.parseIdent();
          switch (this.type) {
            case tt.name:
              return this.parseIdent();
  
            case tt.bracketL:
              var node = this.startNode();
              this.next();
              node.elements = this.parseBindingList(tt.bracketR, true, true);
              return this.finishNode(node, "ArrayPattern");
  
            case tt.braceL:
              return this.parseObj(true);
  
            default:
              this.unexpected();
          }
        };
  
        pp.parseBindingList = function(close, allowEmpty, allowTrailingComma) {
          var elts = [],
            first = true;
          while (!this.eat(close)) {
            if (first) first = false;
            else this.expect(tt.comma);
            if (allowEmpty && this.type === tt.comma) {
              elts.push(null);
            } else if (allowTrailingComma && this.afterTrailingComma(close)) {
              break;
            } else if (this.type === tt.ellipsis) {
              var rest = this.parseRest();
              this.parseBindingListItem(rest);
              elts.push(rest);
              this.expect(close);
              break;
            } else {
              var elem = this.parseMaybeDefault(this.start, this.startLoc);
              this.parseBindingListItem(elem);
              elts.push(elem);
            }
          }
          return elts;
        };
  
        pp.parseBindingListItem = function(param) {
          return param;
        };
  
        // Parses assignment pattern around given atom if possible.
  
        pp.parseMaybeDefault = function(startPos, startLoc, left) {
          if (Array.isArray(startPos)) {
            if (this.options.locations && noCalls === undefined) {
              // shift arguments to left by one
              left = startLoc;
              // flatten startPos
              startLoc = startPos[1];
              startPos = startPos[0];
            }
          }
          left = left || this.parseBindingAtom();
          if (!this.eat(tt.eq)) return left;
          var node = this.startNodeAt(startPos, startLoc);
          node.operator = "=";
          node.left = left;
          node.right = this.parseMaybeAssign();
          return this.finishNode(node, "AssignmentPattern");
        };
  
        // Verify that a node is an lval — something that can be assigned
        // to.
  
        pp.checkLVal = function(expr, isBinding, checkClashes) {
          switch (expr.type) {
            case "Identifier":
              if (this.strict && (reservedWords.strictBind(expr.name) || reservedWords.strict(expr.name))) this.raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
              if (checkClashes) {
                if (has(checkClashes, expr.name)) this.raise(expr.start, "Argument name clash in strict mode");
                checkClashes[expr.name] = true;
              }
              break;
  
            case "MemberExpression":
              if (isBinding) this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression");
              break;
  
            case "ObjectPattern":
              for (var i = 0; i < expr.properties.length; i++) {
                this.checkLVal(expr.properties[i].value, isBinding, checkClashes);
              }
              break;
  
            case "ArrayPattern":
              for (var i = 0; i < expr.elements.length; i++) {
                var elem = expr.elements[i];
                if (elem) this.checkLVal(elem, isBinding, checkClashes);
              }
              break;
  
            case "AssignmentPattern":
              this.checkLVal(expr.left, isBinding, checkClashes);
              break;
  
            case "RestElement":
              this.checkLVal(expr.argument, isBinding, checkClashes);
              break;
  
            case "ParenthesizedExpression":
              this.checkLVal(expr.expression, isBinding, checkClashes);
              break;
  
            default:
              this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " rvalue");
          }
        };
  
      }, {
        "./identifier": 7,
        "./state": 13,
        "./tokentype": 17,
        "./util": 18
      }],
      10: [function(_dereq_, module, exports) {
        "use strict";
  
        var _classCallCheck = function(instance, Constructor) {
          if (!(instance instanceof Constructor)) {
            throw new TypeError("Cannot call a class as a function");
          }
        };
  
        exports.__esModule = true;
  
        var Parser = _dereq_("./state").Parser;
  
        var SourceLocation = _dereq_("./location").SourceLocation;
  
        // Start an AST node, attaching a start offset.
  
        var pp = Parser.prototype;
  
        var Node = exports.Node = function Node() {
          _classCallCheck(this, Node);
        };
  
        pp.startNode = function() {
          var node = new Node();
          node.start = this.start;
          if (this.options.locations) node.loc = new SourceLocation(this, this.startLoc);
          if (this.options.directSourceFile) node.sourceFile = this.options.directSourceFile;
          if (this.options.ranges) node.range = [this.start, 0];
          return node;
        };
  
        pp.startNodeAt = function(pos, loc) {
          var node = new Node();
          if (Array.isArray(pos)) {
            if (this.options.locations && loc === undefined) {
              // flatten pos
              loc = pos[1];
              pos = pos[0];
            }
          }
          node.start = pos;
          if (this.options.locations) node.loc = new SourceLocation(this, loc);
          if (this.options.directSourceFile) node.sourceFile = this.options.directSourceFile;
          if (this.options.ranges) node.range = [pos, 0];
          return node;
        };
  
        // Finish an AST node, adding `type` and `end` properties.
  
        pp.finishNode = function(node, type) {
          node.type = type;
          node.end = this.lastTokEnd;
          if (this.options.locations) node.loc.end = this.lastTokEndLoc;
          if (this.options.ranges) node.range[1] = this.lastTokEnd;
          return node;
        };
  
        // Finish node at given position
  
        pp.finishNodeAt = function(node, type, pos, loc) {
          node.type = type;
          if (Array.isArray(pos)) {
            if (this.options.locations && loc === undefined) {
              // flatten pos
              loc = pos[1];
              pos = pos[0];
            }
          }
          node.end = pos;
          if (this.options.locations) node.loc.end = loc;
          if (this.options.ranges) node.range[1] = pos;
          return node;
        };
  
      }, {
        "./location": 8,
        "./state": 13
      }],
      11: [function(_dereq_, module, exports) {
  
  
        // Interpret and default an options object
  
        "use strict";
  
        exports.getOptions = getOptions;
        exports.__esModule = true;
  
        var _util = _dereq_("./util");
  
        var has = _util.has;
        var isArray = _util.isArray;
  
        var SourceLocation = _dereq_("./location").SourceLocation;
  
        // A second optional argument can be given to further configure
        // the parser process. These options are recognized:
  
        var defaultOptions = {
          // `ecmaVersion` indicates the ECMAScript version to parse. Must
          // be either 3, or 5, or 6. This influences support for strict
          // mode, the set of reserved words, support for getters and
          // setters and other features.
          ecmaVersion: 5,
          // Source type ("script" or "module") for different semantics
          sourceType: "script",
          // `onInsertedSemicolon` can be a callback that will be called
          // when a semicolon is automatically inserted. It will be passed
          // th position of the comma as an offset, and if `locations` is
          // enabled, it is given the location as a `{line, column}` object
          // as second argument.
          onInsertedSemicolon: null,
          // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
          // trailing commas.
          onTrailingComma: null,
          // By default, reserved words are not enforced. Disable
          // `allowReserved` to enforce them. When this option has the
          // value "never", reserved words and keywords can also not be
          // used as property names.
          allowReserved: true,
          // When enabled, a return at the top level is not considered an
          // error.
          allowReturnOutsideFunction: false,
          // When enabled, import/export statements are not constrained to
          // appearing at the top of the program.
          allowImportExportEverywhere: false,
          // When enabled, hashbang directive in the beginning of file
          // is allowed and treated as a line comment.
          allowHashBang: false,
          // When `locations` is on, `loc` properties holding objects with
          // `start` and `end` properties in `{line, column}` form (with
          // line being 1-based and column 0-based) will be attached to the
          // nodes.
          locations: false,
          // A function can be passed as `onToken` option, which will
          // cause Acorn to call that function with object in the same
          // format as tokenize() returns. Note that you are not
          // allowed to call the parser from the callback—that will
          // corrupt its internal state.
          onToken: null,
          // A function can be passed as `onComment` option, which will
          // cause Acorn to call that function with `(block, text, start,
          // end)` parameters whenever a comment is skipped. `block` is a
          // boolean indicating whether this is a block (`/* */`) comment,
          // `text` is the content of the comment, and `start` and `end` are
          // character offsets that denote the start and end of the comment.
          // When the `locations` option is on, two more parameters are
          // passed, the full `{line, column}` locations of the start and
          // end of the comments. Note that you are not allowed to call the
          // parser from the callback—that will corrupt its internal state.
          onComment: null,
          // Nodes have their start and end characters offsets recorded in
          // `start` and `end` properties (directly on the node, rather than
          // the `loc` object, which holds line/column data. To also add a
          // [semi-standardized][range] `range` property holding a `[start,
          // end]` array with the same numbers, set the `ranges` option to
          // `true`.
          //
          // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
          ranges: false,
          // It is possible to parse multiple files into a single AST by
          // passing the tree produced by parsing the first file as
          // `program` option in subsequent parses. This will add the
          // toplevel forms of the parsed file to the `Program` (top) node
          // of an existing parse tree.
          program: null,
          // When `locations` is on, you can pass this to record the source
          // file in every node's `loc` object.
          sourceFile: null,
          // This value, if given, is stored in every node, whether
          // `locations` is on or off.
          directSourceFile: null,
          // When enabled, parenthesized expressions are represented by
          // (non-standard) ParenthesizedExpression nodes
          preserveParens: false,
          plugins: {}
        };
        exports.defaultOptions = defaultOptions;
  
        function getOptions(opts) {
          var options = {};
          for (var opt in defaultOptions) {
            options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt];
          }
          if (isArray(options.onToken)) {
            (function() {
              var tokens = options.onToken;
              options.onToken = function(token) {
                return tokens.push(token);
              };
            })();
          }
          if (isArray(options.onComment)) options.onComment = pushComment(options, options.onComment);
  
          return options;
        }
  
        function pushComment(options, array) {
          return function(block, text, start, end, startLoc, endLoc) {
            var comment = {
              type: block ? "Block" : "Line",
              value: text,
              start: start,
              end: end
            };
            if (options.locations) comment.loc = new SourceLocation(this, startLoc, endLoc);
            if (options.ranges) comment.range = [start, end];
            array.push(comment);
          };
        }
  
      }, {
        "./location": 8,
        "./util": 18
      }],
      12: [function(_dereq_, module, exports) {
        "use strict";
  
        var tt = _dereq_("./tokentype").types;
  
        var Parser = _dereq_("./state").Parser;
  
        var lineBreak = _dereq_("./whitespace").lineBreak;
  
        var pp = Parser.prototype;
  
        // ## Parser utilities
  
        // Test whether a statement node is the string literal `"use strict"`.
  
        pp.isUseStrict = function(stmt) {
          return this.options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
        };
  
        // Predicate that tests whether the next token is of the given
        // type, and if yes, consumes it as a side effect.
  
        pp.eat = function(type) {
          if (this.type === type) {
            this.next();
            return true;
          } else {
            return false;
          }
        };
  
        // Tests whether parsed token is a contextual keyword.
  
        pp.isContextual = function(name) {
          return this.type === tt.name && this.value === name;
        };
  
        // Consumes contextual keyword if possible.
  
        pp.eatContextual = function(name) {
          return this.value === name && this.eat(tt.name);
        };
  
        // Asserts that following token is given contextual keyword.
  
        pp.expectContextual = function(name) {
          if (!this.eatContextual(name)) this.unexpected();
        };
  
        // Test whether a semicolon can be inserted at the current position.
  
        pp.canInsertSemicolon = function() {
          return this.type === tt.eof || this.type === tt.braceR || lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
        };
  
        pp.insertSemicolon = function() {
          if (this.canInsertSemicolon()) {
            if (this.options.onInsertedSemicolon) this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc);
            return true;
          }
        };
  
        // Consume a semicolon, or, failing that, see if we are allowed to
        // pretend that there is a semicolon at this position.
  
        pp.semicolon = function() {
          if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected();
        };
  
        pp.afterTrailingComma = function(tokType) {
          if (this.type == tokType) {
            if (this.options.onTrailingComma) this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
            this.next();
            return true;
          }
        };
  
        // Expect a token of a given type. If found, consume it, otherwise,
        // raise an unexpected token error.
  
        pp.expect = function(type) {
          this.eat(type) || this.unexpected();
        };
  
        // Raise an unexpected token error.
  
        pp.unexpected = function(pos) {
          this.raise(pos != null ? pos : this.start, "Unexpected token");
        };
  
      }, {
        "./state": 13,
        "./tokentype": 17,
        "./whitespace": 19
      }],
      13: [function(_dereq_, module, exports) {
        "use strict";
  
        exports.Parser = Parser;
        exports.__esModule = true;
  
        var _identifier = _dereq_("./identifier");
  
        var reservedWords = _identifier.reservedWords;
        var keywords = _identifier.keywords;
  
        var tt = _dereq_("./tokentype").types;
  
        var lineBreak = _dereq_("./whitespace").lineBreak;
  
        function Parser(options, input, startPos) {
          this.options = options;
          this.sourceFile = this.options.sourceFile || null;
          this.isKeyword = keywords[this.options.ecmaVersion >= 6 ? 6 : 5];
          this.isReservedWord = reservedWords[this.options.ecmaVersion];
          this.input = input;
  
          // Load plugins
          this.loadPlugins(this.options.plugins);
  
          // Set up token state
  
          // The current position of the tokenizer in the input.
          if (startPos) {
            this.pos = startPos;
            this.lineStart = Math.max(0, this.input.lastIndexOf("\n", startPos));
            this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
          } else {
            this.pos = this.lineStart = 0;
            this.curLine = 1;
          }
  
          // Properties of the current token:
          // Its type
          this.type = tt.eof;
          // For tokens that include more information than their type, the value
          this.value = null;
          // Its start and end offset
          this.start = this.end = this.pos;
          // And, if locations are used, the {line, column} object
          // corresponding to those offsets
          this.startLoc = this.endLoc = null;
  
          // Position information for the previous token
          this.lastTokEndLoc = this.lastTokStartLoc = null;
          this.lastTokStart = this.lastTokEnd = this.pos;
  
          // The context stack is used to superficially track syntactic
          // context to predict whether a regular expression is allowed in a
          // given position.
          this.context = this.initialContext();
          this.exprAllowed = true;
  
          // Figure out if it's a module code.
          this.strict = this.inModule = this.options.sourceType === "module";
  
          // Used to signify the start of a potential arrow function
          this.potentialArrowAt = -1;
  
          // Flags to track whether we are in a function, a generator.
          this.inFunction = this.inGenerator = false;
          // Labels in scope.
          this.labels = [];
  
          // If enabled, skip leading hashbang line.
          if (this.pos === 0 && this.options.allowHashBang && this.input.slice(0, 2) === "#!") this.skipLineComment(2);
        }
  
        Parser.prototype.extend = function(name, f) {
          this[name] = f(this[name]);
        };
  
        // Registered plugins
  
        var plugins = {};
  
        exports.plugins = plugins;
        Parser.prototype.loadPlugins = function(plugins) {
          for (var _name in plugins) {
            var plugin = exports.plugins[_name];
            if (!plugin) throw new Error("Plugin '" + _name + "' not found");
            plugin(this, plugins[_name]);
          }
        };
  
      }, {
        "./identifier": 7,
        "./tokentype": 17,
        "./whitespace": 19
      }],
      14: [function(_dereq_, module, exports) {
        "use strict";
  
        var tt = _dereq_("./tokentype").types;
  
        var Parser = _dereq_("./state").Parser;
  
        var lineBreak = _dereq_("./whitespace").lineBreak;
  
        var pp = Parser.prototype;
  
        // ### Statement parsing
  
        // Parse a program. Initializes the parser, reads any number of
        // statements, and wraps them in a Program node.  Optionally takes a
        // `program` argument.  If present, the statements will be appended
        // to its body instead of creating a new node.
  
        pp.parseTopLevel = function(node) {
          var first = true;
          if (!node.body) node.body = [];
          while (this.type !== tt.eof) {
            var stmt = this.parseStatement(true, true);
            node.body.push(stmt);
            if (first && this.isUseStrict(stmt)) this.setStrict(true);
            first = false;
          }
          this.next();
          if (this.options.ecmaVersion >= 6) {
            node.sourceType = this.options.sourceType;
          }
          return this.finishNode(node, "Program");
        };
  
        var loopLabel = {
            kind: "loop"
          },
          switchLabel = {
            kind: "switch"
          };
  
        // Parse a single statement.
        //
        // If expecting a statement and finding a slash operator, parse a
        // regular expression literal. This is to handle cases like
        // `if (foo) /blah/.exec(foo)`, where looking at the previous token
        // does not help.
  
        pp.parseStatement = function(declaration, topLevel) {
          var starttype = this.type,
            node = this.startNode();
  
          // Most types of statements are recognized by the keyword they
          // start with. Many are trivial to parse, some require a bit of
          // complexity.
  
          switch (starttype) {
            case tt._break:
            case tt._continue:
              return this.parseBreakContinueStatement(node, starttype.keyword);
            case tt._debugger:
              return this.parseDebuggerStatement(node);
            case tt._do:
              return this.parseDoStatement(node);
            case tt._for:
              return this.parseForStatement(node);
            case tt._function:
              if (!declaration && this.options.ecmaVersion >= 6) this.unexpected();
              return this.parseFunctionStatement(node);
            case tt._class:
              if (!declaration) this.unexpected();
              return this.parseClass(node, true);
            case tt._if:
              return this.parseIfStatement(node);
            case tt._return:
              return this.parseReturnStatement(node);
            case tt._switch:
              return this.parseSwitchStatement(node);
            case tt._throw:
              return this.parseThrowStatement(node);
            case tt._try:
              return this.parseTryStatement(node);
            case tt._let:
            case tt._const:
              if (!declaration) this.unexpected(); // NOTE: falls through to _var
            case tt._var:
              return this.parseVarStatement(node, starttype);
            case tt._while:
              return this.parseWhileStatement(node);
            case tt._with:
              return this.parseWithStatement(node);
            case tt.braceL:
              return this.parseBlock();
            case tt.semi:
              return this.parseEmptyStatement(node);
            case tt._export:
            case tt._import:
              if (!this.options.allowImportExportEverywhere) {
                if (!topLevel) this.raise(this.start, "'import' and 'export' may only appear at the top level");
                if (!this.inModule) this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
              }
              return starttype === tt._import ? this.parseImport(node) : this.parseExport(node);
  
              // If the statement does not start with a statement keyword or a
              // brace, it's an ExpressionStatement or LabeledStatement. We
              // simply start parsing an expression, and afterwards, if the
              // next token is a colon and the expression was a simple
              // Identifier node, we switch to interpreting it as a label.
            default:
              var maybeName = this.value,
                expr = this.parseExpression();
              if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon)) return this.parseLabeledStatement(node, maybeName, expr);
              else return this.parseExpressionStatement(node, expr);
          }
        };
  
        pp.parseBreakContinueStatement = function(node, keyword) {
          var isBreak = keyword == "break";
          this.next();
          if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null;
          else if (this.type !== tt.name) this.unexpected();
          else {
            node.label = this.parseIdent();
            this.semicolon();
          }
  
          // Verify that there is an actual destination to break or
          // continue to.
          for (var i = 0; i < this.labels.length; ++i) {
            var lab = this.labels[i];
            if (node.label == null || lab.name === node.label.name) {
              if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
              if (node.label && isBreak) break;
            }
          }
          if (i === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword);
          return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
        };
  
        pp.parseDebuggerStatement = function(node) {
          this.next();
          this.semicolon();
          return this.finishNode(node, "DebuggerStatement");
        };
  
        pp.parseDoStatement = function(node) {
          this.next();
          this.labels.push(loopLabel);
          node.body = this.parseStatement(false);
          this.labels.pop();
          this.expect(tt._while);
          node.test = this.parseParenExpression();
          if (this.options.ecmaVersion >= 6) this.eat(tt.semi);
          else this.semicolon();
          return this.finishNode(node, "DoWhileStatement");
        };
  
        // Disambiguating between a `for` and a `for`/`in` or `for`/`of`
        // loop is non-trivial. Basically, we have to parse the init `var`
        // statement or expression, disallowing the `in` operator (see
        // the second parameter to `parseExpression`), and then check
        // whether the next token is `in` or `of`. When there is no init
        // part (semicolon immediately after the opening parenthesis), it
        // is a regular `for` loop.
  
        pp.parseForStatement = function(node) {
          this.next();
          this.labels.push(loopLabel);
          this.expect(tt.parenL);
          if (this.type === tt.semi) return this.parseFor(node, null);
          if (this.type === tt._var || this.type === tt._let || this.type === tt._const) {
            var _init = this.startNode(),
              varKind = this.type;
            this.next();
            this.parseVar(_init, true, varKind);
            this.finishNode(_init, "VariableDeclaration");
            if ((this.type === tt._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) && _init.declarations.length === 1 && !(varKind !== tt._var && _init.declarations[0].init)) return this.parseForIn(node, _init);
            return this.parseFor(node, _init);
          }
          var refShorthandDefaultPos = {
            start: 0
          };
          var init = this.parseExpression(true, refShorthandDefaultPos);
          if (this.type === tt._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) {
            this.toAssignable(init);
            this.checkLVal(init);
            return this.parseForIn(node, init);
          } else if (refShorthandDefaultPos.start) {
            this.unexpected(refShorthandDefaultPos.start);
          }
          return this.parseFor(node, init);
        };
  
        pp.parseFunctionStatement = function(node) {
          this.next();
          return this.parseFunction(node, true);
        };
  
        pp.parseIfStatement = function(node) {
          this.next();
          node.test = this.parseParenExpression();
          node.consequent = this.parseStatement(false);
          node.alternate = this.eat(tt._else) ? this.parseStatement(false) : null;
          return this.finishNode(node, "IfStatement");
        };
  
        pp.parseReturnStatement = function(node) {
          if (!this.inFunction && !this.options.allowReturnOutsideFunction) this.raise(this.start, "'return' outside of function");
          this.next();
  
          // In `return` (and `break`/`continue`), the keywords with
          // optional arguments, we eagerly look for a semicolon or the
          // possibility to insert one.
  
          if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null;
          else {
            node.argument = this.parseExpression();
            this.semicolon();
          }
          return this.finishNode(node, "ReturnStatement");
        };
  
        pp.parseSwitchStatement = function(node) {
          this.next();
          node.discriminant = this.parseParenExpression();
          node.cases = [];
          this.expect(tt.braceL);
          this.labels.push(switchLabel);
  
          // Statements under must be grouped (by label) in SwitchCase
          // nodes. `cur` is used to keep the node that we are currently
          // adding statements to.
  
          for (var cur, sawDefault; this.type != tt.braceR;) {
            if (this.type === tt._case || this.type === tt._default) {
              var isCase = this.type === tt._case;
              if (cur) this.finishNode(cur, "SwitchCase");
              node.cases.push(cur = this.startNode());
              cur.consequent = [];
              this.next();
              if (isCase) {
                cur.test = this.parseExpression();
              } else {
                if (sawDefault) this.raise(this.lastTokStart, "Multiple default clauses");
                sawDefault = true;
                cur.test = null;
              }
              this.expect(tt.colon);
            } else {
              if (!cur) this.unexpected();
              cur.consequent.push(this.parseStatement(true));
            }
          }
          if (cur) this.finishNode(cur, "SwitchCase");
          this.next(); // Closing brace
          this.labels.pop();
          return this.finishNode(node, "SwitchStatement");
        };
  
        pp.parseThrowStatement = function(node) {
          this.next();
          if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) this.raise(this.lastTokEnd, "Illegal newline after throw");
          node.argument = this.parseExpression();
          this.semicolon();
          return this.finishNode(node, "ThrowStatement");
        };
  
        // Reused empty array added for node fields that are always empty.
  
        var empty = [];
  
        pp.parseTryStatement = function(node) {
          this.next();
          node.block = this.parseBlock();
          node.handler = null;
          if (this.type === tt._catch) {
            var clause = this.startNode();
            this.next();
            this.expect(tt.parenL);
            clause.param = this.parseBindingAtom();
            this.checkLVal(clause.param, true);
            this.expect(tt.parenR);
            clause.guard = null;
            clause.body = this.parseBlock();
            node.handler = this.finishNode(clause, "CatchClause");
          }
          node.guardedHandlers = empty;
          node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;
          if (!node.handler && !node.finalizer) this.raise(node.start, "Missing catch or finally clause");
          return this.finishNode(node, "TryStatement");
        };
  
        pp.parseVarStatement = function(node, kind) {
          this.next();
          this.parseVar(node, false, kind);
          this.semicolon();
          return this.finishNode(node, "VariableDeclaration");
        };
  
        pp.parseWhileStatement = function(node) {
          this.next();
          node.test = this.parseParenExpression();
          this.labels.push(loopLabel);
          node.body = this.parseStatement(false);
          this.labels.pop();
          return this.finishNode(node, "WhileStatement");
        };
  
        pp.parseWithStatement = function(node) {
          if (this.strict) this.raise(this.start, "'with' in strict mode");
          this.next();
          node.object = this.parseParenExpression();
          node.body = this.parseStatement(false);
          return this.finishNode(node, "WithStatement");
        };
  
        pp.parseEmptyStatement = function(node) {
          this.next();
          return this.finishNode(node, "EmptyStatement");
        };
  
        pp.parseLabeledStatement = function(node, maybeName, expr) {
          for (var i = 0; i < this.labels.length; ++i) {
            if (this.labels[i].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared");
          }
          var kind = this.type.isLoop ? "loop" : this.type === tt._switch ? "switch" : null;
          this.labels.push({
            name: maybeName,
            kind: kind
          });
          node.body = this.parseStatement(true);
          this.labels.pop();
          node.label = expr;
          return this.finishNode(node, "LabeledStatement");
        };
  
        pp.parseExpressionStatement = function(node, expr) {
          node.expression = expr;
          this.semicolon();
          return this.finishNode(node, "ExpressionStatement");
        };
  
        // Parse a semicolon-enclosed block of statements, handling `"use
        // strict"` declarations when `allowStrict` is true (used for
        // function bodies).
  
        pp.parseBlock = function(allowStrict) {
          var node = this.startNode(),
            first = true,
            oldStrict = undefined;
          node.body = [];
          this.expect(tt.braceL);
          while (!this.eat(tt.braceR)) {
            var stmt = this.parseStatement(true);
            node.body.push(stmt);
            if (first && allowStrict && this.isUseStrict(stmt)) {
              oldStrict = this.strict;
              this.setStrict(this.strict = true);
            }
            first = false;
          }
          if (oldStrict === false) this.setStrict(false);
          return this.finishNode(node, "BlockStatement");
        };
  
        // Parse a regular `for` loop. The disambiguation code in
        // `parseStatement` will already have parsed the init statement or
        // expression.
  
        pp.parseFor = function(node, init) {
          node.init = init;
          this.expect(tt.semi);
          node.test = this.type === tt.semi ? null : this.parseExpression();
          this.expect(tt.semi);
          node.update = this.type === tt.parenR ? null : this.parseExpression();
          this.expect(tt.parenR);
          node.body = this.parseStatement(false);
          this.labels.pop();
          return this.finishNode(node, "ForStatement");
        };
  
        // Parse a `for`/`in` and `for`/`of` loop, which are almost
        // same from parser's perspective.
  
        pp.parseForIn = function(node, init) {
          var type = this.type === tt._in ? "ForInStatement" : "ForOfStatement";
          this.next();
          node.left = init;
          node.right = this.parseExpression();
          this.expect(tt.parenR);
          node.body = this.parseStatement(false);
          this.labels.pop();
          return this.finishNode(node, type);
        };
  
        // Parse a list of variable declarations.
  
        pp.parseVar = function(node, isFor, kind) {
          node.declarations = [];
          node.kind = kind.keyword;
          for (;;) {
            var decl = this.startNode();
            this.parseVarId(decl);
            if (this.eat(tt.eq)) {
              decl.init = this.parseMaybeAssign(isFor);
            } else if (kind === tt._const && !(this.type === tt._in || this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
              this.unexpected();
            } else if (decl.id.type != "Identifier" && !(isFor && (this.type === tt._in || this.isContextual("of")))) {
              this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value");
            } else {
              decl.init = null;
            }
            node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
            if (!this.eat(tt.comma)) break;
          }
          return node;
        };
  
        pp.parseVarId = function(decl) {
          decl.id = this.parseBindingAtom();
          this.checkLVal(decl.id, true);
        };
  
        // Parse a function declaration or literal (depending on the
        // `isStatement` parameter).
  
        pp.parseFunction = function(node, isStatement, allowExpressionBody) {
          this.initFunction(node);
          if (this.options.ecmaVersion >= 6) node.generator = this.eat(tt.star);
          if (isStatement || this.type === tt.name) node.id = this.parseIdent();
          this.parseFunctionParams(node);
          this.parseFunctionBody(node, allowExpressionBody);
          return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
        };
  
        pp.parseFunctionParams = function(node) {
          this.expect(tt.parenL);
          node.params = this.parseBindingList(tt.parenR, false, false);
        };
  
        // Parse a class declaration or literal (depending on the
        // `isStatement` parameter).
  
        pp.parseClass = function(node, isStatement) {
          this.next();
          this.parseClassId(node, isStatement);
          this.parseClassSuper(node);
          var classBody = this.startNode();
          var hadConstructor = false;
          classBody.body = [];
          this.expect(tt.braceL);
          while (!this.eat(tt.braceR)) {
            if (this.eat(tt.semi)) continue;
            var method = this.startNode();
            var isGenerator = this.eat(tt.star);
            var isMaybeStatic = this.type === tt.name && this.value === "static";
            this.parsePropertyName(method);
            method["static"] = isMaybeStatic && this.type !== tt.parenL;
            if (method["static"]) {
              if (isGenerator) this.unexpected();
              isGenerator = this.eat(tt.star);
              this.parsePropertyName(method);
            }
            method.kind = "method";
            if (!method.computed) {
              var key = method.key;
  
              var isGetSet = false;
              if (!isGenerator && key.type === "Identifier" && this.type !== tt.parenL && (key.name === "get" || key.name === "set")) {
                isGetSet = true;
                method.kind = key.name;
                key = this.parsePropertyName(method);
              }
              if (!method["static"] && (key.type === "Identifier" && key.name === "constructor" || key.type === "Literal" && key.value === "constructor")) {
                if (hadConstructor) this.raise(key.start, "Duplicate constructor in the same class");
                if (isGetSet) this.raise(key.start, "Constructor can't have get/set modifier");
                if (isGenerator) this.raise(key.start, "Constructor can't be a generator");
                method.kind = "constructor";
                hadConstructor = true;
              }
            }
            this.parseClassMethod(classBody, method, isGenerator);
          }
          node.body = this.finishNode(classBody, "ClassBody");
          return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
        };
  
        pp.parseClassMethod = function(classBody, method, isGenerator) {
          method.value = this.parseMethod(isGenerator);
          classBody.body.push(this.finishNode(method, "MethodDefinition"));
        };
  
        pp.parseClassId = function(node, isStatement) {
          node.id = this.type === tt.name ? this.parseIdent() : isStatement ? this.unexpected() : null;
        };
  
        pp.parseClassSuper = function(node) {
          node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null;
        };
  
        // Parses module export declaration.
  
        pp.parseExport = function(node) {
          this.next();
          // export * from '...'
          if (this.eat(tt.star)) {
            this.expectContextual("from");
            node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
            this.semicolon();
            return this.finishNode(node, "ExportAllDeclaration");
          }
          if (this.eat(tt._default)) {
            // export default ...
            var expr = this.parseMaybeAssign();
            var needsSemi = true;
            if (expr.type == "FunctionExpression" || expr.type == "ClassExpression") {
              needsSemi = false;
              if (expr.id) {
                expr.type = expr.type == "FunctionExpression" ? "FunctionDeclaration" : "ClassDeclaration";
              }
            }
            node.declaration = expr;
            if (needsSemi) this.semicolon();
            return this.finishNode(node, "ExportDefaultDeclaration");
          }
          // export var|const|let|function|class ...
          if (this.shouldParseExportStatement()) {
            node.declaration = this.parseStatement(true);
            node.specifiers = [];
            node.source = null;
          } else {
            // export { x, y as z } [from '...']
            node.declaration = null;
            node.specifiers = this.parseExportSpecifiers();
            if (this.eatContextual("from")) {
              node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
            } else {
              node.source = null;
            }
            this.semicolon();
          }
          return this.finishNode(node, "ExportNamedDeclaration");
        };
  
        pp.shouldParseExportStatement = function() {
          return this.type.keyword;
        };
  
        // Parses a comma-separated list of module exports.
  
        pp.parseExportSpecifiers = function() {
          var nodes = [],
            first = true;
          // export { x, y as z } [from '...']
          this.expect(tt.braceL);
          while (!this.eat(tt.braceR)) {
            if (!first) {
              this.expect(tt.comma);
              if (this.afterTrailingComma(tt.braceR)) break;
            } else first = false;
  
            var node = this.startNode();
            node.local = this.parseIdent(this.type === tt._default);
            node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local;
            nodes.push(this.finishNode(node, "ExportSpecifier"));
          }
          return nodes;
        };
  
        // Parses import declaration.
  
        pp.parseImport = function(node) {
          this.next();
          // import '...'
          if (this.type === tt.string) {
            node.specifiers = empty;
            node.source = this.parseExprAtom();
            node.kind = "";
          } else {
            node.specifiers = this.parseImportSpecifiers();
            this.expectContextual("from");
            node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
          }
          this.semicolon();
          return this.finishNode(node, "ImportDeclaration");
        };
  
        // Parses a comma-separated list of module imports.
  
        pp.parseImportSpecifiers = function() {
          var nodes = [],
            first = true;
          if (this.type === tt.name) {
            // import defaultObj, { x, y as z } from '...'
            var node = this.startNode();
            node.local = this.parseIdent();
            this.checkLVal(node.local, true);
            nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
            if (!this.eat(tt.comma)) return nodes;
          }
          if (this.type === tt.star) {
            var node = this.startNode();
            this.next();
            this.expectContextual("as");
            node.local = this.parseIdent();
            this.checkLVal(node.local, true);
            nodes.push(this.finishNode(node, "ImportNamespaceSpecifier"));
            return nodes;
          }
          this.expect(tt.braceL);
          while (!this.eat(tt.braceR)) {
            if (!first) {
              this.expect(tt.comma);
              if (this.afterTrailingComma(tt.braceR)) break;
            } else first = false;
  
            var node = this.startNode();
            node.imported = this.parseIdent(true);
            node.local = this.eatContextual("as") ? this.parseIdent() : node.imported;
            this.checkLVal(node.local, true);
            nodes.push(this.finishNode(node, "ImportSpecifier"));
          }
          return nodes;
        };
  
      }, {
        "./state": 13,
        "./tokentype": 17,
        "./whitespace": 19
      }],
      15: [function(_dereq_, module, exports) {
        "use strict";
  
        var _classCallCheck = function(instance, Constructor) {
          if (!(instance instanceof Constructor)) {
            throw new TypeError("Cannot call a class as a function");
          }
        };
  
        exports.__esModule = true;
        // The algorithm used to determine whether a regexp can appear at a
        // given point in the program is loosely based on sweet.js' approach.
        // See https://github.com/mozilla/sweet.js/wiki/design
  
        var Parser = _dereq_("./state").Parser;
  
        var tt = _dereq_("./tokentype").types;
  
        var lineBreak = _dereq_("./whitespace").lineBreak;
  
        var TokContext = exports.TokContext = function TokContext(token, isExpr, preserveSpace, override) {
          _classCallCheck(this, TokContext);
  
          this.token = token;
          this.isExpr = isExpr;
          this.preserveSpace = preserveSpace;
          this.override = override;
        };
  
        var types = {
          b_stat: new TokContext("{", false),
          b_expr: new TokContext("{", true),
          b_tmpl: new TokContext("${", true),
          p_stat: new TokContext("(", false),
          p_expr: new TokContext("(", true),
          q_tmpl: new TokContext("`", true, true, function(p) {
            return p.readTmplToken();
          }),
          f_expr: new TokContext("function", true)
        };
  
        exports.types = types;
        var pp = Parser.prototype;
  
        pp.initialContext = function() {
          return [types.b_stat];
        };
  
        pp.braceIsBlock = function(prevType) {
          var parent = undefined;
          if (prevType === tt.colon && (parent = this.curContext()).token == "{") return !parent.isExpr;
          if (prevType === tt._return) return lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
          if (prevType === tt._else || prevType === tt.semi || prevType === tt.eof) return true;
          if (prevType == tt.braceL) return this.curContext() === types.b_stat;
          return !this.exprAllowed;
        };
  
        pp.updateContext = function(prevType) {
          var update = undefined,
            type = this.type;
          if (type.keyword && prevType == tt.dot) this.exprAllowed = false;
          else if (update = type.updateContext) update.call(this, prevType);
          else this.exprAllowed = type.beforeExpr;
        };
  
        // Token-specific context update code
  
        tt.parenR.updateContext = tt.braceR.updateContext = function() {
          if (this.context.length == 1) {
            this.exprAllowed = true;
            return;
          }
          var out = this.context.pop();
          if (out === types.b_stat && this.curContext() === types.f_expr) {
            this.context.pop();
            this.exprAllowed = false;
          } else if (out === types.b_tmpl) {
            this.exprAllowed = true;
          } else {
            this.exprAllowed = !out.isExpr;
          }
        };
  
        tt.braceL.updateContext = function(prevType) {
          this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr);
          this.exprAllowed = true;
        };
  
        tt.dollarBraceL.updateContext = function() {
          this.context.push(types.b_tmpl);
          this.exprAllowed = true;
        };
  
        tt.parenL.updateContext = function(prevType) {
          var statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while;
          this.context.push(statementParens ? types.p_stat : types.p_expr);
          this.exprAllowed = true;
        };
  
        tt.incDec.updateContext = function() {};
  
        tt._function.updateContext = function() {
          if (this.curContext() !== types.b_stat) this.context.push(types.f_expr);
          this.exprAllowed = false;
        };
  
        tt.backQuote.updateContext = function() {
          if (this.curContext() === types.q_tmpl) this.context.pop();
          else this.context.push(types.q_tmpl);
          this.exprAllowed = false;
        };
  
        // tokExprAllowed stays unchanged
  
      }, {
        "./state": 13,
        "./tokentype": 17,
        "./whitespace": 19
      }],
      16: [function(_dereq_, module, exports) {
        "use strict";
  
        var _classCallCheck = function(instance, Constructor) {
          if (!(instance instanceof Constructor)) {
            throw new TypeError("Cannot call a class as a function");
          }
        };
  
        exports.__esModule = true;
  
        var _identifier = _dereq_("./identifier");
  
        var isIdentifierStart = _identifier.isIdentifierStart;
        var isIdentifierChar = _identifier.isIdentifierChar;
  
        var _tokentype = _dereq_("./tokentype");
  
        var tt = _tokentype.types;
        var keywordTypes = _tokentype.keywords;
  
        var Parser = _dereq_("./state").Parser;
  
        var SourceLocation = _dereq_("./location").SourceLocation;
  
        var _whitespace = _dereq_("./whitespace");
  
        var lineBreak = _whitespace.lineBreak;
        var lineBreakG = _whitespace.lineBreakG;
        var isNewLine = _whitespace.isNewLine;
        var nonASCIIwhitespace = _whitespace.nonASCIIwhitespace;
  
        // Object type used to represent tokens. Note that normally, tokens
        // simply exist as properties on the parser object. This is only
        // used for the onToken callback and the external tokenizer.
  
        var Token = exports.Token = function Token(p) {
          _classCallCheck(this, Token);
  
          this.type = p.type;
          this.value = p.value;
          this.start = p.start;
          this.end = p.end;
          if (p.options.locations) this.loc = new SourceLocation(p, p.startLoc, p.endLoc);
          if (p.options.ranges) this.range = [p.start, p.end];
        };
  
        // ## Tokenizer
  
        var pp = Parser.prototype;
  
        // Are we running under Rhino?
        var isRhino = typeof Packages !== "undefined";
  
        // Move to the next token
  
        pp.next = function() {
          if (this.options.onToken) this.options.onToken(new Token(this));
  
          this.lastTokEnd = this.end;
          this.lastTokStart = this.start;
          this.lastTokEndLoc = this.endLoc;
          this.lastTokStartLoc = this.startLoc;
          this.nextToken();
        };
  
        pp.getToken = function() {
          this.next();
          return new Token(this);
        };
  
        // If we're in an ES6 environment, make parsers iterable
        if (typeof Symbol !== "undefined") pp[Symbol.iterator] = function() {
          var self = this;
          return {
            next: function next() {
              var token = self.getToken();
              return {
                done: token.type === tt.eof,
                value: token
              };
            }
          };
        };
  
        // Toggle strict mode. Re-reads the next number or string to please
        // pedantic tests (`"use strict"; 010;` should fail).
  
        pp.setStrict = function(strict) {
          this.strict = strict;
          if (this.type !== tt.num && this.type !== tt.string) return;
          this.pos = this.start;
          if (this.options.locations) {
            while (this.pos < this.lineStart) {
              this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1;
              --this.curLine;
            }
          }
          this.nextToken();
        };
  
        pp.curContext = function() {
          return this.context[this.context.length - 1];
        };
  
        // Read a single token, updating the parser object's token-related
        // properties.
  
        pp.nextToken = function() {
          var curContext = this.curContext();
          if (!curContext || !curContext.preserveSpace) this.skipSpace();
  
          this.start = this.pos;
          if (this.options.locations) this.startLoc = this.curPosition();
          if (this.pos >= this.input.length) return this.finishToken(tt.eof);
  
          if (curContext.override) return curContext.override(this);
          else this.readToken(this.fullCharCodeAtPos());
        };
  
        pp.readToken = function(code) {
          // Identifier or keyword. '\uXXXX' sequences are allowed in
          // identifiers, so '\' also dispatches to that.
          if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */ ) return this.readWord();
  
          return this.getTokenFromCode(code);
        };
  
        pp.fullCharCodeAtPos = function() {
          var code = this.input.charCodeAt(this.pos);
          if (code <= 55295 || code >= 57344) return code;
          var next = this.input.charCodeAt(this.pos + 1);
          return (code << 10) + next - 56613888;
        };
  
        pp.skipBlockComment = function() {
          var startLoc = this.options.onComment && this.options.locations && this.curPosition();
          var start = this.pos,
            end = this.input.indexOf("*/", this.pos += 2);
          if (end === -1) this.raise(this.pos - 2, "Unterminated comment");
          this.pos = end + 2;
          if (this.options.locations) {
            lineBreakG.lastIndex = start;
            var match = undefined;
            while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
              ++this.curLine;
              this.lineStart = match.index + match[0].length;
            }
          }
          if (this.options.onComment) this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos, startLoc, this.options.locations && this.curPosition());
        };
  
        pp.skipLineComment = function(startSkip) {
          var start = this.pos;
          var startLoc = this.options.onComment && this.options.locations && this.curPosition();
          var ch = this.input.charCodeAt(this.pos += startSkip);
          while (this.pos < this.input.length && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
            ++this.pos;
            ch = this.input.charCodeAt(this.pos);
          }
          if (this.options.onComment) this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos, startLoc, this.options.locations && this.curPosition());
        };
  
        // Called at the start of the parse and after every token. Skips
        // whitespace and comments, and.
  
        pp.skipSpace = function() {
          while (this.pos < this.input.length) {
            var ch = this.input.charCodeAt(this.pos);
            if (ch === 32) {
              // ' '
              ++this.pos;
            } else if (ch === 13) {
              ++this.pos;
              var next = this.input.charCodeAt(this.pos);
              if (next === 10) {
                ++this.pos;
              }
              if (this.options.locations) {
                ++this.curLine;
                this.lineStart = this.pos;
              }
            } else if (ch === 10 || ch === 8232 || ch === 8233) {
              ++this.pos;
              if (this.options.locations) {
                ++this.curLine;
                this.lineStart = this.pos;
              }
            } else if (ch > 8 && ch < 14) {
              ++this.pos;
            } else if (ch === 47) {
              // '/'
              var next = this.input.charCodeAt(this.pos + 1);
              if (next === 42) {
                // '*'
                this.skipBlockComment();
              } else if (next === 47) {
                // '/'
                this.skipLineComment(2);
              } else break;
            } else if (ch === 160) {
              // '\xa0'
              ++this.pos;
            } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
              ++this.pos;
            } else {
              break;
            }
          }
        };
  
        // Called at the end of every token. Sets `end`, `val`, and
        // maintains `context` and `exprAllowed`, and skips the space after
        // the token, so that the next one's `start` will point at the
        // right position.
  
        pp.finishToken = function(type, val) {
          this.end = this.pos;
          if (this.options.locations) this.endLoc = this.curPosition();
          var prevType = this.type;
          this.type = type;
          this.value = val;
  
          this.updateContext(prevType);
        };
  
        // ### Token reading
  
        // This is the function that is called to fetch the next token. It
        // is somewhat obscure, because it works in character codes rather
        // than characters, and because operator parsing has been inlined
        // into it.
        //
        // All in the name of speed.
        //
        pp.readToken_dot = function() {
          var next = this.input.charCodeAt(this.pos + 1);
          if (next >= 48 && next <= 57) return this.readNumber(true);
          var next2 = this.input.charCodeAt(this.pos + 2);
          if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) {
            // 46 = dot '.'
            this.pos += 3;
            return this.finishToken(tt.ellipsis);
          } else {
            ++this.pos;
            return this.finishToken(tt.dot);
          }
        };
  
        pp.readToken_slash = function() {
          // '/'
          var next = this.input.charCodeAt(this.pos + 1);
          if (this.exprAllowed) {
            ++this.pos;
            return this.readRegexp();
          }
          if (next === 61) return this.finishOp(tt.assign, 2);
          return this.finishOp(tt.slash, 1);
        };
  
        pp.readToken_mult_modulo = function(code) {
          // '%*'
          var next = this.input.charCodeAt(this.pos + 1);
          if (next === 61) return this.finishOp(tt.assign, 2);
          return this.finishOp(code === 42 ? tt.star : tt.modulo, 1);
        };
  
        pp.readToken_pipe_amp = function(code) {
          // '|&'
          var next = this.input.charCodeAt(this.pos + 1);
          if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2);
          if (next === 61) return this.finishOp(tt.assign, 2);
          return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1);
        };
  
        pp.readToken_caret = function() {
          // '^'
          var next = this.input.charCodeAt(this.pos + 1);
          if (next === 61) return this.finishOp(tt.assign, 2);
          return this.finishOp(tt.bitwiseXOR, 1);
        };
  
        pp.readToken_plus_min = function(code) {
          // '+-'
          var next = this.input.charCodeAt(this.pos + 1);
          if (next === code) {
            if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 && lineBreak.test(this.input.slice(this.lastTokEnd, this.pos))) {
              // A `-->` line comment
              this.skipLineComment(3);
              this.skipSpace();
              return this.nextToken();
            }
            return this.finishOp(tt.incDec, 2);
          }
          if (next === 61) return this.finishOp(tt.assign, 2);
          return this.finishOp(tt.plusMin, 1);
        };
  
        pp.readToken_lt_gt = function(code) {
          // '<>'
          var next = this.input.charCodeAt(this.pos + 1);
          var size = 1;
          if (next === code) {
            size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
            if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1);
            return this.finishOp(tt.bitShift, size);
          }
          if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 && this.input.charCodeAt(this.pos + 3) == 45) {
            if (this.inModule) this.unexpected();
            // `<!--`, an XML-style comment that should be interpreted as a line comment
            this.skipLineComment(4);
            this.skipSpace();
            return this.nextToken();
          }
          if (next === 61) size = this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2;
          return this.finishOp(tt.relational, size);
        };
  
        pp.readToken_eq_excl = function(code) {
          // '=!'
          var next = this.input.charCodeAt(this.pos + 1);
          if (next === 61) return this.finishOp(tt.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2);
          if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) {
            // '=>'
            this.pos += 2;
            return this.finishToken(tt.arrow);
          }
          return this.finishOp(code === 61 ? tt.eq : tt.prefix, 1);
        };
  
        pp.getTokenFromCode = function(code) {
          switch (code) {
            // The interpretation of a dot depends on whether it is followed
            // by a digit or another two dots.
            case 46:
              // '.'
              return this.readToken_dot();
  
              // Punctuation tokens.
            case 40:
              ++this.pos;
              return this.finishToken(tt.parenL);
            case 41:
              ++this.pos;
              return this.finishToken(tt.parenR);
            case 59:
              ++this.pos;
              return this.finishToken(tt.semi);
            case 44:
              ++this.pos;
              return this.finishToken(tt.comma);
            case 91:
              ++this.pos;
              return this.finishToken(tt.bracketL);
            case 93:
              ++this.pos;
              return this.finishToken(tt.bracketR);
            case 123:
              ++this.pos;
              return this.finishToken(tt.braceL);
            case 125:
              ++this.pos;
              return this.finishToken(tt.braceR);
            case 58:
              ++this.pos;
              return this.finishToken(tt.colon);
            case 63:
              ++this.pos;
              return this.finishToken(tt.question);
  
            case 96:
              // '`'
              if (this.options.ecmaVersion < 6) break;
              ++this.pos;
              return this.finishToken(tt.backQuote);
  
            case 48:
              // '0'
              var next = this.input.charCodeAt(this.pos + 1);
              if (next === 120 || next === 88) return this.readRadixNumber(16); // '0x', '0X' - hex number
              if (this.options.ecmaVersion >= 6) {
                if (next === 111 || next === 79) return this.readRadixNumber(8); // '0o', '0O' - octal number
                if (next === 98 || next === 66) return this.readRadixNumber(2); // '0b', '0B' - binary number
              }
              // Anything else beginning with a digit is an integer, octal
              // number, or float.
            case 49:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
              // 1-9
              return this.readNumber(false);
  
              // Quotes produce strings.
            case 34:
            case 39:
              // '"', "'"
              return this.readString(code);
  
              // Operators are parsed inline in tiny state machines. '=' (61) is
              // often referred to. `finishOp` simply skips the amount of
              // characters it is given as second argument, and returns a token
              // of the type given by its first argument.
  
            case 47:
              // '/'
              return this.readToken_slash();
  
            case 37:
            case 42:
              // '%*'
              return this.readToken_mult_modulo(code);
  
            case 124:
            case 38:
              // '|&'
              return this.readToken_pipe_amp(code);
  
            case 94:
              // '^'
              return this.readToken_caret();
  
            case 43:
            case 45:
              // '+-'
              return this.readToken_plus_min(code);
  
            case 60:
            case 62:
              // '<>'
              return this.readToken_lt_gt(code);
  
            case 61:
            case 33:
              // '=!'
              return this.readToken_eq_excl(code);
  
            case 126:
              // '~'
              return this.finishOp(tt.prefix, 1);
          }
  
          this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
        };
  
        pp.finishOp = function(type, size) {
          var str = this.input.slice(this.pos, this.pos + size);
          this.pos += size;
          return this.finishToken(type, str);
        };
  
        var regexpUnicodeSupport = false;
        try {
          new RegExp("", "u");
          regexpUnicodeSupport = true;
        } catch (e) {}
  
        // Parse a regular expression. Some context-awareness is necessary,
        // since a '/' inside a '[]' set does not end the expression.
  
        pp.readRegexp = function() {
          var escaped = undefined,
            inClass = undefined,
            start = this.pos;
          for (;;) {
            if (this.pos >= this.input.length) this.raise(start, "Unterminated regular expression");
            var ch = this.input.charAt(this.pos);
            if (lineBreak.test(ch)) this.raise(start, "Unterminated regular expression");
            if (!escaped) {
              if (ch === "[") inClass = true;
              else if (ch === "]" && inClass) inClass = false;
              else if (ch === "/" && !inClass) break;
              escaped = ch === "\\";
            } else escaped = false;
            ++this.pos;
          }
          var content = this.input.slice(start, this.pos);
          ++this.pos;
          // Need to use `readWord1` because '\uXXXX' sequences are allowed
          // here (don't ask).
          var mods = this.readWord1();
          var tmp = content;
          if (mods) {
            var validFlags = /^[gmsiy]*$/;
            if (this.options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/;
            if (!validFlags.test(mods)) this.raise(start, "Invalid regular expression flag");
            if (mods.indexOf("u") >= 0 && !regexpUnicodeSupport) {
              // Replace each astral symbol and every Unicode escape sequence that
              // possibly represents an astral symbol or a paired surrogate with a
              // single ASCII symbol to avoid throwing on regular expressions that
              // are only valid in combination with the `/u` flag.
              // Note: replacing with the ASCII symbol `x` might cause false
              // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a
              // perfectly valid pattern that is equivalent to `[a-b]`, but it would
              // be replaced by `[x-b]` which throws an error.
              tmp = tmp.replace(/\\u([a-fA-F0-9]{4})|\\u\{([0-9a-fA-F]+)\}|[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x");
            }
          }
          // Detect invalid regular expressions.
          var value = null;
          // Rhino's regular expression parser is flaky and throws uncatchable exceptions,
          // so don't do detection if we are running under Rhino
          if (!isRhino) {
            try {
              new RegExp(tmp);
            } catch (e) {
              if (e instanceof SyntaxError) this.raise(start, "Error parsing regular expression: " + e.message);
              this.raise(e);
            }
            // Get a regular expression object for this pattern-flag pair, or `null` in
            // case the current environment doesn't support the flags it uses.
            try {
              value = new RegExp(content, mods);
            } catch (err) {}
          }
          return this.finishToken(tt.regexp, {
            pattern: content,
            flags: mods,
            value: value
          });
        };
  
        // Read an integer in the given radix. Return null if zero digits
        // were read, the integer value otherwise. When `len` is given, this
        // will return `null` unless the integer has exactly `len` digits.
  
        pp.readInt = function(radix, len) {
          var start = this.pos,
            total = 0;
          for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
            var code = this.input.charCodeAt(this.pos),
              val = undefined;
            if (code >= 97) val = code - 97 + 10; // a
            else if (code >= 65) val = code - 65 + 10; // A
            else if (code >= 48 && code <= 57) val = code - 48; // 0-9
            else val = Infinity;
            if (val >= radix) break;
            ++this.pos;
            total = total * radix + val;
          }
          if (this.pos === start || len != null && this.pos - start !== len) return null;
  
          return total;
        };
  
        pp.readRadixNumber = function(radix) {
          this.pos += 2; // 0x
          var val = this.readInt(radix);
          if (val == null) this.raise(this.start + 2, "Expected number in radix " + radix);
          if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
          return this.finishToken(tt.num, val);
        };
  
        // Read an integer, octal integer, or floating-point number.
  
        pp.readNumber = function(startsWithDot) {
          var start = this.pos,
            isFloat = false,
            octal = this.input.charCodeAt(this.pos) === 48;
          if (!startsWithDot && this.readInt(10) === null) this.raise(start, "Invalid number");
          if (this.input.charCodeAt(this.pos) === 46) {
            ++this.pos;
            this.readInt(10);
            isFloat = true;
          }
          var next = this.input.charCodeAt(this.pos);
          if (next === 69 || next === 101) {
            // 'eE'
            next = this.input.charCodeAt(++this.pos);
            if (next === 43 || next === 45) ++this.pos; // '+-'
            if (this.readInt(10) === null) this.raise(start, "Invalid number");
            isFloat = true;
          }
          if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
  
          var str = this.input.slice(start, this.pos),
            val = undefined;
          if (isFloat) val = parseFloat(str);
          else if (!octal || str.length === 1) val = parseInt(str, 10);
          else if (/[89]/.test(str) || this.strict) this.raise(start, "Invalid number");
          else val = parseInt(str, 8);
          return this.finishToken(tt.num, val);
        };
  
        // Read a string value, interpreting backslash-escapes.
  
        pp.readCodePoint = function() {
          var ch = this.input.charCodeAt(this.pos),
            code = undefined;
  
          if (ch === 123) {
            if (this.options.ecmaVersion < 6) this.unexpected();
            ++this.pos;
            code = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos);
            ++this.pos;
            if (code > 1114111) this.unexpected();
          } else {
            code = this.readHexChar(4);
          }
          return code;
        };
  
        function codePointToString(code) {
          // UTF-16 Decoding
          if (code <= 65535) {
            return String.fromCharCode(code);
          }
          return String.fromCharCode((code - 65536 >> 10) + 55296, (code - 65536 & 1023) + 56320);
        }
  
        pp.readString = function(quote) {
          var out = "",
            chunkStart = ++this.pos;
          for (;;) {
            if (this.pos >= this.input.length) this.raise(this.start, "Unterminated string constant");
            var ch = this.input.charCodeAt(this.pos);
            if (ch === quote) break;
            if (ch === 92) {
              // '\'
              out += this.input.slice(chunkStart, this.pos);
              out += this.readEscapedChar();
              chunkStart = this.pos;
            } else {
              if (isNewLine(ch)) this.raise(this.start, "Unterminated string constant");
              ++this.pos;
            }
          }
          out += this.input.slice(chunkStart, this.pos++);
          return this.finishToken(tt.string, out);
        };
  
        // Reads template string tokens.
  
        pp.readTmplToken = function() {
          var out = "",
            chunkStart = this.pos;
          for (;;) {
            if (this.pos >= this.input.length) this.raise(this.start, "Unterminated template");
            var ch = this.input.charCodeAt(this.pos);
            if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) {
              // '`', '${'
              if (this.pos === this.start && this.type === tt.template) {
                if (ch === 36) {
                  this.pos += 2;
                  return this.finishToken(tt.dollarBraceL);
                } else {
                  ++this.pos;
                  return this.finishToken(tt.backQuote);
                }
              }
              out += this.input.slice(chunkStart, this.pos);
              return this.finishToken(tt.template, out);
            }
            if (ch === 92) {
              // '\'
              out += this.input.slice(chunkStart, this.pos);
              out += this.readEscapedChar();
              chunkStart = this.pos;
            } else if (isNewLine(ch)) {
              out += this.input.slice(chunkStart, this.pos);
              ++this.pos;
              if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
                ++this.pos;
                out += "\n";
              } else {
                out += String.fromCharCode(ch);
              }
              if (this.options.locations) {
                ++this.curLine;
                this.lineStart = this.pos;
              }
              chunkStart = this.pos;
            } else {
              ++this.pos;
            }
          }
        };
  
        // Used to read escaped characters
  
        pp.readEscapedChar = function() {
          var ch = this.input.charCodeAt(++this.pos);
          var octal = /^[0-7]+/.exec(this.input.slice(this.pos, this.pos + 3));
          if (octal) octal = octal[0];
          while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
          if (octal === "0") octal = null;
          ++this.pos;
          if (octal) {
            if (this.strict) this.raise(this.pos - 2, "Octal literal in strict mode");
            this.pos += octal.length - 1;
            return String.fromCharCode(parseInt(octal, 8));
          } else {
            switch (ch) {
              case 110:
                return "\n"; // 'n' -> '\n'
              case 114:
                return "\r"; // 'r' -> '\r'
              case 120:
                return String.fromCharCode(this.readHexChar(2)); // 'x'
              case 117:
                return codePointToString(this.readCodePoint()); // 'u'
              case 116:
                return "\t"; // 't' -> '\t'
              case 98:
                return "\b"; // 'b' -> '\b'
              case 118:
                return "\u000b"; // 'v' -> '\u000b'
              case 102:
                return "\f"; // 'f' -> '\f'
              case 48:
                return "\u0000"; // 0 -> '\0'
              case 13:
                if (this.input.charCodeAt(this.pos) === 10) ++this.pos; // '\r\n'
              case 10:
                // ' \n'
                if (this.options.locations) {
                  this.lineStart = this.pos;
                  ++this.curLine;
                }
                return "";
              default:
                return String.fromCharCode(ch);
            }
          }
        };
  
        // Used to read character escape sequences ('\x', '\u', '\U').
  
        pp.readHexChar = function(len) {
          var n = this.readInt(16, len);
          if (n === null) this.raise(this.start, "Bad character escape sequence");
          return n;
        };
  
        // Used to signal to callers of `readWord1` whether the word
        // contained any escape sequences. This is needed because words with
        // escape sequences must not be interpreted as keywords.
  
        var containsEsc;
  
        // Read an identifier, and return it as a string. Sets `containsEsc`
        // to whether the word contained a '\u' escape.
        //
        // Incrementally adds only escaped chars, adding other chunks as-is
        // as a micro-optimization.
  
        pp.readWord1 = function() {
          containsEsc = false;
          var word = "",
            first = true,
            chunkStart = this.pos;
          var astral = this.options.ecmaVersion >= 6;
          while (this.pos < this.input.length) {
            var ch = this.fullCharCodeAtPos();
            if (isIdentifierChar(ch, astral)) {
              this.pos += ch <= 65535 ? 1 : 2;
            } else if (ch === 92) {
              // "\"
              containsEsc = true;
              word += this.input.slice(chunkStart, this.pos);
              var escStart = this.pos;
              if (this.input.charCodeAt(++this.pos) != 117) // "u"
                this.raise(this.pos, "Expecting Unicode escape sequence \\uXXXX");
              ++this.pos;
              var esc = this.readCodePoint();
              if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral)) this.raise(escStart, "Invalid Unicode escape");
              word += codePointToString(esc);
              chunkStart = this.pos;
            } else {
              break;
            }
            first = false;
          }
          return word + this.input.slice(chunkStart, this.pos);
        };
  
        // Read an identifier or keyword token. Will check for reserved
        // words when necessary.
  
        pp.readWord = function() {
          var word = this.readWord1();
          var type = tt.name;
          if ((this.options.ecmaVersion >= 6 || !containsEsc) && this.isKeyword(word)) type = keywordTypes[word];
          return this.finishToken(type, word);
        };
  
      }, {
        "./identifier": 7,
        "./location": 8,
        "./state": 13,
        "./tokentype": 17,
        "./whitespace": 19
      }],
      17: [function(_dereq_, module, exports) {
        "use strict";
  
        var _classCallCheck = function(instance, Constructor) {
          if (!(instance instanceof Constructor)) {
            throw new TypeError("Cannot call a class as a function");
          }
        };
  
        exports.__esModule = true;
        // ## Token types
  
        // The assignment of fine-grained, information-carrying type objects
        // allows the tokenizer to store the information it has about a
        // token in a way that is very cheap for the parser to look up.
  
        // All token type variables start with an underscore, to make them
        // easy to recognize.
  
        // The `beforeExpr` property is used to disambiguate between regular
        // expressions and divisions. It is set on all token types that can
        // be followed by an expression (thus, a slash after them would be a
        // regular expression).
        //
        // `isLoop` marks a keyword as starting a loop, which is important
        // to know when parsing a label, in order to allow or disallow
        // continue jumps to that label.
  
        var TokenType = exports.TokenType = function TokenType(label) {
          var conf = arguments[1] === undefined ? {} : arguments[1];
  
          _classCallCheck(this, TokenType);
  
          this.label = label;
          this.keyword = conf.keyword;
          this.beforeExpr = !!conf.beforeExpr;
          this.startsExpr = !!conf.startsExpr;
          this.isLoop = !!conf.isLoop;
          this.isAssign = !!conf.isAssign;
          this.prefix = !!conf.prefix;
          this.postfix = !!conf.postfix;
          this.binop = conf.binop || null;
          this.updateContext = null;
        };
  
        function binop(name, prec) {
          return new TokenType(name, {
            beforeExpr: true,
            binop: prec
          });
        }
        var beforeExpr = {
            beforeExpr: true
          },
          startsExpr = {
            startsExpr: true
          };
  
        var types = {
          num: new TokenType("num", startsExpr),
          regexp: new TokenType("regexp", startsExpr),
          string: new TokenType("string", startsExpr),
          name: new TokenType("name", startsExpr),
          eof: new TokenType("eof"),
  
          // Punctuation token types.
          bracketL: new TokenType("[", {
            beforeExpr: true,
            startsExpr: true
          }),
          bracketR: new TokenType("]"),
          braceL: new TokenType("{", {
            beforeExpr: true,
            startsExpr: true
          }),
          braceR: new TokenType("}"),
          parenL: new TokenType("(", {
            beforeExpr: true,
            startsExpr: true
          }),
          parenR: new TokenType(")"),
          comma: new TokenType(",", beforeExpr),
          semi: new TokenType(";", beforeExpr),
          colon: new TokenType(":", beforeExpr),
          dot: new TokenType("."),
          question: new TokenType("?", beforeExpr),
          arrow: new TokenType("=>", beforeExpr),
          template: new TokenType("template"),
          ellipsis: new TokenType("...", beforeExpr),
          backQuote: new TokenType("`", startsExpr),
          dollarBraceL: new TokenType("${", {
            beforeExpr: true,
            startsExpr: true
          }),
  
          // Operators. These carry several kinds of properties to help the
          // parser use them properly (the presence of these properties is
          // what categorizes them as operators).
          //
          // `binop`, when present, specifies that this operator is a binary
          // operator, and will refer to its precedence.
          //
          // `prefix` and `postfix` mark the operator as a prefix or postfix
          // unary operator.
          //
          // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
          // binary operators with a very low precedence, that should result
          // in AssignmentExpression nodes.
  
          eq: new TokenType("=", {
            beforeExpr: true,
            isAssign: true
          }),
          assign: new TokenType("_=", {
            beforeExpr: true,
            isAssign: true
          }),
          incDec: new TokenType("++/--", {
            prefix: true,
            postfix: true,
            startsExpr: true
          }),
          prefix: new TokenType("prefix", {
            beforeExpr: true,
            prefix: true,
            startsExpr: true
          }),
          logicalOR: binop("||", 1),
          logicalAND: binop("&&", 2),
          bitwiseOR: binop("|", 3),
          bitwiseXOR: binop("^", 4),
          bitwiseAND: binop("&", 5),
          equality: binop("==/!=", 6),
          relational: binop("</>", 7),
          bitShift: binop("<</>>", 8),
          plusMin: new TokenType("+/-", {
            beforeExpr: true,
            binop: 9,
            prefix: true,
            startsExpr: true
          }),
          modulo: binop("%", 10),
          star: binop("*", 10),
          slash: binop("/", 10)
        };
  
        exports.types = types;
        // Map keyword names to token types.
  
        var keywords = {};
  
        exports.keywords = keywords;
        // Succinct definitions of keyword token types
        function kw(name) {
          var options = arguments[1] === undefined ? {} : arguments[1];
  
          options.keyword = name;
          keywords[name] = types["_" + name] = new TokenType(name, options);
        }
  
        kw("break");
        kw("case", beforeExpr);
        kw("catch");
        kw("continue");
        kw("debugger");
        kw("default");
        kw("do", {
          isLoop: true
        });
        kw("else", beforeExpr);
        kw("finally");
        kw("for", {
          isLoop: true
        });
        kw("function", startsExpr);
        kw("if");
        kw("return", beforeExpr);
        kw("switch");
        kw("throw", beforeExpr);
        kw("try");
        kw("var");
        kw("let");
        kw("const");
        kw("while", {
          isLoop: true
        });
        kw("with");
        kw("new", {
          beforeExpr: true,
          startsExpr: true
        });
        kw("this", startsExpr);
        kw("super", startsExpr);
        kw("class");
        kw("extends", beforeExpr);
        kw("export");
        kw("import");
        kw("yield", {
          beforeExpr: true,
          startsExpr: true
        });
        kw("null", startsExpr);
        kw("true", startsExpr);
        kw("false", startsExpr);
        kw("in", {
          beforeExpr: true,
          binop: 7
        });
        kw("instanceof", {
          beforeExpr: true,
          binop: 7
        });
        kw("typeof", {
          beforeExpr: true,
          prefix: true,
          startsExpr: true
        });
        kw("void", {
          beforeExpr: true,
          prefix: true,
          startsExpr: true
        });
        kw("delete", {
          beforeExpr: true,
          prefix: true,
          startsExpr: true
        });
  
      }, {}],
      18: [function(_dereq_, module, exports) {
        "use strict";
  
        exports.isArray = isArray;
  
        // Checks if an object has a property.
  
        exports.has = has;
        exports.__esModule = true;
  
        function isArray(obj) {
          return Object.prototype.toString.call(obj) === "[object Array]";
        }
  
        function has(obj, propName) {
          return Object.prototype.hasOwnProperty.call(obj, propName);
        }
  
      }, {}],
      19: [function(_dereq_, module, exports) {
        "use strict";
  
        exports.isNewLine = isNewLine;
        exports.__esModule = true;
        // Matches a whole line break (where CRLF is considered a single
        // line break). Used to count lines.
  
        var lineBreak = /\r\n?|\n|\u2028|\u2029/;
        exports.lineBreak = lineBreak;
        var lineBreakG = new RegExp(lineBreak.source, "g");
  
        exports.lineBreakG = lineBreakG;
  
        function isNewLine(code) {
          return code === 10 || code === 13 || code === 8232 || code == 8233;
        }
  
        var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
        exports.nonASCIIwhitespace = nonASCIIwhitespace;
  
      }, {}]
    }, {}, [1])(1)
  });