{"version":3,"file":"buble.deps.js","sources":["../node_modules/acorn/dist/acorn.js","../node_modules/acorn-jsx/xhtml.js","../node_modules/acorn-jsx/inject.js","../node_modules/acorn-object-spread/inject.js","../node_modules/vlq/src/vlq.js","../node_modules/magic-string/dist/magic-string.es6.js","../src/program/keys.js","../src/program/Node.js","../src/utils/spread.js","../src/program/types/ArrayExpression.js","../src/program/types/ArrowFunctionExpression.js","../src/utils/locate.js","../src/utils/getSnippet.js","../src/utils/CompileError.js","../src/program/types/AssignmentExpression.js","../src/program/types/BinaryExpression.js","../src/program/types/BreakStatement.js","../src/program/types/CallExpression.js","../src/utils/array.js","../src/utils/reserved.js","../src/program/types/ClassBody.js","../src/utils/deindent.js","../src/program/types/ClassDeclaration.js","../src/program/types/ClassExpression.js","../src/program/types/ContinueStatement.js","../src/program/types/ExportDefaultDeclaration.js","../src/program/types/ExportNamedDeclaration.js","../src/program/extractNames.js","../src/program/types/shared/LoopStatement.js","../src/program/types/ForStatement.js","../src/program/types/ForInStatement.js","../src/program/types/ForOfStatement.js","../src/program/types/FunctionDeclaration.js","../src/program/types/FunctionExpression.js","../src/utils/isReference.js","../src/program/types/Identifier.js","../src/program/types/ImportDeclaration.js","../src/program/types/ImportDefaultSpecifier.js","../src/program/types/ImportSpecifier.js","../src/program/types/JSXAttribute.js","../src/program/types/JSXClosingElement.js","../src/program/types/JSXElement.js","../src/program/types/JSXExpressionContainer.js","../src/program/types/JSXOpeningElement.js","../src/program/types/JSXSpreadAttribute.js","../node_modules/regenerate/regenerate.js","../node_modules/regexpu-core/data/character-class-escape-sets.js","../node_modules/regexpu-core/data/iu-mappings.js","../node_modules/regenerate-unicode-properties/index.js","../node_modules/unicode-loose-match/data/mappings.js","../node_modules/unicode-loose-match/index.js","../node_modules/regjsparser/parser.js","../node_modules/regjsgen/regjsgen.js","../node_modules/regexpu-core/rewrite-pattern.js","../src/program/types/Literal.js","../src/program/types/MemberExpression.js","../src/program/types/ObjectExpression.js","../src/program/types/Property.js","../src/program/types/ReturnStatement.js","../src/program/types/SpreadProperty.js","../src/program/types/Super.js","../src/program/types/TaggedTemplateExpression.js","../src/program/types/TemplateElement.js","../src/program/types/TemplateLiteral.js","../src/program/types/ThisExpression.js","../src/program/types/UpdateExpression.js","../src/utils/destructure.js","../src/program/types/VariableDeclaration.js","../src/program/types/VariableDeclarator.js","../src/program/types/index.js","../src/program/wrap.js","../src/program/Scope.js","../src/program/BlockStatement.js","../src/program/Program.js","../src/support.js","../package.json","../src/index.js"],"sourcesContent":["(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= 6 && (prop.computed || prop.method || prop.shorthand)) return;\n var key = prop.key;var name = undefined;\n switch (key.type) {\n case \"Identifier\":\n name = key.name;break;\n case \"Literal\":\n name = String(key.value);break;\n default:\n return;\n }\n var kind = prop.kind;\n\n if (this.options.ecmaVersion >= 6) {\n if (name === \"__proto__\" && kind === \"init\") {\n if (propHash.proto) this.raiseRecoverable(key.start, \"Redefinition of __proto__ property\");\n propHash.proto = true;\n }\n return;\n }\n name = \"$\" + name;\n var other = propHash[name];\n if (other) {\n var isGetSet = kind !== \"init\";\n if ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init)) this.raiseRecoverable(key.start, \"Redefinition of property\");\n } else {\n other = propHash[name] = {\n init: false,\n get: false,\n set: false\n };\n }\n other[kind] = true;\n};\n\n// ### Expression parsing\n\n// These nest, from the most general expression type at the top to\n// 'atomic', nondivisible expression types at the bottom. Most of\n// the functions will simply let the function(s) below them parse,\n// and, *if* the syntactic construct they handle is present, wrap\n// the AST node that the inner parser gave them in another node.\n\n// Parse a full expression. The optional arguments are used to\n// forbid the `in` operator (in for loops initalization expressions)\n// and provide reference for storing '=' operator inside shorthand\n// property assignment in contexts where both object expression\n// and object pattern might appear (so it's possible to raise\n// delayed syntax error at correct position).\n\npp.parseExpression = function (noIn, refDestructuringErrors) {\n var startPos = this.start,\n startLoc = this.startLoc;\n var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);\n if (this.type === _tokentype.types.comma) {\n var node = this.startNodeAt(startPos, startLoc);\n node.expressions = [expr];\n while (this.eat(_tokentype.types.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors));\n return this.finishNode(node, \"SequenceExpression\");\n }\n return expr;\n};\n\n// Parse an assignment expression. This includes applications of\n// operators like `+=`.\n\npp.parseMaybeAssign = function (noIn, refDestructuringErrors, afterLeftParse) {\n if (this.inGenerator && this.isContextual(\"yield\")) return this.parseYield();\n\n var validateDestructuring = false;\n if (!refDestructuringErrors) {\n refDestructuringErrors = { shorthandAssign: 0, trailingComma: 0 };\n validateDestructuring = true;\n }\n var startPos = this.start,\n startLoc = this.startLoc;\n if (this.type == _tokentype.types.parenL || this.type == _tokentype.types.name) this.potentialArrowAt = this.start;\n var left = this.parseMaybeConditional(noIn, refDestructuringErrors);\n if (afterLeftParse) left = afterLeftParse.call(this, left, startPos, startLoc);\n if (this.type.isAssign) {\n if (validateDestructuring) this.checkPatternErrors(refDestructuringErrors, true);\n var node = this.startNodeAt(startPos, startLoc);\n node.operator = this.value;\n node.left = this.type === _tokentype.types.eq ? this.toAssignable(left) : left;\n refDestructuringErrors.shorthandAssign = 0; // reset because shorthand default was used correctly\n this.checkLVal(left);\n this.next();\n node.right = this.parseMaybeAssign(noIn);\n return this.finishNode(node, \"AssignmentExpression\");\n } else {\n if (validateDestructuring) this.checkExpressionErrors(refDestructuringErrors, true);\n }\n return left;\n};\n\n// Parse a ternary conditional (`?:`) operator.\n\npp.parseMaybeConditional = function (noIn, refDestructuringErrors) {\n var startPos = this.start,\n startLoc = this.startLoc;\n var expr = this.parseExprOps(noIn, refDestructuringErrors);\n if (this.checkExpressionErrors(refDestructuringErrors)) return expr;\n if (this.eat(_tokentype.types.question)) {\n var node = this.startNodeAt(startPos, startLoc);\n node.test = expr;\n node.consequent = this.parseMaybeAssign();\n this.expect(_tokentype.types.colon);\n node.alternate = this.parseMaybeAssign(noIn);\n return this.finishNode(node, \"ConditionalExpression\");\n }\n return expr;\n};\n\n// Start the precedence parser.\n\npp.parseExprOps = function (noIn, refDestructuringErrors) {\n var startPos = this.start,\n startLoc = this.startLoc;\n var expr = this.parseMaybeUnary(refDestructuringErrors, false);\n if (this.checkExpressionErrors(refDestructuringErrors)) return expr;\n return this.parseExprOp(expr, startPos, startLoc, -1, noIn);\n};\n\n// Parse binary operators with the operator precedence parsing\n// algorithm. `left` is the left-hand side of the operator.\n// `minPrec` provides context that allows the function to stop and\n// defer further parser to one of its callers when it encounters an\n// operator that has a lower precedence than the set it is parsing.\n\npp.parseExprOp = function (left, leftStartPos, leftStartLoc, minPrec, noIn) {\n var prec = this.type.binop;\n if (prec != null && (!noIn || this.type !== _tokentype.types._in)) {\n if (prec > minPrec) {\n var logical = this.type === _tokentype.types.logicalOR || this.type === _tokentype.types.logicalAND;\n var op = this.value;\n this.next();\n var startPos = this.start,\n startLoc = this.startLoc;\n var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);\n var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical);\n return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn);\n }\n }\n return left;\n};\n\npp.buildBinary = function (startPos, startLoc, left, right, op, logical) {\n var node = this.startNodeAt(startPos, startLoc);\n node.left = left;\n node.operator = op;\n node.right = right;\n return this.finishNode(node, logical ? \"LogicalExpression\" : \"BinaryExpression\");\n};\n\n// Parse unary operators, both prefix and postfix.\n\npp.parseMaybeUnary = function (refDestructuringErrors, sawUnary) {\n var startPos = this.start,\n startLoc = this.startLoc,\n expr = undefined;\n if (this.type.prefix) {\n var node = this.startNode(),\n update = this.type === _tokentype.types.incDec;\n node.operator = this.value;\n node.prefix = true;\n this.next();\n node.argument = this.parseMaybeUnary(null, true);\n this.checkExpressionErrors(refDestructuringErrors, true);\n if (update) this.checkLVal(node.argument);else if (this.strict && node.operator === \"delete\" && node.argument.type === \"Identifier\") this.raiseRecoverable(node.start, \"Deleting local variable in strict mode\");else sawUnary = true;\n expr = this.finishNode(node, update ? \"UpdateExpression\" : \"UnaryExpression\");\n } else {\n expr = this.parseExprSubscripts(refDestructuringErrors);\n if (this.checkExpressionErrors(refDestructuringErrors)) return expr;\n while (this.type.postfix && !this.canInsertSemicolon()) {\n var node = this.startNodeAt(startPos, startLoc);\n node.operator = this.value;\n node.prefix = false;\n node.argument = expr;\n this.checkLVal(expr);\n this.next();\n expr = this.finishNode(node, \"UpdateExpression\");\n }\n }\n\n if (!sawUnary && this.eat(_tokentype.types.starstar)) return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), \"**\", false);else return expr;\n};\n\n// Parse call, dot, and `[]`-subscript expressions.\n\npp.parseExprSubscripts = function (refDestructuringErrors) {\n var startPos = this.start,\n startLoc = this.startLoc;\n var expr = this.parseExprAtom(refDestructuringErrors);\n var skipArrowSubscripts = expr.type === \"ArrowFunctionExpression\" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== \")\";\n if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) return expr;\n return this.parseSubscripts(expr, startPos, startLoc);\n};\n\npp.parseSubscripts = function (base, startPos, startLoc, noCalls) {\n for (;;) {\n if (this.eat(_tokentype.types.dot)) {\n var node = this.startNodeAt(startPos, startLoc);\n node.object = base;\n node.property = this.parseIdent(true);\n node.computed = false;\n base = this.finishNode(node, \"MemberExpression\");\n } else if (this.eat(_tokentype.types.bracketL)) {\n var node = this.startNodeAt(startPos, startLoc);\n node.object = base;\n node.property = this.parseExpression();\n node.computed = true;\n this.expect(_tokentype.types.bracketR);\n base = this.finishNode(node, \"MemberExpression\");\n } else if (!noCalls && this.eat(_tokentype.types.parenL)) {\n var node = this.startNodeAt(startPos, startLoc);\n node.callee = base;\n node.arguments = this.parseExprList(_tokentype.types.parenR, false);\n base = this.finishNode(node, \"CallExpression\");\n } else if (this.type === _tokentype.types.backQuote) {\n var node = this.startNodeAt(startPos, startLoc);\n node.tag = base;\n node.quasi = this.parseTemplate();\n base = this.finishNode(node, \"TaggedTemplateExpression\");\n } else {\n return base;\n }\n }\n};\n\n// Parse an atomic expression — either a single token that is an\n// expression, an expression started by a keyword like `function` or\n// `new`, or an expression wrapped in punctuation like `()`, `[]`,\n// or `{}`.\n\npp.parseExprAtom = function (refDestructuringErrors) {\n var node = undefined,\n canBeArrow = this.potentialArrowAt == this.start;\n switch (this.type) {\n case _tokentype.types._super:\n if (!this.inFunction) this.raise(this.start, \"'super' outside of function or class\");\n\n case _tokentype.types._this:\n var type = this.type === _tokentype.types._this ? \"ThisExpression\" : \"Super\";\n node = this.startNode();\n this.next();\n return this.finishNode(node, type);\n\n case _tokentype.types.name:\n var startPos = this.start,\n startLoc = this.startLoc;\n var id = this.parseIdent(this.type !== _tokentype.types.name);\n if (canBeArrow && !this.canInsertSemicolon() && this.eat(_tokentype.types.arrow)) return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id]);\n return id;\n\n case _tokentype.types.regexp:\n var value = this.value;\n node = this.parseLiteral(value.value);\n node.regex = { pattern: value.pattern, flags: value.flags };\n return node;\n\n case _tokentype.types.num:case _tokentype.types.string:\n return this.parseLiteral(this.value);\n\n case _tokentype.types._null:case _tokentype.types._true:case _tokentype.types._false:\n node = this.startNode();\n node.value = this.type === _tokentype.types._null ? null : this.type === _tokentype.types._true;\n node.raw = this.type.keyword;\n this.next();\n return this.finishNode(node, \"Literal\");\n\n case _tokentype.types.parenL:\n return this.parseParenAndDistinguishExpression(canBeArrow);\n\n case _tokentype.types.bracketL:\n node = this.startNode();\n this.next();\n node.elements = this.parseExprList(_tokentype.types.bracketR, true, true, refDestructuringErrors);\n return this.finishNode(node, \"ArrayExpression\");\n\n case _tokentype.types.braceL:\n return this.parseObj(false, refDestructuringErrors);\n\n case _tokentype.types._function:\n node = this.startNode();\n this.next();\n return this.parseFunction(node, false);\n\n case _tokentype.types._class:\n return this.parseClass(this.startNode(), false);\n\n case _tokentype.types._new:\n return this.parseNew();\n\n case _tokentype.types.backQuote:\n return this.parseTemplate();\n\n default:\n this.unexpected();\n }\n};\n\npp.parseLiteral = function (value) {\n var node = this.startNode();\n node.value = value;\n node.raw = this.input.slice(this.start, this.end);\n this.next();\n return this.finishNode(node, \"Literal\");\n};\n\npp.parseParenExpression = function () {\n this.expect(_tokentype.types.parenL);\n var val = this.parseExpression();\n this.expect(_tokentype.types.parenR);\n return val;\n};\n\npp.parseParenAndDistinguishExpression = function (canBeArrow) {\n var startPos = this.start,\n startLoc = this.startLoc,\n val = undefined;\n if (this.options.ecmaVersion >= 6) {\n this.next();\n\n var innerStartPos = this.start,\n innerStartLoc = this.startLoc;\n var exprList = [],\n first = true;\n var refDestructuringErrors = { shorthandAssign: 0, trailingComma: 0 },\n spreadStart = undefined,\n innerParenStart = undefined;\n while (this.type !== _tokentype.types.parenR) {\n first ? first = false : this.expect(_tokentype.types.comma);\n if (this.type === _tokentype.types.ellipsis) {\n spreadStart = this.start;\n exprList.push(this.parseParenItem(this.parseRest()));\n break;\n } else {\n if (this.type === _tokentype.types.parenL && !innerParenStart) {\n innerParenStart = this.start;\n }\n exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem));\n }\n }\n var innerEndPos = this.start,\n innerEndLoc = this.startLoc;\n this.expect(_tokentype.types.parenR);\n\n if (canBeArrow && !this.canInsertSemicolon() && this.eat(_tokentype.types.arrow)) {\n this.checkPatternErrors(refDestructuringErrors, true);\n if (innerParenStart) this.unexpected(innerParenStart);\n return this.parseParenArrowList(startPos, startLoc, exprList);\n }\n\n if (!exprList.length) this.unexpected(this.lastTokStart);\n if (spreadStart) this.unexpected(spreadStart);\n this.checkExpressionErrors(refDestructuringErrors, true);\n\n if (exprList.length > 1) {\n val = this.startNodeAt(innerStartPos, innerStartLoc);\n val.expressions = exprList;\n this.finishNodeAt(val, \"SequenceExpression\", innerEndPos, innerEndLoc);\n } else {\n val = exprList[0];\n }\n } else {\n val = this.parseParenExpression();\n }\n\n if (this.options.preserveParens) {\n var par = this.startNodeAt(startPos, startLoc);\n par.expression = val;\n return this.finishNode(par, \"ParenthesizedExpression\");\n } else {\n return val;\n }\n};\n\npp.parseParenItem = function (item) {\n return item;\n};\n\npp.parseParenArrowList = function (startPos, startLoc, exprList) {\n return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList);\n};\n\n// New's precedence is slightly tricky. It must allow its argument to\n// be a `[]` or dot subscript expression, but not a call — at least,\n// not without wrapping it in parentheses. Thus, it uses the noCalls\n// argument to parseSubscripts to prevent it from consuming the\n// argument list.\n\nvar empty = [];\n\npp.parseNew = function () {\n var node = this.startNode();\n var meta = this.parseIdent(true);\n if (this.options.ecmaVersion >= 6 && this.eat(_tokentype.types.dot)) {\n node.meta = meta;\n node.property = this.parseIdent(true);\n if (node.property.name !== \"target\") this.raiseRecoverable(node.property.start, \"The only valid meta property for new is new.target\");\n if (!this.inFunction) this.raiseRecoverable(node.start, \"new.target can only be used in functions\");\n return this.finishNode(node, \"MetaProperty\");\n }\n var startPos = this.start,\n startLoc = this.startLoc;\n node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);\n if (this.eat(_tokentype.types.parenL)) node.arguments = this.parseExprList(_tokentype.types.parenR, false);else node.arguments = empty;\n return this.finishNode(node, \"NewExpression\");\n};\n\n// Parse template expression.\n\npp.parseTemplateElement = function () {\n var elem = this.startNode();\n elem.value = {\n raw: this.input.slice(this.start, this.end).replace(/\\r\\n?/g, '\\n'),\n cooked: this.value\n };\n this.next();\n elem.tail = this.type === _tokentype.types.backQuote;\n return this.finishNode(elem, \"TemplateElement\");\n};\n\npp.parseTemplate = function () {\n var node = this.startNode();\n this.next();\n node.expressions = [];\n var curElt = this.parseTemplateElement();\n node.quasis = [curElt];\n while (!curElt.tail) {\n this.expect(_tokentype.types.dollarBraceL);\n node.expressions.push(this.parseExpression());\n this.expect(_tokentype.types.braceR);\n node.quasis.push(curElt = this.parseTemplateElement());\n }\n this.next();\n return this.finishNode(node, \"TemplateLiteral\");\n};\n\n// Parse an object literal or binding pattern.\n\npp.parseObj = function (isPattern, refDestructuringErrors) {\n var node = this.startNode(),\n first = true,\n propHash = {};\n node.properties = [];\n this.next();\n while (!this.eat(_tokentype.types.braceR)) {\n if (!first) {\n this.expect(_tokentype.types.comma);\n if (this.afterTrailingComma(_tokentype.types.braceR)) break;\n } else first = false;\n\n var prop = this.startNode(),\n isGenerator = undefined,\n startPos = undefined,\n startLoc = undefined;\n if (this.options.ecmaVersion >= 6) {\n prop.method = false;\n prop.shorthand = false;\n if (isPattern || refDestructuringErrors) {\n startPos = this.start;\n startLoc = this.startLoc;\n }\n if (!isPattern) isGenerator = this.eat(_tokentype.types.star);\n }\n this.parsePropertyName(prop);\n this.parsePropertyValue(prop, isPattern, isGenerator, startPos, startLoc, refDestructuringErrors);\n this.checkPropClash(prop, propHash);\n node.properties.push(this.finishNode(prop, \"Property\"));\n }\n return this.finishNode(node, isPattern ? \"ObjectPattern\" : \"ObjectExpression\");\n};\n\npp.parsePropertyValue = function (prop, isPattern, isGenerator, startPos, startLoc, refDestructuringErrors) {\n if (this.eat(_tokentype.types.colon)) {\n prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);\n prop.kind = \"init\";\n } else if (this.options.ecmaVersion >= 6 && this.type === _tokentype.types.parenL) {\n if (isPattern) this.unexpected();\n prop.kind = \"init\";\n prop.method = true;\n prop.value = this.parseMethod(isGenerator);\n } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === \"Identifier\" && (prop.key.name === \"get\" || prop.key.name === \"set\") && this.type != _tokentype.types.comma && this.type != _tokentype.types.braceR) {\n if (isGenerator || isPattern) this.unexpected();\n prop.kind = prop.key.name;\n this.parsePropertyName(prop);\n prop.value = this.parseMethod(false);\n var paramCount = prop.kind === \"get\" ? 0 : 1;\n if (prop.value.params.length !== paramCount) {\n var start = prop.value.start;\n if (prop.kind === \"get\") this.raiseRecoverable(start, \"getter should have no params\");else this.raiseRecoverable(start, \"setter should have exactly one param\");\n }\n if (prop.kind === \"set\" && prop.value.params[0].type === \"RestElement\") this.raiseRecoverable(prop.value.params[0].start, \"Setter cannot use rest params\");\n } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === \"Identifier\") {\n prop.kind = \"init\";\n if (isPattern) {\n if (this.keywords.test(prop.key.name) || (this.strict ? this.reservedWordsStrictBind : this.reservedWords).test(prop.key.name) || this.inGenerator && prop.key.name == \"yield\") this.raiseRecoverable(prop.key.start, \"Binding \" + prop.key.name);\n prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);\n } else if (this.type === _tokentype.types.eq && refDestructuringErrors) {\n if (!refDestructuringErrors.shorthandAssign) refDestructuringErrors.shorthandAssign = this.start;\n prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);\n } else {\n prop.value = prop.key;\n }\n prop.shorthand = true;\n } else this.unexpected();\n};\n\npp.parsePropertyName = function (prop) {\n if (this.options.ecmaVersion >= 6) {\n if (this.eat(_tokentype.types.bracketL)) {\n prop.computed = true;\n prop.key = this.parseMaybeAssign();\n this.expect(_tokentype.types.bracketR);\n return prop.key;\n } else {\n prop.computed = false;\n }\n }\n return prop.key = this.type === _tokentype.types.num || this.type === _tokentype.types.string ? this.parseExprAtom() : this.parseIdent(true);\n};\n\n// Initialize empty function node.\n\npp.initFunction = function (node) {\n node.id = null;\n if (this.options.ecmaVersion >= 6) {\n node.generator = false;\n node.expression = false;\n }\n};\n\n// Parse object or class method.\n\npp.parseMethod = function (isGenerator) {\n var node = this.startNode(),\n oldInGen = this.inGenerator;\n this.inGenerator = isGenerator;\n this.initFunction(node);\n this.expect(_tokentype.types.parenL);\n node.params = this.parseBindingList(_tokentype.types.parenR, false, false);\n if (this.options.ecmaVersion >= 6) node.generator = isGenerator;\n this.parseFunctionBody(node, false);\n this.inGenerator = oldInGen;\n return this.finishNode(node, \"FunctionExpression\");\n};\n\n// Parse arrow function expression with given parameters.\n\npp.parseArrowExpression = function (node, params) {\n var oldInGen = this.inGenerator;\n this.inGenerator = false;\n this.initFunction(node);\n node.params = this.toAssignableList(params, true);\n this.parseFunctionBody(node, true);\n this.inGenerator = oldInGen;\n return this.finishNode(node, \"ArrowFunctionExpression\");\n};\n\n// Parse function body and check parameters.\n\npp.parseFunctionBody = function (node, isArrowFunction) {\n var isExpression = isArrowFunction && this.type !== _tokentype.types.braceL;\n\n if (isExpression) {\n node.body = this.parseMaybeAssign();\n node.expression = true;\n } else {\n // Start a new scope with regard to labels and the `inFunction`\n // flag (restore them to their old value afterwards).\n var oldInFunc = this.inFunction,\n oldLabels = this.labels;\n this.inFunction = true;this.labels = [];\n node.body = this.parseBlock(true);\n node.expression = false;\n this.inFunction = oldInFunc;this.labels = oldLabels;\n }\n\n // If this is a strict mode function, verify that argument names\n // are not repeated, and it does not try to bind the words `eval`\n // or `arguments`.\n if (this.strict || !isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) {\n var oldStrict = this.strict;\n this.strict = true;\n if (node.id) this.checkLVal(node.id, true);\n this.checkParams(node);\n this.strict = oldStrict;\n } else if (isArrowFunction) {\n this.checkParams(node);\n }\n};\n\n// Checks function params for various disallowed patterns such as using \"eval\"\n// or \"arguments\" and duplicate parameters.\n\npp.checkParams = function (node) {\n var nameHash = {};\n for (var i = 0; i < node.params.length; i++) {\n this.checkLVal(node.params[i], true, nameHash);\n }\n};\n\n// Parses a comma-separated list of expressions, and returns them as\n// an array. `close` is the token type that ends the list, and\n// `allowEmpty` can be turned on to allow subsequent commas with\n// nothing in between them to be parsed as `null` (which is needed\n// for array literals).\n\npp.parseExprList = function (close, allowTrailingComma, allowEmpty, refDestructuringErrors) {\n var elts = [],\n first = true;\n while (!this.eat(close)) {\n if (!first) {\n this.expect(_tokentype.types.comma);\n if (allowTrailingComma && this.afterTrailingComma(close)) break;\n } else first = false;\n\n var elt = undefined;\n if (allowEmpty && this.type === _tokentype.types.comma) elt = null;else if (this.type === _tokentype.types.ellipsis) {\n elt = this.parseSpread(refDestructuringErrors);\n if (this.type === _tokentype.types.comma && refDestructuringErrors && !refDestructuringErrors.trailingComma) {\n refDestructuringErrors.trailingComma = this.lastTokStart;\n }\n } else elt = this.parseMaybeAssign(false, refDestructuringErrors);\n elts.push(elt);\n }\n return elts;\n};\n\n// Parse the next token as an identifier. If `liberal` is true (used\n// when parsing properties), it will also convert keywords into\n// identifiers.\n\npp.parseIdent = function (liberal) {\n var node = this.startNode();\n if (liberal && this.options.allowReserved == \"never\") liberal = false;\n if (this.type === _tokentype.types.name) {\n if (!liberal && (this.strict ? this.reservedWordsStrict : this.reservedWords).test(this.value) && (this.options.ecmaVersion >= 6 || this.input.slice(this.start, this.end).indexOf(\"\\\\\") == -1)) this.raiseRecoverable(this.start, \"The keyword '\" + this.value + \"' is reserved\");\n if (!liberal && this.inGenerator && this.value === \"yield\") this.raiseRecoverable(this.start, \"Can not use 'yield' as identifier inside a generator\");\n node.name = this.value;\n } else if (liberal && this.type.keyword) {\n node.name = this.type.keyword;\n } else {\n this.unexpected();\n }\n this.next();\n return this.finishNode(node, \"Identifier\");\n};\n\n// Parses yield expression inside generator.\n\npp.parseYield = function () {\n var node = this.startNode();\n this.next();\n if (this.type == _tokentype.types.semi || this.canInsertSemicolon() || this.type != _tokentype.types.star && !this.type.startsExpr) {\n node.delegate = false;\n node.argument = null;\n } else {\n node.delegate = this.eat(_tokentype.types.star);\n node.argument = this.parseMaybeAssign();\n }\n return this.finishNode(node, \"YieldExpression\");\n};\n\n},{\"./state\":10,\"./tokentype\":14}],2:[function(_dereq_,module,exports){\n// Reserved word lists for various dialects of the language\n\n\"use strict\";\n\nexports.__esModule = true;\nexports.isIdentifierStart = isIdentifierStart;\nexports.isIdentifierChar = isIdentifierChar;\nvar reservedWords = {\n 3: \"abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile\",\n 5: \"class enum extends super const export import\",\n 6: \"enum\",\n 7: \"enum\",\n strict: \"implements interface let package private protected public static yield\",\n strictBind: \"eval arguments\"\n};\n\nexports.reservedWords = reservedWords;\n// And the keywords\n\nvar 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\";\n\nvar keywords = {\n 5: ecma5AndLessKeywords,\n 6: ecma5AndLessKeywords + \" const class extends export import super\"\n};\n\nexports.keywords = keywords;\n// ## Character categories\n\n// Big ugly regular expressions that match characters in the\n// whitespace, identifier, and identifier-start categories. These\n// are only applied when a character is found to actually have a\n// code point above 128.\n// Generated by `bin/generate-identifier-regex.js`.\n\nvar nonASCIIidentifierStartChars = \"ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠ-ࢴऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚౠౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿕ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞭꞰ-ꞷꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭥꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼA-Za-zヲ-하-ᅦᅧ-ᅬᅭ-ᅲᅳ-ᅵ\";\nvar nonASCIIidentifierChars = \"‌‍·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࣣ-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఃా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ഁ-ഃാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ංඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ູົຼ່-ໍ໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜔ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠐-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭ᳲ-᳴᳸᳹᷀-᷵᷼-᷿‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧꢀꢁꢴ-꣄꣐-꣙꣠-꣱꤀-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏0-9_\";\n\nvar nonASCIIidentifierStart = new RegExp(\"[\" + nonASCIIidentifierStartChars + \"]\");\nvar nonASCIIidentifier = new RegExp(\"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\");\n\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null;\n\n// These are a run-length and offset encoded representation of the\n// >0xffff code points that are a valid part of identifiers. The\n// offset starts at 0x10000, and each pair of numbers represents an\n// offset to the next range, and then a size of the range. They were\n// generated by bin/generate-identifier-regex.js\nvar 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, 66, 18, 2, 1, 11, 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, 56, 50, 14, 50, 785, 52, 76, 44, 33, 24, 27, 35, 42, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 287, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 86, 25, 391, 63, 32, 0, 449, 56, 1288, 921, 103, 110, 18, 195, 2749, 1070, 4050, 582, 8634, 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, 3, 5761, 10591, 541];\nvar 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, 10, 2, 4, 9, 83, 11, 168, 11, 6, 9, 7, 3, 57, 0, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 316, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 423, 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, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 3617, 6, 792618, 239];\n\n// This has a complexity linear to the value of the code. The\n// assumption is that looking up astral identifier characters is\n// rare.\nfunction isInAstralSet(code, set) {\n var pos = 0x10000;\n for (var i = 0; i < set.length; i += 2) {\n pos += set[i];\n if (pos > code) return false;\n pos += set[i + 1];\n if (pos >= code) return true;\n }\n}\n\n// Test whether a given character code starts an identifier.\n\nfunction isIdentifierStart(code, astral) {\n if (code < 65) return code === 36;\n if (code < 91) return true;\n if (code < 97) return code === 95;\n if (code < 123) return true;\n if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));\n if (astral === false) return false;\n return isInAstralSet(code, astralIdentifierStartCodes);\n}\n\n// Test whether a given character is part of an identifier.\n\nfunction isIdentifierChar(code, astral) {\n if (code < 48) return code === 36;\n if (code < 58) return true;\n if (code < 65) return false;\n if (code < 91) return true;\n if (code < 97) return code === 95;\n if (code < 123) return true;\n if (code <= 0xffff) return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));\n if (astral === false) return false;\n return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);\n}\n\n},{}],3:[function(_dereq_,module,exports){\n// Acorn is a tiny, fast JavaScript parser written in JavaScript.\n//\n// Acorn was written by Marijn Haverbeke, Ingvar Stepanyan, and\n// various contributors and released under an MIT license.\n//\n// Git repositories for Acorn are available at\n//\n// http://marijnhaverbeke.nl/git/acorn\n// https://github.com/ternjs/acorn.git\n//\n// Please use the [github bug tracker][ghbt] to report issues.\n//\n// [ghbt]: https://github.com/ternjs/acorn/issues\n//\n// This file defines the main parser interface. The library also comes\n// with a [error-tolerant parser][dammit] and an\n// [abstract syntax tree walker][walk], defined in other files.\n//\n// [dammit]: acorn_loose.js\n// [walk]: util/walk.js\n\n\"use strict\";\n\nexports.__esModule = true;\nexports.parse = parse;\nexports.parseExpressionAt = parseExpressionAt;\nexports.tokenizer = tokenizer;\n\nvar _state = _dereq_(\"./state\");\n\n_dereq_(\"./parseutil\");\n\n_dereq_(\"./statement\");\n\n_dereq_(\"./lval\");\n\n_dereq_(\"./expression\");\n\n_dereq_(\"./location\");\n\nexports.Parser = _state.Parser;\nexports.plugins = _state.plugins;\n\nvar _options = _dereq_(\"./options\");\n\nexports.defaultOptions = _options.defaultOptions;\n\nvar _locutil = _dereq_(\"./locutil\");\n\nexports.Position = _locutil.Position;\nexports.SourceLocation = _locutil.SourceLocation;\nexports.getLineInfo = _locutil.getLineInfo;\n\nvar _node = _dereq_(\"./node\");\n\nexports.Node = _node.Node;\n\nvar _tokentype = _dereq_(\"./tokentype\");\n\nexports.TokenType = _tokentype.TokenType;\nexports.tokTypes = _tokentype.types;\n\nvar _tokencontext = _dereq_(\"./tokencontext\");\n\nexports.TokContext = _tokencontext.TokContext;\nexports.tokContexts = _tokencontext.types;\n\nvar _identifier = _dereq_(\"./identifier\");\n\nexports.isIdentifierChar = _identifier.isIdentifierChar;\nexports.isIdentifierStart = _identifier.isIdentifierStart;\n\nvar _tokenize = _dereq_(\"./tokenize\");\n\nexports.Token = _tokenize.Token;\n\nvar _whitespace = _dereq_(\"./whitespace\");\n\nexports.isNewLine = _whitespace.isNewLine;\nexports.lineBreak = _whitespace.lineBreak;\nexports.lineBreakG = _whitespace.lineBreakG;\nvar version = \"3.1.0\";\n\nexports.version = version;\n// The main exported interface (under `self.acorn` when in the\n// browser) is a `parse` function that takes a code string and\n// returns an abstract syntax tree as specified by [Mozilla parser\n// API][api].\n//\n// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API\n\nfunction parse(input, options) {\n return new _state.Parser(options, input).parse();\n}\n\n// This function tries to parse a single expression at a given\n// offset in a string. Useful for parsing mixed-language formats\n// that embed JavaScript expressions.\n\nfunction parseExpressionAt(input, pos, options) {\n var p = new _state.Parser(options, input, pos);\n p.nextToken();\n return p.parseExpression();\n}\n\n// Acorn is organized as a tokenizer and a recursive-descent parser.\n// The `tokenizer` export provides an interface to the tokenizer.\n\nfunction tokenizer(input, options) {\n return new _state.Parser(options, input);\n}\n\n},{\"./expression\":1,\"./identifier\":2,\"./location\":4,\"./locutil\":5,\"./lval\":6,\"./node\":7,\"./options\":8,\"./parseutil\":9,\"./state\":10,\"./statement\":11,\"./tokencontext\":12,\"./tokenize\":13,\"./tokentype\":14,\"./whitespace\":16}],4:[function(_dereq_,module,exports){\n\"use strict\";\n\nvar _state = _dereq_(\"./state\");\n\nvar _locutil = _dereq_(\"./locutil\");\n\nvar pp = _state.Parser.prototype;\n\n// This function is used to raise exceptions on parse errors. It\n// takes an offset integer (into the current `input`) to indicate\n// the location of the error, attaches the position to the end\n// of the error message, and then raises a `SyntaxError` with that\n// message.\n\npp.raise = function (pos, message) {\n var loc = _locutil.getLineInfo(this.input, pos);\n message += \" (\" + loc.line + \":\" + loc.column + \")\";\n var err = new SyntaxError(message);\n err.pos = pos;err.loc = loc;err.raisedAt = this.pos;\n throw err;\n};\n\npp.raiseRecoverable = pp.raise;\n\npp.curPosition = function () {\n if (this.options.locations) {\n return new _locutil.Position(this.curLine, this.pos - this.lineStart);\n }\n};\n\n},{\"./locutil\":5,\"./state\":10}],5:[function(_dereq_,module,exports){\n\"use strict\";\n\nexports.__esModule = true;\nexports.getLineInfo = getLineInfo;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar _whitespace = _dereq_(\"./whitespace\");\n\n// These are used when `options.locations` is on, for the\n// `startLoc` and `endLoc` properties.\n\nvar Position = (function () {\n function Position(line, col) {\n _classCallCheck(this, Position);\n\n this.line = line;\n this.column = col;\n }\n\n Position.prototype.offset = function offset(n) {\n return new Position(this.line, this.column + n);\n };\n\n return Position;\n})();\n\nexports.Position = Position;\n\nvar SourceLocation = function SourceLocation(p, start, end) {\n _classCallCheck(this, SourceLocation);\n\n this.start = start;\n this.end = end;\n if (p.sourceFile !== null) this.source = p.sourceFile;\n}\n\n// The `getLineInfo` function is mostly useful when the\n// `locations` option is off (for performance reasons) and you\n// want to find the line/column position for a given character\n// offset. `input` should be the code string that the offset refers\n// into.\n\n;\n\nexports.SourceLocation = SourceLocation;\n\nfunction getLineInfo(input, offset) {\n for (var line = 1, cur = 0;;) {\n _whitespace.lineBreakG.lastIndex = cur;\n var match = _whitespace.lineBreakG.exec(input);\n if (match && match.index < offset) {\n ++line;\n cur = match.index + match[0].length;\n } else {\n return new Position(line, offset - cur);\n }\n }\n}\n\n},{\"./whitespace\":16}],6:[function(_dereq_,module,exports){\n\"use strict\";\n\nvar _tokentype = _dereq_(\"./tokentype\");\n\nvar _state = _dereq_(\"./state\");\n\nvar _util = _dereq_(\"./util\");\n\nvar pp = _state.Parser.prototype;\n\n// Convert existing expression atom to assignable pattern\n// if possible.\n\npp.toAssignable = function (node, isBinding) {\n if (this.options.ecmaVersion >= 6 && node) {\n switch (node.type) {\n case \"Identifier\":\n case \"ObjectPattern\":\n case \"ArrayPattern\":\n break;\n\n case \"ObjectExpression\":\n node.type = \"ObjectPattern\";\n for (var i = 0; i < node.properties.length; i++) {\n var prop = node.properties[i];\n if (prop.kind !== \"init\") this.raise(prop.key.start, \"Object pattern can't contain getter or setter\");\n this.toAssignable(prop.value, isBinding);\n }\n break;\n\n case \"ArrayExpression\":\n node.type = \"ArrayPattern\";\n this.toAssignableList(node.elements, isBinding);\n break;\n\n case \"AssignmentExpression\":\n if (node.operator === \"=\") {\n node.type = \"AssignmentPattern\";\n delete node.operator;\n // falls through to AssignmentPattern\n } else {\n this.raise(node.left.end, \"Only '=' operator can be used for specifying default value.\");\n break;\n }\n\n case \"AssignmentPattern\":\n if (node.right.type === \"YieldExpression\") this.raise(node.right.start, \"Yield expression cannot be a default value\");\n break;\n\n case \"ParenthesizedExpression\":\n node.expression = this.toAssignable(node.expression, isBinding);\n break;\n\n case \"MemberExpression\":\n if (!isBinding) break;\n\n default:\n this.raise(node.start, \"Assigning to rvalue\");\n }\n }\n return node;\n};\n\n// Convert list of expression atoms to binding list.\n\npp.toAssignableList = function (exprList, isBinding) {\n var end = exprList.length;\n if (end) {\n var last = exprList[end - 1];\n if (last && last.type == \"RestElement\") {\n --end;\n } else if (last && last.type == \"SpreadElement\") {\n last.type = \"RestElement\";\n var arg = last.argument;\n this.toAssignable(arg, isBinding);\n if (arg.type !== \"Identifier\" && arg.type !== \"MemberExpression\" && arg.type !== \"ArrayPattern\") this.unexpected(arg.start);\n --end;\n }\n\n if (isBinding && last.type === \"RestElement\" && last.argument.type !== \"Identifier\") this.unexpected(last.argument.start);\n }\n for (var i = 0; i < end; i++) {\n var elt = exprList[i];\n if (elt) this.toAssignable(elt, isBinding);\n }\n return exprList;\n};\n\n// Parses spread element.\n\npp.parseSpread = function (refDestructuringErrors) {\n var node = this.startNode();\n this.next();\n node.argument = this.parseMaybeAssign(refDestructuringErrors);\n return this.finishNode(node, \"SpreadElement\");\n};\n\npp.parseRest = function (allowNonIdent) {\n var node = this.startNode();\n this.next();\n\n // RestElement inside of a function parameter must be an identifier\n if (allowNonIdent) node.argument = this.type === _tokentype.types.name ? this.parseIdent() : this.unexpected();else node.argument = this.type === _tokentype.types.name || this.type === _tokentype.types.bracketL ? this.parseBindingAtom() : this.unexpected();\n\n return this.finishNode(node, \"RestElement\");\n};\n\n// Parses lvalue (assignable) atom.\n\npp.parseBindingAtom = function () {\n if (this.options.ecmaVersion < 6) return this.parseIdent();\n switch (this.type) {\n case _tokentype.types.name:\n return this.parseIdent();\n\n case _tokentype.types.bracketL:\n var node = this.startNode();\n this.next();\n node.elements = this.parseBindingList(_tokentype.types.bracketR, true, true);\n return this.finishNode(node, \"ArrayPattern\");\n\n case _tokentype.types.braceL:\n return this.parseObj(true);\n\n default:\n this.unexpected();\n }\n};\n\npp.parseBindingList = function (close, allowEmpty, allowTrailingComma, allowNonIdent) {\n var elts = [],\n first = true;\n while (!this.eat(close)) {\n if (first) first = false;else this.expect(_tokentype.types.comma);\n if (allowEmpty && this.type === _tokentype.types.comma) {\n elts.push(null);\n } else if (allowTrailingComma && this.afterTrailingComma(close)) {\n break;\n } else if (this.type === _tokentype.types.ellipsis) {\n var rest = this.parseRest(allowNonIdent);\n this.parseBindingListItem(rest);\n elts.push(rest);\n if (this.type === _tokentype.types.comma) this.raise(this.start, \"Comma is not permitted after the rest element\");\n this.expect(close);\n break;\n } else {\n var elem = this.parseMaybeDefault(this.start, this.startLoc);\n this.parseBindingListItem(elem);\n elts.push(elem);\n }\n }\n return elts;\n};\n\npp.parseBindingListItem = function (param) {\n return param;\n};\n\n// Parses assignment pattern around given atom if possible.\n\npp.parseMaybeDefault = function (startPos, startLoc, left) {\n left = left || this.parseBindingAtom();\n if (this.options.ecmaVersion < 6 || !this.eat(_tokentype.types.eq)) return left;\n var node = this.startNodeAt(startPos, startLoc);\n node.left = left;\n node.right = this.parseMaybeAssign();\n return this.finishNode(node, \"AssignmentPattern\");\n};\n\n// Verify that a node is an lval — something that can be assigned\n// to.\n\npp.checkLVal = function (expr, isBinding, checkClashes) {\n switch (expr.type) {\n case \"Identifier\":\n if (this.strict && this.reservedWordsStrictBind.test(expr.name)) this.raiseRecoverable(expr.start, (isBinding ? \"Binding \" : \"Assigning to \") + expr.name + \" in strict mode\");\n if (checkClashes) {\n if (_util.has(checkClashes, expr.name)) this.raiseRecoverable(expr.start, \"Argument name clash\");\n checkClashes[expr.name] = true;\n }\n break;\n\n case \"MemberExpression\":\n if (isBinding) this.raiseRecoverable(expr.start, (isBinding ? \"Binding\" : \"Assigning to\") + \" member expression\");\n break;\n\n case \"ObjectPattern\":\n for (var i = 0; i < expr.properties.length; i++) {\n this.checkLVal(expr.properties[i].value, isBinding, checkClashes);\n }break;\n\n case \"ArrayPattern\":\n for (var i = 0; i < expr.elements.length; i++) {\n var elem = expr.elements[i];\n if (elem) this.checkLVal(elem, isBinding, checkClashes);\n }\n break;\n\n case \"AssignmentPattern\":\n this.checkLVal(expr.left, isBinding, checkClashes);\n break;\n\n case \"RestElement\":\n this.checkLVal(expr.argument, isBinding, checkClashes);\n break;\n\n case \"ParenthesizedExpression\":\n this.checkLVal(expr.expression, isBinding, checkClashes);\n break;\n\n default:\n this.raise(expr.start, (isBinding ? \"Binding\" : \"Assigning to\") + \" rvalue\");\n }\n};\n\n},{\"./state\":10,\"./tokentype\":14,\"./util\":15}],7:[function(_dereq_,module,exports){\n\"use strict\";\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar _state = _dereq_(\"./state\");\n\nvar _locutil = _dereq_(\"./locutil\");\n\nvar Node = function Node(parser, pos, loc) {\n _classCallCheck(this, Node);\n\n this.type = \"\";\n this.start = pos;\n this.end = 0;\n if (parser.options.locations) this.loc = new _locutil.SourceLocation(parser, loc);\n if (parser.options.directSourceFile) this.sourceFile = parser.options.directSourceFile;\n if (parser.options.ranges) this.range = [pos, 0];\n}\n\n// Start an AST node, attaching a start offset.\n\n;\n\nexports.Node = Node;\nvar pp = _state.Parser.prototype;\n\npp.startNode = function () {\n return new Node(this, this.start, this.startLoc);\n};\n\npp.startNodeAt = function (pos, loc) {\n return new Node(this, pos, loc);\n};\n\n// Finish an AST node, adding `type` and `end` properties.\n\nfunction finishNodeAt(node, type, pos, loc) {\n node.type = type;\n node.end = pos;\n if (this.options.locations) node.loc.end = loc;\n if (this.options.ranges) node.range[1] = pos;\n return node;\n}\n\npp.finishNode = function (node, type) {\n return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc);\n};\n\n// Finish node at given position\n\npp.finishNodeAt = function (node, type, pos, loc) {\n return finishNodeAt.call(this, node, type, pos, loc);\n};\n\n},{\"./locutil\":5,\"./state\":10}],8:[function(_dereq_,module,exports){\n\"use strict\";\n\nexports.__esModule = true;\nexports.getOptions = getOptions;\n\nvar _util = _dereq_(\"./util\");\n\nvar _locutil = _dereq_(\"./locutil\");\n\n// A second optional argument can be given to further configure\n// the parser process. These options are recognized:\n\nvar defaultOptions = {\n // `ecmaVersion` indicates the ECMAScript version to parse. Must\n // be either 3, or 5, or 6. This influences support for strict\n // mode, the set of reserved words, support for getters and\n // setters and other features. The default is 6.\n ecmaVersion: 6,\n // Source type (\"script\" or \"module\") for different semantics\n sourceType: \"script\",\n // `onInsertedSemicolon` can be a callback that will be called\n // when a semicolon is automatically inserted. It will be passed\n // th position of the comma as an offset, and if `locations` is\n // enabled, it is given the location as a `{line, column}` object\n // as second argument.\n onInsertedSemicolon: null,\n // `onTrailingComma` is similar to `onInsertedSemicolon`, but for\n // trailing commas.\n onTrailingComma: null,\n // By default, reserved words are only enforced if ecmaVersion >= 5.\n // Set `allowReserved` to a boolean value to explicitly turn this on\n // an off. When this option has the value \"never\", reserved words\n // and keywords can also not be used as property names.\n allowReserved: null,\n // When enabled, a return at the top level is not considered an\n // error.\n allowReturnOutsideFunction: false,\n // When enabled, import/export statements are not constrained to\n // appearing at the top of the program.\n allowImportExportEverywhere: false,\n // When enabled, hashbang directive in the beginning of file\n // is allowed and treated as a line comment.\n allowHashBang: false,\n // When `locations` is on, `loc` properties holding objects with\n // `start` and `end` properties in `{line, column}` form (with\n // line being 1-based and column 0-based) will be attached to the\n // nodes.\n locations: false,\n // A function can be passed as `onToken` option, which will\n // cause Acorn to call that function with object in the same\n // format as tokens returned from `tokenizer().getToken()`. Note\n // that you are not allowed to call the parser from the\n // callback—that will corrupt its internal state.\n onToken: null,\n // A function can be passed as `onComment` option, which will\n // cause Acorn to call that function with `(block, text, start,\n // end)` parameters whenever a comment is skipped. `block` is a\n // boolean indicating whether this is a block (`/* */`) comment,\n // `text` is the content of the comment, and `start` and `end` are\n // character offsets that denote the start and end of the comment.\n // When the `locations` option is on, two more parameters are\n // passed, the full `{line, column}` locations of the start and\n // end of the comments. Note that you are not allowed to call the\n // parser from the callback—that will corrupt its internal state.\n onComment: null,\n // Nodes have their start and end characters offsets recorded in\n // `start` and `end` properties (directly on the node, rather than\n // the `loc` object, which holds line/column data. To also add a\n // [semi-standardized][range] `range` property holding a `[start,\n // end]` array with the same numbers, set the `ranges` option to\n // `true`.\n //\n // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678\n ranges: false,\n // It is possible to parse multiple files into a single AST by\n // passing the tree produced by parsing the first file as\n // `program` option in subsequent parses. This will add the\n // toplevel forms of the parsed file to the `Program` (top) node\n // of an existing parse tree.\n program: null,\n // When `locations` is on, you can pass this to record the source\n // file in every node's `loc` object.\n sourceFile: null,\n // This value, if given, is stored in every node, whether\n // `locations` is on or off.\n directSourceFile: null,\n // When enabled, parenthesized expressions are represented by\n // (non-standard) ParenthesizedExpression nodes\n preserveParens: false,\n plugins: {}\n};\n\nexports.defaultOptions = defaultOptions;\n// Interpret and default an options object\n\nfunction getOptions(opts) {\n var options = {};\n for (var opt in defaultOptions) {\n options[opt] = opts && _util.has(opts, opt) ? opts[opt] : defaultOptions[opt];\n }if (options.allowReserved == null) options.allowReserved = options.ecmaVersion < 5;\n\n if (_util.isArray(options.onToken)) {\n (function () {\n var tokens = options.onToken;\n options.onToken = function (token) {\n return tokens.push(token);\n };\n })();\n }\n if (_util.isArray(options.onComment)) options.onComment = pushComment(options, options.onComment);\n\n return options;\n}\n\nfunction pushComment(options, array) {\n return function (block, text, start, end, startLoc, endLoc) {\n var comment = {\n type: block ? 'Block' : 'Line',\n value: text,\n start: start,\n end: end\n };\n if (options.locations) comment.loc = new _locutil.SourceLocation(this, startLoc, endLoc);\n if (options.ranges) comment.range = [start, end];\n array.push(comment);\n };\n}\n\n},{\"./locutil\":5,\"./util\":15}],9:[function(_dereq_,module,exports){\n\"use strict\";\n\nvar _tokentype = _dereq_(\"./tokentype\");\n\nvar _state = _dereq_(\"./state\");\n\nvar _whitespace = _dereq_(\"./whitespace\");\n\nvar pp = _state.Parser.prototype;\n\n// ## Parser utilities\n\n// Test whether a statement node is the string literal `\"use strict\"`.\n\npp.isUseStrict = function (stmt) {\n return this.options.ecmaVersion >= 5 && stmt.type === \"ExpressionStatement\" && stmt.expression.type === \"Literal\" && stmt.expression.raw.slice(1, -1) === \"use strict\";\n};\n\n// Predicate that tests whether the next token is of the given\n// type, and if yes, consumes it as a side effect.\n\npp.eat = function (type) {\n if (this.type === type) {\n this.next();\n return true;\n } else {\n return false;\n }\n};\n\n// Tests whether parsed token is a contextual keyword.\n\npp.isContextual = function (name) {\n return this.type === _tokentype.types.name && this.value === name;\n};\n\n// Consumes contextual keyword if possible.\n\npp.eatContextual = function (name) {\n return this.value === name && this.eat(_tokentype.types.name);\n};\n\n// Asserts that following token is given contextual keyword.\n\npp.expectContextual = function (name) {\n if (!this.eatContextual(name)) this.unexpected();\n};\n\n// Test whether a semicolon can be inserted at the current position.\n\npp.canInsertSemicolon = function () {\n return this.type === _tokentype.types.eof || this.type === _tokentype.types.braceR || _whitespace.lineBreak.test(this.input.slice(this.lastTokEnd, this.start));\n};\n\npp.insertSemicolon = function () {\n if (this.canInsertSemicolon()) {\n if (this.options.onInsertedSemicolon) this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc);\n return true;\n }\n};\n\n// Consume a semicolon, or, failing that, see if we are allowed to\n// pretend that there is a semicolon at this position.\n\npp.semicolon = function () {\n if (!this.eat(_tokentype.types.semi) && !this.insertSemicolon()) this.unexpected();\n};\n\npp.afterTrailingComma = function (tokType) {\n if (this.type == tokType) {\n if (this.options.onTrailingComma) this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);\n this.next();\n return true;\n }\n};\n\n// Expect a token of a given type. If found, consume it, otherwise,\n// raise an unexpected token error.\n\npp.expect = function (type) {\n this.eat(type) || this.unexpected();\n};\n\n// Raise an unexpected token error.\n\npp.unexpected = function (pos) {\n this.raise(pos != null ? pos : this.start, \"Unexpected token\");\n};\n\npp.checkPatternErrors = function (refDestructuringErrors, andThrow) {\n var pos = refDestructuringErrors && refDestructuringErrors.trailingComma;\n if (!andThrow) return !!pos;\n if (pos) this.raise(pos, \"Comma is not permitted after the rest element\");\n};\n\npp.checkExpressionErrors = function (refDestructuringErrors, andThrow) {\n var pos = refDestructuringErrors && refDestructuringErrors.shorthandAssign;\n if (!andThrow) return !!pos;\n if (pos) this.raise(pos, \"Shorthand property assignments are valid only in destructuring patterns\");\n};\n\n},{\"./state\":10,\"./tokentype\":14,\"./whitespace\":16}],10:[function(_dereq_,module,exports){\n\"use strict\";\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar _identifier = _dereq_(\"./identifier\");\n\nvar _tokentype = _dereq_(\"./tokentype\");\n\nvar _whitespace = _dereq_(\"./whitespace\");\n\nvar _options = _dereq_(\"./options\");\n\n// Registered plugins\nvar plugins = {};\n\nexports.plugins = plugins;\nfunction keywordRegexp(words) {\n return new RegExp(\"^(\" + words.replace(/ /g, \"|\") + \")$\");\n}\n\nvar Parser = (function () {\n function Parser(options, input, startPos) {\n _classCallCheck(this, Parser);\n\n this.options = options = _options.getOptions(options);\n this.sourceFile = options.sourceFile;\n this.keywords = keywordRegexp(_identifier.keywords[options.ecmaVersion >= 6 ? 6 : 5]);\n var reserved = options.allowReserved ? \"\" : _identifier.reservedWords[options.ecmaVersion] + (options.sourceType == \"module\" ? \" await\" : \"\");\n this.reservedWords = keywordRegexp(reserved);\n var reservedStrict = (reserved ? reserved + \" \" : \"\") + _identifier.reservedWords.strict;\n this.reservedWordsStrict = keywordRegexp(reservedStrict);\n this.reservedWordsStrictBind = keywordRegexp(reservedStrict + \" \" + _identifier.reservedWords.strictBind);\n this.input = String(input);\n\n // Used to signal to callers of `readWord1` whether the word\n // contained any escape sequences. This is needed because words with\n // escape sequences must not be interpreted as keywords.\n this.containsEsc = false;\n\n // Load plugins\n this.loadPlugins(options.plugins);\n\n // Set up token state\n\n // The current position of the tokenizer in the input.\n if (startPos) {\n this.pos = startPos;\n this.lineStart = Math.max(0, this.input.lastIndexOf(\"\\n\", startPos));\n this.curLine = this.input.slice(0, this.lineStart).split(_whitespace.lineBreak).length;\n } else {\n this.pos = this.lineStart = 0;\n this.curLine = 1;\n }\n\n // Properties of the current token:\n // Its type\n this.type = _tokentype.types.eof;\n // For tokens that include more information than their type, the value\n this.value = null;\n // Its start and end offset\n this.start = this.end = this.pos;\n // And, if locations are used, the {line, column} object\n // corresponding to those offsets\n this.startLoc = this.endLoc = this.curPosition();\n\n // Position information for the previous token\n this.lastTokEndLoc = this.lastTokStartLoc = null;\n this.lastTokStart = this.lastTokEnd = this.pos;\n\n // The context stack is used to superficially track syntactic\n // context to predict whether a regular expression is allowed in a\n // given position.\n this.context = this.initialContext();\n this.exprAllowed = true;\n\n // Figure out if it's a module code.\n this.strict = this.inModule = options.sourceType === \"module\";\n\n // Used to signify the start of a potential arrow function\n this.potentialArrowAt = -1;\n\n // Flags to track whether we are in a function, a generator.\n this.inFunction = this.inGenerator = false;\n // Labels in scope.\n this.labels = [];\n\n // If enabled, skip leading hashbang line.\n if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === '#!') this.skipLineComment(2);\n }\n\n // DEPRECATED Kept for backwards compatibility until 3.0 in case a plugin uses them\n\n Parser.prototype.isKeyword = function isKeyword(word) {\n return this.keywords.test(word);\n };\n\n Parser.prototype.isReservedWord = function isReservedWord(word) {\n return this.reservedWords.test(word);\n };\n\n Parser.prototype.extend = function extend(name, f) {\n this[name] = f(this[name]);\n };\n\n Parser.prototype.loadPlugins = function loadPlugins(pluginConfigs) {\n for (var _name in pluginConfigs) {\n var plugin = plugins[_name];\n if (!plugin) throw new Error(\"Plugin '\" + _name + \"' not found\");\n plugin(this, pluginConfigs[_name]);\n }\n };\n\n Parser.prototype.parse = function parse() {\n var node = this.options.program || this.startNode();\n this.nextToken();\n return this.parseTopLevel(node);\n };\n\n return Parser;\n})();\n\nexports.Parser = Parser;\n\n},{\"./identifier\":2,\"./options\":8,\"./tokentype\":14,\"./whitespace\":16}],11:[function(_dereq_,module,exports){\n\"use strict\";\n\nvar _tokentype = _dereq_(\"./tokentype\");\n\nvar _state = _dereq_(\"./state\");\n\nvar _whitespace = _dereq_(\"./whitespace\");\n\nvar _identifier = _dereq_(\"./identifier\");\n\nvar pp = _state.Parser.prototype;\n\n// ### Statement parsing\n\n// Parse a program. Initializes the parser, reads any number of\n// statements, and wraps them in a Program node. Optionally takes a\n// `program` argument. If present, the statements will be appended\n// to its body instead of creating a new node.\n\npp.parseTopLevel = function (node) {\n var first = true;\n if (!node.body) node.body = [];\n while (this.type !== _tokentype.types.eof) {\n var stmt = this.parseStatement(true, true);\n node.body.push(stmt);\n if (first) {\n if (this.isUseStrict(stmt)) this.setStrict(true);\n first = false;\n }\n }\n this.next();\n if (this.options.ecmaVersion >= 6) {\n node.sourceType = this.options.sourceType;\n }\n return this.finishNode(node, \"Program\");\n};\n\nvar loopLabel = { kind: \"loop\" },\n switchLabel = { kind: \"switch\" };\n\npp.isLet = function () {\n if (this.type !== _tokentype.types.name || this.options.ecmaVersion < 6 || this.value != \"let\") return false;\n _whitespace.skipWhiteSpace.lastIndex = this.pos;\n var skip = _whitespace.skipWhiteSpace.exec(this.input);\n var next = this.pos + skip[0].length,\n nextCh = this.input.charCodeAt(next);\n if (nextCh === 91 || nextCh == 123) return true; // '{' and '['\n if (_identifier.isIdentifierStart(nextCh, true)) {\n for (var pos = next + 1; _identifier.isIdentifierChar(this.input.charCodeAt(pos, true)); ++pos) {}\n var ident = this.input.slice(next, pos);\n if (!this.isKeyword(ident)) return true;\n }\n return false;\n};\n\n// Parse a single statement.\n//\n// If expecting a statement and finding a slash operator, parse a\n// regular expression literal. This is to handle cases like\n// `if (foo) /blah/.exec(foo)`, where looking at the previous token\n// does not help.\n\npp.parseStatement = function (declaration, topLevel) {\n var starttype = this.type,\n node = this.startNode(),\n kind = undefined;\n\n if (this.isLet()) {\n starttype = _tokentype.types._var;\n kind = \"let\";\n }\n\n // Most types of statements are recognized by the keyword they\n // start with. Many are trivial to parse, some require a bit of\n // complexity.\n\n switch (starttype) {\n case _tokentype.types._break:case _tokentype.types._continue:\n return this.parseBreakContinueStatement(node, starttype.keyword);\n case _tokentype.types._debugger:\n return this.parseDebuggerStatement(node);\n case _tokentype.types._do:\n return this.parseDoStatement(node);\n case _tokentype.types._for:\n return this.parseForStatement(node);\n case _tokentype.types._function:\n if (!declaration && this.options.ecmaVersion >= 6) this.unexpected();\n return this.parseFunctionStatement(node);\n case _tokentype.types._class:\n if (!declaration) this.unexpected();\n return this.parseClass(node, true);\n case _tokentype.types._if:\n return this.parseIfStatement(node);\n case _tokentype.types._return:\n return this.parseReturnStatement(node);\n case _tokentype.types._switch:\n return this.parseSwitchStatement(node);\n case _tokentype.types._throw:\n return this.parseThrowStatement(node);\n case _tokentype.types._try:\n return this.parseTryStatement(node);\n case _tokentype.types._const:case _tokentype.types._var:\n kind = kind || this.value;\n if (!declaration && kind != \"var\") this.unexpected();\n return this.parseVarStatement(node, kind);\n case _tokentype.types._while:\n return this.parseWhileStatement(node);\n case _tokentype.types._with:\n return this.parseWithStatement(node);\n case _tokentype.types.braceL:\n return this.parseBlock();\n case _tokentype.types.semi:\n return this.parseEmptyStatement(node);\n case _tokentype.types._export:\n case _tokentype.types._import:\n if (!this.options.allowImportExportEverywhere) {\n if (!topLevel) this.raise(this.start, \"'import' and 'export' may only appear at the top level\");\n if (!this.inModule) this.raise(this.start, \"'import' and 'export' may appear only with 'sourceType: module'\");\n }\n return starttype === _tokentype.types._import ? this.parseImport(node) : this.parseExport(node);\n\n // If the statement does not start with a statement keyword or a\n // brace, it's an ExpressionStatement or LabeledStatement. We\n // simply start parsing an expression, and afterwards, if the\n // next token is a colon and the expression was a simple\n // Identifier node, we switch to interpreting it as a label.\n default:\n var maybeName = this.value,\n expr = this.parseExpression();\n if (starttype === _tokentype.types.name && expr.type === \"Identifier\" && this.eat(_tokentype.types.colon)) return this.parseLabeledStatement(node, maybeName, expr);else return this.parseExpressionStatement(node, expr);\n }\n};\n\npp.parseBreakContinueStatement = function (node, keyword) {\n var isBreak = keyword == \"break\";\n this.next();\n if (this.eat(_tokentype.types.semi) || this.insertSemicolon()) node.label = null;else if (this.type !== _tokentype.types.name) this.unexpected();else {\n node.label = this.parseIdent();\n this.semicolon();\n }\n\n // Verify that there is an actual destination to break or\n // continue to.\n for (var i = 0; i < this.labels.length; ++i) {\n var lab = this.labels[i];\n if (node.label == null || lab.name === node.label.name) {\n if (lab.kind != null && (isBreak || lab.kind === \"loop\")) break;\n if (node.label && isBreak) break;\n }\n }\n if (i === this.labels.length) this.raise(node.start, \"Unsyntactic \" + keyword);\n return this.finishNode(node, isBreak ? \"BreakStatement\" : \"ContinueStatement\");\n};\n\npp.parseDebuggerStatement = function (node) {\n this.next();\n this.semicolon();\n return this.finishNode(node, \"DebuggerStatement\");\n};\n\npp.parseDoStatement = function (node) {\n this.next();\n this.labels.push(loopLabel);\n node.body = this.parseStatement(false);\n this.labels.pop();\n this.expect(_tokentype.types._while);\n node.test = this.parseParenExpression();\n if (this.options.ecmaVersion >= 6) this.eat(_tokentype.types.semi);else this.semicolon();\n return this.finishNode(node, \"DoWhileStatement\");\n};\n\n// Disambiguating between a `for` and a `for`/`in` or `for`/`of`\n// loop is non-trivial. Basically, we have to parse the init `var`\n// statement or expression, disallowing the `in` operator (see\n// the second parameter to `parseExpression`), and then check\n// whether the next token is `in` or `of`. When there is no init\n// part (semicolon immediately after the opening parenthesis), it\n// is a regular `for` loop.\n\npp.parseForStatement = function (node) {\n this.next();\n this.labels.push(loopLabel);\n this.expect(_tokentype.types.parenL);\n if (this.type === _tokentype.types.semi) return this.parseFor(node, null);\n var isLet = this.isLet();\n if (this.type === _tokentype.types._var || this.type === _tokentype.types._const || isLet) {\n var _init = this.startNode(),\n kind = isLet ? \"let\" : this.value;\n this.next();\n this.parseVar(_init, true, kind);\n this.finishNode(_init, \"VariableDeclaration\");\n if ((this.type === _tokentype.types._in || this.options.ecmaVersion >= 6 && this.isContextual(\"of\")) && _init.declarations.length === 1 && !(kind !== \"var\" && _init.declarations[0].init)) return this.parseForIn(node, _init);\n return this.parseFor(node, _init);\n }\n var refDestructuringErrors = { shorthandAssign: 0, trailingComma: 0 };\n var init = this.parseExpression(true, refDestructuringErrors);\n if (this.type === _tokentype.types._in || this.options.ecmaVersion >= 6 && this.isContextual(\"of\")) {\n this.checkPatternErrors(refDestructuringErrors, true);\n this.toAssignable(init);\n this.checkLVal(init);\n return this.parseForIn(node, init);\n } else {\n this.checkExpressionErrors(refDestructuringErrors, true);\n }\n return this.parseFor(node, init);\n};\n\npp.parseFunctionStatement = function (node) {\n this.next();\n return this.parseFunction(node, true);\n};\n\npp.parseIfStatement = function (node) {\n this.next();\n node.test = this.parseParenExpression();\n node.consequent = this.parseStatement(false);\n node.alternate = this.eat(_tokentype.types._else) ? this.parseStatement(false) : null;\n return this.finishNode(node, \"IfStatement\");\n};\n\npp.parseReturnStatement = function (node) {\n if (!this.inFunction && !this.options.allowReturnOutsideFunction) this.raise(this.start, \"'return' outside of function\");\n this.next();\n\n // In `return` (and `break`/`continue`), the keywords with\n // optional arguments, we eagerly look for a semicolon or the\n // possibility to insert one.\n\n if (this.eat(_tokentype.types.semi) || this.insertSemicolon()) node.argument = null;else {\n node.argument = this.parseExpression();this.semicolon();\n }\n return this.finishNode(node, \"ReturnStatement\");\n};\n\npp.parseSwitchStatement = function (node) {\n this.next();\n node.discriminant = this.parseParenExpression();\n node.cases = [];\n this.expect(_tokentype.types.braceL);\n this.labels.push(switchLabel);\n\n // Statements under must be grouped (by label) in SwitchCase\n // nodes. `cur` is used to keep the node that we are currently\n // adding statements to.\n\n for (var cur, sawDefault = false; this.type != _tokentype.types.braceR;) {\n if (this.type === _tokentype.types._case || this.type === _tokentype.types._default) {\n var isCase = this.type === _tokentype.types._case;\n if (cur) this.finishNode(cur, \"SwitchCase\");\n node.cases.push(cur = this.startNode());\n cur.consequent = [];\n this.next();\n if (isCase) {\n cur.test = this.parseExpression();\n } else {\n if (sawDefault) this.raiseRecoverable(this.lastTokStart, \"Multiple default clauses\");\n sawDefault = true;\n cur.test = null;\n }\n this.expect(_tokentype.types.colon);\n } else {\n if (!cur) this.unexpected();\n cur.consequent.push(this.parseStatement(true));\n }\n }\n if (cur) this.finishNode(cur, \"SwitchCase\");\n this.next(); // Closing brace\n this.labels.pop();\n return this.finishNode(node, \"SwitchStatement\");\n};\n\npp.parseThrowStatement = function (node) {\n this.next();\n if (_whitespace.lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) this.raise(this.lastTokEnd, \"Illegal newline after throw\");\n node.argument = this.parseExpression();\n this.semicolon();\n return this.finishNode(node, \"ThrowStatement\");\n};\n\n// Reused empty array added for node fields that are always empty.\n\nvar empty = [];\n\npp.parseTryStatement = function (node) {\n this.next();\n node.block = this.parseBlock();\n node.handler = null;\n if (this.type === _tokentype.types._catch) {\n var clause = this.startNode();\n this.next();\n this.expect(_tokentype.types.parenL);\n clause.param = this.parseBindingAtom();\n this.checkLVal(clause.param, true);\n this.expect(_tokentype.types.parenR);\n clause.body = this.parseBlock();\n node.handler = this.finishNode(clause, \"CatchClause\");\n }\n node.finalizer = this.eat(_tokentype.types._finally) ? this.parseBlock() : null;\n if (!node.handler && !node.finalizer) this.raise(node.start, \"Missing catch or finally clause\");\n return this.finishNode(node, \"TryStatement\");\n};\n\npp.parseVarStatement = function (node, kind) {\n this.next();\n this.parseVar(node, false, kind);\n this.semicolon();\n return this.finishNode(node, \"VariableDeclaration\");\n};\n\npp.parseWhileStatement = function (node) {\n this.next();\n node.test = this.parseParenExpression();\n this.labels.push(loopLabel);\n node.body = this.parseStatement(false);\n this.labels.pop();\n return this.finishNode(node, \"WhileStatement\");\n};\n\npp.parseWithStatement = function (node) {\n if (this.strict) this.raise(this.start, \"'with' in strict mode\");\n this.next();\n node.object = this.parseParenExpression();\n node.body = this.parseStatement(false);\n return this.finishNode(node, \"WithStatement\");\n};\n\npp.parseEmptyStatement = function (node) {\n this.next();\n return this.finishNode(node, \"EmptyStatement\");\n};\n\npp.parseLabeledStatement = function (node, maybeName, expr) {\n for (var i = 0; i < this.labels.length; ++i) {\n if (this.labels[i].name === maybeName) this.raise(expr.start, \"Label '\" + maybeName + \"' is already declared\");\n }var kind = this.type.isLoop ? \"loop\" : this.type === _tokentype.types._switch ? \"switch\" : null;\n for (var i = this.labels.length - 1; i >= 0; i--) {\n var label = this.labels[i];\n if (label.statementStart == node.start) {\n label.statementStart = this.start;\n label.kind = kind;\n } else break;\n }\n this.labels.push({ name: maybeName, kind: kind, statementStart: this.start });\n node.body = this.parseStatement(true);\n this.labels.pop();\n node.label = expr;\n return this.finishNode(node, \"LabeledStatement\");\n};\n\npp.parseExpressionStatement = function (node, expr) {\n node.expression = expr;\n this.semicolon();\n return this.finishNode(node, \"ExpressionStatement\");\n};\n\n// Parse a semicolon-enclosed block of statements, handling `\"use\n// strict\"` declarations when `allowStrict` is true (used for\n// function bodies).\n\npp.parseBlock = function (allowStrict) {\n var node = this.startNode(),\n first = true,\n oldStrict = undefined;\n node.body = [];\n this.expect(_tokentype.types.braceL);\n while (!this.eat(_tokentype.types.braceR)) {\n var stmt = this.parseStatement(true);\n node.body.push(stmt);\n if (first && allowStrict && this.isUseStrict(stmt)) {\n oldStrict = this.strict;\n this.setStrict(this.strict = true);\n }\n first = false;\n }\n if (oldStrict === false) this.setStrict(false);\n return this.finishNode(node, \"BlockStatement\");\n};\n\n// Parse a regular `for` loop. The disambiguation code in\n// `parseStatement` will already have parsed the init statement or\n// expression.\n\npp.parseFor = function (node, init) {\n node.init = init;\n this.expect(_tokentype.types.semi);\n node.test = this.type === _tokentype.types.semi ? null : this.parseExpression();\n this.expect(_tokentype.types.semi);\n node.update = this.type === _tokentype.types.parenR ? null : this.parseExpression();\n this.expect(_tokentype.types.parenR);\n node.body = this.parseStatement(false);\n this.labels.pop();\n return this.finishNode(node, \"ForStatement\");\n};\n\n// Parse a `for`/`in` and `for`/`of` loop, which are almost\n// same from parser's perspective.\n\npp.parseForIn = function (node, init) {\n var type = this.type === _tokentype.types._in ? \"ForInStatement\" : \"ForOfStatement\";\n this.next();\n node.left = init;\n node.right = this.parseExpression();\n this.expect(_tokentype.types.parenR);\n node.body = this.parseStatement(false);\n this.labels.pop();\n return this.finishNode(node, type);\n};\n\n// Parse a list of variable declarations.\n\npp.parseVar = function (node, isFor, kind) {\n node.declarations = [];\n node.kind = kind;\n for (;;) {\n var decl = this.startNode();\n this.parseVarId(decl);\n if (this.eat(_tokentype.types.eq)) {\n decl.init = this.parseMaybeAssign(isFor);\n } else if (kind === \"const\" && !(this.type === _tokentype.types._in || this.options.ecmaVersion >= 6 && this.isContextual(\"of\"))) {\n this.unexpected();\n } else if (decl.id.type != \"Identifier\" && !(isFor && (this.type === _tokentype.types._in || this.isContextual(\"of\")))) {\n this.raise(this.lastTokEnd, \"Complex binding patterns require an initialization value\");\n } else {\n decl.init = null;\n }\n node.declarations.push(this.finishNode(decl, \"VariableDeclarator\"));\n if (!this.eat(_tokentype.types.comma)) break;\n }\n return node;\n};\n\npp.parseVarId = function (decl) {\n decl.id = this.parseBindingAtom();\n this.checkLVal(decl.id, true);\n};\n\n// Parse a function declaration or literal (depending on the\n// `isStatement` parameter).\n\npp.parseFunction = function (node, isStatement, allowExpressionBody) {\n this.initFunction(node);\n if (this.options.ecmaVersion >= 6) node.generator = this.eat(_tokentype.types.star);\n var oldInGen = this.inGenerator;\n this.inGenerator = node.generator;\n if (isStatement || this.type === _tokentype.types.name) node.id = this.parseIdent();\n this.parseFunctionParams(node);\n this.parseFunctionBody(node, allowExpressionBody);\n this.inGenerator = oldInGen;\n return this.finishNode(node, isStatement ? \"FunctionDeclaration\" : \"FunctionExpression\");\n};\n\npp.parseFunctionParams = function (node) {\n this.expect(_tokentype.types.parenL);\n node.params = this.parseBindingList(_tokentype.types.parenR, false, false, true);\n};\n\n// Parse a class declaration or literal (depending on the\n// `isStatement` parameter).\n\npp.parseClass = function (node, isStatement) {\n this.next();\n this.parseClassId(node, isStatement);\n this.parseClassSuper(node);\n var classBody = this.startNode();\n var hadConstructor = false;\n classBody.body = [];\n this.expect(_tokentype.types.braceL);\n while (!this.eat(_tokentype.types.braceR)) {\n if (this.eat(_tokentype.types.semi)) continue;\n var method = this.startNode();\n var isGenerator = this.eat(_tokentype.types.star);\n var isMaybeStatic = this.type === _tokentype.types.name && this.value === \"static\";\n this.parsePropertyName(method);\n method[\"static\"] = isMaybeStatic && this.type !== _tokentype.types.parenL;\n if (method[\"static\"]) {\n if (isGenerator) this.unexpected();\n isGenerator = this.eat(_tokentype.types.star);\n this.parsePropertyName(method);\n }\n method.kind = \"method\";\n var isGetSet = false;\n if (!method.computed) {\n var key = method.key;\n\n if (!isGenerator && key.type === \"Identifier\" && this.type !== _tokentype.types.parenL && (key.name === \"get\" || key.name === \"set\")) {\n isGetSet = true;\n method.kind = key.name;\n key = this.parsePropertyName(method);\n }\n if (!method[\"static\"] && (key.type === \"Identifier\" && key.name === \"constructor\" || key.type === \"Literal\" && key.value === \"constructor\")) {\n if (hadConstructor) this.raise(key.start, \"Duplicate constructor in the same class\");\n if (isGetSet) this.raise(key.start, \"Constructor can't have get/set modifier\");\n if (isGenerator) this.raise(key.start, \"Constructor can't be a generator\");\n method.kind = \"constructor\";\n hadConstructor = true;\n }\n }\n this.parseClassMethod(classBody, method, isGenerator);\n if (isGetSet) {\n var paramCount = method.kind === \"get\" ? 0 : 1;\n if (method.value.params.length !== paramCount) {\n var start = method.value.start;\n if (method.kind === \"get\") this.raiseRecoverable(start, \"getter should have no params\");else this.raiseRecoverable(start, \"setter should have exactly one param\");\n }\n if (method.kind === \"set\" && method.value.params[0].type === \"RestElement\") this.raise(method.value.params[0].start, \"Setter cannot use rest params\");\n }\n }\n node.body = this.finishNode(classBody, \"ClassBody\");\n return this.finishNode(node, isStatement ? \"ClassDeclaration\" : \"ClassExpression\");\n};\n\npp.parseClassMethod = function (classBody, method, isGenerator) {\n method.value = this.parseMethod(isGenerator);\n classBody.body.push(this.finishNode(method, \"MethodDefinition\"));\n};\n\npp.parseClassId = function (node, isStatement) {\n node.id = this.type === _tokentype.types.name ? this.parseIdent() : isStatement ? this.unexpected() : null;\n};\n\npp.parseClassSuper = function (node) {\n node.superClass = this.eat(_tokentype.types._extends) ? this.parseExprSubscripts() : null;\n};\n\n// Parses module export declaration.\n\npp.parseExport = function (node) {\n this.next();\n // export * from '...'\n if (this.eat(_tokentype.types.star)) {\n this.expectContextual(\"from\");\n node.source = this.type === _tokentype.types.string ? this.parseExprAtom() : this.unexpected();\n this.semicolon();\n return this.finishNode(node, \"ExportAllDeclaration\");\n }\n if (this.eat(_tokentype.types._default)) {\n // export default ...\n var parens = this.type == _tokentype.types.parenL;\n var expr = this.parseMaybeAssign();\n var needsSemi = true;\n if (!parens && (expr.type == \"FunctionExpression\" || expr.type == \"ClassExpression\")) {\n needsSemi = false;\n if (expr.id) {\n expr.type = expr.type == \"FunctionExpression\" ? \"FunctionDeclaration\" : \"ClassDeclaration\";\n }\n }\n node.declaration = expr;\n if (needsSemi) this.semicolon();\n return this.finishNode(node, \"ExportDefaultDeclaration\");\n }\n // export var|const|let|function|class ...\n if (this.shouldParseExportStatement()) {\n node.declaration = this.parseStatement(true);\n node.specifiers = [];\n node.source = null;\n } else {\n // export { x, y as z } [from '...']\n node.declaration = null;\n node.specifiers = this.parseExportSpecifiers();\n if (this.eatContextual(\"from\")) {\n node.source = this.type === _tokentype.types.string ? this.parseExprAtom() : this.unexpected();\n } else {\n // check for keywords used as local names\n for (var i = 0; i < node.specifiers.length; i++) {\n if (this.keywords.test(node.specifiers[i].local.name) || this.reservedWords.test(node.specifiers[i].local.name)) {\n this.unexpected(node.specifiers[i].local.start);\n }\n }\n\n node.source = null;\n }\n this.semicolon();\n }\n return this.finishNode(node, \"ExportNamedDeclaration\");\n};\n\npp.shouldParseExportStatement = function () {\n return this.type.keyword || this.isLet();\n};\n\n// Parses a comma-separated list of module exports.\n\npp.parseExportSpecifiers = function () {\n var nodes = [],\n first = true;\n // export { x, y as z } [from '...']\n this.expect(_tokentype.types.braceL);\n while (!this.eat(_tokentype.types.braceR)) {\n if (!first) {\n this.expect(_tokentype.types.comma);\n if (this.afterTrailingComma(_tokentype.types.braceR)) break;\n } else first = false;\n\n var node = this.startNode();\n node.local = this.parseIdent(this.type === _tokentype.types._default);\n node.exported = this.eatContextual(\"as\") ? this.parseIdent(true) : node.local;\n nodes.push(this.finishNode(node, \"ExportSpecifier\"));\n }\n return nodes;\n};\n\n// Parses import declaration.\n\npp.parseImport = function (node) {\n this.next();\n // import '...'\n if (this.type === _tokentype.types.string) {\n node.specifiers = empty;\n node.source = this.parseExprAtom();\n } else {\n node.specifiers = this.parseImportSpecifiers();\n this.expectContextual(\"from\");\n node.source = this.type === _tokentype.types.string ? this.parseExprAtom() : this.unexpected();\n }\n this.semicolon();\n return this.finishNode(node, \"ImportDeclaration\");\n};\n\n// Parses a comma-separated list of module imports.\n\npp.parseImportSpecifiers = function () {\n var nodes = [],\n first = true;\n if (this.type === _tokentype.types.name) {\n // import defaultObj, { x, y as z } from '...'\n var node = this.startNode();\n node.local = this.parseIdent();\n this.checkLVal(node.local, true);\n nodes.push(this.finishNode(node, \"ImportDefaultSpecifier\"));\n if (!this.eat(_tokentype.types.comma)) return nodes;\n }\n if (this.type === _tokentype.types.star) {\n var node = this.startNode();\n this.next();\n this.expectContextual(\"as\");\n node.local = this.parseIdent();\n this.checkLVal(node.local, true);\n nodes.push(this.finishNode(node, \"ImportNamespaceSpecifier\"));\n return nodes;\n }\n this.expect(_tokentype.types.braceL);\n while (!this.eat(_tokentype.types.braceR)) {\n if (!first) {\n this.expect(_tokentype.types.comma);\n if (this.afterTrailingComma(_tokentype.types.braceR)) break;\n } else first = false;\n\n var node = this.startNode();\n node.imported = this.parseIdent(true);\n if (this.eatContextual(\"as\")) {\n node.local = this.parseIdent();\n } else {\n node.local = node.imported;\n if (this.isKeyword(node.local.name)) this.unexpected(node.local.start);\n if (this.reservedWordsStrict.test(node.local.name)) this.raise(node.local.start, \"The keyword '\" + node.local.name + \"' is reserved\");\n }\n this.checkLVal(node.local, true);\n nodes.push(this.finishNode(node, \"ImportSpecifier\"));\n }\n return nodes;\n};\n\n},{\"./identifier\":2,\"./state\":10,\"./tokentype\":14,\"./whitespace\":16}],12:[function(_dereq_,module,exports){\n// The algorithm used to determine whether a regexp can appear at a\n// given point in the program is loosely based on sweet.js' approach.\n// See https://github.com/mozilla/sweet.js/wiki/design\n\n\"use strict\";\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar _state = _dereq_(\"./state\");\n\nvar _tokentype = _dereq_(\"./tokentype\");\n\nvar _whitespace = _dereq_(\"./whitespace\");\n\nvar TokContext = function TokContext(token, isExpr, preserveSpace, override) {\n _classCallCheck(this, TokContext);\n\n this.token = token;\n this.isExpr = !!isExpr;\n this.preserveSpace = !!preserveSpace;\n this.override = override;\n};\n\nexports.TokContext = TokContext;\nvar types = {\n b_stat: new TokContext(\"{\", false),\n b_expr: new TokContext(\"{\", true),\n b_tmpl: new TokContext(\"${\", true),\n p_stat: new TokContext(\"(\", false),\n p_expr: new TokContext(\"(\", true),\n q_tmpl: new TokContext(\"`\", true, true, function (p) {\n return p.readTmplToken();\n }),\n f_expr: new TokContext(\"function\", true)\n};\n\nexports.types = types;\nvar pp = _state.Parser.prototype;\n\npp.initialContext = function () {\n return [types.b_stat];\n};\n\npp.braceIsBlock = function (prevType) {\n if (prevType === _tokentype.types.colon) {\n var _parent = this.curContext();\n if (_parent === types.b_stat || _parent === types.b_expr) return !_parent.isExpr;\n }\n if (prevType === _tokentype.types._return) return _whitespace.lineBreak.test(this.input.slice(this.lastTokEnd, this.start));\n if (prevType === _tokentype.types._else || prevType === _tokentype.types.semi || prevType === _tokentype.types.eof || prevType === _tokentype.types.parenR) return true;\n if (prevType == _tokentype.types.braceL) return this.curContext() === types.b_stat;\n return !this.exprAllowed;\n};\n\npp.updateContext = function (prevType) {\n var update = undefined,\n type = this.type;\n if (type.keyword && prevType == _tokentype.types.dot) this.exprAllowed = false;else if (update = type.updateContext) update.call(this, prevType);else this.exprAllowed = type.beforeExpr;\n};\n\n// Token-specific context update code\n\n_tokentype.types.parenR.updateContext = _tokentype.types.braceR.updateContext = function () {\n if (this.context.length == 1) {\n this.exprAllowed = true;\n return;\n }\n var out = this.context.pop();\n if (out === types.b_stat && this.curContext() === types.f_expr) {\n this.context.pop();\n this.exprAllowed = false;\n } else if (out === types.b_tmpl) {\n this.exprAllowed = true;\n } else {\n this.exprAllowed = !out.isExpr;\n }\n};\n\n_tokentype.types.braceL.updateContext = function (prevType) {\n this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr);\n this.exprAllowed = true;\n};\n\n_tokentype.types.dollarBraceL.updateContext = function () {\n this.context.push(types.b_tmpl);\n this.exprAllowed = true;\n};\n\n_tokentype.types.parenL.updateContext = function (prevType) {\n var statementParens = prevType === _tokentype.types._if || prevType === _tokentype.types._for || prevType === _tokentype.types._with || prevType === _tokentype.types._while;\n this.context.push(statementParens ? types.p_stat : types.p_expr);\n this.exprAllowed = true;\n};\n\n_tokentype.types.incDec.updateContext = function () {\n // tokExprAllowed stays unchanged\n};\n\n_tokentype.types._function.updateContext = function (prevType) {\n if (prevType.beforeExpr && prevType !== _tokentype.types.semi && prevType !== _tokentype.types._else && (prevType !== _tokentype.types.colon || this.curContext() !== types.b_stat)) this.context.push(types.f_expr);\n this.exprAllowed = false;\n};\n\n_tokentype.types.backQuote.updateContext = function () {\n if (this.curContext() === types.q_tmpl) this.context.pop();else this.context.push(types.q_tmpl);\n this.exprAllowed = false;\n};\n\n},{\"./state\":10,\"./tokentype\":14,\"./whitespace\":16}],13:[function(_dereq_,module,exports){\n\"use strict\";\n\nexports.__esModule = true;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar _identifier = _dereq_(\"./identifier\");\n\nvar _tokentype = _dereq_(\"./tokentype\");\n\nvar _state = _dereq_(\"./state\");\n\nvar _locutil = _dereq_(\"./locutil\");\n\nvar _whitespace = _dereq_(\"./whitespace\");\n\n// Object type used to represent tokens. Note that normally, tokens\n// simply exist as properties on the parser object. This is only\n// used for the onToken callback and the external tokenizer.\n\nvar Token = function Token(p) {\n _classCallCheck(this, Token);\n\n this.type = p.type;\n this.value = p.value;\n this.start = p.start;\n this.end = p.end;\n if (p.options.locations) this.loc = new _locutil.SourceLocation(p, p.startLoc, p.endLoc);\n if (p.options.ranges) this.range = [p.start, p.end];\n}\n\n// ## Tokenizer\n\n;\n\nexports.Token = Token;\nvar pp = _state.Parser.prototype;\n\n// Are we running under Rhino?\nvar isRhino = typeof Packages == \"object\" && Object.prototype.toString.call(Packages) == \"[object JavaPackage]\";\n\n// Move to the next token\n\npp.next = function () {\n if (this.options.onToken) this.options.onToken(new Token(this));\n\n this.lastTokEnd = this.end;\n this.lastTokStart = this.start;\n this.lastTokEndLoc = this.endLoc;\n this.lastTokStartLoc = this.startLoc;\n this.nextToken();\n};\n\npp.getToken = function () {\n this.next();\n return new Token(this);\n};\n\n// If we're in an ES6 environment, make parsers iterable\nif (typeof Symbol !== \"undefined\") pp[Symbol.iterator] = function () {\n var self = this;\n return { next: function next() {\n var token = self.getToken();\n return {\n done: token.type === _tokentype.types.eof,\n value: token\n };\n } };\n};\n\n// Toggle strict mode. Re-reads the next number or string to please\n// pedantic tests (`\"use strict\"; 010;` should fail).\n\npp.setStrict = function (strict) {\n this.strict = strict;\n if (this.type !== _tokentype.types.num && this.type !== _tokentype.types.string) return;\n this.pos = this.start;\n if (this.options.locations) {\n while (this.pos < this.lineStart) {\n this.lineStart = this.input.lastIndexOf(\"\\n\", this.lineStart - 2) + 1;\n --this.curLine;\n }\n }\n this.nextToken();\n};\n\npp.curContext = function () {\n return this.context[this.context.length - 1];\n};\n\n// Read a single token, updating the parser object's token-related\n// properties.\n\npp.nextToken = function () {\n var curContext = this.curContext();\n if (!curContext || !curContext.preserveSpace) this.skipSpace();\n\n this.start = this.pos;\n if (this.options.locations) this.startLoc = this.curPosition();\n if (this.pos >= this.input.length) return this.finishToken(_tokentype.types.eof);\n\n if (curContext.override) return curContext.override(this);else this.readToken(this.fullCharCodeAtPos());\n};\n\npp.readToken = function (code) {\n // Identifier or keyword. '\\uXXXX' sequences are allowed in\n // identifiers, so '\\' also dispatches to that.\n if (_identifier.isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\\' */) return this.readWord();\n\n return this.getTokenFromCode(code);\n};\n\npp.fullCharCodeAtPos = function () {\n var code = this.input.charCodeAt(this.pos);\n if (code <= 0xd7ff || code >= 0xe000) return code;\n var next = this.input.charCodeAt(this.pos + 1);\n return (code << 10) + next - 0x35fdc00;\n};\n\npp.skipBlockComment = function () {\n var startLoc = this.options.onComment && this.curPosition();\n var start = this.pos,\n end = this.input.indexOf(\"*/\", this.pos += 2);\n if (end === -1) this.raise(this.pos - 2, \"Unterminated comment\");\n this.pos = end + 2;\n if (this.options.locations) {\n _whitespace.lineBreakG.lastIndex = start;\n var match = undefined;\n while ((match = _whitespace.lineBreakG.exec(this.input)) && match.index < this.pos) {\n ++this.curLine;\n this.lineStart = match.index + match[0].length;\n }\n }\n if (this.options.onComment) this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos, startLoc, this.curPosition());\n};\n\npp.skipLineComment = function (startSkip) {\n var start = this.pos;\n var startLoc = this.options.onComment && this.curPosition();\n var ch = this.input.charCodeAt(this.pos += startSkip);\n while (this.pos < this.input.length && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {\n ++this.pos;\n ch = this.input.charCodeAt(this.pos);\n }\n if (this.options.onComment) this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos, startLoc, this.curPosition());\n};\n\n// Called at the start of the parse and after every token. Skips\n// whitespace and comments, and.\n\npp.skipSpace = function () {\n loop: while (this.pos < this.input.length) {\n var ch = this.input.charCodeAt(this.pos);\n switch (ch) {\n case 32:case 160:\n // ' '\n ++this.pos;\n break;\n case 13:\n if (this.input.charCodeAt(this.pos + 1) === 10) {\n ++this.pos;\n }\n case 10:case 8232:case 8233:\n ++this.pos;\n if (this.options.locations) {\n ++this.curLine;\n this.lineStart = this.pos;\n }\n break;\n case 47:\n // '/'\n switch (this.input.charCodeAt(this.pos + 1)) {\n case 42:\n // '*'\n this.skipBlockComment();\n break;\n case 47:\n this.skipLineComment(2);\n break;\n default:\n break loop;\n }\n break;\n default:\n if (ch > 8 && ch < 14 || ch >= 5760 && _whitespace.nonASCIIwhitespace.test(String.fromCharCode(ch))) {\n ++this.pos;\n } else {\n break loop;\n }\n }\n }\n};\n\n// Called at the end of every token. Sets `end`, `val`, and\n// maintains `context` and `exprAllowed`, and skips the space after\n// the token, so that the next one's `start` will point at the\n// right position.\n\npp.finishToken = function (type, val) {\n this.end = this.pos;\n if (this.options.locations) this.endLoc = this.curPosition();\n var prevType = this.type;\n this.type = type;\n this.value = val;\n\n this.updateContext(prevType);\n};\n\n// ### Token reading\n\n// This is the function that is called to fetch the next token. It\n// is somewhat obscure, because it works in character codes rather\n// than characters, and because operator parsing has been inlined\n// into it.\n//\n// All in the name of speed.\n//\npp.readToken_dot = function () {\n var next = this.input.charCodeAt(this.pos + 1);\n if (next >= 48 && next <= 57) return this.readNumber(true);\n var next2 = this.input.charCodeAt(this.pos + 2);\n if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) {\n // 46 = dot '.'\n this.pos += 3;\n return this.finishToken(_tokentype.types.ellipsis);\n } else {\n ++this.pos;\n return this.finishToken(_tokentype.types.dot);\n }\n};\n\npp.readToken_slash = function () {\n // '/'\n var next = this.input.charCodeAt(this.pos + 1);\n if (this.exprAllowed) {\n ++this.pos;return this.readRegexp();\n }\n if (next === 61) return this.finishOp(_tokentype.types.assign, 2);\n return this.finishOp(_tokentype.types.slash, 1);\n};\n\npp.readToken_mult_modulo_exp = function (code) {\n // '%*'\n var next = this.input.charCodeAt(this.pos + 1);\n var size = 1;\n var tokentype = code === 42 ? _tokentype.types.star : _tokentype.types.modulo;\n\n // exponentiation operator ** and **=\n if (this.options.ecmaVersion >= 7 && next === 42) {\n ++size;\n tokentype = _tokentype.types.starstar;\n next = this.input.charCodeAt(this.pos + 2);\n }\n\n if (next === 61) return this.finishOp(_tokentype.types.assign, size + 1);\n return this.finishOp(tokentype, size);\n};\n\npp.readToken_pipe_amp = function (code) {\n // '|&'\n var next = this.input.charCodeAt(this.pos + 1);\n if (next === code) return this.finishOp(code === 124 ? _tokentype.types.logicalOR : _tokentype.types.logicalAND, 2);\n if (next === 61) return this.finishOp(_tokentype.types.assign, 2);\n return this.finishOp(code === 124 ? _tokentype.types.bitwiseOR : _tokentype.types.bitwiseAND, 1);\n};\n\npp.readToken_caret = function () {\n // '^'\n var next = this.input.charCodeAt(this.pos + 1);\n if (next === 61) return this.finishOp(_tokentype.types.assign, 2);\n return this.finishOp(_tokentype.types.bitwiseXOR, 1);\n};\n\npp.readToken_plus_min = function (code) {\n // '+-'\n var next = this.input.charCodeAt(this.pos + 1);\n if (next === code) {\n if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 && _whitespace.lineBreak.test(this.input.slice(this.lastTokEnd, this.pos))) {\n // A `-->` line comment\n this.skipLineComment(3);\n this.skipSpace();\n return this.nextToken();\n }\n return this.finishOp(_tokentype.types.incDec, 2);\n }\n if (next === 61) return this.finishOp(_tokentype.types.assign, 2);\n return this.finishOp(_tokentype.types.plusMin, 1);\n};\n\npp.readToken_lt_gt = function (code) {\n // '<>'\n var next = this.input.charCodeAt(this.pos + 1);\n var size = 1;\n if (next === code) {\n size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;\n if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(_tokentype.types.assign, size + 1);\n return this.finishOp(_tokentype.types.bitShift, size);\n }\n if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 && this.input.charCodeAt(this.pos + 3) == 45) {\n if (this.inModule) this.unexpected();\n // `