text: import regeneratorRuntime from "regenerator-runtime";
  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);
      }
  }
  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);
          });
      };
  }
  function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
      }
  }
  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);
      }
  }
  function _createClass(Constructor, protoProps, staticProps) {
      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
      if (staticProps) _defineProperties(Constructor, staticProps);
      return Constructor;
  }
  var C = // @target: ES5
  // @lib: es5,es2015.promise
  // @noEmitHelpers: true
  /*#__PURE__*/ function() {
      "use strict";
      function C() {
          _classCallCheck(this, C);
      }
      _createClass(C, [
          {
              key: "method",
              value: function method() {
                  var other = function other() {
                  };
                  function fn() {
                      return _fn.apply(this, arguments);
                  }
                  function _fn() {
                      _fn = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
                          var _args = arguments;
                          return regeneratorRuntime.wrap(function _callee$(_ctx) {
                              while(1)switch(_ctx.prev = _ctx.next){
                                  case 0:
                                      _ctx.next = 2;
                                      return other.apply(this, _args);
                                  case 2:
                                  case "end":
                                      return _ctx.stop();
                              }
                          }, _callee, this);
                      }).bind(this));
                      return _fn.apply(this, arguments);
                  }
              }
          }
      ]);
      return C;
  }();
  