astexplorer.app/vendor/astexplorer/out/21.js

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

(window.webpackJsonp=window.webpackJsonp||[]).push([[21],{"./node_modules/acorn-to-esprima/src/attachComments.js":function(module,exports){eval("// comment fixes\nmodule.exports = function (ast, comments, tokens) {\n  if (comments.length) {\n    var firstComment = comments[0];\n    var lastComment = comments[comments.length - 1];\n    // fixup program start\n    if (!tokens.length) {\n      // if no tokens, the program starts at the end of the last comment\n      ast.start = lastComment.end;\n      ast.loc.start.line = lastComment.loc.end.line;\n      ast.loc.start.column = lastComment.loc.end.column;\n\n      if (ast.leadingComments === null && ast.innerComments.length) {\n        ast.leadingComments = ast.innerComments;\n      }\n    } else if (firstComment.start < tokens[0].start) {\n      // if there are comments before the first token, the program starts at the first token\n      var token = tokens[0];\n      ast.start = token.start;\n      ast.loc.start.line = token.loc.start.line;\n      ast.loc.start.column = token.loc.start.column;\n\n      // estraverse do not put leading comments on first node when the comment\n      // appear before the first token\n      if (ast.body.length) {\n        var node = ast.body[0];\n        node.leadingComments = [];\n        var firstTokenStart = token.start;\n        var len = comments.length;\n        for (var i = 0; i < len && comments[i].start < firstTokenStart; i++) {\n          node.leadingComments.push(comments[i]);\n        }\n      }\n    }\n    // fixup program end\n    if (tokens.length) {\n      var lastToken = tokens[tokens.length - 1];\n      if (lastComment.end > lastToken.end) {\n        // If there is a comment after the last token, the program ends at the\n        // last token and not the comment\n        ast.end = lastToken.end;\n        ast.loc.end.line = lastToken.loc.end.line;\n        ast.loc.end.column = lastToken.loc.end.column;\n      }\n    }\n  } else {\n    if (!tokens.length) {\n      ast.loc.start.line = 0;\n      ast.loc.end.line = 0;\n    }\n  }\n  if (ast.body && ast.body.length > 0) {\n    ast.loc.start.line = ast.body[0].loc.start.line;\n    ast.start = ast.body[0].start;\n  }\n  ast.range[0] = ast.start;\n  ast.range[1] = ast.end;\n};\n\n\n//# sourceURL=webpack:///./node_modules/acorn-to-esprima/src/attachComments.js?")},"./node_modules/acorn-to-esprima/src/convertTemplateType.js":function(module,exports){eval('module.exports = function (tokens, tt) {\n  var startingToken    = 0;\n  var currentToken     = 0;\n  var numBraces        = 0; // track use of {}\n  var numBackQuotes    = 0; // track number of nested templates\n\n  function isBackQuote(token) {\n    return tokens[token].type === tt.backQuote;\n  }\n\n  function isTemplateStarter(token) {\n    return isBackQuote(token) ||\n           // only can be a template starter when in a template already\n           tokens[token].type === tt.braceR && numBackQuotes > 0;\n  }\n\n  function isTemplateEnder(token) {\n    return isBackQuote(token) ||\n           tokens[token].type === tt.dollarBraceL;\n  }\n\n  // append the values between start and end\n  function createTemplateValue(start, end) {\n    var value = "";\n    while (start <= end) {\n      if (tokens[start].value) {\n        value += tokens[start].value;\n      } else if (tokens[start].type !== tt.template) {\n        value += tokens[start].type.label;\n      }\n      start++;\n    }\n    return value;\n  }\n\n  // create Template token\n  function replaceWithTemplateType(start, end) {\n    var templateToken = {\n      type: "Template",\n      value: createTemplateValue(start, end),\n      start: tokens[start].start,\n      end: tokens[end].end,\n      loc: {\n        start: tokens[start].loc.start,\n        end: tokens[end].loc.end\n      }\n    };\n\n    // put new token in place of old tokens\n    tokens.splice(start, end - start + 1, templateToken);\n  }\n\n  function trackNumBraces(token) {\n    if (tokens[token].type === tt.braceL) {\n      numBraces++;\n    } else if (tokens[token].type === tt.braceR) {\n      numBraces--;\n    }\n  }\n\n  while (startingToken < tokens.length) {\n    // template start: check if ` or }\n    if (isTemplateStarter(startingToken) && numBraces === 0) {\n      if (isBackQuote(startingToken)) {\n        numBackQuotes++;\n      }\n\n      currentToken = startingToken + 1;\n\n      // check if token after template start is "template"\n      if (currentToken >= tokens.length - 1 || tokens[currentToken].type !== tt.template) {\n        break;\n      }\n\n      // template end: find ` or ${\n      while (!isTemplateEnder(currentToken)) {\n        if (currentToken >= tokens.length - 1) {\n          break;\n        }\n        currentToken++;\n      }\n\n      if (isBackQuote(currentToken)) {\n        numBackQuotes--;\n      }\n      // template start and end found: create new token\n      replaceWithTemplateType(startingToken, currentToken);\n    } else if (numBackQuotes > 0) {\n      trackNumBraces(startingToken);\n    }\n    startingToken++;\n  }\n}\n\n//# sourceURL=webpack:///./node_modules/acorn-to-esprima/src/convertTemplateType.js?')},"./node_modules/acorn-to-esprima/src/index.js":function(module,exports,__webpack_require__){eval('exports.attachComments = __webpack_require__("./node_modules/acorn-to-esprima/src/attachComments.js");\n\nexports.toTokens       = __webpack_require__("./node_modules/acorn-to-esprima/src/toTokens.js"); // requires babel tokTypes\nexports.toAST          = __webpack_require__("./node_modules/acorn-to-esprima/src/toAST.js"); // requires traversal method\n\nexports.convertComments = function (comments) {\n  for (var i = 0; i < comments.length; i++) {\n    var comment = comments[i];\n    if (comment.type === "CommentBlock") {\n      comment.type = "Block";\n    } else if (comment.type === "CommentLine") {\n      comment.type = "Line";\n    }\n    // sometimes comments don\'t get ranges computed,\n    // even with options.ranges === true\n    if (!comment.range) {\n      comment.range = [comment.start, comment.end];\n    }\n  }\n}\n\n//# sourceURL=webpack:///./node_modules/acorn-to-esprima/src/index.js?')},"./node_modules/acorn-to-esprima/src/toAST.js":function(module,exports){eval("// var traverse = require(\"babel-core\").traverse;\n\nvar source;\n\nmodule.exports = function (ast, traverse, code) {\n  source = code;\n  ast.sourceType = \"module\";\n  ast.range = [ast.start, ast.end];\n  traverse(ast, astTransformVisitor);\n};\n\nfunction changeToLiteral(node) {\n  node.type = 'Literal';\n  if (!node.raw) {\n    if (node.extra && node.extra.raw) {\n      node.raw = node.extra.raw;\n    } else {\n      node.raw = source.slice(node.start, node.end);\n    }\n  }\n}\n\nvar astTransformVisitor = {\n  noScope: true,\n  enter: function (path) {\n    var node = path.node;\n    node.range = [node.start, node.end];\n\n    // private var to track original node type\n    node._babelType = node.type;\n\n    if (node.innerComments) {\n      node.trailingComments = node.innerComments;\n      delete node.innerComments;\n    }\n\n    if (node.trailingComments) {\n      for (var i = 0; i < node.trailingComments.length; i++) {\n        var comment = node.trailingComments[i];\n        if (comment.type === 'CommentLine') {\n          comment.type = 'Line';\n        } else if (comment.type === 'CommentBlock') {\n          comment.type = 'Block';\n        }\n        comment.range = [comment.start, comment.end];\n      }\n    }\n\n    if (node.leadingComments) {\n      for (var i = 0; i < node.leadingComments.length; i++) {\n        var comment = node.leadingComments[i];\n        if (comment.type === 'CommentLine') {\n          comment.type = 'Line';\n        } else if (comment.type === 'CommentBlock') {\n          comment.type = 'Block';\n        }\n        comment.range = [comment.start, comment.end];\n      }\n    }\n\n    // make '_paths' non-enumerable (babel-eslint #200)\n    Object.defineProperty(node, \"_paths\", { value: node._paths, writable: true });\n  },\n  exit: function (path) {\n    var node = path.node;\n\n    [\n      fixDirectives,\n    ].forEach(function (fixer) {\n      fixer(path);\n    });\n\n    if (path.isJSXText()) {\n      node.type = 'Literal';\n      node.raw = node.value;\n    }\n\n    if (path.isNumericLiteral() ||\n        path.isStringLiteral()) {\n      changeToLiteral(node);\n    }\n\n    if (path.isBooleanLiteral()) {\n      node.type = 'Literal';\n      node.raw = String(node.value);\n    }\n\n    if (path.isNullLiteral()) {\n      node.type = 'Literal';\n      node.raw = 'null';\n      node.value = null;\n    }\n\n    if (path.isRegExpLiteral()) {\n      node.type = 'Literal';\n      node.raw = node.extra.raw;\n      node.value = {};\n      node.regex = {\n        pattern: node.pattern,\n        flags: node.flags\n      };\n      delete node.extra;\n      delete node.pattern;\n      delete node.flags;\n    }\n\n    if (path.isObjectProperty()) {\n      node.type = 'Property';\n      node.kind = 'init';\n    }\n\n    if (path.isClassMethod() || path.isObjectMethod()) {\n      var code = source.slice(node.key.end, node.body.start);\n      var offset = code.indexOf(\"(\");\n\n      node.value = {\n          type: 'FunctionExpression',\n          id: node.id,\n          params: node.params,\n          body: node.body,\n          async: node.async,\n          generator: node.generator,\n          expression: node.expression,\n          defaults: [], // basic support - TODO: remove (old esprima)\n          loc: {\n            start: {\n              line: node.key.loc.start.line,\n              column: node.key.loc.end.column + offset // a[() {]\n            },\n            end: node.body.loc.end\n          }\n      }\n\n      // [asdf]() {\n      node.value.range = [node.key.end + offset, node.body.end];\n\n      if (node.returnType) {\n        node.value.returnType = node.returnType;\n      }\n\n      if (node.typeParameters) {\n        node.value.typeParameters = node.typeParameters;\n      }\n\n      if (path.isClassMethod()) {\n        node.type = 'MethodDefinition';\n      }\n\n      if (path.isObjectMethod()) {\n        node.type = 'Property';\n        if (node.kind === 'method') {\n          node.kind = 'init';\n        }\n      }\n\n      delete node.body;\n      delete node.id;\n      delete node.async;\n      delete node.generator;\n      delete node.expression;\n      delete node.params;\n      delete node.returnType;\n      delete node.typeParameters;\n    }\n\n    if (path.isRestProperty() || path.isSpreadProperty()) {\n      node.type = \"SpreadProperty\";\n      node.key = node.value = node.argument;\n    }\n\n    // flow: prevent \"no-undef\"\n    // for \"Component\" in: \"let x: React.Component\"\n    if (path.isQualifiedTypeIdentifier()) {\n      delete node.id;\n    }\n    // for \"b\" in: \"var a: { b: Foo }\"\n    if (path.isObjectTypeProperty()) {\n      delete node.key;\n    }\n    // for \"indexer\" in: \"var a: {[indexer: string]: number}\"\n    if (path.isObjectTypeIndexer()) {\n      delete node.id;\n    }\n    // for \"param\" in: \"var a: { func(param: Foo): Bar };\"\n    if (path.isFunctionTypeParam()) {\n      delete node.name;\n    }\n\n    // modules\n\n    if (path.isImportDeclaration()) {\n      delete node.isType;\n    }\n\n    if (path.isExportDeclaration()) {\n      var declar = path.get(\"declaration\");\n      if (declar.isClassExpression()) {\n        node.declaration.type = \"ClassDeclaration\";\n      } else if (declar.isFunctionExpression()) {\n        node.declaration.type = \"FunctionDeclaration\";\n      }\n    }\n\n    // remove class property keys (or patch in escope)\n    if (path.isClassProperty()) {\n      delete node.key;\n    }\n\n    // async function as generator\n    if (path.isFunction()) {\n      if (node.async) node.generator = true;\n    }\n\n    // TODO: remove (old esprima)\n    if (path.isFunction()) {\n      if (!node.defaults) {\n        node.defaults = [];\n      }\n    }\n\n    // await transform to yield\n    if (path.isAwaitExpression()) {\n      node.type = \"YieldExpression\";\n      node.delegate = node.all;\n      delete node.all;\n    }\n\n    // template string range fixes\n    if (path.isTemplateLiteral()) {\n      node.quasis.forEach(function (q) {\n        q.range[0] -= 1;\n        if (q.tail) {\n          q.range[1] += 1;\n        } else {\n          q.range[1] += 2;\n        }\n        q.loc.start.column -= 1;\n        if (q.tail) {\n          q.loc.end.column += 1;\n        } else {\n          q.loc.end.column += 2;\n        }\n      });\n    }\n  }\n};\n\n\nfunction fixDirectives (path) {\n  if (!(path.isProgram() || path.isFunction())) return;\n\n  var node = path.node;\n  var directivesContainer = node;\n  var body = node.body;\n\n  if (node.type !== \"Program\") {\n    directivesContainer = body;\n    body = body.body;\n  }\n\n  if (!directivesContainer.directives) return;\n\n  directivesContainer.directives.reverse().forEach(function (directive) {\n    directive.type = \"ExpressionStatement\";\n    directive.expression = directive.value;\n    delete directive.value;\n    directive.expression.type = \"Literal\";\n    changeToLiteral(directive.expression);\n    body.unshift(directive);\n  });\n  delete directivesContainer.directives;\n}\n// fixDirectives\n\n\n//# sourceURL=webpack:///./node_modules/acorn-to-esprima/src/toAST.js?")},"./node_modules/acorn-to-esprima/src/toToken.js":function(module,exports){eval('module.exports = function (token, tt, source) {\n  var type = token.type;\n  token.range = [token.start, token.end];\n\n  if (type === tt.name) {\n    token.type = "Identifier";\n  } else if (type === tt.semi || type === tt.comma ||\n             type === tt.parenL || type === tt.parenR ||\n             type === tt.braceL || type === tt.braceR ||\n             type === tt.slash || type === tt.dot ||\n             type === tt.bracketL || type === tt.bracketR ||\n             type === tt.ellipsis || type === tt.arrow ||\n             type === tt.star || type === tt.incDec ||\n             type === tt.colon || type === tt.question ||\n             type === tt.template || type === tt.backQuote ||\n             type === tt.dollarBraceL || type === tt.at ||\n             type === tt.logicalOR || type === tt.logicalAND ||\n             type === tt.bitwiseOR || type === tt.bitwiseXOR ||\n             type === tt.bitwiseAND || type === tt.equality ||\n             type === tt.relational || type === tt.bitShift ||\n             type === tt.plusMin || type === tt.modulo ||\n             type === tt.exponent || type === tt.prefix ||\n             type === tt.doubleColon ||\n             type.isAssign) {\n    token.type = "Punctuator";\n    if (!token.value) token.value = type.label;\n  } else if (type === tt.jsxTagStart) {\n    token.type = "Punctuator";\n    token.value = "<";\n  } else if (type === tt.jsxTagEnd) {\n    token.type = "Punctuator";\n    token.value = ">";\n  } else if (type === tt.jsxName) {\n    token.type = "JSXIdentifier";\n  } else if (type === tt.jsxText) {\n    token.type = "JSXText";\n  } else if (type.keyword === "null") {\n    token.type = "Null";\n  } else if (type.keyword === "false" || type.keyword === "true") {\n    token.type = "Boolean";\n  } else if (type.keyword) {\n    token.type = "Keyword";\n  } else if (type === tt.num) {\n    token.type = "Numeric";\n    token.value = source.slice(token.start, token.end);\n  } else if (type === tt.string) {\n    token.type = "String";\n    token.value = source.slice(token.start, token.end);\n  } else if (type === tt.regexp) {\n    token.type = "RegularExpression";\n    var value = token.value;\n    token.regex = {\n      pattern: value.pattern,\n      flags: value.flags\n    };\n    token.value = "/" + value.pattern + "/" + value.flags;\n  }\n\n  return token;\n};\n\n\n//# sourceURL=webpack:///./node_modules/acorn-to-esprima/src/toToken.js?')},"./node_modules/acorn-to-esprima/src/toTokens.js":function(module,exports,__webpack_require__){eval('// var tt                  = require("babylon").tokTypes;\n// var tt                  = require("babel-core").acorn.tokTypes;\nvar convertTemplateType = __webpack_require__("./node_modules/acorn-to-esprima/src/convertTemplateType.js");\nvar toToken = __webpack_require__("./node_modules/acorn-to-esprima/src/toToken.js");\n\nmodule.exports = function (tokens, tt, code) {\n  // transform tokens to type "Template"\n  convertTemplateType(tokens, tt);\n  var transformedTokens = tokens.filter(function (token) {\n    return token.type !== "CommentLine" && token.type !== "CommentBlock";\n  });\n\n  for (var i = 0, l = transformedTokens.length; i < l; i++) {\n    transformedTokens[i] = toToken(transformedTokens[i], tt, code);\n  }\n\n  return transformedTokens;\n};\n\n\n//# sourceURL=webpack:///./node_modules/acorn-to-esprima/src/toTokens.js?')},"./node_modules/alter/alter.js":function(module,exports,__webpack_require__){eval('// alter.js\n// MIT licensed, see LICENSE file\n// Copyright (c) 2013 Olov Lassus <olov.lassus@gmail.com>\n\nvar assert = __webpack_require__("./node_modules/assert/assert.js");\nvar stableSort = __webpack_require__("./node_modules/stable/stable.js");\n\n// fragments is a list of {start: index, end: index, str: string to replace with}\nfunction alter(str, fragments) {\n    "use strict";\n\n    var isArray = Array.isArray || function(v) {\n        return Object.prototype.toString.call(v) === "[object Array]";\n    };;\n\n    assert(typeof str === "string");\n    assert(isArray(fragments));\n\n    // stableSort isn\'t in-place so no need to copy array first\n    var sortedFragments = stableSort(fragments, function(a, b) {\n        return a.start - b.start;\n    });\n\n    var outs = [];\n\n    var pos = 0;\n    for (var i = 0; i < sortedFragments.length; i++) {\n        var frag = sortedFragments[i];\n\n        assert(pos <= frag.start);\n        assert(frag.start <= frag.end);\n        outs.push(str.slice(pos, frag.start));\n        outs.push(frag.str);\n        pos = frag.end;\n    }\n    if (pos < str.length) {\n        outs.push(str.slice(pos));\n    }\n\n    return outs.join("");\n}\n\nif ( true && typeof module.exports !== "undefined") {\n    module.exports = alter;\n}\n\n\n//# sourceURL=webpack:///./node_modules/alter/alter.js?')},"./node_modules/ansi-regex/index.js":function(module,exports,__webpack_require__){"use strict";eval("\nmodule.exports = function () {\n\treturn /[\\u001b\\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;\n};\n\n\n//# sourceURL=webpack:///./node_modules/ansi-regex/index.js?")},"./node_modules/assert/assert.js":function(module,exports,__webpack_require__){"use strict";eval("/* WEBPACK VAR INJECTION */(function(global) {\n\nvar objectAssign = __webpack_require__(\"./node_modules/object-assign/index.js\");\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n// NB: The URL to the CommonJS spec is kept just for tradition.\n//     node-assert has evolved a lot since then, both in API and behavior.\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = __webpack_require__(\"./node_modules/util/util.js\");\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\n// Expose a strict only variant of assert\nfunction strict(value, message) {\n  if (!value) fail(value, true, message, '==', strict);\n}\nassert.strict = objectAssign(strict, assert, {\n  equal: assert.strictEqual,\n  deepEqual: assert.deepStrictEqual,\n  notEqual: assert.notStrictEqual,\n  notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(\"./node_modules/webpack/buildin/global.js\")))\n\n//# sourceURL=webpack:///./node_modules/assert/assert.js?")},"./node_modules/ast-traverse/ast-traverse.js":function(module,exports,__webpack_require__){eval('function traverse(root, options) {\n    "use strict";\n\n    options = options || {};\n    var pre = options.pre;\n    var post = options.post;\n    var skipProperty = options.skipProperty;\n\n    function visit(node, parent, prop, idx) {\n        if (!node || typeof node.type !== "string") {\n            return;\n        }\n\n        var res = undefined;\n        if (pre) {\n            res = pre(node, parent, prop, idx);\n        }\n\n        if (res !== false) {\n            for (var prop in node) {\n                if (skipProperty ? skipProperty(prop, node) : prop[0] === "$") {\n                    continue;\n                }\n\n                var child = node[prop];\n\n                if (Array.isArray(child)) {\n                    for (var i = 0; i < child.length; i++) {\n                        visit(child[i], node, prop, i);\n                    }\n                } else {\n                    visit(child, node, prop);\n                }\n            }\n        }\n\n        if (post) {\n            post(node, parent, prop, idx);\n        }\n    }\n\n    visit(root, null);\n};\n\nif ( true && typeof module.exports !== "undefined") {\n    module.exports = traverse;\n}\n\n\n//# sourceURL=webpack:///./node_modules/ast-traverse/ast-traverse.js?')},"./node_modules/babel-plugin-constant-folding/lib/index.js":function(module,exports,__webpack_require__){"use strict";eval('\n\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nexports["default"] = function (_ref) {\n  var Plugin = _ref.Plugin;\n  var t = _ref.types;\n\n  return new Plugin("constant-folding", {\n    metadata: {\n      group: "builtin-prepass",\n      experimental: true\n    },\n\n    visitor: {\n      AssignmentExpression: function AssignmentExpression() {\n        var left = this.get("left");\n        if (!left.isIdentifier()) return;\n\n        var binding = this.scope.getBinding(left.node.name);\n        if (!binding || binding.hasDeoptValue) return;\n\n        var evaluated = this.get("right").evaluate();\n        if (evaluated.confident) {\n          binding.setValue(evaluated.value);\n        } else {\n          binding.deoptValue();\n        }\n      },\n\n      IfStatement: function IfStatement() {\n        var evaluated = this.get("test").evaluate();\n        if (!evaluated.confident) {\n          // todo: deopt binding values for constant violations inside\n          return this.skip();\n        }\n\n        if (evaluated.value) {\n          this.skipKey("alternate");\n        } else {\n          this.skipKey("consequent");\n        }\n      },\n\n      Scopable: {\n        enter: function enter() {\n          var funcScope = this.scope.getFunctionParent();\n\n          for (var name in this.scope.bindings) {\n            var binding = this.scope.bindings[name];\n            var deopt = false;\n\n            var _iteratorNormalCompletion = true;\n            var _didIteratorError = false;\n            var _iteratorError = undefined;\n\n            try {\n              for (var _iterator = binding.constantViolations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                var path = _step.value;\n\n                var funcViolationScope = path.scope.getFunctionParent();\n                if (funcViolationScope !== funcScope) {\n                  deopt = true;\n                  break;\n                }\n              }\n            } catch (err) {\n              _didIteratorError = true;\n              _iteratorError = err;\n            } finally {\n              try {\n                if (!_iteratorNormalCompletion && _iterator["return"]) {\n                  _iterator["return"]();\n                }\n              } finally {\n                if (_didIteratorError) {\n                  throw _iteratorError;\n                }\n              }\n            }\n\n            if (deopt) binding.deoptValue();\n          }\n        },\n\n        exit: function exit() {\n          for (var name in this.scope.bindings) {\n            var binding = this.scope.bindings[name];\n            binding.clearValue();\n          }\n        }\n      },\n\n      Expression: {\n        exit: function exit() {\n          var res = this.evaluate();\n          if (res.confident) return t.valueToNode(res.value);\n        }\n      }\n    }\n  });\n};\n\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/babel-plugin-constant-folding/lib/index.js?')},"./node_modules/babel-plugin-dead-code-elimination/lib/index.js":function(module,exports,__webpack_require__){"use strict";eval('\n\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nexports["default"] = function (_ref) {\n  var Plugin = _ref.Plugin;\n  var t = _ref.types;\n\n  function toStatements(node) {\n    if (t.isBlockStatement(node)) {\n      var hasBlockScoped = false;\n\n      for (var i = 0; i < node.body.length; i++) {\n        var bodyNode = node.body[i];\n        if (t.isBlockScoped(bodyNode)) hasBlockScoped = true;\n      }\n\n      if (!hasBlockScoped) {\n        return node.body;\n      }\n    }\n\n    return node;\n  }\n\n  var visitor = {\n    ReferencedIdentifier: function ReferencedIdentifier(node, parent, scope) {\n      var binding = scope.getBinding(node.name);\n      if (!binding || binding.references > 1 || !binding.constant) return;\n      if (binding.kind === "param" || binding.kind === "module") return;\n\n      var replacement = binding.path.node;\n      if (t.isVariableDeclarator(replacement)) {\n        replacement = replacement.init;\n      }\n      if (!replacement) return;\n\n      // ensure it\'s a "pure" type\n      if (!scope.isPure(replacement, true)) return;\n\n      if (t.isClass(replacement) || t.isFunction(replacement)) {\n        // don\'t change this if it\'s in a different scope, this can be bad\n        // for performance since it may be inside a loop or deeply nested in\n        // hot code\n        if (binding.path.scope.parent !== scope) return;\n      }\n\n      if (this.findParent(function (path) {\n        return path.node === replacement;\n      })) {\n        return;\n      }\n\n      t.toExpression(replacement);\n      scope.removeBinding(node.name);\n      binding.path.dangerouslyRemove();\n      return replacement;\n    },\n\n    "ClassDeclaration|FunctionDeclaration": function ClassDeclarationFunctionDeclaration(node, parent, scope) {\n      var binding = scope.getBinding(node.id.name);\n      if (binding && !binding.referenced) {\n        this.dangerouslyRemove();\n      }\n    },\n\n    VariableDeclarator: function VariableDeclarator(node, parent, scope) {\n      if (!t.isIdentifier(node.id) || !scope.isPure(node.init, true)) return;\n      visitor["ClassDeclaration|FunctionDeclaration"].apply(this, arguments);\n    },\n\n    ConditionalExpression: function ConditionalExpression(node) {\n      var evaluateTest = this.get("test").evaluateTruthy();\n      if (evaluateTest === true) {\n        return node.consequent;\n      } else if (evaluateTest === false) {\n        return node.alternate;\n      }\n    },\n\n    BlockStatement: function BlockStatement() {\n      var paths = this.get("body");\n\n      var purge = false;\n\n      for (var i = 0; i < paths.length; i++) {\n        var path = paths[i];\n\n        if (!purge && path.isCompletionStatement()) {\n          purge = true;\n          continue;\n        }\n\n        if (purge && !path.isFunctionDeclaration()) {\n          path.dangerouslyRemove();\n        }\n      }\n    },\n\n    IfStatement: {\n      exit: function exit(node) {\n        var consequent = node.consequent;\n        var alternate = node.alternate;\n        var test = node.test;\n\n        var evaluateTest = this.get("test").evaluateTruthy();\n\n        // we can check if a test will be truthy 100% and if so then we can inline\n        // the consequent and completely ignore the alternate\n        //\n        //   if (true) { foo; } -> { foo; }\n        //   if ("foo") { foo; } -> { foo; }\n        //\n\n        if (evaluateTest === true) {\n          return toStatements(consequent);\n        }\n\n        // we can check if a test will be falsy 100% and if so we can inline the\n        // alternate if there is one and completely remove the consequent\n        //\n        //   if ("") { bar; } else { foo; } -> { foo; }\n        //   if ("") { bar; } ->\n        //\n\n        if (evaluateTest === false) {\n          if (alternate) {\n            return toStatements(alternate);\n          } else {\n            return this.dangerouslyRemove();\n          }\n        }\n\n        // remove alternate blocks that are empty\n        //\n        //   if (foo) { foo; } else {} -> if (foo) { foo; }\n        //\n\n        if (t.isBlockStatement(alternate) && !alternate.body.length) {\n          alternate = node.alternate = null;\n        }\n\n        // if the consequent block is empty turn alternate blocks into a consequent\n        // and flip the test\n        //\n        //   if (foo) {} else { bar; } -> if (!foo) { bar; }\n        //\n\n        if (t.isBlockStatement(consequent) && !consequent.body.length && t.isBlockStatement(alternate) && alternate.body.length) {\n          node.consequent = node.alternate;\n          node.alternate = null;\n          node.test = t.unaryExpression("!", test, true);\n        }\n      }\n    }\n  };\n\n  return new Plugin("dead-code-elimination", {\n    metadata: {\n      group: "builtin-pre",\n      experimental: true\n    },\n\n    visitor: visitor\n  });\n};\n\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/babel-plugin-dead-code-elimination/lib/index.js?')},"./node_modules/babel-plugin-eval/lib/index.js":function(module,exports,__webpack_require__){"use strict";eval('\n\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nexports["default"] = function (_ref) {\n  var Plugin = _ref.Plugin;\n  var parse = _ref.parse;\n  var traverse = _ref.traverse;\n\n  return new Plugin("eval", {\n    metadata: {\n      group: "builtin-pre"\n    },\n\n    visitor: {\n      CallExpression: function CallExpression(node) {\n        if (this.get("callee").isIdentifier({ name: "eval" }) && node.arguments.length === 1) {\n          var evaluate = this.get("arguments")[0].evaluate();\n          if (!evaluate.confident) return;\n\n          var code = evaluate.value;\n          if (typeof code !== "string") return;\n\n          var ast = parse(code);\n          traverse.removeProperties(ast);\n          return ast.program;\n        }\n      }\n    }\n  });\n};\n\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/babel-plugin-eval/lib/index.js?')},"./node_modules/babel-plugin-inline-environment-variables/lib/index.js":function(module,exports,__webpack_require__){"use strict";eval('/* WEBPACK VAR INJECTION */(function(process) {\n\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nexports["default"] = function (_ref) {\n  var Plugin = _ref.Plugin;\n  var t = _ref.types;\n\n  return new Plugin("inline-environment-variables", {\n    metadata: {\n      group: "builtin-pre"\n    },\n\n    visitor: {\n      MemberExpression: function MemberExpression(node) {\n        if (this.get("object").matchesPattern("process.env")) {\n          var key = this.toComputedKey();\n          if (t.isLiteral(key)) {\n            return t.valueToNode(process.env[key.value]);\n          }\n        }\n      }\n    }\n  });\n};\n\nmodule.exports = exports["default"];\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("./node_modules/process/browser.js")))\n\n//# sourceURL=webpack:///./node_modules/babel-plugin-inline-environment-variables/lib/index.js?')},"./node_modules/babel-plugin-jscript/lib/index.js":function(module,exports,__webpack_require__){"use strict";eval('\n\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nexports["default"] = function (_ref) {\n  var Plugin = _ref.Plugin;\n  var t = _ref.types;\n\n  return new Plugin("jscript", {\n    metadata: {\n      group: "builtin-trailing"\n    },\n\n    visitor: {\n      FunctionExpression: {\n        exit: function exit(node) {\n          if (!node.id) return;\n          node._ignoreUserWhitespace = true;\n\n          return t.callExpression(t.functionExpression(null, [], t.blockStatement([t.toStatement(node), t.returnStatement(node.id)])), []);\n        }\n      }\n    }\n  });\n};\n\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/babel-plugin-jscript/lib/index.js?')},"./node_modules/babel-plugin-member-expression-literals/lib/index.js":function(module,exports,__webpack_require__){"use strict";eval('\n\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nexports["default"] = function (_ref) {\n  var Plugin = _ref.Plugin;\n  var t = _ref.types;\n\n  return new Plugin("member-expression-literals", {\n    metadata: {\n      group: "builtin-trailing"\n    },\n\n    visitor: {\n      MemberExpression: {\n        exit: function exit(node) {\n          var prop = node.property;\n          if (node.computed && t.isLiteral(prop) && t.isValidIdentifier(prop.value)) {\n            // foo["bar"] => foo.bar\n            node.property = t.identifier(prop.value);\n            node.computed = false;\n          }\n        }\n      }\n    }\n  });\n};\n\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/babel-plugin-member-expression-literals/lib/index.js?')},"./node_modules/babel-plugin-property-literals/lib/index.js":function(module,exports,__webpack_require__){"use strict";eval('\n\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nexports["default"] = function (_ref) {\n  var Plugin = _ref.Plugin;\n  var t = _ref.types;\n\n  return new Plugin("property-literals", {\n    metadata: {\n      group: "builtin-trailing"\n    },\n\n    visitor: {\n      Property: {\n        exit: function exit(node) {\n          var key = node.key;\n          if (t.isLiteral(key) && t.isValidIdentifier(key.value)) {\n            // "foo": "bar" -> foo: "bar"\n            node.key = t.identifier(key.value);\n            node.computed = false;\n          }\n        }\n      }\n    }\n  });\n};\n\nmodule.exports = exports["default"];\n\n//# sourceU