condenser 0.0.4 → 0.0.5

data/lib/condenser/processors/node_modules/@babel/helper-wrap-function/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-2018 Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/condenser/processors/node_modules/@babel/helper-wrap-function/README.md

@@ -1,27 +1,19 @@
 # @babel/helper-wrap-function
 
-This helper wraps a function within a call expression. It works with any function: statements, expressions and methods; both named and anonymous.
+> Helper to wrap functions inside a function call.
 
-## Example
+See our website [@babel/helper-wrap-function](https://babeljs.io/docs/en/next/babel-helper-wrap-function.html) for more information.
 
-**In**
+## Install
 
-```js
-(function () {
-}());
-```
-
-**Out**
+Using npm:
 
-```js
-_wrapper(function () {
-})();
+```sh
+npm install --save-dev @babel/helper-wrap-function
 ```
 
-## Usage
-
-```js
-import wrapFunction from "@babel/helper-wrap-function";
+or using yarn:
 
-wrapFunction(nodePathOfTheFunction, nodeWhichReferencesToTheWrapper);
+```sh
+yarn add @babel/helper-wrap-function --dev
 ```

data/lib/condenser/processors/node_modules/@babel/helper-wrap-function/lib/index.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = wrapFunction;
 
 function _helperFunctionName() {
-  var data = _interopRequireDefault(require("@babel/helper-function-name"));
+  const data = _interopRequireDefault(require("@babel/helper-function-name"));
 
-  _helperFunctionName = function _helperFunctionName() {
+  _helperFunctionName = function () {
     return data;
   };
 
@@ -16,9 +16,9 @@ function _helperFunctionName() {
 }
 
 function _template() {
-  var data = _interopRequireDefault(require("@babel/template"));
+  const data = _interopRequireDefault(require("@babel/template"));
 
-  _template = function _template() {
+  _template = function () {
     return data;
   };
 
@@ -26,9 +26,9 @@ function _template() {
 }
 
 function t() {
-  var data = _interopRequireWildcard(require("@babel/types"));
+  const data = _interopRequireWildcard(require("@babel/types"));
 
-  t = function t() {
+  t = function () {
     return data;
   };
 
@@ -39,14 +39,37 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var buildExpressionWrapper = _template().default.expression("\n  (function () {\n    var REF = FUNCTION;\n    return function NAME(PARAMS) {\n      return REF.apply(this, arguments);\n    };\n  })()\n");
-
-var buildDeclarationWrapper = (0, _template().default)("\n  function NAME(PARAMS) { return REF.apply(this, arguments); }\n  function REF() {\n    REF = FUNCTION;\n    return REF.apply(this, arguments);\n  }\n");
+const buildAnonymousExpressionWrapper = _template().default.expression(`
+  (function () {
+    var REF = FUNCTION;
+    return function NAME(PARAMS) {
+      return REF.apply(this, arguments);
+    };
+  })()
+`);
+
+const buildNamedExpressionWrapper = _template().default.expression(`
+  (function () {
+    var REF = FUNCTION;
+    function NAME(PARAMS) {
+      return REF.apply(this, arguments);
+    }
+    return NAME;
+  })()
+`);
+
+const buildDeclarationWrapper = (0, _template().default)(`
+  function NAME(PARAMS) { return REF.apply(this, arguments); }
+  function REF() {
+    REF = FUNCTION;
+    return REF.apply(this, arguments);
+  }
+`);
 
 function classOrObjectMethod(path, callId) {
-  var node = path.node;
-  var body = node.body;
-  var container = t().functionExpression(null, [], t().blockStatement(body.body), true);
+  const node = path.node;
+  const body = node.body;
+  const container = t().functionExpression(null, [], t().blockStatement(body.body), true);
   body.body = [t().returnStatement(t().callExpression(t().callExpression(callId, [container]), []))];
   node.async = false;
   node.generator = false;
@@ -54,10 +77,10 @@ function classOrObjectMethod(path, callId) {
 }
 
 function plainFunction(path, callId) {
-  var node = path.node;
-  var isDeclaration = path.isFunctionDeclaration();
-  var functionId = node.id;
-  var wrapper = isDeclaration ? buildDeclarationWrapper : buildExpressionWrapper;
+  const node = path.node;
+  const isDeclaration = path.isFunctionDeclaration();
+  const functionId = node.id;
+  const wrapper = isDeclaration ? buildDeclarationWrapper : functionId ? buildNamedExpressionWrapper : buildAnonymousExpressionWrapper;
 
   if (path.isArrowFunctionExpression()) {
     path.arrowFunctionToExpression();
@@ -69,12 +92,12 @@ function plainFunction(path, callId) {
     node.type = "FunctionExpression";
   }
 
-  var built = t().callExpression(callId, [node]);
-  var container = wrapper({
+  const built = t().callExpression(callId, [node]);
+  const container = wrapper({
     NAME: functionId || null,
     REF: path.scope.generateUidIdentifier(functionId ? functionId.name : "ref"),
     FUNCTION: built,
-    PARAMS: node.params.reduce(function (acc, param) {
+    PARAMS: node.params.reduce((acc, param) => {
       acc.done = acc.done || t().isAssignmentPattern(param) || t().isRestElement(param);
 
       if (!acc.done) {
@@ -92,7 +115,7 @@ function plainFunction(path, callId) {
     path.replaceWith(container[0]);
     path.insertAfter(container[1]);
   } else {
-    var retFunction = container.callee.body.body[1].argument;
+    const retFunction = container.callee.body.body[1].argument;
 
     if (!functionId) {
       (0, _helperFunctionName().default)({

data/lib/condenser/processors/node_modules/@babel/helper-wrap-function/package.json

@@ -1,43 +1,46 @@
 {
-  "_from": "@babel/helper-wrap-function@7.0.0-beta.44",
-  "_id": "@babel/helper-wrap-function@7.0.0-beta.44",
+  "_from": "@babel/helper-wrap-function@^7.1.0",
+  "_id": "@babel/helper-wrap-function@7.2.0",
   "_inBundle": false,
-  "_integrity": "sha512-qCdMAdMzDhO87r7yS2adqzIl2N9FJaVkPYq6bKllkNcmHquytve+hd/jD/lruD71i3JWkH+M352U+lhW2qkToA==",
+  "_integrity": "sha512-o9fP1BZLLSrYlxYEYyl2aS+Flun5gtjTIG8iln+XuEzQTs0PLagAGSXUcqruJwD5fM48jzIEggCKpIfWTcR7pQ==",
   "_location": "/@babel/helper-wrap-function",
   "_phantomChildren": {},
   "_requested": {
-    "type": "version",
+    "type": "range",
     "registry": true,
-    "raw": "@babel/helper-wrap-function@7.0.0-beta.44",
+    "raw": "@babel/helper-wrap-function@^7.1.0",
     "name": "@babel/helper-wrap-function",
     "escapedName": "@babel%2fhelper-wrap-function",
     "scope": "@babel",
-    "rawSpec": "7.0.0-beta.44",
+    "rawSpec": "^7.1.0",
     "saveSpec": null,
-    "fetchSpec": "7.0.0-beta.44"
+    "fetchSpec": "^7.1.0"
   },
   "_requiredBy": [
     "/@babel/helper-remap-async-to-generator"
   ],
-  "_resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.0.0-beta.44.tgz",
-  "_shasum": "d128718a543f313264dff7cb386957e3e465c95d",
-  "_spec": "@babel/helper-wrap-function@7.0.0-beta.44",
-  "_where": "/Users/malomalo/Code/tmp/condenser/lib/condenser/processors/node_modules/@babel/helper-remap-async-to-generator",
+  "_resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.2.0.tgz",
+  "_shasum": "c4e0012445769e2815b55296ead43a958549f6fa",
+  "_spec": "@babel/helper-wrap-function@^7.1.0",
+  "_where": "/Users/malomalo/Code/condenser/lib/condenser/processors/node_modules/@babel/helper-remap-async-to-generator",
   "bundleDependencies": false,
   "dependencies": {
-    "@babel/helper-function-name": "7.0.0-beta.44",
-    "@babel/template": "7.0.0-beta.44",
-    "@babel/traverse": "7.0.0-beta.44",
-    "@babel/types": "7.0.0-beta.44"
+    "@babel/helper-function-name": "^7.1.0",
+    "@babel/template": "^7.1.0",
+    "@babel/traverse": "^7.1.0",
+    "@babel/types": "^7.2.0"
   },
   "deprecated": false,
   "description": "Helper to wrap functions inside a function call.",
   "license": "MIT",
   "main": "lib/index.js",
   "name": "@babel/helper-wrap-function",
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/babel/babel/tree/master/packages/babel-helper-wrap-function"
   },
-  "version": "7.0.0-beta.44"
+  "version": "7.2.0"
 }

data/lib/condenser/processors/node_modules/@babel/helpers/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/condenser/processors/node_modules/@babel/helpers/README.md

@@ -2,55 +2,18 @@
 
 > Collection of helper functions used by Babel transforms.
 
+See our website [@babel/helpers](https://babeljs.io/docs/en/next/babel-helpers.html) for more information.
+
 ## Install
 
+Using npm:
+
 ```sh
 npm install --save-dev @babel/helpers
 ```
 
-## Usage
-
-Direct:
-
-```js
-import * as helpers from '@babel/helpers';
-import * as t from '@babel/types';
-
-const typeofHelper = helpers.get('typeof');
-
-t.isExpressionStatement(typeofHelper);
-// true
-```
-
-Inside a plugin:
-
-```js
-export default {
-  visitor: {
-    UnaryExpression(path) {
-      // The .addHelper function adds, if needed, the helper to the file
-      // and returns an expression which references the helper
-      const typeofHelper = this.addHelper("typeof");
-      t.isExpression(typeofHelper); // true
-  }
-};
-```
-
-## Defining Helpers
+or using yarn:
 
-> **NOTE**: This package is only meant to be used by the packages inluded in this repository. There is currently no way for third-party plugins to define an helper.
-
-Helpers are defined in the `src/helpers.js` file, and they must be valid modules which follow these guidelines:
- - They must have a default export, which is their entry-point.
- - They can import other helpers, exclusively by using default imports.
- - They can't have named exports.
-
-```js
-helpers.customHelper = defineHelper(`
-  import dep from "dependency";
-  const foo = 2;
-  export default function getFooTimesDepPlusX(x) {
-    return foo * dep() + x;
-  }
-`);
+```sh
+yarn add @babel/helpers --dev
 ```

data/lib/condenser/processors/node_modules/@babel/helpers/lib/helpers.js

@@ -6,275 +6,1877 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 
 function _template() {
-  var data = _interopRequireDefault(require("@babel/template"));
+  const data = _interopRequireDefault(require("@babel/template"));
 
-  _template = function _template() {
+  _template = function () {
     return data;
   };
 
   return data;
 }
 
-var _templateObject = _taggedTemplateLiteralLoose(["\n  export default function _typeof(obj) {\n    if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n      _typeof = function (obj) { return typeof obj; };\n    } else {\n      _typeof = function (obj) {\n        return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype\n          ? \"symbol\"\n          : typeof obj;\n      };\n    }\n\n    return _typeof(obj);\n  }\n"]),
-    _templateObject2 = _taggedTemplateLiteralLoose(["\n  var REACT_ELEMENT_TYPE;\n\n  export default function _createRawReactElement(type, props, key, children) {\n    if (!REACT_ELEMENT_TYPE) {\n      REACT_ELEMENT_TYPE = (\n        typeof Symbol === \"function\" && Symbol.for && Symbol.for(\"react.element\")\n      ) || 0xeac7;\n    }\n\n    var defaultProps = type && type.defaultProps;\n    var childrenLength = arguments.length - 3;\n\n    if (!props && childrenLength !== 0) {\n      // If we're going to assign props.children, we create a new object now\n      // to avoid mutating defaultProps.\n      props = {\n        children: void 0,\n      };\n    }\n    if (props && defaultProps) {\n      for (var propName in defaultProps) {\n        if (props[propName] === void 0) {\n          props[propName] = defaultProps[propName];\n        }\n      }\n    } else if (!props) {\n      props = defaultProps || {};\n    }\n\n    if (childrenLength === 1) {\n      props.children = children;\n    } else if (childrenLength > 1) {\n      var childArray = new Array(childrenLength);\n      for (var i = 0; i < childrenLength; i++) {\n        childArray[i] = arguments[i + 3];\n      }\n      props.children = childArray;\n    }\n\n    return {\n      $$typeof: REACT_ELEMENT_TYPE,\n      type: type,\n      key: key === undefined ? null : '' + key,\n      ref: null,\n      props: props,\n      _owner: null,\n    };\n  }\n"]),
-    _templateObject3 = _taggedTemplateLiteralLoose(["\n  export default function _asyncIterator(iterable) {\n    if (typeof Symbol === \"function\") {\n      if (Symbol.asyncIterator) {\n        var method = iterable[Symbol.asyncIterator];\n        if (method != null) return method.call(iterable);\n      }\n      if (Symbol.iterator) {\n        return iterable[Symbol.iterator]();\n      }\n    }\n    throw new TypeError(\"Object is not async iterable\");\n  }\n"]),
-    _templateObject4 = _taggedTemplateLiteralLoose(["\n  export default function _AwaitValue(value) {\n    this.wrapped = value;\n  }\n"]),
-    _templateObject5 = _taggedTemplateLiteralLoose(["\n  import AwaitValue from \"AwaitValue\";\n\n  export default function AsyncGenerator(gen) {\n    var front, back;\n\n    function send(key, arg) {\n      return new Promise(function (resolve, reject) {\n        var request = {\n          key: key,\n          arg: arg,\n          resolve: resolve,\n          reject: reject,\n          next: null,\n        };\n\n        if (back) {\n          back = back.next = request;\n        } else {\n          front = back = request;\n          resume(key, arg);\n        }\n      });\n    }\n\n    function resume(key, arg) {\n      try {\n        var result = gen[key](arg)\n        var value = result.value;\n        var wrappedAwait = value instanceof AwaitValue;\n\n        Promise.resolve(wrappedAwait ? value.wrapped : value).then(\n          function (arg) {\n            if (wrappedAwait) {\n              resume(\"next\", arg);\n              return\n            }\n\n            settle(result.done ? \"return\" : \"normal\", arg);\n          },\n          function (err) { resume(\"throw\", err); });\n      } catch (err) {\n        settle(\"throw\", err);\n      }\n    }\n\n    function settle(type, value) {\n      switch (type) {\n        case \"return\":\n          front.resolve({ value: value, done: true });\n          break;\n        case \"throw\":\n          front.reject(value);\n          break;\n        default:\n          front.resolve({ value: value, done: false });\n          break;\n      }\n\n      front = front.next;\n      if (front) {\n        resume(front.key, front.arg);\n      } else {\n        back = null;\n      }\n    }\n\n    this._invoke = send;\n\n    // Hide \"return\" method if generator return is not supported\n    if (typeof gen.return !== \"function\") {\n      this.return = undefined;\n    }\n  }\n\n  if (typeof Symbol === \"function\" && Symbol.asyncIterator) {\n    AsyncGenerator.prototype[Symbol.asyncIterator] = function () { return this; };\n  }\n\n  AsyncGenerator.prototype.next = function (arg) { return this._invoke(\"next\", arg); };\n  AsyncGenerator.prototype.throw = function (arg) { return this._invoke(\"throw\", arg); };\n  AsyncGenerator.prototype.return = function (arg) { return this._invoke(\"return\", arg); };\n"]),
-    _templateObject6 = _taggedTemplateLiteralLoose(["\n  import AsyncGenerator from \"AsyncGenerator\";\n\n  export default function _wrapAsyncGenerator(fn) {\n    return function () {\n      return new AsyncGenerator(fn.apply(this, arguments));\n    };\n  }\n"]),
-    _templateObject7 = _taggedTemplateLiteralLoose(["\n  import AwaitValue from \"AwaitValue\";\n\n  export default function _awaitAsyncGenerator(value) {\n    return new AwaitValue(value);\n  }\n"]),
-    _templateObject8 = _taggedTemplateLiteralLoose(["\n  export default function _asyncGeneratorDelegate(inner, awaitWrap) {\n    var iter = {}, waiting = false;\n\n    function pump(key, value) {\n      waiting = true;\n      value = new Promise(function (resolve) { resolve(inner[key](value)); });\n      return { done: false, value: awaitWrap(value) };\n    };\n\n    if (typeof Symbol === \"function\" && Symbol.iterator) {\n      iter[Symbol.iterator] = function () { return this; };\n    }\n\n    iter.next = function (value) {\n      if (waiting) {\n        waiting = false;\n        return value;\n      }\n      return pump(\"next\", value);\n    };\n\n    if (typeof inner.throw === \"function\") {\n      iter.throw = function (value) {\n        if (waiting) {\n          waiting = false;\n          throw value;\n        }\n        return pump(\"throw\", value);\n      };\n    }\n\n    if (typeof inner.return === \"function\") {\n      iter.return = function (value) {\n        return pump(\"return\", value);\n      };\n    }\n\n    return iter;\n  }\n"]),
-    _templateObject9 = _taggedTemplateLiteralLoose(["\n  export default function _asyncToGenerator(fn) {\n    return function () {\n      var self = this, args = arguments;\n      return new Promise(function (resolve, reject) {\n        var gen = fn.apply(self, args);\n        function step(key, arg) {\n          try {\n            var info = gen[key](arg);\n            var value = info.value;\n          } catch (error) {\n            reject(error);\n            return;\n          }\n\n          if (info.done) {\n            resolve(value);\n          } else {\n            Promise.resolve(value).then(_next, _throw);\n          }\n        }\n        function _next(value) { step(\"next\", value); }\n        function _throw(err) { step(\"throw\", err); }\n\n        _next();\n      });\n    };\n  }\n"]),
-    _templateObject10 = _taggedTemplateLiteralLoose(["\n  export default function _classCallCheck(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n      throw new TypeError(\"Cannot call a class as a function\");\n    }\n  }\n"]),
-    _templateObject11 = _taggedTemplateLiteralLoose(["\n  function _defineProperties(target, props) {\n    for (var i = 0; i < props.length; i ++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  export default function _createClass(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    return Constructor;\n  }\n"]),
-    _templateObject12 = _taggedTemplateLiteralLoose(["\n  export default function _defineEnumerableProperties(obj, descs) {\n    for (var key in descs) {\n      var desc = descs[key];\n      desc.configurable = desc.enumerable = true;\n      if (\"value\" in desc) desc.writable = true;\n      Object.defineProperty(obj, key, desc);\n    }\n\n    // Symbols are not enumerated over by for-in loops. If native\n    // Symbols are available, fetch all of the descs object's own\n    // symbol properties and define them on our target object too.\n    if (Object.getOwnPropertySymbols) {\n      var objectSymbols = Object.getOwnPropertySymbols(descs);\n      for (var i = 0; i < objectSymbols.length; i++) {\n        var sym = objectSymbols[i];\n        var desc = descs[sym];\n        desc.configurable = desc.enumerable = true;\n        if (\"value\" in desc) desc.writable = true;\n        Object.defineProperty(obj, sym, desc);\n      }\n    }\n    return obj;\n  }\n"]),
-    _templateObject13 = _taggedTemplateLiteralLoose(["\n  export default function _defaults(obj, defaults) {\n    var keys = Object.getOwnPropertyNames(defaults);\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i];\n      var value = Object.getOwnPropertyDescriptor(defaults, key);\n      if (value && value.configurable && obj[key] === undefined) {\n        Object.defineProperty(obj, key, value);\n      }\n    }\n    return obj;\n  }\n"]),
-    _templateObject14 = _taggedTemplateLiteralLoose(["\n  export default function _defineProperty(obj, key, value) {\n    // Shortcircuit the slow defineProperty path when possible.\n    // We are trying to avoid issues where setters defined on the\n    // prototype cause side effects under the fast path of simple\n    // assignment. By checking for existence of the property with\n    // the in operator, we can optimize most of this overhead away.\n    if (key in obj) {\n      Object.defineProperty(obj, key, {\n        value: value,\n        enumerable: true,\n        configurable: true,\n        writable: true\n      });\n    } else {\n      obj[key] = value;\n    }\n    return obj;\n  }\n"]),
-    _templateObject15 = _taggedTemplateLiteralLoose(["\n  export default function _extends() {\n    _extends = Object.assign || function (target) {\n      for (var i = 1; i < arguments.length; i++) {\n        var source = arguments[i];\n        for (var key in source) {\n          if (Object.prototype.hasOwnProperty.call(source, key)) {\n            target[key] = source[key];\n          }\n        }\n      }\n      return target;\n    };\n\n    return _extends.apply(this, arguments);\n  }\n"]),
-    _templateObject16 = _taggedTemplateLiteralLoose(["\n  import defineProperty from \"defineProperty\";\n\n  export default function _objectSpread(target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = (arguments[i] != null) ? arguments[i] : {};\n      var ownKeys = Object.keys(source);\n      if (typeof Object.getOwnPropertySymbols === 'function') {\n        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {\n          return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n        }));\n      }\n      ownKeys.forEach(function(key) {\n        defineProperty(target, key, source[key]);\n      });\n    }\n    return target;\n  }\n"]),
-    _templateObject17 = _taggedTemplateLiteralLoose(["\n  export default function _get(object, property, receiver) {\n    if (object === null) object = Function.prototype;\n\n    var desc = Object.getOwnPropertyDescriptor(object, property);\n\n    if (desc === undefined) {\n      var parent = Object.getPrototypeOf(object);\n\n      if (parent === null) {\n        return undefined;\n      } else {\n        return _get(parent, property, receiver);\n      }\n    } else if (\"value\" in desc) {\n      return desc.value;\n    } else {\n      var getter = desc.get;\n\n      if (getter === undefined) {\n        return undefined;\n      }\n\n      return getter.call(receiver);\n    }\n  }\n"]),
-    _templateObject18 = _taggedTemplateLiteralLoose(["\n  export default function _inherits(subClass, superClass) {\n    if (typeof superClass !== \"function\" && superClass !== null) {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n    subClass.prototype = Object.create(superClass && superClass.prototype, {\n      constructor: {\n        value: subClass,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    if (superClass)\n      Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n  }\n"]),
-    _templateObject19 = _taggedTemplateLiteralLoose(["\n  export default function _inheritsLoose(subClass, superClass) {\n    subClass.prototype = Object.create(superClass.prototype);\n    subClass.prototype.constructor = subClass;\n    subClass.__proto__ = superClass;\n  }\n"]),
-    _templateObject20 = _taggedTemplateLiteralLoose(["\n  function _gPO(o) {\n    _gPO = Object.getPrototypeOf || function _gPO(o) { return o.__proto__ };\n    return _gPO(o);\n  }\n  function _sPO(o, p) {\n    _sPO = Object.setPrototypeOf || function _sPO(o, p) { o.__proto__ = p; return o };\n    return _sPO(o, p);\n  }\n  function _construct(Parent, args, Class) {\n    _construct = (typeof Reflect === \"object\" && Reflect.construct) ||\n      function _construct(Parent, args, Class) {\n        var Constructor, a = [null];\n        a.push.apply(a, args);\n        Constructor = Parent.bind.apply(Parent, a);\n        return _sPO(new Constructor, Class.prototype);\n      };\n    return _construct(Parent, args, Class);\n  }\n\n  export default function _wrapNativeSuper(Class) {\n    var _cache = typeof Map === \"function\" ? new Map() : undefined;\n\n    _wrapNativeSuper = function _wrapNativeSuper(Class) {\n      if (typeof Class !== \"function\") {\n        throw new TypeError(\"Super expression must either be null or a function\");\n      }\n      if (typeof _cache !== \"undefined\") {\n        if (_cache.has(Class)) return _cache.get(Class);\n        _cache.set(Class, Wrapper);\n      }\n      function Wrapper() {}\n      Wrapper.prototype = Object.create(Class.prototype, {\n        constructor: {\n          value: Wrapper,\n          enumerable: false,\n          writable: true,\n          configurable: true,\n        }\n      });\n      return _sPO(\n        Wrapper,\n        _sPO(\n          function Super() {\n            return _construct(Class, arguments, _gPO(this).constructor);\n          },\n          Class\n        )\n      );\n    }\n\n    return _wrapNativeSuper(Class)\n  }\n"]),
-    _templateObject21 = _taggedTemplateLiteralLoose(["\n  export default function _instanceof(left, right) {\n    if (right != null && typeof Symbol !== \"undefined\" && right[Symbol.hasInstance]) {\n      return right[Symbol.hasInstance](left);\n    } else {\n      return left instanceof right;\n    }\n  }\n"]),
-    _templateObject22 = _taggedTemplateLiteralLoose(["\n  export default function _interopRequireDefault(obj) {\n    return obj && obj.__esModule ? obj : { default: obj };\n  }\n"]),
-    _templateObject23 = _taggedTemplateLiteralLoose(["\n  export default function _interopRequireWildcard(obj) {\n    if (obj && obj.__esModule) {\n      return obj;\n    } else {\n      var newObj = {};\n      if (obj != null) {\n        for (var key in obj) {\n          if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            var desc = Object.defineProperty && Object.getOwnPropertyDescriptor\n              ? Object.getOwnPropertyDescriptor(obj, key)\n              : {};\n            if (desc.get || desc.set) {\n              Object.defineProperty(newObj, key, desc);\n            } else {\n              newObj[key] = obj[key];\n            }\n          }\n        }\n      }\n      newObj.default = obj;\n      return newObj;\n    }\n  }\n"]),
-    _templateObject24 = _taggedTemplateLiteralLoose(["\n  export default function _newArrowCheck(innerThis, boundThis) {\n    if (innerThis !== boundThis) {\n      throw new TypeError(\"Cannot instantiate an arrow function\");\n    }\n  }\n"]),
-    _templateObject25 = _taggedTemplateLiteralLoose(["\n  export default function _objectDestructuringEmpty(obj) {\n    if (obj == null) throw new TypeError(\"Cannot destructure undefined\");\n  }\n"]),
-    _templateObject26 = _taggedTemplateLiteralLoose(["\n  export default function _objectWithoutProperties(source, excluded) {\n    if (source == null) return {};\n\n    var target = {};\n    var sourceKeys = Object.keys(source);\n    var key, i;\n\n    for (i = 0; i < sourceKeys.length; i++) {\n      key = sourceKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      target[key] = source[key];\n    }\n\n    if (Object.getOwnPropertySymbols) {\n      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n      for (i = 0; i < sourceSymbolKeys.length; i++) {\n        key = sourceSymbolKeys[i];\n        if (excluded.indexOf(key) >= 0) continue;\n        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n        target[key] = source[key];\n      }\n    }\n\n    return target;\n  }\n"]),
-    _templateObject27 = _taggedTemplateLiteralLoose(["\n  export default function _assertThisInitialized(self) {\n    if (self === void 0) {\n      throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n    }\n    return self;\n  }\n"]),
-    _templateObject28 = _taggedTemplateLiteralLoose(["\n  import assertThisInitialized from \"assertThisInitialized\";\n\n  export default function _possibleConstructorReturn(self, call) {\n    if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n      return call;\n    }\n    return assertThisInitialized(self);\n  }\n"]),
-    _templateObject29 = _taggedTemplateLiteralLoose(["\n  export default function _set(object, property, value, receiver) {\n    var desc = Object.getOwnPropertyDescriptor(object, property);\n\n    if (desc === undefined) {\n      var parent = Object.getPrototypeOf(object);\n\n      if (parent !== null) {\n        _set(parent, property, value, receiver);\n      }\n    } else if (\"value\" in desc && desc.writable) {\n      desc.value = value;\n    } else {\n      var setter = desc.set;\n\n      if (setter !== undefined) {\n        setter.call(receiver, value);\n      }\n    }\n\n    return value;\n  }\n"]),
-    _templateObject30 = _taggedTemplateLiteralLoose(["\n  export default function _taggedTemplateLiteral(strings, raw) {\n    if (!raw) { raw = strings.slice(0); }\n    return Object.freeze(Object.defineProperties(strings, {\n        raw: { value: Object.freeze(raw) }\n    }));\n  }\n"]),
-    _templateObject31 = _taggedTemplateLiteralLoose(["\n  export default function _taggedTemplateLiteralLoose(strings, raw) {\n    if (!raw) { raw = strings.slice(0); }\n    strings.raw = raw;\n    return strings;\n  }\n"]),
-    _templateObject32 = _taggedTemplateLiteralLoose(["\n  import undef from \"temporalUndefined\";\n\n  export default function _temporalRef(val, name) {\n    if (val === undef) {\n      throw new ReferenceError(name + \" is not defined - temporal dead zone\");\n    } else {\n      return val;\n    }\n  }\n"]),
-    _templateObject33 = _taggedTemplateLiteralLoose(["\n  export default function _readOnlyError(name) {\n    throw new Error(\"\\\"\" + name + \"\\\" is read-only\");\n  }\n"], ["\n  export default function _readOnlyError(name) {\n    throw new Error(\"\\\\\"\" + name + \"\\\\\" is read-only\");\n  }\n"]),
-    _templateObject34 = _taggedTemplateLiteralLoose(["\n  export default function _classNameTDZError(name) {\n    throw new Error(\"Class \\\"\" + name + \"\\\" cannot be referenced in computed property keys.\");\n  }\n"], ["\n  export default function _classNameTDZError(name) {\n    throw new Error(\"Class \\\\\"\" + name + \"\\\\\" cannot be referenced in computed property keys.\");\n  }\n"]),
-    _templateObject35 = _taggedTemplateLiteralLoose(["\n  export default {};\n"]),
-    _templateObject36 = _taggedTemplateLiteralLoose(["\n  import arrayWithHoles from \"arrayWithHoles\";\n  import iterableToArrayLimit from \"iterableToArrayLimit\";\n  import nonIterableRest from \"nonIterableRest\";\n\n  export default function _slicedToArray(arr, i) {\n    return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();\n  }\n"]),
-    _templateObject37 = _taggedTemplateLiteralLoose(["\n  import arrayWithHoles from \"arrayWithHoles\";\n  import iterableToArrayLimitLoose from \"iterableToArrayLimitLoose\";\n  import nonIterableRest from \"nonIterableRest\";\n\n  export default function _slicedToArrayLoose(arr, i) {\n    return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();\n  }\n"]),
-    _templateObject38 = _taggedTemplateLiteralLoose(["\n  import arrayWithHoles from \"arrayWithHoles\";\n  import iterableToArray from \"iterableToArray\";\n  import nonIterableRest from \"nonIterableRest\";\n\n  export default function _toArray(arr) {\n    return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();\n  }\n"]),
-    _templateObject39 = _taggedTemplateLiteralLoose(["\n  import arrayWithoutHoles from \"arrayWithoutHoles\";\n  import iterableToArray from \"iterableToArray\";\n  import nonIterableSpread from \"nonIterableSpread\";\n\n  export default function _toConsumableArray(arr) {\n    return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();\n  }\n"]),
-    _templateObject40 = _taggedTemplateLiteralLoose(["\n  export default function _arrayWithoutHoles(arr) {\n    if (Array.isArray(arr)) {\n      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n      return arr2;\n    }\n  }\n"]),
-    _templateObject41 = _taggedTemplateLiteralLoose(["\n  export default function _arrayWithoutHoles(arr) {\n    if (Array.isArray(arr)) return arr;\n  }\n"]),
-    _templateObject42 = _taggedTemplateLiteralLoose(["\n  export default function _iterableToArray(iter) {\n    if (\n      Symbol.iterator in Object(iter) ||\n      Object.prototype.toString.call(iter) === \"[object Arguments]\"\n    ) return Array.from(iter);\n  }\n"]),
-    _templateObject43 = _taggedTemplateLiteralLoose(["\n  export default function _iterableToArrayLimit(arr, i) {\n    // this is an expanded form of `for...of` that properly supports abrupt completions of\n    // iterators etc. variable names have been minimised to reduce the size of this massive\n    // helper. sometimes spec compliancy is annoying :(\n    //\n    // _n = _iteratorNormalCompletion\n    // _d = _didIteratorError\n    // _e = _iteratorError\n    // _i = _iterator\n    // _s = _step\n\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n    try {\n      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n    return _arr;\n  }\n"], ["\n  export default function _iterableToArrayLimit(arr, i) {\n    // this is an expanded form of \\`for...of\\` that properly supports abrupt completions of\n    // iterators etc. variable names have been minimised to reduce the size of this massive\n    // helper. sometimes spec compliancy is annoying :(\n    //\n    // _n = _iteratorNormalCompletion\n    // _d = _didIteratorError\n    // _e = _iteratorError\n    // _i = _iterator\n    // _s = _step\n\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n    try {\n      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n    return _arr;\n  }\n"]),
-    _templateObject44 = _taggedTemplateLiteralLoose(["\n  export default function _iterableToArrayLimitLoose(arr, i) {\n    var _arr = [];\n    for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {\n      _arr.push(_step.value);\n      if (i && _arr.length === i) break;\n    }\n    return _arr;\n  }\n"]),
-    _templateObject45 = _taggedTemplateLiteralLoose(["\n  export default function _nonIterableSpread() {\n    throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n  }\n"]),
-    _templateObject46 = _taggedTemplateLiteralLoose(["\n  export default function _nonIterableRest() {\n    throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n  }\n"]),
-    _templateObject47 = _taggedTemplateLiteralLoose(["\n  export default function _skipFirstGeneratorNext(fn) {\n    return function () {\n      var it = fn.apply(this, arguments);\n      it.next();\n      return it;\n    }\n  }\n"]),
-    _templateObject48 = _taggedTemplateLiteralLoose(["\n  export default function _toPropertyKey(key) {\n    if (typeof key === \"symbol\") {\n      return key;\n    } else {\n      return String(key);\n    }\n  }\n"]),
-    _templateObject49 = _taggedTemplateLiteralLoose(["\n    export default function _initializerWarningHelper(descriptor, context){\n        throw new Error(\n          'Decorating class property failed. Please ensure that ' +\n          'proposal-class-properties is enabled and set to use loose mode. ' +\n          'To use proposal-class-properties in spec mode with decorators, wait for ' +\n          'the next major version of decorators in stage 2.'\n        );\n    }\n"]),
-    _templateObject50 = _taggedTemplateLiteralLoose(["\n    export default function _initializerDefineProperty(target, property, descriptor, context){\n        if (!descriptor) return;\n\n        Object.defineProperty(target, property, {\n            enumerable: descriptor.enumerable,\n            configurable: descriptor.configurable,\n            writable: descriptor.writable,\n            value: descriptor.initializer ? descriptor.initializer.call(context) : void 0,\n        });\n    }\n"]),
-    _templateObject51 = _taggedTemplateLiteralLoose(["\n    export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context){\n        var desc = {};\n        Object['ke' + 'ys'](descriptor).forEach(function(key){\n            desc[key] = descriptor[key];\n        });\n        desc.enumerable = !!desc.enumerable;\n        desc.configurable = !!desc.configurable;\n        if ('value' in desc || desc.initializer){\n            desc.writable = true;\n        }\n\n        desc = decorators.slice().reverse().reduce(function(desc, decorator){\n            return decorator(target, property, desc) || desc;\n        }, desc);\n\n        if (context && desc.initializer !== void 0){\n            desc.value = desc.initializer ? desc.initializer.call(context) : void 0;\n            desc.initializer = undefined;\n        }\n\n        if (desc.initializer === void 0){\n            // This is a hack to avoid this being processed by 'transform-runtime'.\n            // See issue #9.\n            Object['define' + 'Property'](target, property, desc);\n            desc = null;\n        }\n\n        return desc;\n    }\n"]);
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _taggedTemplateLiteralLoose(strings, raw) { if (!raw) { raw = strings.slice(0); } strings.raw = raw; return strings; }
-
-var helpers = {};
+const helpers = Object.create(null);
 var _default = helpers;
 exports.default = _default;
 
-helpers.typeof = function () {
-  return _template().default.program.ast(_templateObject);
-};
+const helper = minVersion => tpl => ({
+  minVersion,
+  ast: () => _template().default.program.ast(tpl)
+});
+
+helpers.typeof = helper("7.0.0-beta.0")`
+  export default function _typeof(obj) {
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof = function (obj) { return typeof obj; };
+    } else {
+      _typeof = function (obj) {
+        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype
+          ? "symbol"
+          : typeof obj;
+      };
+    }
+
+    return _typeof(obj);
+  }
+`;
+helpers.jsx = helper("7.0.0-beta.0")`
+  var REACT_ELEMENT_TYPE;
+
+  export default function _createRawReactElement(type, props, key, children) {
+    if (!REACT_ELEMENT_TYPE) {
+      REACT_ELEMENT_TYPE = (
+        typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element")
+      ) || 0xeac7;
+    }
+
+    var defaultProps = type && type.defaultProps;
+    var childrenLength = arguments.length - 3;
+
+    if (!props && childrenLength !== 0) {
+      // If we're going to assign props.children, we create a new object now
+      // to avoid mutating defaultProps.
+      props = {
+        children: void 0,
+      };
+    }
+    if (props && defaultProps) {
+      for (var propName in defaultProps) {
+        if (props[propName] === void 0) {
+          props[propName] = defaultProps[propName];
+        }
+      }
+    } else if (!props) {
+      props = defaultProps || {};
+    }
+
+    if (childrenLength === 1) {
+      props.children = children;
+    } else if (childrenLength > 1) {
+      var childArray = new Array(childrenLength);
+      for (var i = 0; i < childrenLength; i++) {
+        childArray[i] = arguments[i + 3];
+      }
+      props.children = childArray;
+    }
+
+    return {
+      $$typeof: REACT_ELEMENT_TYPE,
+      type: type,
+      key: key === undefined ? null : '' + key,
+      ref: null,
+      props: props,
+      _owner: null,
+    };
+  }
+`;
+helpers.asyncIterator = helper("7.0.0-beta.0")`
+  export default function _asyncIterator(iterable) {
+    var method
+    if (typeof Symbol !== "undefined") {
+      if (Symbol.asyncIterator) {
+        method = iterable[Symbol.asyncIterator]
+        if (method != null) return method.call(iterable);
+      }
+      if (Symbol.iterator) {
+        method = iterable[Symbol.iterator]
+        if (method != null) return method.call(iterable);
+      }
+    }
+    throw new TypeError("Object is not async iterable");
+  }
+`;
+helpers.AwaitValue = helper("7.0.0-beta.0")`
+  export default function _AwaitValue(value) {
+    this.wrapped = value;
+  }
+`;
+helpers.AsyncGenerator = helper("7.0.0-beta.0")`
+  import AwaitValue from "AwaitValue";
+
+  export default function AsyncGenerator(gen) {
+    var front, back;
+
+    function send(key, arg) {
+      return new Promise(function (resolve, reject) {
+        var request = {
+          key: key,
+          arg: arg,
+          resolve: resolve,
+          reject: reject,
+          next: null,
+        };
+
+        if (back) {
+          back = back.next = request;
+        } else {
+          front = back = request;
+          resume(key, arg);
+        }
+      });
+    }
+
+    function resume(key, arg) {
+      try {
+        var result = gen[key](arg)
+        var value = result.value;
+        var wrappedAwait = value instanceof AwaitValue;
+
+        Promise.resolve(wrappedAwait ? value.wrapped : value).then(
+          function (arg) {
+            if (wrappedAwait) {
+              resume("next", arg);
+              return
+            }
+
+            settle(result.done ? "return" : "normal", arg);
+          },
+          function (err) { resume("throw", err); });
+      } catch (err) {
+        settle("throw", err);
+      }
+    }
+
+    function settle(type, value) {
+      switch (type) {
+        case "return":
+          front.resolve({ value: value, done: true });
+          break;
+        case "throw":
+          front.reject(value);
+          break;
+        default:
+          front.resolve({ value: value, done: false });
+          break;
+      }
+
+      front = front.next;
+      if (front) {
+        resume(front.key, front.arg);
+      } else {
+        back = null;
+      }
+    }
+
+    this._invoke = send;
+
+    // Hide "return" method if generator return is not supported
+    if (typeof gen.return !== "function") {
+      this.return = undefined;
+    }
+  }
+
+  if (typeof Symbol === "function" && Symbol.asyncIterator) {
+    AsyncGenerator.prototype[Symbol.asyncIterator] = function () { return this; };
+  }
+
+  AsyncGenerator.prototype.next = function (arg) { return this._invoke("next", arg); };
+  AsyncGenerator.prototype.throw = function (arg) { return this._invoke("throw", arg); };
+  AsyncGenerator.prototype.return = function (arg) { return this._invoke("return", arg); };
+`;
+helpers.wrapAsyncGenerator = helper("7.0.0-beta.0")`
+  import AsyncGenerator from "AsyncGenerator";
+
+  export default function _wrapAsyncGenerator(fn) {
+    return function () {
+      return new AsyncGenerator(fn.apply(this, arguments));
+    };
+  }
+`;
+helpers.awaitAsyncGenerator = helper("7.0.0-beta.0")`
+  import AwaitValue from "AwaitValue";
+
+  export default function _awaitAsyncGenerator(value) {
+    return new AwaitValue(value);
+  }
+`;
+helpers.asyncGeneratorDelegate = helper("7.0.0-beta.0")`
+  export default function _asyncGeneratorDelegate(inner, awaitWrap) {
+    var iter = {}, waiting = false;
+
+    function pump(key, value) {
+      waiting = true;
+      value = new Promise(function (resolve) { resolve(inner[key](value)); });
+      return { done: false, value: awaitWrap(value) };
+    };
+
+    if (typeof Symbol === "function" && Symbol.iterator) {
+      iter[Symbol.iterator] = function () { return this; };
+    }
+
+    iter.next = function (value) {
+      if (waiting) {
+        waiting = false;
+        return value;
+      }
+      return pump("next", value);
+    };
+
+    if (typeof inner.throw === "function") {
+      iter.throw = function (value) {
+        if (waiting) {
+          waiting = false;
+          throw value;
+        }
+        return pump("throw", value);
+      };
+    }
+
+    if (typeof inner.return === "function") {
+      iter.return = function (value) {
+        return pump("return", value);
+      };
+    }
+
+    return iter;
+  }
+`;
+helpers.asyncToGenerator = helper("7.0.0-beta.0")`
+  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+      var info = gen[key](arg);
+      var value = info.value;
+    } catch (error) {
+      reject(error);
+      return;
+    }
+
+    if (info.done) {
+      resolve(value);
+    } else {
+      Promise.resolve(value).then(_next, _throw);
+    }
+  }
+
+  export default function _asyncToGenerator(fn) {
+    return function () {
+      var self = this, args = arguments;
+      return new Promise(function (resolve, reject) {
+        var gen = fn.apply(self, args);
+        function _next(value) {
+          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+        }
+        function _throw(err) {
+          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+        }
+
+        _next(undefined);
+      });
+    };
+  }
+`;
+helpers.classCallCheck = helper("7.0.0-beta.0")`
+  export default function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+`;
+helpers.createClass = helper("7.0.0-beta.0")`
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i ++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  export default function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+`;
+helpers.defineEnumerableProperties = helper("7.0.0-beta.0")`
+  export default function _defineEnumerableProperties(obj, descs) {
+    for (var key in descs) {
+      var desc = descs[key];
+      desc.configurable = desc.enumerable = true;
+      if ("value" in desc) desc.writable = true;
+      Object.defineProperty(obj, key, desc);
+    }
+
+    // Symbols are not enumerated over by for-in loops. If native
+    // Symbols are available, fetch all of the descs object's own
+    // symbol properties and define them on our target object too.
+    if (Object.getOwnPropertySymbols) {
+      var objectSymbols = Object.getOwnPropertySymbols(descs);
+      for (var i = 0; i < objectSymbols.length; i++) {
+        var sym = objectSymbols[i];
+        var desc = descs[sym];
+        desc.configurable = desc.enumerable = true;
+        if ("value" in desc) desc.writable = true;
+        Object.defineProperty(obj, sym, desc);
+      }
+    }
+    return obj;
+  }
+`;
+helpers.defaults = helper("7.0.0-beta.0")`
+  export default function _defaults(obj, defaults) {
+    var keys = Object.getOwnPropertyNames(defaults);
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+      var value = Object.getOwnPropertyDescriptor(defaults, key);
+      if (value && value.configurable && obj[key] === undefined) {
+        Object.defineProperty(obj, key, value);
+      }
+    }
+    return obj;
+  }
+`;
+helpers.defineProperty = helper("7.0.0-beta.0")`
+  export default function _defineProperty(obj, key, value) {
+    // Shortcircuit the slow defineProperty path when possible.
+    // We are trying to avoid issues where setters defined on the
+    // prototype cause side effects under the fast path of simple
+    // assignment. By checking for existence of the property with
+    // the in operator, we can optimize most of this overhead away.
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+`;
+helpers.extends = helper("7.0.0-beta.0")`
+  export default function _extends() {
+    _extends = Object.assign || function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+      return target;
+    };
+
+    return _extends.apply(this, arguments);
+  }
+`;
+helpers.objectSpread = helper("7.0.0-beta.0")`
+  import defineProperty from "defineProperty";
+
+  export default function _objectSpread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = (arguments[i] != null) ? arguments[i] : {};
+      var ownKeys = Object.keys(source);
+      if (typeof Object.getOwnPropertySymbols === 'function') {
+        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+      }
+      ownKeys.forEach(function(key) {
+        defineProperty(target, key, source[key]);
+      });
+    }
+    return target;
+  }
+`;
+helpers.objectSpread2 = helper("7.5.0")`
+  import defineProperty from "defineProperty";
+
+  // This function is different to "Reflect.ownKeys". The enumerableOnly
+  // filters on symbol properties only. Returned string properties are always 
+  // enumerable. It is good to use in objectSpread.
+
+  function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      if (enumerableOnly) symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+      keys.push.apply(keys, symbols);
+    }
+    return keys;
+  }
+
+  export default function _objectSpread2(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = (arguments[i] != null) ? arguments[i] : {};
+      if (i % 2) {
+        ownKeys(source, true).forEach(function (key) {
+          defineProperty(target, key, source[key]);
+        });
+      } else if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+      } else {
+        ownKeys(source).forEach(function (key) {
+          Object.defineProperty(
+            target,
+            key,
+            Object.getOwnPropertyDescriptor(source, key)
+          );
+        });
+      }
+    }
+    return target;
+  }
+`;
+helpers.inherits = helper("7.0.0-beta.0")`
+  import setPrototypeOf from "setPrototypeOf";
+
+  export default function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+      constructor: {
+        value: subClass,
+        writable: true,
+        configurable: true
+      }
+    });
+    if (superClass) setPrototypeOf(subClass, superClass);
+  }
+`;
+helpers.inheritsLoose = helper("7.0.0-beta.0")`
+  export default function _inheritsLoose(subClass, superClass) {
+    subClass.prototype = Object.create(superClass.prototype);
+    subClass.prototype.constructor = subClass;
+    subClass.__proto__ = superClass;
+  }
+`;
+helpers.getPrototypeOf = helper("7.0.0-beta.0")`
+  export default function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf
+      ? Object.getPrototypeOf
+      : function _getPrototypeOf(o) {
+          return o.__proto__ || Object.getPrototypeOf(o);
+        };
+    return _getPrototypeOf(o);
+  }
+`;
+helpers.setPrototypeOf = helper("7.0.0-beta.0")`
+  export default function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+    return _setPrototypeOf(o, p);
+  }
+`;
+helpers.construct = helper("7.0.0-beta.0")`
+  import setPrototypeOf from "setPrototypeOf";
+
+  function isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+
+    // core-js@3
+    if (Reflect.construct.sham) return false;
+
+    // Proxy can't be polyfilled. Every browser implemented
+    // proxies before or at the same time as Reflect.construct,
+    // so if they support Proxy they also support Reflect.construct.
+    if (typeof Proxy === "function") return true;
+
+    // Since Reflect.construct can't be properly polyfilled, some
+    // implementations (e.g. core-js@2) don't set the correct internal slots.
+    // Those polyfills don't allow us to subclass built-ins, so we need to
+    // use our fallback implementation.
+    try {
+      // If the internal slots aren't set, this throws an error similar to
+      //   TypeError: this is not a Date object.
+      Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  export default function _construct(Parent, args, Class) {
+    if (isNativeReflectConstruct()) {
+      _construct = Reflect.construct;
+    } else {
+      // NOTE: If Parent !== Class, the correct __proto__ is set *after*
+      //       calling the constructor.
+      _construct = function _construct(Parent, args, Class) {
+        var a = [null];
+        a.push.apply(a, args);
+        var Constructor = Function.bind.apply(Parent, a);
+        var instance = new Constructor();
+        if (Class) setPrototypeOf(instance, Class.prototype);
+        return instance;
+      };
+    }
+    // Avoid issues with Class being present but undefined when it wasn't
+    // present in the original call.
+    return _construct.apply(null, arguments);
+  }
+`;
+helpers.isNativeFunction = helper("7.0.0-beta.0")`
+  export default function _isNativeFunction(fn) {
+    // Note: This function returns "true" for core-js functions.
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+  }
+`;
+helpers.wrapNativeSuper = helper("7.0.0-beta.0")`
+  import getPrototypeOf from "getPrototypeOf";
+  import setPrototypeOf from "setPrototypeOf";
+  import isNativeFunction from "isNativeFunction";
+  import construct from "construct";
+
+  export default function _wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+
+    _wrapNativeSuper = function _wrapNativeSuper(Class) {
+      if (Class === null || !isNativeFunction(Class)) return Class;
+      if (typeof Class !== "function") {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      if (typeof _cache !== "undefined") {
+        if (_cache.has(Class)) return _cache.get(Class);
+        _cache.set(Class, Wrapper);
+      }
+      function Wrapper() {
+        return construct(Class, arguments, getPrototypeOf(this).constructor)
+      }
+      Wrapper.prototype = Object.create(Class.prototype, {
+        constructor: {
+          value: Wrapper,
+          enumerable: false,
+          writable: true,
+          configurable: true,
+        }
+      });
+
+      return setPrototypeOf(Wrapper, Class);
+    }
+
+    return _wrapNativeSuper(Class)
+  }
+`;
+helpers.instanceof = helper("7.0.0-beta.0")`
+  export default function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+      return !!right[Symbol.hasInstance](left);
+    } else {
+      return left instanceof right;
+    }
+  }
+`;
+helpers.interopRequireDefault = helper("7.0.0-beta.0")`
+  export default function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+  }
+`;
+helpers.interopRequireWildcard = helper("7.0.0-beta.0")`
+  export default function _interopRequireWildcard(obj) {
+    if (obj && obj.__esModule) {
+      return obj;
+    } else {
+      var newObj = {};
+      if (obj != null) {
+        for (var key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = Object.defineProperty && Object.getOwnPropertyDescriptor
+              ? Object.getOwnPropertyDescriptor(obj, key)
+              : {};
+            if (desc.get || desc.set) {
+              Object.defineProperty(newObj, key, desc);
+            } else {
+              newObj[key] = obj[key];
+            }
+          }
+        }
+      }
+      newObj.default = obj;
+      return newObj;
+    }
+  }
+`;
+helpers.newArrowCheck = helper("7.0.0-beta.0")`
+  export default function _newArrowCheck(innerThis, boundThis) {
+    if (innerThis !== boundThis) {
+      throw new TypeError("Cannot instantiate an arrow function");
+    }
+  }
+`;
+helpers.objectDestructuringEmpty = helper("7.0.0-beta.0")`
+  export default function _objectDestructuringEmpty(obj) {
+    if (obj == null) throw new TypeError("Cannot destructure undefined");
+  }
+`;
+helpers.objectWithoutPropertiesLoose = helper("7.0.0-beta.0")`
+  export default function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+
+    for (i = 0; i < sourceKeys.length; i++) {
+      key = sourceKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+
+    return target;
+  }
+`;
+helpers.objectWithoutProperties = helper("7.0.0-beta.0")`
+  import objectWithoutPropertiesLoose from "objectWithoutPropertiesLoose";
+
+  export default function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+
+    var target = objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+
+    if (Object.getOwnPropertySymbols) {
+      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+      for (i = 0; i < sourceSymbolKeys.length; i++) {
+        key = sourceSymbolKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+      }
+    }
+
+    return target;
+  }
+`;
+helpers.assertThisInitialized = helper("7.0.0-beta.0")`
+  export default function _assertThisInitialized(self) {
+    if (self === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+  }
+`;
+helpers.possibleConstructorReturn = helper("7.0.0-beta.0")`
+  import assertThisInitialized from "assertThisInitialized";
+
+  export default function _possibleConstructorReturn(self, call) {
+    if (call && (typeof call === "object" || typeof call === "function")) {
+      return call;
+    }
+    return assertThisInitialized(self);
+  }
+`;
+helpers.superPropBase = helper("7.0.0-beta.0")`
+  import getPrototypeOf from "getPrototypeOf";
+
+  export default function _superPropBase(object, property) {
+    // Yes, this throws if object is null to being with, that's on purpose.
+    while (!Object.prototype.hasOwnProperty.call(object, property)) {
+      object = getPrototypeOf(object);
+      if (object === null) break;
+    }
+    return object;
+  }
+`;
+helpers.get = helper("7.0.0-beta.0")`
+  import superPropBase from "superPropBase";
+
+  export default function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+      _get = Reflect.get;
+    } else {
+      _get = function _get(target, property, receiver) {
+        var base = superPropBase(target, property);
+
+        if (!base) return;
+
+        var desc = Object.getOwnPropertyDescriptor(base, property);
+        if (desc.get) {
+          return desc.get.call(receiver);
+        }
+
+        return desc.value;
+      };
+    }
+    return _get(target, property, receiver || target);
+  }
+`;
+helpers.set = helper("7.0.0-beta.0")`
+  import superPropBase from "superPropBase";
+  import defineProperty from "defineProperty";
+
+  function set(target, property, value, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.set) {
+      set = Reflect.set;
+    } else {
+      set = function set(target, property, value, receiver) {
+        var base = superPropBase(target, property);
+        var desc;
+
+        if (base) {
+          desc = Object.getOwnPropertyDescriptor(base, property);
+          if (desc.set) {
+            desc.set.call(receiver, value);
+            return true;
+          } else if (!desc.writable) {
+            // Both getter and non-writable fall into this.
+            return false;
+          }
+        }
+
+        // Without a super that defines the property, spec boils down to
+        // "define on receiver" for some reason.
+        desc = Object.getOwnPropertyDescriptor(receiver, property);
+        if (desc) {
+          if (!desc.writable) {
+            // Setter, getter, and non-writable fall into this.
+            return false;
+          }
+
+          desc.value = value;
+          Object.defineProperty(receiver, property, desc);
+        } else {
+          // Avoid setters that may be defined on Sub's prototype, but not on
+          // the instance.
+          defineProperty(receiver, property, value);
+        }
+
+        return true;
+      };
+    }
+
+    return set(target, property, value, receiver);
+  }
+
+  export default function _set(target, property, value, receiver, isStrict) {
+    var s = set(target, property, value, receiver || target);
+    if (!s && isStrict) {
+      throw new Error('failed to set property');
+    }
+
+    return value;
+  }
+`;
+helpers.taggedTemplateLiteral = helper("7.0.0-beta.0")`
+  export default function _taggedTemplateLiteral(strings, raw) {
+    if (!raw) { raw = strings.slice(0); }
+    return Object.freeze(Object.defineProperties(strings, {
+        raw: { value: Object.freeze(raw) }
+    }));
+  }
+`;
+helpers.taggedTemplateLiteralLoose = helper("7.0.0-beta.0")`
+  export default function _taggedTemplateLiteralLoose(strings, raw) {
+    if (!raw) { raw = strings.slice(0); }
+    strings.raw = raw;
+    return strings;
+  }
+`;
+helpers.temporalRef = helper("7.0.0-beta.0")`
+  import undef from "temporalUndefined";
+
+  export default function _temporalRef(val, name) {
+    if (val === undef) {
+      throw new ReferenceError(name + " is not defined - temporal dead zone");
+    } else {
+      return val;
+    }
+  }
+`;
+helpers.readOnlyError = helper("7.0.0-beta.0")`
+  export default function _readOnlyError(name) {
+    throw new Error("\\"" + name + "\\" is read-only");
+  }
+`;
+helpers.classNameTDZError = helper("7.0.0-beta.0")`
+  export default function _classNameTDZError(name) {
+    throw new Error("Class \\"" + name + "\\" cannot be referenced in computed property keys.");
+  }
+`;
+helpers.temporalUndefined = helper("7.0.0-beta.0")`
+  export default {};
+`;
+helpers.slicedToArray = helper("7.0.0-beta.0")`
+  import arrayWithHoles from "arrayWithHoles";
+  import iterableToArrayLimit from "iterableToArrayLimit";
+  import nonIterableRest from "nonIterableRest";
+
+  export default function _slicedToArray(arr, i) {
+    return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+  }
+`;
+helpers.slicedToArrayLoose = helper("7.0.0-beta.0")`
+  import arrayWithHoles from "arrayWithHoles";
+  import iterableToArrayLimitLoose from "iterableToArrayLimitLoose";
+  import nonIterableRest from "nonIterableRest";
+
+  export default function _slicedToArrayLoose(arr, i) {
+    return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();
+  }
+`;
+helpers.toArray = helper("7.0.0-beta.0")`
+  import arrayWithHoles from "arrayWithHoles";
+  import iterableToArray from "iterableToArray";
+  import nonIterableRest from "nonIterableRest";
+
+  export default function _toArray(arr) {
+    return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();
+  }
+`;
+helpers.toConsumableArray = helper("7.0.0-beta.0")`
+  import arrayWithoutHoles from "arrayWithoutHoles";
+  import iterableToArray from "iterableToArray";
+  import nonIterableSpread from "nonIterableSpread";
+
+  export default function _toConsumableArray(arr) {
+    return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+  }
+`;
+helpers.arrayWithoutHoles = helper("7.0.0-beta.0")`
+  export default function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) {
+      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+      return arr2;
+    }
+  }
+`;
+helpers.arrayWithHoles = helper("7.0.0-beta.0")`
+  export default function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+`;
+helpers.iterableToArray = helper("7.0.0-beta.0")`
+  export default function _iterableToArray(iter) {
+    if (
+      Symbol.iterator in Object(iter) ||
+      Object.prototype.toString.call(iter) === "[object Arguments]"
+    ) return Array.from(iter);
+  }
+`;
+helpers.iterableToArrayLimit = helper("7.0.0-beta.0")`
+  export default function _iterableToArrayLimit(arr, i) {
+    // this is an expanded form of \`for...of\` that properly supports abrupt completions of
+    // iterators etc. variable names have been minimised to reduce the size of this massive
+    // helper. sometimes spec compliancy is annoying :(
+    //
+    // _n = _iteratorNormalCompletion
+    // _d = _didIteratorError
+    // _e = _iteratorError
+    // _i = _iterator
+    // _s = _step
+
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _e = undefined;
+    try {
+      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"] != null) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+`;
+helpers.iterableToArrayLimitLoose = helper("7.0.0-beta.0")`
+  export default function _iterableToArrayLimitLoose(arr, i) {
+    var _arr = [];
+    for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
+      _arr.push(_step.value);
+      if (i && _arr.length === i) break;
+    }
+    return _arr;
+  }
+`;
+helpers.nonIterableSpread = helper("7.0.0-beta.0")`
+  export default function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance");
+  }
+`;
+helpers.nonIterableRest = helper("7.0.0-beta.0")`
+  export default function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance");
+  }
+`;
+helpers.skipFirstGeneratorNext = helper("7.0.0-beta.0")`
+  export default function _skipFirstGeneratorNext(fn) {
+    return function () {
+      var it = fn.apply(this, arguments);
+      it.next();
+      return it;
+    }
+  }
+`;
+helpers.toPrimitive = helper("7.1.5")`
+  export default function _toPrimitive(
+    input,
+    hint /*: "default" | "string" | "number" | void */
+  ) {
+    if (typeof input !== "object" || input === null) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== undefined) {
+      var res = prim.call(input, hint || "default");
+      if (typeof res !== "object") return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+`;
+helpers.toPropertyKey = helper("7.1.5")`
+  import toPrimitive from "toPrimitive";
+
+  export default function _toPropertyKey(arg) {
+    var key = toPrimitive(arg, "string");
+    return typeof key === "symbol" ? key : String(key);
+  }
+`;
+helpers.initializerWarningHelper = helper("7.0.0-beta.0")`
+    export default function _initializerWarningHelper(descriptor, context){
+        throw new Error(
+          'Decorating class property failed. Please ensure that ' +
+          'proposal-class-properties is enabled and set to use loose mode. ' +
+          'To use proposal-class-properties in spec mode with decorators, wait for ' +
+          'the next major version of decorators in stage 2.'
+        );
+    }
+`;
+helpers.initializerDefineProperty = helper("7.0.0-beta.0")`
+    export default function _initializerDefineProperty(target, property, descriptor, context){
+        if (!descriptor) return;
+
+        Object.defineProperty(target, property, {
+            enumerable: descriptor.enumerable,
+            configurable: descriptor.configurable,
+            writable: descriptor.writable,
+            value: descriptor.initializer ? descriptor.initializer.call(context) : void 0,
+        });
+    }
+`;
+helpers.applyDecoratedDescriptor = helper("7.0.0-beta.0")`
+    export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context){
+        var desc = {};
+        Object.keys(descriptor).forEach(function(key){
+            desc[key] = descriptor[key];
+        });
+        desc.enumerable = !!desc.enumerable;
+        desc.configurable = !!desc.configurable;
+        if ('value' in desc || desc.initializer){
+            desc.writable = true;
+        }
+
+        desc = decorators.slice().reverse().reduce(function(desc, decorator){
+            return decorator(target, property, desc) || desc;
+        }, desc);
+
+        if (context && desc.initializer !== void 0){
+            desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
+            desc.initializer = undefined;
+        }
+
+        if (desc.initializer === void 0){
+            // This is a hack to avoid this being processed by 'transform-runtime'.
+            // See issue #9.
+            Object.defineProperty(target, property, desc);
+            desc = null;
+        }
+
+        return desc;
+    }
+`;
+helpers.classPrivateFieldLooseKey = helper("7.0.0-beta.0")`
+  var id = 0;
+  export default function _classPrivateFieldKey(name) {
+    return "__private_" + (id++) + "_" + name;
+  }
+`;
+helpers.classPrivateFieldLooseBase = helper("7.0.0-beta.0")`
+  export default function _classPrivateFieldBase(receiver, privateKey) {
+    if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+      throw new TypeError("attempted to use private field on non-instance");
+    }
+    return receiver;
+  }
+`;
+helpers.classPrivateFieldGet = helper("7.0.0-beta.0")`
+  export default function _classPrivateFieldGet(receiver, privateMap) {
+    var descriptor = privateMap.get(receiver);
+    if (!descriptor) {
+      throw new TypeError("attempted to get private field on non-instance");
+    }
+    if (descriptor.get) {
+      return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+  }
+`;
+helpers.classPrivateFieldSet = helper("7.0.0-beta.0")`
+  export default function _classPrivateFieldSet(receiver, privateMap, value) {
+    var descriptor = privateMap.get(receiver);
+    if (!descriptor) {
+      throw new TypeError("attempted to set private field on non-instance");
+    }
+    if (descriptor.set) {
+      descriptor.set.call(receiver, value);
+    } else {
+      if (!descriptor.writable) {
+        // This should only throw in strict mode, but class bodies are
+        // always strict and private fields can only be used inside
+        // class bodies.
+        throw new TypeError("attempted to set read only private field");
+      }
+
+      descriptor.value = value;
+    }
+
+    return value;
+  }
+`;
+helpers.classPrivateFieldDestructureSet = helper("7.4.4")`
+  export default function _classPrivateFieldDestructureSet(receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+      throw new TypeError("attempted to set private field on non-instance");
+    }
+    var descriptor = privateMap.get(receiver);
+    if (descriptor.set) {
+      if (!("__destrObj" in descriptor)) {
+        descriptor.__destrObj = {
+          set value(v) {
+            descriptor.set.call(receiver, v)
+          },
+        };
+      }
+      return descriptor.__destrObj;
+    } else {
+      if (!descriptor.writable) {
+        // This should only throw in strict mode, but class bodies are
+        // always strict and private fields can only be used inside
+        // class bodies.
+        throw new TypeError("attempted to set read only private field");
+      }
+
+      return descriptor;
+    }
+  }
+`;
+helpers.classStaticPrivateFieldSpecGet = helper("7.0.2")`
+  export default function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
+    if (receiver !== classConstructor) {
+      throw new TypeError("Private static access of wrong provenance");
+    }
+    return descriptor.value;
+  }
+`;
+helpers.classStaticPrivateFieldSpecSet = helper("7.0.2")`
+  export default function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {
+    if (receiver !== classConstructor) {
+      throw new TypeError("Private static access of wrong provenance");
+    }
+    if (!descriptor.writable) {
+      // This should only throw in strict mode, but class bodies are
+      // always strict and private fields can only be used inside
+      // class bodies.
+      throw new TypeError("attempted to set read only private field");
+    }
+    descriptor.value = value;
+    return value;
+  }
+`;
+helpers.classStaticPrivateMethodGet = helper("7.3.2")`
+  export default function _classStaticPrivateMethodGet(receiver, classConstructor, method) {
+    if (receiver !== classConstructor) {
+      throw new TypeError("Private static access of wrong provenance");
+    }
+    return method;
+  }
+`;
+helpers.classStaticPrivateMethodSet = helper("7.3.2")`
+  export default function _classStaticPrivateMethodSet() {
+    throw new TypeError("attempted to set read only static private field");
+  }
+`;
+helpers.decorate = helper("7.1.5")`
+  import toArray from "toArray";
+  import toPropertyKey from "toPropertyKey";
+
+  // These comments are stripped by @babel/template
+  /*::
+  type PropertyDescriptor =
+    | {
+        value: any,
+        writable: boolean,
+        configurable: boolean,
+        enumerable: boolean,
+      }
+    | {
+        get?: () => any,
+        set?: (v: any) => void,
+        configurable: boolean,
+        enumerable: boolean,
+      };
+
+  type FieldDescriptor ={
+    writable: boolean,
+    configurable: boolean,
+    enumerable: boolean,
+  };
+
+  type Placement = "static" | "prototype" | "own";
+  type Key = string | symbol; // PrivateName is not supported yet.
+
+  type ElementDescriptor =
+    | {
+        kind: "method",
+        key: Key,
+        placement: Placement,
+        descriptor: PropertyDescriptor
+      }
+    | {
+        kind: "field",
+        key: Key,
+        placement: Placement,
+        descriptor: FieldDescriptor,
+        initializer?: () => any,
+      };
+
+  // This is exposed to the user code
+  type ElementObjectInput = ElementDescriptor & {
+    [@@toStringTag]?: "Descriptor"
+  };
+
+  // This is exposed to the user code
+  type ElementObjectOutput = ElementDescriptor & {
+    [@@toStringTag]?: "Descriptor"
+    extras?: ElementDescriptor[],
+    finisher?: ClassFinisher,
+  };
+
+  // This is exposed to the user code
+  type ClassObject = {
+    [@@toStringTag]?: "Descriptor",
+    kind: "class",
+    elements: ElementDescriptor[],
+  };
+
+  type ElementDecorator = (descriptor: ElementObjectInput) => ?ElementObjectOutput;
+  type ClassDecorator = (descriptor: ClassObject) => ?ClassObject;
+  type ClassFinisher = <A, B>(cl: Class<A>) => Class<B>;
+
+  // Only used by Babel in the transform output, not part of the spec.
+  type ElementDefinition =
+    | {
+        kind: "method",
+        value: any,
+        key: Key,
+        static?: boolean,
+        decorators?: ElementDecorator[],
+      }
+    | {
+        kind: "field",
+        value: () => any,
+        key: Key,
+        static?: boolean,
+        decorators?: ElementDecorator[],
+    };
+
+  declare function ClassFactory<C>(initialize: (instance: C) => void): {
+    F: Class<C>,
+    d: ElementDefinition[]
+  }
+
+  */
+
+  /*::
+  // Various combinations with/without extras and with one or many finishers
+
+  type ElementFinisherExtras = {
+    element: ElementDescriptor,
+    finisher?: ClassFinisher,
+    extras?: ElementDescriptor[],
+  };
+
+  type ElementFinishersExtras = {
+    element: ElementDescriptor,
+    finishers: ClassFinisher[],
+    extras: ElementDescriptor[],
+  };
+
+  type ElementsFinisher = {
+    elements: ElementDescriptor[],
+    finisher?: ClassFinisher,
+  };
+
+  type ElementsFinishers = {
+    elements: ElementDescriptor[],
+    finishers: ClassFinisher[],
+  };
+
+  */
+
+  /*::
+
+  type Placements = {
+    static: Key[],
+    prototype: Key[],
+    own: Key[],
+  };
+
+  */
+
+  // ClassDefinitionEvaluation (Steps 26-*)
+  export default function _decorate(
+    decorators /*: ClassDecorator[] */,
+    factory /*: ClassFactory */,
+    superClass /*: ?Class<*> */,
+    mixins /*: ?Array<Function> */,
+  ) /*: Class<*> */ {
+    var api = _getDecoratorsApi();
+    if (mixins) {
+      for (var i = 0; i < mixins.length; i++) {
+        api = mixins[i](api);
+      }
+    }
+
+    var r = factory(function initialize(O) {
+      api.initializeInstanceElements(O, decorated.elements);
+    }, superClass);
+    var decorated = api.decorateClass(
+      _coalesceClassElements(r.d.map(_createElementDescriptor)),
+      decorators,
+    );
+
+    api.initializeClassElements(r.F, decorated.elements);
+
+    return api.runClassFinishers(r.F, decorated.finishers);
+  }
+
+  function _getDecoratorsApi() {
+    _getDecoratorsApi = function() {
+      return api;
+    };
+
+    var api = {
+      elementsDefinitionOrder: [["method"], ["field"]],
+
+      // InitializeInstanceElements
+      initializeInstanceElements: function(
+        /*::<C>*/ O /*: C */,
+        elements /*: ElementDescriptor[] */,
+      ) {
+        ["method", "field"].forEach(function(kind) {
+          elements.forEach(function(element /*: ElementDescriptor */) {
+            if (element.kind === kind && element.placement === "own") {
+              this.defineClassElement(O, element);
+            }
+          }, this);
+        }, this);
+      },
+
+      // InitializeClassElements
+      initializeClassElements: function(
+        /*::<C>*/ F /*: Class<C> */,
+        elements /*: ElementDescriptor[] */,
+      ) {
+        var proto = F.prototype;
+
+        ["method", "field"].forEach(function(kind) {
+          elements.forEach(function(element /*: ElementDescriptor */) {
+            var placement = element.placement;
+            if (
+              element.kind === kind &&
+              (placement === "static" || placement === "prototype")
+            ) {
+              var receiver = placement === "static" ? F : proto;
+              this.defineClassElement(receiver, element);
+            }
+          }, this);
+        }, this);
+      },
+
+      // DefineClassElement
+      defineClassElement: function(
+        /*::<C>*/ receiver /*: C | Class<C> */,
+        element /*: ElementDescriptor */,
+      ) {
+        var descriptor /*: PropertyDescriptor */ = element.descriptor;
+        if (element.kind === "field") {
+          var initializer = element.initializer;
+          descriptor = {
+            enumerable: descriptor.enumerable,
+            writable: descriptor.writable,
+            configurable: descriptor.configurable,
+            value: initializer === void 0 ? void 0 : initializer.call(receiver),
+          };
+        }
+        Object.defineProperty(receiver, element.key, descriptor);
+      },
+
+      // DecorateClass
+      decorateClass: function(
+        elements /*: ElementDescriptor[] */,
+        decorators /*: ClassDecorator[] */,
+      ) /*: ElementsFinishers */ {
+        var newElements /*: ElementDescriptor[] */ = [];
+        var finishers /*: ClassFinisher[] */ = [];
+        var placements /*: Placements */ = {
+          static: [],
+          prototype: [],
+          own: [],
+        };
+
+        elements.forEach(function(element /*: ElementDescriptor */) {
+          this.addElementPlacement(element, placements);
+        }, this);
+
+        elements.forEach(function(element /*: ElementDescriptor */) {
+          if (!_hasDecorators(element)) return newElements.push(element);
+
+          var elementFinishersExtras /*: ElementFinishersExtras */ = this.decorateElement(
+            element,
+            placements,
+          );
+          newElements.push(elementFinishersExtras.element);
+          newElements.push.apply(newElements, elementFinishersExtras.extras);
+          finishers.push.apply(finishers, elementFinishersExtras.finishers);
+        }, this);
+
+        if (!decorators) {
+          return { elements: newElements, finishers: finishers };
+        }
+
+        var result /*: ElementsFinishers */ = this.decorateConstructor(
+          newElements,
+          decorators,
+        );
+        finishers.push.apply(finishers, result.finishers);
+        result.finishers = finishers;
+
+        return result;
+      },
+
+      // AddElementPlacement
+      addElementPlacement: function(
+        element /*: ElementDescriptor */,
+        placements /*: Placements */,
+        silent /*: boolean */,
+      ) {
+        var keys = placements[element.placement];
+        if (!silent && keys.indexOf(element.key) !== -1) {
+          throw new TypeError("Duplicated element (" + element.key + ")");
+        }
+        keys.push(element.key);
+      },
+
+      // DecorateElement
+      decorateElement: function(
+        element /*: ElementDescriptor */,
+        placements /*: Placements */,
+      ) /*: ElementFinishersExtras */ {
+        var extras /*: ElementDescriptor[] */ = [];
+        var finishers /*: ClassFinisher[] */ = [];
+
+        for (
+          var decorators = element.decorators, i = decorators.length - 1;
+          i >= 0;
+          i--
+        ) {
+          // (inlined) RemoveElementPlacement
+          var keys = placements[element.placement];
+          keys.splice(keys.indexOf(element.key), 1);
+
+          var elementObject /*: ElementObjectInput */ = this.fromElementDescriptor(
+            element,
+          );
+          var elementFinisherExtras /*: ElementFinisherExtras */ = this.toElementFinisherExtras(
+            (0, decorators[i])(elementObject) /*: ElementObjectOutput */ ||
+              elementObject,
+          );
+
+          element = elementFinisherExtras.element;
+          this.addElementPlacement(element, placements);
+
+          if (elementFinisherExtras.finisher) {
+            finishers.push(elementFinisherExtras.finisher);
+          }
+
+          var newExtras /*: ElementDescriptor[] | void */ =
+            elementFinisherExtras.extras;
+          if (newExtras) {
+            for (var j = 0; j < newExtras.length; j++) {
+              this.addElementPlacement(newExtras[j], placements);
+            }
+            extras.push.apply(extras, newExtras);
+          }
+        }
+
+        return { element: element, finishers: finishers, extras: extras };
+      },
+
+      // DecorateConstructor
+      decorateConstructor: function(
+        elements /*: ElementDescriptor[] */,
+        decorators /*: ClassDecorator[] */,
+      ) /*: ElementsFinishers */ {
+        var finishers /*: ClassFinisher[] */ = [];
+
+        for (var i = decorators.length - 1; i >= 0; i--) {
+          var obj /*: ClassObject */ = this.fromClassDescriptor(elements);
+          var elementsAndFinisher /*: ElementsFinisher */ = this.toClassDescriptor(
+            (0, decorators[i])(obj) /*: ClassObject */ || obj,
+          );
+
+          if (elementsAndFinisher.finisher !== undefined) {
+            finishers.push(elementsAndFinisher.finisher);
+          }
 
-helpers.jsx = function () {
-  return _template().default.program.ast(_templateObject2);
-};
+          if (elementsAndFinisher.elements !== undefined) {
+            elements = elementsAndFinisher.elements;
 
-helpers.asyncIterator = function () {
-  return _template().default.program.ast(_templateObject3);
-};
+            for (var j = 0; j < elements.length - 1; j++) {
+              for (var k = j + 1; k < elements.length; k++) {
+                if (
+                  elements[j].key === elements[k].key &&
+                  elements[j].placement === elements[k].placement
+                ) {
+                  throw new TypeError(
+                    "Duplicated element (" + elements[j].key + ")",
+                  );
+                }
+              }
+            }
+          }
+        }
 
-helpers.AwaitValue = function () {
-  return _template().default.program.ast(_templateObject4);
-};
+        return { elements: elements, finishers: finishers };
+      },
 
-helpers.AsyncGenerator = function () {
-  return _template().default.program.ast(_templateObject5);
-};
+      // FromElementDescriptor
+      fromElementDescriptor: function(
+        element /*: ElementDescriptor */,
+      ) /*: ElementObject */ {
+        var obj /*: ElementObject */ = {
+          kind: element.kind,
+          key: element.key,
+          placement: element.placement,
+          descriptor: element.descriptor,
+        };
 
-helpers.wrapAsyncGenerator = function () {
-  return _template().default.program.ast(_templateObject6);
-};
+        var desc = {
+          value: "Descriptor",
+          configurable: true,
+        };
+        Object.defineProperty(obj, Symbol.toStringTag, desc);
 
-helpers.awaitAsyncGenerator = function () {
-  return _template().default.program.ast(_templateObject7);
-};
+        if (element.kind === "field") obj.initializer = element.initializer;
 
-helpers.asyncGeneratorDelegate = function () {
-  return _template().default.program.ast(_templateObject8);
-};
+        return obj;
+      },
 
-helpers.asyncToGenerator = function () {
-  return _template().default.program.ast(_templateObject9);
-};
+      // ToElementDescriptors
+      toElementDescriptors: function(
+        elementObjects /*: ElementObject[] */,
+      ) /*: ElementDescriptor[] */ {
+        if (elementObjects === undefined) return;
+        return toArray(elementObjects).map(function(elementObject) {
+          var element = this.toElementDescriptor(elementObject);
+          this.disallowProperty(elementObject, "finisher", "An element descriptor");
+          this.disallowProperty(elementObject, "extras", "An element descriptor");
+          return element;
+        }, this);
+      },
 
-helpers.classCallCheck = function () {
-  return _template().default.program.ast(_templateObject10);
-};
+      // ToElementDescriptor
+      toElementDescriptor: function(
+        elementObject /*: ElementObject */,
+      ) /*: ElementDescriptor */ {
+        var kind = String(elementObject.kind);
+        if (kind !== "method" && kind !== "field") {
+          throw new TypeError(
+            'An element descriptor\\'s .kind property must be either "method" or' +
+              ' "field", but a decorator created an element descriptor with' +
+              ' .kind "' +
+              kind +
+              '"',
+          );
+        }
 
-helpers.createClass = function () {
-  return _template().default.program.ast(_templateObject11);
-};
+        var key = toPropertyKey(elementObject.key);
 
-helpers.defineEnumerableProperties = function () {
-  return _template().default.program.ast(_templateObject12);
-};
+        var placement = String(elementObject.placement);
+        if (
+          placement !== "static" &&
+          placement !== "prototype" &&
+          placement !== "own"
+        ) {
+          throw new TypeError(
+            'An element descriptor\\'s .placement property must be one of "static",' +
+              ' "prototype" or "own", but a decorator created an element descriptor' +
+              ' with .placement "' +
+              placement +
+              '"',
+          );
+        }
 
-helpers.defaults = function () {
-  return _template().default.program.ast(_templateObject13);
-};
+        var descriptor /*: PropertyDescriptor */ = elementObject.descriptor;
 
-helpers.defineProperty = function () {
-  return _template().default.program.ast(_templateObject14);
-};
+        this.disallowProperty(elementObject, "elements", "An element descriptor");
 
-helpers.extends = function () {
-  return _template().default.program.ast(_templateObject15);
-};
+        var element /*: ElementDescriptor */ = {
+          kind: kind,
+          key: key,
+          placement: placement,
+          descriptor: Object.assign({}, descriptor),
+        };
 
-helpers.objectSpread = function () {
-  return _template().default.program.ast(_templateObject16);
-};
+        if (kind !== "field") {
+          this.disallowProperty(elementObject, "initializer", "A method descriptor");
+        } else {
+          this.disallowProperty(
+            descriptor,
+            "get",
+            "The property descriptor of a field descriptor",
+          );
+          this.disallowProperty(
+            descriptor,
+            "set",
+            "The property descriptor of a field descriptor",
+          );
+          this.disallowProperty(
+            descriptor,
+            "value",
+            "The property descriptor of a field descriptor",
+          );
 
-helpers.get = function () {
-  return _template().default.program.ast(_templateObject17);
-};
+          element.initializer = elementObject.initializer;
+        }
 
-helpers.inherits = function () {
-  return _template().default.program.ast(_templateObject18);
-};
+        return element;
+      },
 
-helpers.inheritsLoose = function () {
-  return _template().default.program.ast(_templateObject19);
-};
+      toElementFinisherExtras: function(
+        elementObject /*: ElementObject */,
+      ) /*: ElementFinisherExtras */ {
+        var element /*: ElementDescriptor */ = this.toElementDescriptor(
+          elementObject,
+        );
+        var finisher /*: ClassFinisher */ = _optionalCallableProperty(
+          elementObject,
+          "finisher",
+        );
+        var extras /*: ElementDescriptors[] */ = this.toElementDescriptors(
+          elementObject.extras,
+        );
 
-helpers.wrapNativeSuper = function () {
-  return _template().default.program.ast(_templateObject20);
-};
+        return { element: element, finisher: finisher, extras: extras };
+      },
 
-helpers.instanceof = function () {
-  return _template().default.program.ast(_templateObject21);
-};
+      // FromClassDescriptor
+      fromClassDescriptor: function(
+        elements /*: ElementDescriptor[] */,
+      ) /*: ClassObject */ {
+        var obj = {
+          kind: "class",
+          elements: elements.map(this.fromElementDescriptor, this),
+        };
 
-helpers.interopRequireDefault = function () {
-  return _template().default.program.ast(_templateObject22);
-};
+        var desc = { value: "Descriptor", configurable: true };
+        Object.defineProperty(obj, Symbol.toStringTag, desc);
 
-helpers.interopRequireWildcard = function () {
-  return _template().default.program.ast(_templateObject23);
-};
+        return obj;
+      },
 
-helpers.newArrowCheck = function () {
-  return _template().default.program.ast(_templateObject24);
-};
+      // ToClassDescriptor
+      toClassDescriptor: function(
+        obj /*: ClassObject */,
+      ) /*: ElementsFinisher */ {
+        var kind = String(obj.kind);
+        if (kind !== "class") {
+          throw new TypeError(
+            'A class descriptor\\'s .kind property must be "class", but a decorator' +
+              ' created a class descriptor with .kind "' +
+              kind +
+              '"',
+          );
+        }
 
-helpers.objectDestructuringEmpty = function () {
-  return _template().default.program.ast(_templateObject25);
-};
+        this.disallowProperty(obj, "key", "A class descriptor");
+        this.disallowProperty(obj, "placement", "A class descriptor");
+        this.disallowProperty(obj, "descriptor", "A class descriptor");
+        this.disallowProperty(obj, "initializer", "A class descriptor");
+        this.disallowProperty(obj, "extras", "A class descriptor");
 
-helpers.objectWithoutProperties = function () {
-  return _template().default.program.ast(_templateObject26);
-};
+        var finisher = _optionalCallableProperty(obj, "finisher");
+        var elements = this.toElementDescriptors(obj.elements);
 
-helpers.assertThisInitialized = function () {
-  return _template().default.program.ast(_templateObject27);
-};
+        return { elements: elements, finisher: finisher };
+      },
 
-helpers.possibleConstructorReturn = function () {
-  return _template().default.program.ast(_templateObject28);
-};
+      // RunClassFinishers
+      runClassFinishers: function(
+        constructor /*: Class<*> */,
+        finishers /*: ClassFinisher[] */,
+      ) /*: Class<*> */ {
+        for (var i = 0; i < finishers.length; i++) {
+          var newConstructor /*: ?Class<*> */ = (0, finishers[i])(constructor);
+          if (newConstructor !== undefined) {
+            // NOTE: This should check if IsConstructor(newConstructor) is false.
+            if (typeof newConstructor !== "function") {
+              throw new TypeError("Finishers must return a constructor.");
+            }
+            constructor = newConstructor;
+          }
+        }
+        return constructor;
+      },
 
-helpers.set = function () {
-  return _template().default.program.ast(_templateObject29);
-};
+      disallowProperty: function(obj, name, objectType) {
+        if (obj[name] !== undefined) {
+          throw new TypeError(objectType + " can't have a ." + name + " property.");
+        }
+      }
+    };
 
-helpers.taggedTemplateLiteral = function () {
-  return _template().default.program.ast(_templateObject30);
-};
+    return api;
+  }
 
-helpers.taggedTemplateLiteralLoose = function () {
-  return _template().default.program.ast(_templateObject31);
-};
+  // ClassElementEvaluation
+  function _createElementDescriptor(
+    def /*: ElementDefinition */,
+  ) /*: ElementDescriptor */ {
+    var key = toPropertyKey(def.key);
 
-helpers.temporalRef = function () {
-  return _template().default.program.ast(_templateObject32);
-};
+    var descriptor /*: PropertyDescriptor */;
+    if (def.kind === "method") {
+      descriptor = {
+        value: def.value,
+        writable: true,
+        configurable: true,
+        enumerable: false,
+      };
+    } else if (def.kind === "get") {
+      descriptor = { get: def.value, configurable: true, enumerable: false };
+    } else if (def.kind === "set") {
+      descriptor = { set: def.value, configurable: true, enumerable: false };
+    } else if (def.kind === "field") {
+      descriptor = { configurable: true, writable: true, enumerable: true };
+    }
 
-helpers.readOnlyError = function () {
-  return _template().default.program.ast(_templateObject33);
-};
+    var element /*: ElementDescriptor */ = {
+      kind: def.kind === "field" ? "field" : "method",
+      key: key,
+      placement: def.static
+        ? "static"
+        : def.kind === "field"
+        ? "own"
+        : "prototype",
+      descriptor: descriptor,
+    };
+    if (def.decorators) element.decorators = def.decorators;
+    if (def.kind === "field") element.initializer = def.value;
 
-helpers.classNameTDZError = function () {
-  return _template().default.program.ast(_templateObject34);
-};
+    return element;
+  }
 
-helpers.temporalUndefined = function () {
-  return _template().default.program.ast(_templateObject35);
-};
+  // CoalesceGetterSetter
+  function _coalesceGetterSetter(
+    element /*: ElementDescriptor */,
+    other /*: ElementDescriptor */,
+  ) {
+    if (element.descriptor.get !== undefined) {
+      other.descriptor.get = element.descriptor.get;
+    } else {
+      other.descriptor.set = element.descriptor.set;
+    }
+  }
 
-helpers.slicedToArray = function () {
-  return _template().default.program.ast(_templateObject36);
-};
+  // CoalesceClassElements
+  function _coalesceClassElements(
+    elements /*: ElementDescriptor[] */,
+  ) /*: ElementDescriptor[] */ {
+    var newElements /*: ElementDescriptor[] */ = [];
 
-helpers.slicedToArrayLoose = function () {
-  return _template().default.program.ast(_templateObject37);
-};
+    var isSameElement = function(
+      other /*: ElementDescriptor */,
+    ) /*: boolean */ {
+      return (
+        other.kind === "method" &&
+        other.key === element.key &&
+        other.placement === element.placement
+      );
+    };
 
-helpers.toArray = function () {
-  return _template().default.program.ast(_templateObject38);
-};
+    for (var i = 0; i < elements.length; i++) {
+      var element /*: ElementDescriptor */ = elements[i];
+      var other /*: ElementDescriptor */;
 
-helpers.toConsumableArray = function () {
-  return _template().default.program.ast(_templateObject39);
-};
+      if (
+        element.kind === "method" &&
+        (other = newElements.find(isSameElement))
+      ) {
+        if (
+          _isDataDescriptor(element.descriptor) ||
+          _isDataDescriptor(other.descriptor)
+        ) {
+          if (_hasDecorators(element) || _hasDecorators(other)) {
+            throw new ReferenceError(
+              "Duplicated methods (" + element.key + ") can't be decorated.",
+            );
+          }
+          other.descriptor = element.descriptor;
+        } else {
+          if (_hasDecorators(element)) {
+            if (_hasDecorators(other)) {
+              throw new ReferenceError(
+                "Decorators can't be placed on different accessors with for " +
+                  "the same property (" +
+                  element.key +
+                  ").",
+              );
+            }
+            other.decorators = element.decorators;
+          }
+          _coalesceGetterSetter(element, other);
+        }
+      } else {
+        newElements.push(element);
+      }
+    }
 
-helpers.arrayWithoutHoles = function () {
-  return _template().default.program.ast(_templateObject40);
-};
+    return newElements;
+  }
 
-helpers.arrayWithHoles = function () {
-  return _template().default.program.ast(_templateObject41);
-};
+  function _hasDecorators(element /*: ElementDescriptor */) /*: boolean */ {
+    return element.decorators && element.decorators.length;
+  }
 
-helpers.iterableToArray = function () {
-  return _template().default.program.ast(_templateObject42);
-};
+  function _isDataDescriptor(desc /*: PropertyDescriptor */) /*: boolean */ {
+    return (
+      desc !== undefined &&
+      !(desc.value === undefined && desc.writable === undefined)
+    );
+  }
 
-helpers.iterableToArrayLimit = function () {
-  return _template().default.program.ast(_templateObject43);
-};
+  function _optionalCallableProperty /*::<T>*/(
+    obj /*: T */,
+    name /*: $Keys<T> */,
+  ) /*: ?Function */ {
+    var value = obj[name];
+    if (value !== undefined && typeof value !== "function") {
+      throw new TypeError("Expected '" + name + "' to be a function");
+    }
+    return value;
+  }
 
-helpers.iterableToArrayLimitLoose = function () {
-  return _template().default.program.ast(_templateObject44);
-};
+`;
+helpers.classPrivateMethodGet = helper("7.1.6")`
+  export default function _classPrivateMethodGet(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+      throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+  }
+`;
+helpers.classPrivateMethodSet = helper("7.1.6")`
+  export default function _classPrivateMethodSet() {
+    throw new TypeError("attempted to reassign private method");
+  }
+`;
+helpers.wrapRegExp = helper("7.2.6")`
+  import wrapNativeSuper from "wrapNativeSuper";
+  import getPrototypeOf from "getPrototypeOf";
+  import possibleConstructorReturn from "possibleConstructorReturn";
+  import inherits from "inherits";
 
-helpers.nonIterableSpread = function () {
-  return _template().default.program.ast(_templateObject45);
-};
+  export default function _wrapRegExp(re, groups) {
+    _wrapRegExp = function(re, groups) {
+      return new BabelRegExp(re, groups);
+    };
 
-helpers.nonIterableRest = function () {
-  return _template().default.program.ast(_templateObject46);
-};
+    var _RegExp = wrapNativeSuper(RegExp);
+    var _super = RegExp.prototype;
+    var _groups = new WeakMap();
 
-helpers.skipFirstGeneratorNext = function () {
-  return _template().default.program.ast(_templateObject47);
-};
+    function BabelRegExp(re, groups) {
+      var _this = _RegExp.call(this, re);
+      _groups.set(_this, groups);
+      return _this;
+    }
+    inherits(BabelRegExp, _RegExp);
 
-helpers.toPropertyKey = function () {
-  return _template().default.program.ast(_templateObject48);
-};
+    BabelRegExp.prototype.exec = function(str) {
+      var result = _super.exec.call(this, str);
+      if (result) result.groups = buildGroups(result, this);
+      return result;
+    };
+    BabelRegExp.prototype[Symbol.replace] = function(str, substitution) {
+      if (typeof substitution === "string") {
+        var groups = _groups.get(this);
+        return _super[Symbol.replace].call(
+          this,
+          str,
+          substitution.replace(/\\$<([^>]+)>/g, function(_, name) {
+            return "$" + groups[name];
+          })
+        );
+      } else if (typeof substitution === "function") {
+        var _this = this;
+        return _super[Symbol.replace].call(
+          this,
+          str,
+          function() {
+            var args = [];
+            args.push.apply(args, arguments);
+            if (typeof args[args.length - 1] !== "object") {
+              // Modern engines already pass result.groups as the last arg.
+              args.push(buildGroups(args, _this));
+            }
+            return substitution.apply(this, args);
+          }
+        );
+      } else {
+        return _super[Symbol.replace].call(this, str, substitution);
+      }
+    }
 
-helpers.initializerWarningHelper = function () {
-  return _template().default.program.ast(_templateObject49);
-};
+    function buildGroups(result, re) {
+      // NOTE: This function should return undefined if there are no groups,
+      // but in that case Babel doesn't add the wrapper anyway.
 
-helpers.initializerDefineProperty = function () {
-  return _template().default.program.ast(_templateObject50);
-};
+      var g = _groups.get(re);
+      return Object.keys(g).reduce(function(groups, name) {
+        groups[name] = result[g[name]];
+        return groups;
+      }, Object.create(null));
+    }
 
-helpers.applyDecoratedDescriptor = function () {
-  return _template().default.program.ast(_templateObject51);
-};
+    return _wrapRegExp.apply(this, arguments);
+  }
+`;