text: import regeneratorRuntime from "regenerator-runtime";
  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
      try {
          var info = gen[key](arg), value = info.value;
      } catch (error) {
          reject(error);
          return;
      }
      info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
  }
  function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
  }
  function _construct(Parent, args, Class) {
      return (_construct = !function() {
          if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
          if (Reflect.construct.sham) return !1;
          if ("function" == typeof Proxy) return !0;
          try {
              return Date.prototype.toString.call(Reflect.construct(Date, [], function() {
              })), !0;
          } catch (e) {
              return !1;
          }
      }() ? function _construct(Parent, args, Class) {
          var a = [
              null
          ];
          a.push.apply(a, args);
          var Constructor = Function.bind.apply(Parent, a), instance = new Constructor();
          return Class && _setPrototypeOf(instance, Class.prototype), instance;
      } : Reflect.construct).apply(null, arguments);
  }
  function _defineProperties(target, props) {
      for(var i = 0; i < props.length; i++){
          var descriptor = props[i];
          descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
      }
  }
  function _getPrototypeOf(o) {
      return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
          return o.__proto__ || Object.getPrototypeOf(o);
      }, _getPrototypeOf(o);
  }
  function _setPrototypeOf(o, p) {
      return _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
          return o.__proto__ = p, o;
      }, _setPrototypeOf(o, p);
  }
  function _wrapNativeSuper(Class) {
      var _cache = "function" == typeof Map ? new Map() : void 0;
      return _wrapNativeSuper = function _wrapNativeSuper(Class) {
          var fn;
          if (null === Class || (fn = Class, -1 === Function.toString.call(fn).indexOf("[native code]"))) return Class;
          if ("function" != typeof Class) throw new TypeError("Super expression must either be null or a function");
          if (void 0 !== _cache) {
              if (_cache.has(Class)) return _cache.get(Class);
              _cache.set(Class, Wrapper);
          }
          function Wrapper() {
              return _construct(Class, arguments, _getPrototypeOf(this).constructor);
          }
          return Wrapper.prototype = Object.create(Class.prototype, {
              constructor: {
                  value: Wrapper,
                  enumerable: !1,
                  writable: !0,
                  configurable: !0
              }
          }), _setPrototypeOf(Wrapper, Class);
      }, _wrapNativeSuper(Class);
  }
  export var _typeof, Task = function(Promise) {
      "use strict";
      !function(subClass, superClass) {
          if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
          subClass.prototype = Object.create(superClass && superClass.prototype, {
              constructor: {
                  value: subClass,
                  writable: !0,
                  configurable: !0
              }
          }), superClass && _setPrototypeOf(subClass, superClass);
      }(Task, Promise);
      var _super = function(Derived) {
          var hasNativeReflectConstruct = function() {
              if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
              if (Reflect.construct.sham) return !1;
              if ("function" == typeof Proxy) return !0;
              try {
                  return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
                  })), !0;
              } catch (e) {
                  return !1;
              }
          }();
          return function() {
              var obj, self, call, result, Super = _getPrototypeOf(Derived);
              if (hasNativeReflectConstruct) {
                  var NewTarget = _getPrototypeOf(this).constructor;
                  result = Reflect.construct(Super, arguments, NewTarget);
              } else result = Super.apply(this, arguments);
              return self = this, (call = result) && ("object" == ((obj = call) && "undefined" != typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj) || "function" == typeof call) ? call : (function(self) {
                  if (void 0 === self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
                  return self;
              })(self);
          };
      }(Task);
      function Task() {
          return _classCallCheck(this, Task), _super.apply(this, arguments);
      }
      return Task;
  }(_wrapNativeSuper(Promise));
  var Test = function() {
      "use strict";
      var Constructor, protoProps, staticProps;
      function Test() {
          _classCallCheck(this, Test);
      }
      return Constructor = Test, protoProps = [
          {
              key: "example",
              value: function() {
                  return (function(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(void 0);
                          });
                      };
                  })(regeneratorRuntime.mark(function _callee() {
                      return regeneratorRuntime.wrap(function(_ctx) {
                          for(;;)switch(_ctx.prev = _ctx.next){
                              case 0:
                                  return _ctx.abrupt("return");
                              case 1:
                              case "end":
                                  return _ctx.stop();
                          }
                      }, _callee);
                  }))();
              }
          }
      ], _defineProperties(Constructor.prototype, protoProps), staticProps && _defineProperties(Constructor, staticProps), Test;
  }();
  