astexplorer.app/vendor/astexplorer/out/54.js

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

(window.webpackJsonp=window.webpackJsonp||[]).push([[54],{"./node_modules/babylon5/lib/index.js":function(module,exports,__webpack_require__){"use strict";eval('\n\nexports.__esModule = true;\nexports.parse = parse;\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }\n\nvar _parser = __webpack_require__("./node_modules/babylon5/lib/parser/index.js");\n\nvar _parser2 = _interopRequireDefault(_parser);\n\n__webpack_require__("./node_modules/babylon5/lib/parser/util.js");\n\n__webpack_require__("./node_modules/babylon5/lib/parser/statement.js");\n\n__webpack_require__("./node_modules/babylon5/lib/parser/lval.js");\n\n__webpack_require__("./node_modules/babylon5/lib/parser/expression.js");\n\n__webpack_require__("./node_modules/babylon5/lib/parser/node.js");\n\n__webpack_require__("./node_modules/babylon5/lib/parser/location.js");\n\n__webpack_require__("./node_modules/babylon5/lib/parser/comments.js");\n\nvar _tokenizerTypes = __webpack_require__("./node_modules/babylon5/lib/tokenizer/types.js");\n\n__webpack_require__("./node_modules/babylon5/lib/tokenizer/index.js");\n\n__webpack_require__("./node_modules/babylon5/lib/tokenizer/context.js");\n\nvar _pluginsFlow = __webpack_require__("./node_modules/babylon5/lib/plugins/flow.js");\n\nvar _pluginsFlow2 = _interopRequireDefault(_pluginsFlow);\n\nvar _pluginsJsx = __webpack_require__("./node_modules/babylon5/lib/plugins/jsx/index.js");\n\nvar _pluginsJsx2 = _interopRequireDefault(_pluginsJsx);\n\n_parser.plugins.flow = _pluginsFlow2["default"];\n_parser.plugins.jsx = _pluginsJsx2["default"];\n\nfunction parse(input, options) {\n  return new _parser2["default"](options, input).parse();\n}\n\nexports.tokTypes = _tokenizerTypes.types;\n\n//# sourceURL=webpack:///./node_modules/babylon5/lib/index.js?')},"./node_modules/babylon5/lib/options.js":function(module,exports,__webpack_require__){"use strict";eval('// A second optional argument can be given to further configure\n// the parser process. These options are recognized:\n\n\n\nexports.__esModule = true;\nexports.getOptions = getOptions;\nvar defaultOptions = {\n  // Source type ("script" or "module") for different semantics\n  sourceType: "script",\n  // By default, reserved words are not enforced. Disable\n  // `allowReserved` to enforce them. When this option has the\n  // value "never", reserved words and keywords can also not be\n  // used as property names.\n  allowReserved: true,\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  plugins: {},\n  // Babel-specific options\n  features: {},\n  strictMode: null\n};\n\nexports.defaultOptions = defaultOptions;\n// Interpret and default an options object\n\nfunction getOptions(opts) {\n  var options = {};\n  for (var key in defaultOptions) {\n    options[key] = opts && key in opts ? opts[key] : defaultOptions[key];\n  }\n  return options;\n}\n\n//# sourceURL=webpack:///./node_modules/babylon5/lib/options.js?')},"./node_modules/babylon5/lib/parser/comments.js":function(module,exports,__webpack_require__){"use strict";eval('/**\n * Based on the comment attachment algorithm used in espree and estraverse.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright\n *   notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n *   notice, this list of conditions and the following disclaimer in the\n *   documentation and/or other materials provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n\n\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }\n\nvar _index = __webpack_require__("./node_modules/babylon5/lib/parser/index.js");\n\nvar _index2 = _interopRequireDefault(_index);\n\nfunction last(stack) {\n  return stack[stack.length - 1];\n}\n\nvar pp = _index2["default"].prototype;\n\npp.addComment = function (comment) {\n  this.state.trailingComments.push(comment);\n  this.state.leadingComments.push(comment);\n};\n\npp.processComment = function (node) {\n  if (node.type === "Program" && node.body.length > 0) return;\n\n  var stack = this.state.commentStack;\n\n  var lastChild, trailingComments, i;\n\n  if (this.state.trailingComments.length > 0) {\n    // If the first comment in trailingComments comes after the\n    // current node, then we\'re good - all comments in the array will\n    // come after the node and so it\'s safe to add them as official\n    // trailingComments.\n    if (this.state.trailingComments[0].start >= node.end) {\n      trailingComments = this.state.trailingComments;\n      this.state.trailingComments = [];\n    } else {\n      // Otherwise, if the first comment doesn\'t come after the\n      // current node, that means we have a mix of leading and trailing\n      // comments in the array and that leadingComments contains the\n      // same items as trailingComments. Reset trailingComments to\n      // zero items and we\'ll handle this by evaluating leadingComments\n      // later.\n      this.state.trailingComments.length = 0;\n    }\n  } else {\n    var lastInStack = last(stack);\n    if (stack.length > 0 && lastInStack.trailingComments && lastInStack.trailingComments[0].start >= node.end) {\n      trailingComments = lastInStack.trailingComments;\n      lastInStack.trailingComments = null;\n    }\n  }\n\n  // Eating the stack.\n  while (stack.length > 0 && last(stack).start >= node.start) {\n    lastChild = stack.pop();\n  }\n\n  if (lastChild) {\n    if (lastChild.leadingComments) {\n      if (lastChild !== node && last(lastChild.leadingComments).end <= node.start) {\n        node.leadingComments = lastChild.leadingComments;\n        lastChild.leadingComments = null;\n      } else {\n        // A leading comment for an anonymous class had been stolen by its first MethodDefinition,\n        // so this takes back the leading comment.\n        // See also: https://github.com/eslint/espree/issues/158\n        for (i = lastChild.leadingComments.length - 2; i >= 0; --i) {\n          if (lastChild.leadingComments[i].end <= node.start) {\n            node.leadingComments = lastChild.leadingComments.splice(0, i + 1);\n            break;\n          }\n        }\n      }\n    }\n  } else if (this.state.leadingComments.length > 0) {\n    if (last(this.state.leadingComments).end <= node.start) {\n      node.leadingComments = this.state.leadingComments;\n      this.state.leadingComments = [];\n    } else {\n      // https://github.com/eslint/espree/issues/2\n      //\n      // In special cases, such as return (without a value) and\n      // debugger, all comments will end up as leadingComments and\n      // will otherwise be eliminated. This step runs when the\n      // commentStack is empty and there are comments left\n      // in leadingComments.\n      //\n      // This loop figures out the stopping point between the actual\n      // leading and trailing comments by finding the location of the\n      // first comment that comes after the given node.\n      for (i = 0; i < this.state.leadingComments.length; i++) {\n        if (this.state.leadingComments[i].end > node.start) {\n          break;\n        }\n      }\n\n      // Split the array based on the location of the first comment\n      // that comes after the node. Keep in mind that this could\n      // result in an empty array, and if so, the array must be\n      // deleted.\n      node.leadingComments = this.state.leadingComments.slice(0, i);\n      if (node.leadingComments.length === 0) {\n        node.leadingComments = null;\n      }\n\n      // Similarly, trailing comments are attached later. The variable\n      // must be reset to null if there are no trailing comments.\n      trailingComments = this.state.leadingComments.slice(i);\n      if (trailingComments.length === 0) {\n        trailingComments = null;\n      }\n    }\n  }\n\n  if (trailingComments) {\n    if (trailingComments.length && trailingComments[0].start >= node.start && last(trailingComments).end <= node.end) {\n      node.innerComments = trailingComments;\n    } else {\n      node.trailingComments = trailingComments;\n    }\n  }\n\n  stack.push(node);\n};\n\n//# sourceURL=webpack:///./node_modules/babylon5/lib/parser/comments.js?')},"./node_modules/babylon5/lib/parser/expression.js":function(module,exports,__webpack_require__){"use strict";eval('// A recursive descent parser operates by defining functions for all\n// syntactic elements, and recursively calling those, each function\n// advancing the input stream and returning an AST node. Precedence\n// of constructs (for example, the fact that `!x[1]` means `!(x[1])`\n// instead of `(!x)[1]` is handled by the fact that the parser\n// function that parses unary prefix operators is called first, and\n// in turn calls the function that parses `[]` subscripts — that\n// way, it\'ll receive the node for `x[1]` already parsed, and wraps\n// *that* in the unary operator node.\n//\n// Acorn uses an [operator precedence parser][opp] to handle binary\n// operator precedence, because it is much more compact than using\n// the technique outlined above, which uses different, nesting\n// functions to specify precedence, for all of the ten binary\n// precedence levels that JavaScript defines.\n//\n// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser\n\n\n\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }\n\nvar _tokenizerTypes = __webpack_require__("./node_modules/babylon5/lib/tokenizer/types.js");\n\nvar _index = __webpack_require__("./node_modules/babylon5/lib/parser/index.js");\n\nvar _index2 = _interopRequireDefault(_index);\n\nvar _utilIdentifier = __webpack_require__("./node_modules/babylon5/lib/util/identifier.js");\n\nvar pp = _index2["default"].prototype;\n\n// Check if property name clashes with already added.\n// Object/class getters and setters are not allowed to clash —\n// either with each other or with an init property — and in\n// strict mode, init properties are also not allowed to be repeated.\n\npp.checkPropClash = function (prop, propHash) {\n  if (prop.computed || prop.method || prop.shorthand) return;\n\n  var key = prop.key,\n      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\n  var kind = prop.kind;\n  if (name === "__proto__" && kind === "init") {\n    if (propHash.proto) this.raise(key.start, "Redefinition of __proto__ property");\n    propHash.proto = true;\n  }\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, refShorthandDefaultPos) {\n  var startPos = this.state.start,\n      startLoc = this.state.startLoc;\n  var expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos);\n  if (this.match(_tokenizerTypes.types.comma)) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.expressions = [expr];\n    while (this.eat(_tokenizerTypes.types.comma)) {\n      node.expressions.push(this.parseMaybeAssign(noIn, refShorthandDefaultPos));\n    }\n    this.toReferencedList(node.expressions);\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, refShorthandDefaultPos, afterLeftParse) {\n  if (this.match(_tokenizerTypes.types._yield) && this.state.inGenerator) {\n    return this.parseYield();\n  }\n\n  var failOnShorthandAssign = undefined;\n  if (!refShorthandDefaultPos) {\n    refShorthandDefaultPos = { start: 0 };\n    failOnShorthandAssign = true;\n  } else {\n    failOnShorthandAssign = false;\n  }\n  var startPos = this.state.start,\n      startLoc = this.state.startLoc;\n  if (this.match(_tokenizerTypes.types.parenL) || this.match(_tokenizerTypes.types.name)) {\n    this.state.potentialArrowAt = this.state.start;\n  }\n  var left = this.parseMaybeConditional(noIn, refShorthandDefaultPos);\n  if (afterLeftParse) left = afterLeftParse.call(this, left, startPos, startLoc);\n  if (this.state.type.isAssign) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.operator = this.state.value;\n    node.left = this.match(_tokenizerTypes.types.eq) ? this.toAssignable(left) : left;\n    refShorthandDefaultPos.start = 0; // reset because shorthand default was used correctly\n    this.checkLVal(left);\n    if (left.parenthesizedExpression) {\n      var errorMsg = undefined;\n      if (left.type === "ObjectPattern") {\n        errorMsg = "`({a}) = 0` use `({a} = 0)`";\n      } else if (left.type === "ArrayPattern") {\n        errorMsg = "`([a]) = 0` use `([a] = 0)`";\n      }\n      if (errorMsg) {\n        this.raise(left.start, "You\'re trying to assign to a parenthesized expression, eg. instead of " + errorMsg);\n      }\n    }\n    this.next();\n    node.right = this.parseMaybeAssign(noIn);\n    return this.finishNode(node, "AssignmentExpression");\n  } else if (failOnShorthandAssign && refShorthandDefaultPos.start) {\n    this.unexpected(refShorthandDefaultPos.start);\n  }\n  return left;\n};\n\n// Parse a ternary conditional (`?:`) operator.\n\npp.parseMaybeConditional = function (noIn, refShorthandDefaultPos) {\n  var startPos = this.state.start,\n      startLoc = this.state.startLoc;\n  var expr = this.parseExprOps(noIn, refShorthandDefaultPos);\n  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;\n  if (this.eat(_tokenizerTypes.types.question)) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.test = expr;\n    node.consequent = this.parseMaybeAssign();\n    this.expect(_tokenizerTypes.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, refShorthandDefaultPos) {\n  var startPos = this.state.start,\n      startLoc = this.state.startLoc;\n  var expr = this.parseMaybeUnary(refShorthandDefaultPos);\n  if (refShorthandDefaultPos && refShorthandDefaultPos.start) {\n    return expr;\n  } else {\n    return this.parseExprOp(expr, startPos, startLoc, -1, noIn);\n  }\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.state.type.binop;\n  if (prec != null && (!noIn || !this.match(_tokenizerTypes.types._in))) {\n    if (prec > minPrec) {\n      var node = this.startNodeAt(leftStartPos, leftStartLoc);\n      node.left = left;\n      node.operator = this.state.value;\n      var op = this.state.type;\n      this.next();\n      var startPos = this.state.start,\n          startLoc = this.state.startLoc;\n      node.right = this.parseExprOp(this.parseMaybeUnary(), startPos, startLoc, op.rightAssociative ? prec - 1 : prec, noIn);\n      this.finishNode(node, op === _tokenizerTypes.types.logicalOR || op === _tokenizerTypes.types.logicalAND ? "LogicalExpression" : "BinaryExpression");\n      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn);\n    }\n  }\n  return left;\n};\n\n// Parse unary operators, both prefix and postfix.\n\npp.parseMaybeUnary = function (refShorthandDefaultPos) {\n  if (this.state.type.prefix) {\n    var node = this.startNode(),\n        update = this.match(_tokenizerTypes.types.incDec);\n    node.operator = this.state.value;\n    node.prefix = true;\n    this.next();\n    node.argument = this.parseMaybeUnary();\n    if (refShorthandDefaultPos && refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);\n    if (update) {\n      this.checkLVal(node.argument);\n    } else if (this.strict && node.operator === "delete" && node.argument.type === "Identifier") {\n      this.raise(node.start, "Deleting local variable in strict mode");\n    }\n    return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");\n  }\n\n  var startPos = this.state.start,\n      startLoc = this.state.startLoc;\n  var expr = this.parseExprSubscripts(refShorthandDefaultPos);\n  if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;\n  while (this.state.type.postfix && !this.canInsertSemicolon()) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.operator = this.state.value;\n    node.prefix = false;\n    node.argument = expr;\n    this.checkLVal(expr);\n    this.next();\n    expr = this.finishNode(node, "UpdateExpression");\n  }\n  return expr;\n};\n\n// Parse call, dot, and `[]`-subscript expressions.\n\npp.parseExprSubscripts = function (refShorthandDefaultPos) {\n  var startPos = this.state.start,\n      startLoc = this.state.startLoc;\n  var expr = this.parseExprAtom(refShorthandDefaultPos);\n  if (refShorthandDefaultPos && refShorthandDefaultPos.start) {\n    return expr;\n  } else {\n    return this.parseSubscripts(expr, startPos, startLoc);\n  }\n};\n\npp.parseSubscripts = function (base, startPos, startLoc, noCalls) {\n  for (;;) {\n    if (!noCalls && this.eat(_tokenizerTypes.types.doubleColon)) {\n      var node = this.startNodeAt(startPos, startLoc);\n      node.object = base;\n      node.callee = this.parseNoCallExpr();\n      return this.parseSubscripts(this.finishNode(node, "BindExpression"), startPos, startLoc, noCalls);\n    } else if (this.eat(_tokenizerTypes.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(_tokenizerTypes.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(_tokenizerTypes.types.bracketR);\n      base = this.finishNode(node, "MemberExpression");\n    } else if (!noCalls && this.match(_tokenizerTypes.types.parenL)) {\n      var possibleAsync = base.type === "Identifier" && base.name === "async" && !this.canInsertSemicolon();\n      this.next();\n\n      var node = this.startNodeAt(startPos, startLoc);\n      node.callee = base;\n      node.arguments = this.parseExprList(_tokenizerTypes.types.parenR, this.options.features["es7.trailingFunctionCommas"]);\n      base = this.finishNode(node, "CallExpression");\n\n      if (possibleAsync && (this.match(_tokenizerTypes.types.colon) || this.match(_tokenizerTypes.types.arrow))) {\n        base = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startPos, startLoc), node);\n      } else {\n        this.toReferencedList(node.arguments);\n      }\n    } else if (this.match(_tokenizerTypes.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\npp.parseAsyncArrowFromCallExpression = function (node, call) {\n  if (!this.options.features["es7.asyncFunctions"]) this.unexpected();\n  this.expect(_tokenizerTypes.types.arrow);\n  return this.parseArrowExpression(node, call.arguments, true);\n};\n\n// Parse a no-call expression (like argument of `new` or `::` operators).\n\npp.parseNoCallExpr = function () {\n  var startPos = this.state.start,\n      startLoc = this.state.startLoc;\n  return this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);\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 (refShorthandDefaultPos) {\n  var node = undefined,\n      canBeArrow = this.state.potentialArrowAt === this.state.start;\n  switch (this.state.type) {\n    case _tokenizerTypes.types._super:\n      if (!this.state.inFunction) this.raise(this.state.start, "\'super\' outside of function or class");\n    case _tokenizerTypes.types._this:\n      var type = this.match(_tokenizerTypes.types._this) ? "ThisExpression" : "Super";\n      node = this.startNode();\n      this.next();\n      return this.finishNode(node, type);\n\n    case _tokenizerTypes.types._yield:\n      if (this.state.inGenerator) this.unexpected();\n\n    case _tokenizerTypes.types._do:\n      if (this.options.features["es7.doExpressions"]) {\n        var _node = this.startNode();\n        this.next();\n        var oldInFunction = this.state.inFunction;\n        var oldLabels = this.state.labels;\n        this.state.labels = [];\n        this.state.inFunction = false;\n        _node.body = this.parseBlock();\n        this.state.inFunction = oldInFunction;\n        this.state.labels = oldLabels;\n        return this.finishNode(_node, "DoExpression");\n      }\n\n    case _tokenizerTypes.types.name:\n      node = this.startNode();\n      var id = this.parseIdent(true);\n\n      if (this.options.features["es7.asyncFunctions"]) {\n        if (id.name === "await") {\n          if (this.inAsync) return this.parseAwait(node);\n        } else if (id.name === "async" && this.match(_tokenizerTypes.types._function) && !this.canInsertSemicolon()) {\n          this.next();\n          return this.parseFunction(node, false, false, true);\n        } else if (canBeArrow && id.name === "async" && this.match(_tokenizerTypes.types.name)) {\n          var params = [this.parseIdent()];\n          this.expect(_tokenizerTypes.types.arrow);\n          // var foo = bar => {};\n          return this.parseArrowExpression(node, params, true);\n        }\n      }\n\n      if (canBeArrow && !this.canInsertSemicolon() && this.eat(_tokenizerTypes.types.arrow)) {\n        return this.parseArrowExpression(node, [id]);\n      }\n\n      return id;\n\n    case _tokenizerTypes.types.regexp:\n      var value = this.state.value;\n      node = this.parseLiteral(value.value);\n      node.regex = { pattern: value.pattern, flags: value.flags };\n      return node;\n\n    case _tokenizerTypes.types.num:case _tokenizerTypes.types.string:\n      return this.parseLiteral(this.state.value);\n\n    case _tokenizerTypes.types._null:case _tokenizerTypes.types._true:case _tokenizerTypes.types._false:\n      node = this.startNode();\n      node.rawValue = node.value = this.match(_tokenizerTypes.types._null) ? null : this.match(_tokenizerTypes.types._true);\n      node.raw = this.state.type.keyword;\n      this.next();\n      return this.finishNode(node, "Literal");\n\n    case _tokenizerTypes.types.parenL:\n      return this.parseParenAndDistinguishExpression(null, null, canBeArrow);\n\n    case _tokenizerTypes.types.bracketL:\n      node = this.startNode();\n      this.next();\n      // check whether this is array comprehension or regular array\n      if (this.options.features["es7.comprehensions"] && this.match(_tokenizerTypes.types._for)) {\n        return this.parseComprehension(node, false);\n      }\n      node.elements = this.parseExprList(_tokenizerTypes.types.bracketR, true, true, refShorthandDefaultPos);\n      this.toReferencedList(node.elements);\n      return this.finishNode(node, "ArrayExpression");\n\n    case _tokenizerTypes.types.braceL:\n      return this.parseObj(false, refShorthandDefaultPos);\n\n    case _tokenizerTypes.types._function:\n      node = this.startNode();\n      this.next();\n      return this.parseFunction(node, false);\n\n    case _tokenizerTypes.types.at:\n      this.parseDecorators();\n\n    case _tokenizerTypes.types._class:\n      node = this.startNode();\n      this.takeDecorators(node);\n      return this.parseClass(node, false);\n\n    case _tokenizerTypes.types._new:\n      return this.parseNew();\n\n    case _tokenizerTypes.types.backQuote:\n      return this.parseTemplate();\n\n    case _tokenizerTypes.types.doubleColon:\n      node = this.startNode();\n      this.next();\n      node.object = null;\n      var callee = node.callee = this.parseNoCallExpr();\n      if (callee.type === "MemberExpression") {\n        return this.finishNode(node, "BindExpression");\n      } else {\n        this.raise(callee.start, "Binding should be performed on object property.");\n      }\n\n    default:\n      this.unexpected();\n  }\n};\n\npp.parseLiteral = function (value) {\n  var node = this.startNode();\n  node.rawValue = node.value = value;\n  node.raw = this.input.slice(this.state.start, this.state.end);\n  this.next();\n  return this.finishNode(node, "Literal");\n};\n\npp.parseParenExpression = function () {\n  this.expect(_tokenizerTypes.types.parenL);\n  var val = this.parseExpression();\n  this.expect(_tokenizerTypes.types.parenR);\n  return val;\n};\n\npp.parseParenAndDistinguishExpression = function (startPos, startLoc, canBeArrow, isAsync) {\n  startPos = startPos || this.state.start;\n  startLoc = startLoc || this.state.startLoc;\n  var val = undefined;\n  this.next();\n\n  if (this.options.features["es7.comprehensions"] && this.match(_tokenizerTypes.types._for)) {\n    return this.parseComprehension(this.startNodeAt(startPos, startLoc), true);\n  }\n\n  var innerStartPos = this.state.start,\n      innerStartLoc = this.state.startLoc;\n  var exprList = [],\n      first = true;\n  var refShorthandDefaultPos = { start: 0 },\n      spreadStart = undefined,\n      innerParenStart = undefined,\n      optionalCommaStart = undefined;\n  while (!this.match(_tokenizerTypes.types.parenR)) {\n    if (first) {\n      first = false;\n    } else {\n      this.expect(_tokenizerTypes.types.comma);\n      if (this.match(_tokenizerTypes.types.parenR) && this.options.features["es7.trailingFunctionCommas"]) {\n        optionalCommaStart = this.state.start;\n        break;\n      }\n    }\n\n    if (this.match(_tokenizerTypes.types.ellipsis)) {\n      var spreadNodeStartPos = this.state.start,\n          spreadNodeStartLoc = this.state.startLoc;\n      spreadStart = this.state.start;\n      exprList.push(this.parseParenItem(this.parseRest(), spreadNodeStartLoc, spreadNodeStartPos));\n      break;\n    } else {\n      if (this.match(_tokenizerTypes.types.parenL) && !innerParenStart) {\n        innerParenStart = this.state.start;\n      }\n      exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos, this.parseParenItem));\n    }\n  }\n  var innerEndPos = this.state.start;\n  var innerEndLoc = this.state.startLoc;\n  this.expect(_tokenizerTypes.types.parenR);\n\n  if (canBeArrow && !this.canInsertSemicolon() && this.eat(_tokenizerTypes.types.arrow)) {\n    if (innerParenStart) this.unexpected(innerParenStart);\n    return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, isAsync);\n  }\n\n  if (!exprList.length) {\n    if (isAsync) {\n      return;\n    } else {\n      this.unexpected(this.state.lastTokStart);\n    }\n  }\n  if (optionalCommaStart) this.unexpected(optionalCommaStart);\n  if (spreadStart) this.unexpected(spreadStart);\n  if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);\n\n  if (exprList.length > 1) {\n    val = this.startNodeAt(innerStartPos, innerStartLoc);\n    val.expressions = exprList;\n    this.toReferencedList(val.expressions);\n    this.finishNodeAt(val, "SequenceExpression", innerEndPos, innerEndLoc);\n  } else {\n    val = exprList[0];\n  }\n\n  val.parenthesizedExpression = true;\n  return val;\n};\n\npp.parseParenItem = function (node) {\n  return node;\n};\n\n// New\'s precedence is slightly tricky. It must allow its argument\n// to be a `[]` or dot subscript expression, but not a call — at\n// least, not without wrapping it in parentheses. Thus, it uses the\n\npp.parseNew = function () {\n  var node = this.startNode();\n  var meta = this.parseIdent(true);\n\n  if (this.eat(_tokenizerTypes.types.dot)) {\n    node.meta = meta;\n    node.property = this.parseIdent(true);\n\n    if (node.property.name !== "target") {\n      this.raise(node.property.start, "The only valid meta property for new is new.target");\n    }\n\n    return this.finishNode(node, "MetaProperty");\n  }\n\n  node.callee = this.parseNoCallExpr();\n\n  if (this.eat(_tokenizerTypes.types.parenL)) {\n    node.arguments = this.parseExprList(_tokenizerTypes.types.parenR, this.options.features["es7.trailingFunctionCommas"]);\n    this.toReferencedList(node.arguments);\n  } else {\n    node.arguments = [];\n  }\n\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.state.start, this.state.end).replace(/\\r\\n?/g, "\\n"),\n    cooked: this.state.value\n  };\n  this.next();\n  elem.tail = this.match(_tokenizerTypes.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(_tokenizerTypes.types.dollarBraceL);\n    node.expressions.push(this.parseExpression());\n    this.expect(_tokenizerTypes.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, refShorthandDefaultPos) {\n  var node = this.startNode(),\n      first = true,\n      propHash = Object.create(null);\n  node.properties = [];\n  var decorators = [];\n  this.next();\n  while (!this.eat(_tokenizerTypes.types.braceR)) {\n    if (first) {\n      first = false;\n    } else {\n      this.expect(_tokenizerTypes.types.comma);\n      if (this.eat(_tokenizerTypes.types.braceR)) break;\n    }\n\n    while (this.match(_tokenizerTypes.types.at)) {\n      decorators.push(this.parseDecorator());\n    }\n\n    var prop = this.startNode(),\n        isGenerator = false,\n        isAsync = false,\n        startPos = undefined,\n        startLoc = undefined;\n    if (decorators.length) {\n      prop.decorators = decorators;\n      decorators = [];\n    }\n    if (this.options.features["es7.objectRestSpread"] && this.match(_tokenizerTypes.types.ellipsis)) {\n      prop = this.parseSpread();\n      prop.type = "SpreadProperty";\n      node.properties.push(prop);\n      continue;\n    }\n    prop.method = false;\n    prop.shorthand = false;\n    if (isPattern || refShorthandDefaultPos) {\n      startPos = this.state.start;\n      startLoc = this.state.startLoc;\n    }\n    if (!isPattern) {\n      isGenerator = this.eat(_tokenizerTypes.types.star);\n    }\n    if (!isPattern && this.options.features["es7.asyncFunctions"] && this.isContextual("async")) {\n      if (isGenerator) this.unexpected();\n      var asyncId = this.parseIdent();\n      if (this.match(_tokenizerTypes.types.colon) || this.match(_tokenizerTypes.types.parenL) || this.match(_tokenizerTypes.types.braceR)) {\n        prop.key = asyncId;\n      } else {\n        isAsync = true;\n        this.parsePropertyName(prop);\n      }\n    } else {\n      this.parsePropertyName(prop);\n    }\n    this.parseObjPropValue(prop, startPos, startLoc, isGenerator, isAsync, isPattern, refShorthandDefaultPos);\n    this.checkPropClash(prop, propHash);\n    node.properties.push(this.finishNode(prop, "Property"));\n  }\n  if (decorators.length) {\n    this.raise(this.state.start, "You have trailing decorators with no property");\n  }\n  return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");\n};\n\npp.parseObjPropValue = function (prop, startPos, startLoc, isGenerator, isAsync, isPattern, refShorthandDefaultPos) {\n  if (this.eat(_tokenizerTypes.types.colon)) {\n    prop.value = isPattern ? this.parseMaybeDefault(this.state.start, this.state.startLoc) : this.parseMaybeAssign(false, refShorthandDefaultPos);\n    prop.kind = "init";\n  } else if (this.match(_tokenizerTypes.types.parenL)) {\n    if (isPattern) this.unexpected();\n    prop.kind = "init";\n    prop.method = true;\n    prop.value = this.parseMethod(isGenerator, isAsync);\n  } else if (!prop.computed && prop.key.type === "Identifier" && (prop.key.name === "get" || prop.key.name === "set") && !this.match(_tokenizerTypes.types.comma) && !this.match(_tokenizerTypes.types.braceR)) {\n    if (isGenerator || isAsync || 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.raise(start, "getter should have no params");else this.raise(start, "setter should have exactly one param");\n    }\n  } else if (!prop.computed && prop.key.type === "Identifier") {\n    prop.kind = "init";\n    if (isPattern) {\n      if (this.isKeyword(prop.key.name) || this.strict && (_utilIdentifier.reservedWords.strictBind(prop.key.name) || _utilIdentifier.reservedWords.strict(prop.key.name)) || !this.options.allowReserved && this.isReservedWord(prop.key.name)) this.raise(prop.key.start, "Binding " + prop.key.name);\n      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key.__clone());\n    } else if (this.match(_tokenizerTypes.types.eq) && refShorthandDefaultPos) {\n      if (!refShorthandDefaultPos.start) refShorthandDefaultPos.start = this.state.start;\n      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key.__clone());\n    } else {\n      prop.value = prop.key.__clone();\n    }\n    prop.shorthand = true;\n  } else {\n    this.unexpected();\n  }\n};\n\npp.parsePropertyName = function (prop) {\n  if (this.eat(_tokenizerTypes.types.bracketL)) {\n    prop.computed = true;\n    prop.key = this.parseMaybeAssign();\n    this.expect(_tokenizerTypes.types.bracketR);\n    return prop.key;\n  } else {\n    prop.computed = false;\n    return prop.key = this.match(_tokenizerTypes.types.num) || this.match(_tokenizerTypes.types.string) ? this.parseExprAtom() : this.parseIdent(true);\n  }\n};\n\n// Initialize empty function node.\n\npp.initFunction = function (node, isAsync) {\n  node.id = null;\n  node.generator = false;\n  node.expression = false;\n  if (this.options.features["es7.asyncFunctions"]) {\n    node.async = !!isAsync;\n  }\n};\n\n// Parse object or class method.\n\npp.parseMethod = function (isGenerator, isAsync) {\n  var node = this.startNode();\n  this.initFunction(node, isAsync);\n  this.expect(_tokenizerTypes.types.parenL);\n  node.params = this.parseBindingList(_tokenizerTypes.types.parenR, false, this.options.features["es7.trailingFunctionCommas"]);\n  node.generator = isGenerator;\n  this.parseFunctionBody(node);\n  return this.finishNode(node, "FunctionExpression");\n};\n\n// Parse arrow function expression with given parameters.\n\npp.parseArrowExpression = function (node, params, isAsync) {\n  this.initFunction(node, isAsync);\n  node.params = this.toAssignableList(params, true);\n  this.parseFunctionBody(node, true);\n  return this.finishNode(node, "ArrowFunctionExpression");\n};\n\n// Parse function body and check parameters.\n\npp.parseFunctionBody = function (node, allowExpression) {\n  var isExpression = allowExpression && !this.match(_tokenizerTypes.types.braceL);\n\n  var oldInAsync = this.inAsync;\n  this.inAsync = node.async;\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.state.inFunction,\n        oldInGen = this.state.inGenerator,\n        oldLabels = this.state.labels;\n    this.state.inFunction = true;this.state.inGenerator = node.generator;this.state.labels = [];\n    node.body = this.parseBlock(true);\n    node.expression = false;\n    this.state.inFunction = oldInFunc;this.state.inGenerator = oldInGen;this.state.labels = oldLabels;\n  }\n  this.inAsync = oldInAsync;\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 nameHash = Object.create(null),\n        oldStrict = this.strict;\n    this.strict = true;\n    if (node.id) {\n      this.checkLVal(node.id, true);\n    }\n    var _arr = node.params;\n    for (var _i = 0; _i < _arr.length; _i++) {\n      var param = _arr[_i];\n      this.checkLVal(param, true, nameHash);\n    }\n    this.strict = oldStrict;\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, refShorthandDefaultPos) {\n  var elts = [],\n      first = true;\n  while (!this.eat(close)) {\n    if (first) {\n      first = false;\n    } else {\n      this.expect(_tokenizerTypes.types.comma);\n      if (allowTrailingComma && this.eat(close)) break;\n    }\n\n    elts.push(this.parseExprListItem(allowEmpty, refShorthandDefaultPos));\n  }\n  return elts;\n};\n\npp.parseExprListItem = function (allowEmpty, refShorthandDefaultPos) {\n  var elt = undefined;\n  if (allowEmpty && this.match(_tokenizerTypes.types.comma)) {\n    elt = null;\n  } else if (this.match(_tokenizerTypes.types.ellipsis)) {\n    elt = this.parseSpread(refShorthandDefaultPos);\n  } else {\n    elt = this.parseMaybeAssign(false, refShorthandDefaultPos);\n  }\n  return elt;\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 (this.match(_tokenizerTypes.types.name)) {\n    if (!liberal && (!this.options.allowReserved && this.isReservedWord(this.state.value) || this.strict && _utilIdentifier.reservedWords.strict(this.state.value))) this.raise(this.state.start, "The keyword \'" + this.state.value + "\' is reserved");\n    node.name = this.state.value;\n  } else if (liberal && this.state.type.keyword) {\n    node.name = this.state.type.keyword;\n  } else {\n    this.unexpected();\n  }\n  this.next();\n  return this.finishNode(node, "Identifier");\n};\n\n// Parses await expression inside async function.\n\npp.parseAwait = function (node) {\n  if (this.eat(_tokenizerTypes.types.semi) || this.canInsertSemicolon()) {\n    this.unexpected();\n  }\n  node.all = this.eat(_tokenizerTypes.types.star);\n  node.argument = this.parseMaybeUnary();\n  return this.finishNode(node, "AwaitExpression");\n};\n\n// Parses yield expression inside generator.\n\npp.parseYield = function () {\n  var node = this.startNode();\n  this.next();\n  if (this.match(_tokenizerTypes.types.semi) || this.canInsertSemicolon() || !this.match(_tokenizerTypes.types.star) && !this.state.type.startsExpr) {\n    node.delegate = false;\n    node.argument = null;\n  } else {\n    node.delegate = this.eat(_tokenizerTypes.types.star);\n    node.argument = this.parseMaybeAssign();\n  }\n  return this.finishNode(node, "YieldExpression");\n};\n\n// Parses array and generator comprehensions.\n\npp.parseComprehension = function (node, isGenerator) {\n  node.blocks = [];\n  while (this.match(_tokenizerTypes.types._for)) {\n    var block = this.startNode();\n    this.next();\n    this.expect(_tokenizerTypes.types.parenL);\n    block.left = this.parseBindingAtom();\n    this.checkLVal(block.left, true);\n    this.expectContextual("of");\n    block.right = this.parseExpression();\n    this.expect(_tokenizerTypes.types.parenR);\n    node.blocks.push(this.finishNode(block, "ComprehensionBlock"));\n  }\n  node.filter = this.eat(_tokenizerTypes.types._if) ? this.parseParenExpression() : null;\n  node.body = this.parseExpression();\n  this.expect(isGenerator ? _tokenizerTypes.types.parenR : _tokenizerTypes.types.bracketR);\n  node.generator = isGenerator;\n  return this.finishNode(node, "ComprehensionExpression");\n};\n\n//# sourceURL=webpack:///./node_modules/babylon5/lib/parser/expression.js?')},"./node_modules/babylon5/lib/parser/index.js":function(module,exports,__webpack_require__){"use strict";eval('\n\nexports.__esModule = true;\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }\n\n// istanbul ignore next\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }\n\n// istanbul ignore next\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\nvar _utilIdentifier = __webpack_require__("./node_modules/babylon5/lib/util/identifier.js");\n\nvar _options = __webpack_require__("./node_modules/babylon5/lib/options.js");\n\nvar _tokenizer = __webpack_require__("./node_modules/babylon5/lib/tokenizer/index.js");\n\nvar _tokenizer2 = _interopRequireDefault(_tokenizer);\n\n// Registered plugins\n\nvar plugins = {};\n\nexports.plugins = plugins;\n\nvar Parser = (function (_Tokenizer) {\n  _inherits(Parser, _Tokenizer);\n\n  function Parser(options, input) {\n    _classCallCheck(this, Parser);\n\n    _Tokenizer.call(this, input);\n\n    this.options = _options.getOptions(options);\n    this.isKeyword = _utilIdentifier.isKeyword;\n    this.isReservedWord = _utilIdentifier.reservedWords[6];\n    this.input = input;\n    this.loadPlugins(this.options.plugins);\n\n    // Figure out if it\'s a module code.\n    this.inModule = this.options.sourceType === "module";\n    this.strict = this.options.strictMode === false ? false : this.inModule;\n\n    // If enabled, skip leading hashbang line.\n    if (this.state.pos === 0 && this.input[0] === "#" && this.input[1] === "!") {\n      this.skipLineComment(2);\n    }\n  }\n\n  Parser.prototype.extend = function extend(name, f) {\n    this[name] = f(this[name]);\n  };\n\n  Parser.prototype.loadPlugins = function loadPlugins(plugins) {\n    for (var _name in plugins) {\n      var plugin = exports.plugins[_name];\n      if (!plugin) throw new Error("Plugin \'" + _name + "\' not found");\n      plugin(this, plugins[_name]);\n    }\n  };\n\n  Parser.prototype.parse = function parse() {\n    var file = this.startNode();\n    var program = this.startNode();\n    this.nextToken();\n    return this.parseTopLevel(file, program);\n  };\n\n  return Parser;\n})(_tokenizer2["default"]);\n\nexports["default"] = Parser;\n\n//# sourceURL=webpack:///./node_modules/babylon5/lib/parser/index.js?')},"./node_modules/babylon5/lib/parser/location.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }\n\nvar _utilLocation = __webpack_require__("./node_modules/babylon5/lib/util/location.js");\n\nvar _index = __webpack_require__("./node_modules/babylon5/lib/parser/index.js");\n\nvar _index2 = _interopRequireDefault(_index);\n\nvar pp = _index2["default"].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 = _utilLocation.getLineInfo(this.input, pos);\n  message += " (" + loc.line + ":" + loc.column + ")";\n  var err = new SyntaxError(message);\n  err.pos = pos;\n  err.loc = loc;\n  throw err;\n};\n\n//# sourceURL=webpack:///./node_modules/babylon5/lib/parser/location.js?')},"./node_modules/babylon5/lib/parser/lval.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n// istanbul ignore next\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }\n\nvar _tokenizerTypes = __webpack_require__("./node_modules/babylon5/lib/tokenizer/types.js");\n\nvar _index = __webpack_require__("./node_modules/babylon5/lib/parser/index.js");\n\nvar _index2 = _interopRequireDefault(_index);\n\nvar _utilIdentifier = __webpack_require__("./node_modules/babylon5/lib/util/identifier.js");\n\nvar pp = _index2["default"].prototype;\n\n// Convert existing expression atom to assignable pattern\n// if possible.\n\npp.toAssignable = function (node, isBinding) {\n  if (node) {\n    switch (node.type) {\n      case "Identifier":\n      case "ObjectPattern":\n      case "ArrayPattern":\n      case "AssignmentPattern":\n        break;\n\n      case "ObjectExpression":\n        node.type = "ObjectPattern";\n        var _arr = node.properties;\n        for (var _i = 0; _i < _arr.length; _i++) {\n          var prop = _arr[_i];\n          if (prop.type === "SpreadProperty") continue;\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        } else {\n          this.raise(node.left.end, "Only \'=\' operator can be used for specifying default value.");\n        }\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") {\n        this.unexpected(arg.start);\n      }\n      --end;\n    }\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// Convert list of expression atoms to a list of\n\npp.toReferencedList = function (exprList) {\n  return exprList;\n};\n\n// Parses spread element.\n\npp.parseSpread = function (refShorthandDefaultPos) {\n  var node = this.startNode();\n  this.next();\n  node.argument = this.parseMaybeAssign(refShorthandDefaultPos);\n  return this.finishNode(node, "SpreadElement");\n};\n\npp.parseRest = function () {\n  var node = this.startNode();\n  this.next();\n  node.argument = this.match(_tokenizerTypes.types.name) || this.match(_tokenizerTypes.types.bra