@pomle/spotify-web-sdk/dist/index.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

require("core-js/shim");

require("regenerator-runtime/runtime");

require("core-js/fn/regexp/escape");

if (global._babelPolyfill) {
  throw new Error("only one instance of babel-polyfill is allowed");
}
global._babelPolyfill = true;

var DEFINE_PROPERTY = "defineProperty";
function define(O, key, value) {
  O[key] || Object[DEFINE_PROPERTY](O, key, {
    writable: true,
    configurable: true,
    value: value
  });
}

define(String.prototype, "padLeft", "".padStart);
define(String.prototype, "padRight", "".padEnd);

"pop,reverse,shift,keys,values,entries,indexOf,every,some,forEach,map,filter,find,findIndex,includes,join,slice,concat,push,splice,unshift,sort,lastIndexOf,reduce,reduceRight,copyWithin,fill".split(",").forEach(function (key) {
  [][key] && define(Array, key, Function.call.bind([][key]));
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
  return typeof obj;
} : function (obj) {
  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};









var asyncToGenerator = function (fn) {
  return function () {
    var gen = fn.apply(this, arguments);
    return new Promise(function (resolve, reject) {
      function step(key, arg) {
        try {
          var info = gen[key](arg);
          var value = info.value;
        } catch (error) {
          reject(error);
          return;
        }

        if (info.done) {
          resolve(value);
        } else {
          return Promise.resolve(value).then(function (value) {
            step("next", value);
          }, function (err) {
            step("throw", err);
          });
        }
      }

      return step("next");
    });
  };
};

var classCallCheck = function (instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
};

var createClass = 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);
    }
  }

  return function (Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();





var defineProperty = function (obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
};



var inherits = function (subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
};











var possibleConstructorReturn = function (self, call) {
  if (!self) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return call && (typeof call === "object" || typeof call === "function") ? call : self;
};





var slicedToArray = function () {
  function sliceIterator(arr, i) {
    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"]) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  return function (arr, i) {
    if (Array.isArray(arr)) {
      return arr;
    } else if (Symbol.iterator in Object(arr)) {
      return sliceIterator(arr, i);
    } else {
      throw new TypeError("Invalid attempt to destructure non-iterable instance");
    }
  };
}();

/* Spotify JS-SDK - v1.2.0-6dd1382 */
!function (e) {
  function t(s) {
    if (n[s]) return n[s].exports;var r = n[s] = { i: s, l: !1, exports: {} };return e[s].call(r.exports, r, r.exports, t), r.l = !0, r.exports;
  }var n = {};t.m = e, t.c = n, t.d = function (e, n, s) {
    t.o(e, n) || Object.defineProperty(e, n, { configurable: !1, enumerable: !0, get: s });
  }, t.n = function (e) {
    var n = e && e.__esModule ? function () {
      return e.default;
    } : function () {
      return e;
    };return t.d(n, "a", n), n;
  }, t.o = function (e, t) {
    return Object.prototype.hasOwnProperty.call(e, t);
  }, t.p = "", t(t.s = 2);
}([function (e, t, n) {
  var s = { SPOTIFY_MESSAGE: "SP_MESSAGE", ACCOUNT_ERROR: "ACCOUNT_ERROR", AUTH_ERROR: "AUTH_ERROR", CONNECT: "CONNECT", CONNECTED: "CONNECTED", CURRENT_STATE: "CURRENT_STATE", DISCONNECT: "DISCONNECT", EVENT: "EVENT", GET_CURRENT_STATE: "GET_CURRENT_STATE", GET_TOKEN: "GET_TOKEN", GET_VOLUME: "GET_VOLUME", INIT: "INIT", LOADED: "LOADED", NEXT_TRACK: "NEXT_TRACK", PAUSE: "PAUSE", PLAYBACK_ERROR: "PLAYBACK_ERROR", PLAYER_INIT_ERROR: "PLAYER_INIT_ERROR", PLAYER_READY: "PLAYER_READY", PLAYER_STATE_CHANGED: "PLAYER_STATE_CHANGED", PREV_TRACK: "PREV_TRACK", RESUME: "RESUME", SEEK: "SEEK", SET_VOLUME: "SET_VOLUME", TOGGLE_PLAY: "TOGGLE_PLAY", TOKEN: "TOKEN", VOLUME: "VOLUME", accountError: function accountError(e) {
      return this._createEventMessage(s.ACCOUNT_ERROR, { message: e });
    }, authError: function authError(e) {
      return this._createEventMessage(s.AUTH_ERROR, e);
    }, playbackError: function playbackError(e) {
      return this._createEventMessage(s.PLAYBACK_ERROR, e);
    }, playerReady: function playerReady(e) {
      return this._createEventMessage(s.PLAYER_READY, e);
    }, connect: function connect() {
      return this._createMessage(s.CONNECT);
    }, connected: function connected(e, t) {
      return this._createMessage(s.CONNECTED, { connected: e, ref: t });
    }, disconnect: function disconnect() {
      return this._createMessage(s.DISCONNECT);
    }, init: function init(e) {
      return this._createMessage(s.INIT, e);
    }, playerInitError: function playerInitError(e) {
      return this._createEventMessage(s.PLAYER_INIT_ERROR, e);
    }, getToken: function getToken() {
      return this._createMessage(s.GET_TOKEN);
    }, token: function token(e, t) {
      return this._createMessage(s.TOKEN, { token: e, ref: t });
    }, pause: function pause() {
      return this._createMessage(s.PAUSE);
    }, resume: function resume() {
      return this._createMessage(s.RESUME);
    }, togglePlay: function togglePlay() {
      return this._createMessage(s.TOGGLE_PLAY);
    }, seek: function seek(e) {
      return this._createMessage(s.SEEK, e);
    }, nextTrack: function nextTrack(e) {
      return this._createMessage(s.NEXT_TRACK, e);
    }, previousTrack: function previousTrack(e) {
      return this._createMessage(s.PREV_TRACK, e);
    }, getCurrentState: function getCurrentState() {
      return this._createMessage(s.GET_CURRENT_STATE);
    }, currentState: function currentState(e, t) {
      return this._createMessage(s.CURRENT_STATE, { state: e, ref: t });
    }, playerStateChanged: function playerStateChanged(e) {
      return this._createEventMessage(s.PLAYER_STATE_CHANGED, e);
    }, getVolume: function getVolume() {
      return this._createMessage(s.GET_VOLUME);
    }, volume: function volume(e, t) {
      return this._createMessage(s.VOLUME, { volume: e, ref: t });
    }, setVolume: function setVolume(e) {
      return this._createMessage(s.SET_VOLUME, e);
    }, embeddedLoaded: function embeddedLoaded() {
      return this._createMessage(s.LOADED);
    }, _createEventMessage: function _createEventMessage(e, t) {
      return this._createMessage(s.EVENT, { name: e, eventData: t });
    }, _createMessage: function _createMessage(e, t) {
      return { type: s.SPOTIFY_MESSAGE, body: { topic: e, data: t ? JSON.parse(JSON.stringify(t)) : null } };
    } };e.exports = s;
}, function (e, t) {
  var n;n = function () {
    return this;
  }();try {
    n = n || Function("return this")() || (eval)("this");
  } catch (e) {
    "object" == (typeof window === "undefined" ? "undefined" : _typeof(window)) && (n = window);
  }e.exports = n;
}, function (e, t, n) {
  function s() {
    var e = n(3);if (!document.body) throw new Error("Document doesn't have a body");if (window.Spotify = { Player: e.setupPlayerEnv(window) }, window.onSpotifyWebPlaybackSDKReady) window.onSpotifyWebPlaybackSDKReady();else {
      if (!window.onSpotifyPlayerAPIReady) throw new Error("onSpotifyWebPlaybackSDKReady is not defined");window.onSpotifyPlayerAPIReady();
    }
  }"complete" === document.readyState ? s() : window.addEventListener("load", s);
}, function (e, t, n) {
  var s = n(4),
      r = n(5),
      o = n(0),
      i = n(6),
      a = function a(e, t) {
    var n,
        a = "https://sdk.scdn.co/embedded/index.html",
        u = r.defer(),
        c = new s(),
        _ = t || function (t) {
      var n = e.document.createElement("iframe");return n.src = t, n.style.setProperty("display", "none", "important"), n.allow = "encrypted-media", e.document.body.appendChild(n), n.contentWindow;
    },
        h = function h(t) {
      t === o.LOADED && (c.stopListening(e, h), u.resolve());
    };c.listen(e, h), n = _(a);var d = function d(t) {
      this._options = this._sanitizeOptions(t), this._handleMessages = this._handleMessages.bind(this), this._messageHandlers = {}, this._eventListeners = {}, this._setupMessageHandlers(), this._connectionRequests = {}, this._getCurrentStateRequests = {}, this._getVolumeRequests = {}, this.isLoaded = u.promise.then(function () {
        c.listen(e, this._handleMessages), this._sendMessage(o.init(this._options));
      }.bind(this));
    };return d.prototype._sanitizeOptions = function (t) {
      var n = e && e.location && e.location.hostname || "";return { name: t.name || n, id: i.get(), getOAuthToken: t.getOAuthToken || t.getOauthToken, volume: t.volume || 1 };
    }, d.prototype._setupMessageHandlers = function () {
      this._messageHandlers[o.GET_TOKEN] = this._onGetToken.bind(this), this._messageHandlers[o.EVENT] = this._onEvent.bind(this), this._messageHandlers[o.CONNECTED] = this._onConnected.bind(this), this._messageHandlers[o.CURRENT_STATE] = this._onCurrentState.bind(this), this._messageHandlers[o.VOLUME] = this._onVolume.bind(this);
    }, d.prototype.connect = function () {
      return this.isLoaded.then(function () {
        var e = this._sendMessage(o.connect());return this._connectionRequests[e] = r.defer(), this._connectionRequests[e].promise;
      }.bind(this));
    }, d.prototype.on = function (e, t) {
      this._eventListeners[e] = this._eventListeners[e] || [], this._eventListeners[e].push(t);
    }, d.prototype.getCurrentState = function () {
      return this.isLoaded.then(function () {
        var e = this._sendMessage(o.getCurrentState());return this._getCurrentStateRequests[e] = r.defer(), this._getCurrentStateRequests[e].promise;
      }.bind(this));
    }, d.prototype.getVolume = function () {
      return this.isLoaded.then(function () {
        var e = this._sendMessage(o.getVolume());return this._getVolumeRequests[e] = r.defer(), this._getVolumeRequests[e].promise;
      }.bind(this));
    }, d.prototype.setVolume = function (e) {
      return this._sendMessageWhenLoaded(o.setVolume(e));
    }, d.prototype.pause = function () {
      return this._sendMessageWhenLoaded(o.pause());
    }, d.prototype.resume = function () {
      return this._sendMessageWhenLoaded(o.resume());
    }, d.prototype.togglePlay = function () {
      return this._sendMessageWhenLoaded(o.togglePlay());
    }, d.prototype.seek = function (e) {
      return this._sendMessageWhenLoaded(o.seek(e));
    }, d.prototype.previousTrack = function (e) {
      return this._sendMessageWhenLoaded(o.previousTrack(e));
    }, d.prototype.nextTrack = function (e) {
      return this._sendMessageWhenLoaded(o.nextTrack(e));
    }, d.prototype.disconnect = function () {
      return this._sendMessageWhenLoaded(o.disconnect());
    }, d.prototype._getListeners = function () {
      var e = {};return e[o.ACCOUNT_ERROR] = "account_error", e[o.AUTH_ERROR] = "authentication_error", e[o.PLAYBACK_ERROR] = "playback_error", e[o.PLAYER_INIT_ERROR] = "initialization_error", e[o.PLAYER_READY] = "ready", e[o.PLAYER_STATE_CHANGED] = "player_state_changed", function (t) {
        return this._eventListeners[e[t]] || [];
      };
    }(), d.prototype._onEvent = function (e) {
      this._getListeners(e.name).forEach(function (t) {
        t(e.eventData);
      });
    }, d.prototype._onGetToken = function (e, t) {
      var n = this._options.getOAuthToken;if ("function" != typeof n) {
        var s = "getOAuthToken is not a function";if (this._getListeners(o.PLAYER_INIT_ERROR).length) return void this._onEvent({ name: o.PLAYER_INIT_ERROR, eventData: { message: s } });throw new Error(s);
      }new r(n).then(function (e) {
        this._sendMessage(o.token(e, t));
      }.bind(this));
    }, d.prototype._onConnected = function (e) {
      e.ref in this._connectionRequests && (this._connectionRequests[e.ref].resolve(e.connected), delete this._connectionRequests[e.ref]);
    }, d.prototype._onCurrentState = function (e) {
      e.ref in this._getCurrentStateRequests && (this._getCurrentStateRequests[e.ref].resolve(e.state), delete this._getCurrentStateRequests[e.ref]);
    }, d.prototype._onVolume = function (e) {
      e.ref in this._getVolumeRequests && (this._getVolumeRequests[e.ref].resolve(e.volume), delete this._getVolumeRequests[e.ref]);
    }, d.prototype._handleMessages = function (e, t, n) {
      e in this._messageHandlers && this._messageHandlers[e](t, n);
    }, d.prototype._sendMessage = function (e) {
      return c.send(n, e, a);
    }, d.prototype._sendMessageWhenLoaded = function (e) {
      return this.isLoaded.then(this._sendMessage.bind(this, e));
    }, d;
  };e.exports.setupPlayerEnv = a;
}, function (e, t, n) {
  var s = n(0),
      r = function r() {
    this._onMessageCallback = function () {}, this._receiveMessage = this._receiveMessage.bind(this), this._messageId = 0;
  };r.prototype.listen = function (e, t) {
    this._onMessageCallback = t, e.addEventListener("message", this._receiveMessage);
  }, r.prototype.stopListening = function (e) {
    e.removeEventListener("message", this._receiveMessage);
  }, r.prototype.send = function (e, t, n) {
    return e.postMessage(this._addMessageId(t), n || "*"), t.seq;
  }, r.prototype._addMessageId = function (e) {
    return e.seq = this._messageId++, e;
  }, r.prototype._receiveMessage = function (e) {
    var t = e.data;t.type === s.SPOTIFY_MESSAGE && t.body && t.body.topic && this._onMessageCallback(t.body.topic, t.body.data, t.seq);
  }, e.exports = r;
}, function (e, t, n) {
  (function (t) {
    var n = t.Promise;if (!n) throw new Error("Fatal: no Promise implementation available.");var s;s = Object.defineProperty ? function (e, t, n) {
      return e[t] ? e : (Object.defineProperty(e, t, { value: n, configurable: !0, writable: !0 }), e);
    } : function (e, t, n) {
      return e[t] ? e : (e[t] = n, e);
    }, s(n, "defer", function () {
      var e = {};return e.promise = new n(function (t, n) {
        e.resolve = t, e.reject = n;
      }), e;
    }), s(n.prototype, "spread", function (e, t) {
      return this.then(function (e) {
        return n.all(e);
      }).then(function (t) {
        return 1 === t.length ? e(t[0]) : e.apply(this, t);
      }, t);
    }), e.exports = n;
  }).call(t, n(1));
}, function (e, t, n) {
  (function (t) {
    function s() {
      var e = new t.Uint8Array(16);return t.crypto.getRandomValues(e), i.toHex(e.join(""), 40).slice(0, 40);
    }function r() {
      for (var e = new Array(27), t = e.length; t--;) {
        e[t] = Math.floor(8 * Math.random());
      }return i.toHex(e.join(""), 40);
    }function o(e, n) {
      if (e && "string" == typeof e) return e;if (n) return u();var s = t.localStorage.getItem(c);return s || (s = u(), t.localStorage.setItem(c, s)), s;
    }var i = n(7),
        a = "function" == typeof t.Uint8Array && void 0 !== t.crypto && "function" == typeof t.crypto.getRandomValues,
        u = a ? s : r,
        c = "_spharmony_device_id";e.exports = { get: o, generate: u, generateWithCrypto: s, generateWithRandom: r };
  }).call(t, n(1));
}, function (e, t, n) {
  function s(e, t, n) {
    for (var s = 0, r = 0; r < e.length; ++r) {
      var o = e[r] * t + s;e[r] = o % n, s = ~~(o / n);
    }for (; s;) {
      e.push(s % n), s = ~~(s / n);
    }
  }function r(e, t, n, s) {
    var r,
        o,
        i = 0;for (o = 0; o < t.length; ++o) {
      r = ~~e[o] + t[o] * n + i, e[o] = r % s, i = ~~(r / s);
    }for (; i;) {
      r = ~~e[o] + i, e[o] = r % s, i = ~~(r / s), ++o;
    }
  }function o(e, t, n) {
    for (var o = [0], i = [1], a = 0; a < e.length; ++a) {
      r(o, i, e[a], n), s(i, t, n);
    }return o;
  }function i(e, t) {
    for (var n = [], s = 0; s < e.length; ++s) {
      n.push(t[e[s]]);
    }return n.reverse();
  }function a(e, t) {
    for (; e.length < t;) {
      e.push(0);
    }return e;
  }var u = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
      c = {},
      _ = {};!function () {
    var e, t;for (e = 0, t = u.length; e < t; ++e) {
      _[u[e]] = e;
    }for (e = 0; e < 16; ++e) {
      c["0123456789abcdef"[e]] = e;
    }for (e = 0; e < 16; ++e) {
      c["0123456789ABCDEF"[e]] = e;
    }
  }(), e.exports = { fromBytes: function fromBytes(e, t) {
      return i(a(o(e.slice(0).reverse(), 256, 62), t), u).join("");
    }, toBytes: function toBytes(e, t) {
      return a(o(i(e, _), 62, 256), t).reverse();
    }, toHex: function toHex(e, t) {
      return i(a(o(i(e, _), 62, 16), t), u).join("");
    }, fromHex: function fromHex(e, t) {
      return i(a(o(i(e, c), 16, 62), t), u).join("");
    } };
}]);

var CoreAPI = function () {
  function CoreAPI(token) {
    classCallCheck(this, CoreAPI);

    this.base = 'https://api.spotify.com/';
    this.token = token;
  }

  createClass(CoreAPI, [{
    key: 'consume',
    value: function () {
      var _ref = asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(request, callback) {
        var result;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return request;

              case 2:
                result = _context.sent;

                request = null;

                if (result.items) {
                  callback(result.items);
                }

                if (result.next) {
                  request = this.request(result.next);
                }

              case 6:
                if (request) {
                  _context.next = 0;
                  break;
                }

              case 7:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function consume(_x, _x2) {
        return _ref.apply(this, arguments);
      }

      return consume;
    }()
  }, {
    key: 'request',
    value: function request(url) {
      var body = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
      var method = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'GET';

      var headers = new Headers({
        'Content-Type': 'application/json'
      });

      if (this.token) {
        headers.append('Authorization', 'Bearer ' + this.token);
      }

      var req = new Request(url, {
        method: method,
        headers: headers,
        body: body ? JSON.stringify(body) : null
      });

      return fetch(req).then(function (response) {
        var contentType = response.headers.get('content-type');

        if (contentType && contentType.startsWith('application/json')) {
          return response.json();
        }

        return response.text();
      });
    }
  }, {
    key: 'url',
    value: function url(path) {
      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

      var url = this.base;

      url += path;

      if (params) {
        url += '?' + params.map(function (pair) {
          return pair.map(encodeURIComponent).join('=');
        }).join('&');
      }

      return url;
    }
  }]);
  return CoreAPI;
}();

var AlbumAPI = function (_CoreAPI) {
  inherits(AlbumAPI, _CoreAPI);

  function AlbumAPI() {
    classCallCheck(this, AlbumAPI);
    return possibleConstructorReturn(this, (AlbumAPI.__proto__ || Object.getPrototypeOf(AlbumAPI)).apply(this, arguments));
  }

  createClass(AlbumAPI, [{
    key: 'getAlbum',
    value: function getAlbum(albumId) {
      return this.request(this.url('v1/albums/' + albumId));
    }
  }]);
  return AlbumAPI;
}(CoreAPI);

var PlaylistAPI = function (_CoreAPI) {
  inherits(PlaylistAPI, _CoreAPI);

  function PlaylistAPI() {
    classCallCheck(this, PlaylistAPI);
    return possibleConstructorReturn(this, (PlaylistAPI.__proto__ || Object.getPrototypeOf(PlaylistAPI)).apply(this, arguments));
  }

  createClass(PlaylistAPI, [{
    key: 'getPlaylists',
    value: function getPlaylists() {
      return this.request(this.url('v1/me/playlists'));
    }
  }, {
    key: 'getPlaylist',
    value: function getPlaylist(userId, playlistId) {
      return this.request(this.url('v1/users/' + userId + '/playlists/' + playlistId));
    }
  }, {
    key: 'getPlaylistTracks',
    value: function getPlaylistTracks(userId, playlistId) {
      return this.request(this.url('v1/users/' + userId + '/playlists/' + playlistId + '/tracks'));
    }
  }]);
  return PlaylistAPI;
}(CoreAPI);

var PlaybackAPI = function (_CoreAPI) {
  inherits(PlaybackAPI, _CoreAPI);

  function PlaybackAPI() {
    classCallCheck(this, PlaybackAPI);
    return possibleConstructorReturn(this, (PlaybackAPI.__proto__ || Object.getPrototypeOf(PlaybackAPI)).apply(this, arguments));
  }

  createClass(PlaybackAPI, [{
    key: 'setDevice',
    value: function setDevice(deviceId) {
      this.deviceId = deviceId;
    }
  }, {
    key: 'urlWithDevice',
    value: function urlWithDevice(path, device_id) {
      if (!device_id) {
        throw new TypeError('Device id argument missing');
      }

      return this.url(path + '?device_id=' + device_id);
    }
  }, {
    key: 'playAlbum',
    value: function playAlbum(albumURI, trackURI) {
      return this.request(this.urlWithDevice('v1/me/player/play', this.deviceId), {
        context_uri: albumURI,
        offset: defineProperty({}, trackURI ? 'uri' : 'position', trackURI || 1)
      }, 'PUT');
    }
  }, {
    key: 'playContext',
    value: function playContext(contextURI) {
      return this.request(this.urlWithDevice('v1/me/player/play', this.deviceId), {
        context_uri: contextURI
      }, 'PUT');
    }
  }, {
    key: 'playTracks',
    value: function playTracks(trackURIs, trackURI) {
      return this.request(this.urlWithDevice('v1/me/player/play', this.deviceId), {
        uris: trackURIs,
        offset: {
          uri: trackURI
        }
      }, 'PUT');
    }
  }, {
    key: 'resume',
    value: function resume() {
      return this.request(this.url('v1/me/player/play'), null, 'PUT');
    }
  }, {
    key: 'pause',
    value: function pause() {
      return this.request(this.url('v1/me/player/pause'), null, 'PUT');
    }
  }, {
    key: 'next',
    value: function next() {
      return this.request(this.url('v1/me/player/next'), null, 'POST');
    }
  }, {
    key: 'prev',
    value: function prev() {
      return this.request(this.url('v1/me/player/previous'), null, 'POST');
    }
  }, {
    key: 'seek',
    value: function seek(ms) {
      return this.request(this.url('v1/me/player/seek', [['position_ms', ms]]), null, 'PUT');
    }
  }]);
  return PlaybackAPI;
}(CoreAPI);

var SearchAPI = function (_CoreAPI) {
  inherits(SearchAPI, _CoreAPI);

  function SearchAPI() {
    classCallCheck(this, SearchAPI);
    return possibleConstructorReturn(this, (SearchAPI.__proto__ || Object.getPrototypeOf(SearchAPI)).apply(this, arguments));
  }

  createClass(SearchAPI, [{
    key: 'search',
    value: function search(type, query) {
      var limit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 50;

      var params = [['type', type], ['limit', limit], ['q', query]];
      return this.request(this.url('v1/search', params));
    }
  }]);
  return SearchAPI;
}(CoreAPI);

var TrackAPI = function (_CoreAPI) {
  inherits(TrackAPI, _CoreAPI);

  function TrackAPI() {
    classCallCheck(this, TrackAPI);
    return possibleConstructorReturn(this, (TrackAPI.__proto__ || Object.getPrototypeOf(TrackAPI)).apply(this, arguments));
  }

  createClass(TrackAPI, [{
    key: 'getAudioAnalysis',
    value: function getAudioAnalysis(trackId) {
      return this.request(this.url('v1/audio-analysis/' + trackId));
    }
  }]);
  return TrackAPI;
}(CoreAPI);

var playerPromise = new Promise(function (resolve) {
  window.onSpotifyWebPlaybackSDKReady = function () {
    console.log('onSpotifyWebPlaybackSDKReady');
    resolve(window.Spotify);
  };
});

var getSpotify = function () {
  var _ref = asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            return _context.abrupt('return', playerPromise);

          case 1:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this);
  }));

  return function getSpotify() {
    return _ref.apply(this, arguments);
  };
}();

var createPlayer = function () {
  var _ref2 = asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(token, options) {
    var Spotify, player;
    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _context2.next = 2;
            return getSpotify();

          case 2:
            Spotify = _context2.sent;
            player = new Spotify.Player(Object.assign({
              getOAuthToken: function getOAuthToken(callback) {
                return callback(token);
              }
            }, options));
            return _context2.abrupt('return', player);

          case 5:
          case 'end':
            return _context2.stop();
        }
      }
    }, _callee2, this);
  }));

  return function createPlayer(_x, _x2) {
    return _ref2.apply(this, arguments);
  };
}();

function createAuthorizationURL(clientId, callbackURL) {
  return 'https://accounts.spotify.com/authorize?' + [['client_id', clientId], ['redirect_uri', callbackURL], ['response_type', 'token'], ['scope', ['user-read-private', 'user-read-playback-state', 'user-modify-playback-state', 'playlist-read-private', 'playlist-read-collaborative', 'streaming'].join(' ')]].map(function (_ref3) {
    var _ref4 = slicedToArray(_ref3, 2),
        key = _ref4[0],
        value = _ref4[1];

    return key + '=' + encodeURIComponent(value);
  }).join('&');
}

exports.AlbumAPI = AlbumAPI;
exports.PlaybackAPI = PlaybackAPI;
exports.PlaylistAPI = PlaylistAPI;
exports.SearchAPI = SearchAPI;
exports.TrackAPI = TrackAPI;
exports.getSpotify = getSpotify;
exports.createPlayer = createPlayer;
exports.createAuthorizationURL = createAuthorizationURL;