text: (function (global, factory) {
  	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  	typeof define === 'function' && define.amd ? define(['exports'], factory) :
  	(factory((global.vueVimeoPlayer = {})));
  }(this, (function (exports) { 'use strict';
  
  /*! @vimeo/player v2.5.0 | (c) 2018 Vimeo | MIT License | https://github.com/vimeo/player.js */
  /**
   * @module lib/functions
   */
  
  /**
   * Check to see this is a node environment.
   * @type {Boolean}
   */
  /* global global */
  var isNode = typeof global !== 'undefined' && {}.toString.call(global) === '[object global]';
  
  /**
   * Get the name of the method for a given getter or setter.
   *
   * @param {string} prop The name of the property.
   * @param {string} type Either “get” or “set”.
   * @return {string}
   */
  function getMethodName(prop, type) {
      if (prop.indexOf(type.toLowerCase()) === 0) {
          return prop;
      }
  
      return '' + type.toLowerCase() + prop.substr(0, 1).toUpperCase() + prop.substr(1);
  }
  
  /**
   * Check to see if the object is a DOM Element.
   *
   * @param {*} element The object to check.
   * @return {boolean}
   */
  function isDomElement(element) {
      return element instanceof window.HTMLElement;
  }
  
  /**
   * Check to see whether the value is a number.
   *
   * @see http://dl.dropboxusercontent.com/u/35146/js/tests/isNumber.html
   * @param {*} value The value to check.
   * @param {boolean} integer Check if the value is an integer.
   * @return {boolean}
   */
  function isInteger(value) {
      // eslint-disable-next-line eqeqeq
      return !isNaN(parseFloat(value)) && isFinite(value) && Math.floor(value) == value;
  }
  
  /**
   * Check to see if the URL is a Vimeo url.
   *
   * @param {string} url The url string.
   * @return {boolean}
   */
  function isVimeoUrl(url) {
      return (/^(https?:)?\/\/((player|www).)?vimeo.com(?=$|\/)/.test(url)
      );
  }
  
  /**
   * Get the Vimeo URL from an element.
   * The element must have either a data-vimeo-id or data-vimeo-url attribute.
   *
   * @param {object} oEmbedParameters The oEmbed parameters.
   * @return {string}
   */
  function getVimeoUrl() {
      var oEmbedParameters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  
      var id = oEmbedParameters.id;
      var url = oEmbedParameters.url;
      var idOrUrl = id || url;
  
      if (!idOrUrl) {
          throw new Error('An id or url must be passed, either in an options object or as a data-vimeo-id or data-vimeo-url attribute.');
      }
  
      if (isInteger(idOrUrl)) {
          return 'https://vimeo.com/' + idOrUrl;
      }
  
      if (isVimeoUrl(idOrUrl)) {
          return idOrUrl.replace('http:', 'https:');
      }
  
      if (id) {
          throw new TypeError('\u201C' + id + '\u201D is not a valid video id.');
      }
  
      throw new TypeError('\u201C' + idOrUrl + '\u201D is not a vimeo.com url.');
  }
  
  var arrayIndexOfSupport = typeof Array.prototype.indexOf !== 'undefined';
  var postMessageSupport = typeof window !== 'undefined' && typeof window.postMessage !== 'undefined';
  
  if (!isNode && (!arrayIndexOfSupport || !postMessageSupport)) {
      throw new Error('Sorry, the Vimeo Player API is not available in this browser.');
  }
  
  var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
  
  
  
  
  
  function createCommonjsModule(fn, module) {
  	return module = { exports: {} }, fn(module, module.exports), module.exports;
  }
  
  var index = createCommonjsModule(function (module, exports) {
  (function (exports) {
    'use strict';
    //shared pointer
  
    var i;
    //shortcuts
    var defineProperty = Object.defineProperty,
        is = function is(a, b) {
      return a === b || a !== a && b !== b;
    };
  
    //Polyfill global objects
    if (typeof WeakMap == 'undefined') {
      exports.WeakMap = createCollection({
        // WeakMap#delete(key:void*):boolean
        'delete': sharedDelete,
        // WeakMap#clear():
        clear: sharedClear,
        // WeakMap#get(key:void*):void*
        get: sharedGet,
        // WeakMap#has(key:void*):boolean
        has: mapHas,
        // WeakMap#set(key:void*, value:void*):void
        set: sharedSet
      }, true);
    }
  
    if (typeof Map == 'undefined' || typeof new Map().values !== 'function' || !new Map().values().next) {
      exports.Map = createCollection({
        // WeakMap#delete(key:void*):boolean
        'delete': sharedDelete,
        //:was Map#get(key:void*[, d3fault:void*]):void*
        // Map#has(key:void*):boolean
        has: mapHas,
        // Map#get(key:void*):boolean
        get: sharedGet,
        // Map#set(key:void*, value:void*):void
        set: sharedSet,
        // Map#keys(void):Iterator
        keys: sharedKeys,
        // Map#values(void):Iterator
        values: sharedValues,
        // Map#entries(void):Iterator
        entries: mapEntries,
        // Map#forEach(callback:Function, context:void*):void ==> callback.call(context, key, value, mapObject) === not in specs`
        forEach: sharedForEach,
        // Map#clear():
        clear: sharedClear
      });
    }
  
    if (typeof Set == 'undefined' || typeof new Set().values !== 'function' || !new Set().values().next) {
      exports.Set = createCollection({
        // Set#has(value:void*):boolean
        has: setHas,
        // Set#add(value:void*):boolean
        add: sharedAdd,
        // Set#delete(key:void*):boolean
        'delete': sharedDelete,
        // Set#clear():
        clear: sharedClear,
        // Set#keys(void):Iterator
        keys: sharedValues, // specs actually say "the same function object as the initial value of the values property"
        // Set#values(void):Iterator
        values: sharedValues,
        // Set#entries(void):Iterator
        entries: setEntries,
        // Set#forEach(callback:Function, context:void*):void ==> callback.call(context, value, index) === not in specs
        forEach: sharedForEach
      });
    }
  
    if (typeof WeakSet == 'undefined') {
      exports.WeakSet = createCollection({
        // WeakSet#delete(key:void*):boolean
        'delete': sharedDelete,
        // WeakSet#add(value:void*):boolean
        add: sharedAdd,
        // WeakSet#clear():
        clear: sharedClear,
        // WeakSet#has(value:void*):boolean
        has: setHas
      }, true);
    }
  
    /**
     * ES6 collection constructor
     * @return {Function} a collection class
     */
    function createCollection(proto, objectOnly) {
      function Collection(a) {
        if (!this || this.constructor !== Collection) return new Collection(a);
        this._keys = [];
        this._values = [];
        this._itp = []; // iteration pointers
        this.objectOnly = objectOnly;
  
        //parse initial iterable argument passed
        if (a) init.call(this, a);
      }
  
      //define size for non object-only collections
      if (!objectOnly) {
        defineProperty(proto, 'size', {
          get: sharedSize
        });
      }
  
      //set prototype
      proto.constructor = Collection;
      Collection.prototype = proto;
  
      return Collection;
    }
  
    /** parse initial iterable argument passed */
    function init(a) {
      if (this.add) a.forEach(this.add, this);
      //init Map argument like `[[1,2], [{}, 4]]`
      else a.forEach(function (a) {
          this.set(a[0], a[1]);
        }, this);
    }
  
    /** delete */
    function sharedDelete(key) {
      if (this.has(key)) {
        this._keys.splice(i, 1);
        this._values.splice(i, 1);
        // update iteration pointers
        this._itp.forEach(function (p) {
          if (i < p[0]) p[0]--;
        });
      }
      // Aurora here does it while Canary doesn't
      return -1 < i;
    }
  
    function sharedGet(key) {
      return this.has(key) ? this._values[i] : undefined;
    }
  
    function has(list, key) {
      if (this.objectOnly && key !== Object(key)) throw new TypeError("Invalid value used as weak collection key");
      //NaN or 0 passed
      if (key != key || key === 0) for (i = list.length; i-- && !is(list[i], key);) {} else i = list.indexOf(key);
      return -1 < i;
    }
  
    function setHas(value) {
      return has.call(this, this._values, value);
    }
  
    function mapHas(value) {
      return has.call(this, this._keys, value);
    }
  
    /** @chainable */
    function sharedSet(key, value) {
      this.has(key) ? this._values[i] = value : this._values[this._keys.push(key) - 1] = value;
      return this;
    }
  
    /** @chainable */
    function sharedAdd(value) {
      if (!this.has(value)) this._values.push(value);
      return this;
    }
  
    function sharedClear() {
      (this._keys || 0).length = this._values.length = 0;
    }
  
    /** keys, values, and iterate related methods */
    function sharedKeys() {
      return sharedIterator(this._itp, this._keys);
    }
  
    function sharedValues() {
      return sharedIterator(this._itp, this._values);
    }
  
    function mapEntries() {
      return sharedIterator(this._itp, this._keys, this._values);
    }
  
    function setEntries() {
      return sharedIterator(this._itp, this._values, this._values);
    }
  
    function sharedIterator(itp, array, array2) {
      var p = [0],
          done = false;
      itp.push(p);
      return {
        next: function next() {
          var v,
              k = p[0];
          if (!done && k < array.length) {
            v = array2 ? [array[k], array2[k]] : array[k];
            p[0]++;
          } else {
            done = true;
            itp.splice(itp.indexOf(p), 1);
          }
          return { done: done, value: v };
        }
      };
    }
  
    function sharedSize() {
      return this._values.length;
    }
  
    function sharedForEach(callback, context) {
      var it = this.entries();
      for (;;) {
        var r = it.next();
        if (r.done) break;
        callback.call(context, r.value[1], r.value[0], this);
      }
    }
  })('object' != 'undefined' && typeof commonjsGlobal != 'undefined' ? commonjsGlobal : window);
  });
  
  var npo_src = createCommonjsModule(function (module) {
  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; };
  
  /*! Native Promise Only
      v0.8.1 (c) Kyle Simpson
      MIT License: http://getify.mit-license.org
  */
  
  (function UMD(name, context, definition) {
  	// special form of UMD for polyfilling across evironments
  	context[name] = context[name] || definition();
  	if ('object' != "undefined" && module.exports) {
  		module.exports = context[name];
  	} else if (typeof undefined == "function" && undefined.amd) {
  		undefined(function $AMD$() {
  			return context[name];
  		});
  	}
  })("Promise", typeof commonjsGlobal != "undefined" ? commonjsGlobal : commonjsGlobal, function DEF() {
  	/*jshint validthis:true */
  	"use strict";
  
  	var builtInProp,
  	    cycle,
  	    scheduling_queue,
  	    ToString = Object.prototype.toString,
  	    timer = typeof setImmediate != "undefined" ? function timer(fn) {
  		return setImmediate(fn);
  	} : setTimeout;
  
  	// dammit, IE8.
  	try {
  		Object.defineProperty({}, "x", {});
  		builtInProp = function builtInProp(obj, name, val, config) {
  			return Object.defineProperty(obj, name, {
  				value: val,
  				writable: true,
  				configurable: config !== false
  			});
  		};
  	} catch (err) {
  		builtInProp = function builtInProp(obj, name, val) {
  			obj[name] = val;
  			return obj;
  		};
  	}
  
  	// Note: using a queue instead of array for efficiency
  	scheduling_queue = function Queue() {
  		var first, last, item;
  
  		function Item(fn, self) {
  			this.fn = fn;
  			this.self = self;
  			this.next = void 0;
  		}
  
  		return {
  			add: function add(fn, self) {
  				item = new Item(fn, self);
  				if (last) {
  					last.next = item;
  				} else {
  					first = item;
  				}
  				last = item;
  				item = void 0;
  			},
  			drain: function drain() {
  				var f = first;
  				first = last = cycle = void 0;
  
  				while (f) {
  					f.fn.call(f.self);
  					f = f.next;
  				}
  			}
  		};
  	}();
  
  	function schedule(fn, self) {
  		scheduling_queue.add(fn, self);
  		if (!cycle) {
  			cycle = timer(scheduling_queue.drain);
  		}
  	}
  
  	// promise duck typing
  	function isThenable(o) {
  		var _then,
  		    o_type = typeof o === "undefined" ? "undefined" : _typeof(o);
  
  		if (o != null && (o_type == "object" || o_type == "function")) {
  			_then = o.then;
  		}
  		return typeof _then == "function" ? _then : false;
  	}
  
  	function notify() {
  		for (var i = 0; i < this.chain.length; i++) {
  			notifyIsolated(this, this.state === 1 ? this.chain[i].success : this.chain[i].failure, this.chain[i]);
  		}
  		this.chain.length = 0;
  	}
  
  	// NOTE: This is a separate function to isolate
  	// the `try..catch` so that other code can be
  	// optimized better
  	function notifyIsolated(self, cb, chain) {
  		var ret, _then;
  		try {
  			if (cb === false) {
  				chain.reject(self.msg);
  			} else {
  				if (cb === true) {
  					ret = self.msg;
  				} else {
  					ret = cb.call(void 0, self.msg);
  				}
  
  				if (ret === chain.promise) {
  					chain.reject(TypeError("Promise-chain cycle"));
  				} else if (_then = isThenable(ret)) {
  					_then.call(ret, chain.resolve, chain.reject);
  				} else {
  					chain.resolve(ret);
  				}
  			}
  		} catch (err) {
  			chain.reject(err);
  		}
  	}
  
  	function resolve(msg) {
  		var _then,
  		    self = this;
  
  		// already triggered?
  		if (self.triggered) {
  			return;
  		}
  
  		self.triggered = true;
  
  		// unwrap
  		if (self.def) {
  			self = self.def;
  		}
  
  		try {
  			if (_then = isThenable(msg)) {
  				schedule(function () {
  					var def_wrapper = new MakeDefWrapper(self);
  					try {
  						_then.call(msg, function $resolve$() {
  							resolve.apply(def_wrapper, arguments);
  						}, function $reject$() {
  							reject.apply(def_wrapper, arguments);
  						});
  					} catch (err) {
  						reject.call(def_wrapper, err);
  					}
  				});
  			} else {
  				self.msg = msg;
  				self.state = 1;
  				if (self.chain.length > 0) {
  					schedule(notify, self);
  				}
  			}
  		} catch (err) {
  			reject.call(new MakeDefWrapper(self), err);
  		}
  	}
  
  	function reject(msg) {
  		var self = this;
  
  		// already triggered?
  		if (self.triggered) {
  			return;
  		}
  
  		self.triggered = true;
  
  		// unwrap
  		if (self.def) {
  			self = self.def;
  		}
  
  		self.msg = msg;
  		self.state = 2;
  		if (self.chain.length > 0) {
  			schedule(notify, self);
  		}
  	}
  
  	function iteratePromises(Constructor, arr, resolver, rejecter) {
  		for (var idx = 0; idx < arr.length; idx++) {
  			(function IIFE(idx) {
  				Constructor.resolve(arr[idx]).then(function $resolver$(msg) {
  					resolver(idx, msg);
  				}, rejecter);
  			})(idx);
  		}
  	}
  
  	function MakeDefWrapper(self) {
  		this.def = self;
  		this.triggered = false;
  	}
  
  	function MakeDef(self) {
  		this.promise = self;
  		this.state = 0;
  		this.triggered = false;
  		this.chain = [];
  		this.msg = void 0;
  	}
  
  	function Promise(executor) {
  		if (typeof executor != "function") {
  			throw TypeError("Not a function");
  		}
  
  		if (this.__NPO__ !== 0) {
  			throw TypeError("Not a promise");
  		}
  
  		// instance shadowing the inherited "brand"
  		// to signal an already "initialized" promise
  		this.__NPO__ = 1;
  
  		var def = new MakeDef(this);
  
  		this["then"] = function then(success, failure) {
  			var o = {
  				success: typeof success == "function" ? success : true,
  				failure: typeof failure == "function" ? failure : false
  			};
  			// Note: `then(..)` itself can be borrowed to be used against
  			// a different promise constructor for making the chained promise,
  			// by substituting a different `this` binding.
  			o.promise = new this.constructor(function extractChain(resolve, reject) {
  				if (typeof resolve != "function" || typeof reject != "function") {
  					throw TypeError("Not a function");
  				}
  
  				o.resolve = resolve;
  				o.reject = reject;
  			});
  			def.chain.push(o);
  
  			if (def.state !== 0) {
  				schedule(notify, def);
  			}
  
  			return o.promise;
  		};
  		this["catch"] = function $catch$(failure) {
  			return this.then(void 0, failure);
  		};
  
  		try {
  			executor.call(void 0, function publicResolve(msg) {
  				resolve.call(def, msg);
  			}, function publicReject(msg) {
  				reject.call(def, msg);
  			});
  		} catch (err) {
  			reject.call(def, err);
  		}
  	}
  
  	var PromisePrototype = builtInProp({}, "constructor", Promise,
  	/*configurable=*/false);
  
  	// Note: Android 4 cannot use `Object.defineProperty(..)` here
  	Promise.prototype = PromisePrototype;
  
  	// built-in "brand" to signal an "uninitialized" promise
  	builtInProp(PromisePrototype, "__NPO__", 0,
  	/*configurable=*/false);
  
  	builtInProp(Promise, "resolve", function Promise$resolve(msg) {
  		var Constructor = this;
  
  		// spec mandated checks
  		// note: best "isPromise" check that's practical for now
  		if (msg && (typeof msg === "undefined" ? "undefined" : _typeof(msg)) == "object" && msg.__NPO__ === 1) {
  			return msg;
  		}
  
  		return new Constructor(function executor(resolve, reject) {
  			if (typeof resolve != "function" || typeof reject != "function") {
  				throw TypeError("Not a function");
  			}
  
  			resolve(msg);
  		});
  	});
  
  	builtInProp(Promise, "reject", function Promise$reject(msg) {
  		return new this(function executor(resolve, reject) {
  			if (typeof resolve != "function" || typeof reject != "function") {
  				throw TypeError("Not a function");
  			}
  
  			reject(msg);
  		});
  	});
  
  	builtInProp(Promise, "all", function Promise$all(arr) {
  		var Constructor = this;
  
  		// spec mandated checks
  		if (ToString.call(arr) != "[object Array]") {
  			return Constructor.reject(TypeError("Not an array"));
  		}
  		if (arr.length === 0) {
  			return Constructor.resolve([]);
  		}
  
  		return new Constructor(function executor(resolve, reject) {
  			if (typeof resolve != "function" || typeof reject != "function") {
  				throw TypeError("Not a function");
  			}
  
  			var len = arr.length,
  			    msgs = Array(len),
  			    count = 0;
  
  			iteratePromises(Constructor, arr, function resolver(idx, msg) {
  				msgs[idx] = msg;
  				if (++count === len) {
  					resolve(msgs);
  				}
  			}, reject);
  		});
  	});
  
  	builtInProp(Promise, "race", function Promise$race(arr) {
  		var Constructor = this;
  
  		// spec mandated checks
  		if (ToString.call(arr) != "[object Array]") {
  			return Constructor.reject(TypeError("Not an array"));
  		}
  
  		return new Constructor(function executor(resolve, reject) {
  			if (typeof resolve != "function" || typeof reject != "function") {
  				throw TypeError("Not a function");
  			}
  
  			iteratePromises(Constructor, arr, function resolver(idx, msg) {
  				resolve(msg);
  			}, reject);
  		});
  	});
  
  	return Promise;
  });
  });
  
  /**
   * @module lib/callbacks
   */
  
  var callbackMap = new WeakMap();
  
  /**
   * Store a callback for a method or event for a player.
   *
   * @param {Player} player The player object.
   * @param {string} name The method or event name.
   * @param {(function(this:Player, *): void|{resolve: function, reject: function})} callback
   *        The callback to call or an object with resolve and reject functions for a promise.
   * @return {void}
   */
  function storeCallback(player, name, callback) {
      var playerCallbacks = callbackMap.get(player.element) || {};
  
      if (!(name in playerCallbacks)) {
          playerCallbacks[name] = [];
      }
  
      playerCallbacks[name].push(callback);
      callbackMap.set(player.element, playerCallbacks);
  }
  
  /**
   * Get the callbacks for a player and event or method.
   *
   * @param {Player} player The player object.
   * @param {string} name The method or event name
   * @return {function[]}
   */
  function getCallbacks(player, name) {
      var playerCallbacks = callbackMap.get(player.element) || {};
      return playerCallbacks[name] || [];
  }
  
  /**
   * Remove a stored callback for a method or event for a player.
   *
   * @param {Player} player The player object.
   * @param {string} name The method or event name
   * @param {function} [callback] The specific callback to remove.
   * @return {boolean} Was this the last callback?
   */
  function removeCallback(player, name, callback) {
      var playerCallbacks = callbackMap.get(player.element) || {};
  
      if (!playerCallbacks[name]) {
          return true;
      }
  
      // If no callback is passed, remove all callbacks for the event
      if (!callback) {
          playerCallbacks[name] = [];
          callbackMap.set(player.element, playerCallbacks);
  
          return true;
      }
  
      var index = playerCallbacks[name].indexOf(callback);
  
      if (index !== -1) {
          playerCallbacks[name].splice(index, 1);
      }
  
      callbackMap.set(player.element, playerCallbacks);
      return playerCallbacks[name] && playerCallbacks[name].length === 0;
  }
  
  /**
   * Return the first stored callback for a player and event or method.
   *
   * @param {Player} player The player object.
   * @param {string} name The method or event name.
   * @return {function} The callback, or false if there were none
   */
  function shiftCallbacks(player, name) {
      var playerCallbacks = getCallbacks(player, name);
  
      if (playerCallbacks.length < 1) {
          return false;
      }
  
      var callback = playerCallbacks.shift();
      removeCallback(player, name, callback);
      return callback;
  }
  
  /**
   * Move callbacks associated with an element to another element.
   *
   * @param {HTMLElement} oldElement The old element.
   * @param {HTMLElement} newElement The new element.
   * @return {void}
   */
  function swapCallbacks(oldElement, newElement) {
      var playerCallbacks = callbackMap.get(oldElement);
  
      callbackMap.set(newElement, playerCallbacks);
      callbackMap.delete(oldElement);
  }
  
  /**
   * @module lib/embed
   */
  
  var oEmbedParameters = ['autopause', 'autoplay', 'background', 'byline', 'color', 'height', 'id', 'loop', 'maxheight', 'maxwidth', 'muted', 'playsinline', 'portrait', 'responsive', 'speed', 'title', 'transparent', 'url', 'width'];
  
  /**
   * Get the 'data-vimeo'-prefixed attributes from an element as an object.
   *
   * @param {HTMLElement} element The element.
   * @param {Object} [defaults={}] The default values to use.
   * @return {Object<string, string>}
   */
  function getOEmbedParameters(element) {
      var defaults = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
      return oEmbedParameters.reduce(function (params, param) {
          var value = element.getAttribute('data-vimeo-' + param);
  
          if (value || value === '') {
              params[param] = value === '' ? 1 : value;
          }
  
          return params;
      }, defaults);
  }
  
  /**
   * Make an oEmbed call for the specified URL.
   *
   * @param {string} videoUrl The vimeo.com url for the video.
   * @param {Object} [params] Parameters to pass to oEmbed.
   * @return {Promise}
   */
  function getOEmbedData(videoUrl) {
      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
      return new Promise(function (resolve, reject) {
          if (!isVimeoUrl(videoUrl)) {
              throw new TypeError('\u201C' + videoUrl + '\u201D is not a vimeo.com url.');
          }
  
          var url = 'https://vimeo.com/api/oembed.json?url=' + encodeURIComponent(videoUrl);
  
          for (var param in params) {
              if (params.hasOwnProperty(param)) {
                  url += '&' + param + '=' + encodeURIComponent(params[param]);
              }
          }
  
          var xhr = 'XDomainRequest' in window ? new XDomainRequest() : new XMLHttpRequest();
          xhr.open('GET', url, true);
  
          xhr.onload = function () {
              if (xhr.status === 404) {
                  reject(new Error('\u201C' + videoUrl + '\u201D was not found.'));
                  return;
              }
  
              if (xhr.status === 403) {
                  reject(new Error('\u201C' + videoUrl + '\u201D is not embeddable.'));
                  return;
              }
  
              try {
                  var json = JSON.parse(xhr.responseText);
                  resolve(json);
              } catch (error) {
                  reject(error);
              }
          };
  
          xhr.onerror = function () {
              var status = xhr.status ? ' (' + xhr.status + ')' : '';
              reject(new Error('There was an error fetching the embed code from Vimeo' + status + '.'));
          };
  
          xhr.send();
      });
  }
  
  /**
   * Create an embed from oEmbed data inside an element.
   *
   * @param {object} data The oEmbed data.
   * @param {HTMLElement} element The element to put the iframe in.
   * @return {HTMLIFrameElement} The iframe embed.
   */
  function createEmbed(_ref, element) {
      var html = _ref.html;
  
      if (!element) {
          throw new TypeError('An element must be provided');
      }
  
      if (element.getAttribute('data-vimeo-initialized') !== null) {
          return element.querySelector('iframe');
      }
  
      var div = document.createElement('div');
      div.innerHTML = html;
  
      element.appendChild(div.firstChild);
      element.setAttribute('data-vimeo-initialized', 'true');
  
      return element.querySelector('iframe');
  }
  
  /**
   * Initialize all embeds within a specific element
   *
   * @param {HTMLElement} [parent=document] The parent element.
   * @return {void}
   */
  function initializeEmbeds() {
      var parent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
  
      var elements = [].slice.call(parent.querySelectorAll('[data-vimeo-id], [data-vimeo-url]'));
  
      var handleError = function handleError(error) {
          if ('console' in window && console.error) {
              console.error('There was an error creating an embed: ' + error);
          }
      };
  
      elements.forEach(function (element) {
          try {
              // Skip any that have data-vimeo-defer
              if (element.getAttribute('data-vimeo-defer') !== null) {
                  return;
              }
  
              var params = getOEmbedParameters(element);
              var url = getVimeoUrl(params);
  
              getOEmbedData(url, params).then(function (data) {
                  return createEmbed(data, element);
              }).catch(handleError);
          } catch (error) {
              handleError(error);
          }
      });
  }
  
  /**
   * Resize embeds when messaged by the player.
   *
   * @param {HTMLElement} [parent=document] The parent element.
   * @return {void}
   */
  function resizeEmbeds() {
      var parent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
  
      var onMessage = function onMessage(event) {
          if (!isVimeoUrl(event.origin)) {
              return;
          }
  
          if (!event.data || event.data.event !== 'spacechange') {
              return;
          }
  
          var iframes = parent.querySelectorAll('iframe');
  
          for (var i = 0; i < iframes.length; i++) {
              if (iframes[i].contentWindow !== event.source) {
                  continue;
              }
  
              var space = iframes[i].parentElement;
  
              if (space && space.className.indexOf('vimeo-space') !== -1) {
                  space.style.paddingBottom = event.data.data[0].bottom + 'px';
              }
  
              break;
          }
      };
  
      if (window.addEventListener) {
          window.addEventListener('message', onMessage, false);
      } else if (window.attachEvent) {
          window.attachEvent('onmessage', onMessage);
      }
  }
  
  /**
   * @module lib/postmessage
   */
  
  /**
   * Parse a message received from postMessage.
   *
   * @param {*} data The data received from postMessage.
   * @return {object}
   */
  function parseMessageData(data) {
      if (typeof data === 'string') {
          data = JSON.parse(data);
      }
  
      return data;
  }
  
  /**
   * Post a message to the specified target.
   *
   * @param {Player} player The player object to use.
   * @param {string} method The API method to call.
   * @param {object} params The parameters to send to the player.
   * @return {void}
   */
  function postMessage(player, method, params) {
      if (!player.element.contentWindow || !player.element.contentWindow.postMessage) {
          return;
      }
  
      var message = {
          method: method
      };
  
      if (params !== undefined) {
          message.value = params;
      }
  
      // IE 8 and 9 do not support passing messages, so stringify them
      var ieVersion = parseFloat(navigator.userAgent.toLowerCase().replace(/^.*msie (\d+).*$/, '$1'));
      if (ieVersion >= 8 && ieVersion < 10) {
          message = JSON.stringify(message);
      }
  
      player.element.contentWindow.postMessage(message, player.origin);
  }
  
  /**
   * Parse the data received from a message event.
   *
   * @param {Player} player The player that received the message.
   * @param {(Object|string)} data The message data. Strings will be parsed into JSON.
   * @return {void}
   */
  function processData(player, data) {
      data = parseMessageData(data);
      var callbacks = [];
      var param = void 0;
  
      if (data.event) {
          if (data.event === 'error') {
              var promises = getCallbacks(player, data.data.method);
  
              promises.forEach(function (promise) {
                  var error = new Error(data.data.message);
                  error.name = data.data.name;
  
                  promise.reject(error);
                  removeCallback(player, data.data.method, promise);
              });
          }
  
          callbacks = getCallbacks(player, 'event:' + data.event);
          param = data.data;
      } else if (data.method) {
          var callback = shiftCallbacks(player, data.method);
  
          if (callback) {
              callbacks.push(callback);
              param = data.value;
          }
      }
  
      callbacks.forEach(function (callback) {
          try {
              if (typeof callback === 'function') {
                  callback.call(player, param);
                  return;
              }
  
              callback.resolve(param);
          } catch (e) {
              // empty
          }
      });
  }
  
  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; }; }();
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var playerMap = new WeakMap();
  var readyMap = new WeakMap();
  
  var Player = function () {
      /**
      * Create a Player.
      *
      * @param {(HTMLIFrameElement|HTMLElement|string|jQuery)} element A reference to the Vimeo
      *        player iframe, and id, or a jQuery object.
      * @param {object} [options] oEmbed parameters to use when creating an embed in the element.
      * @return {Player}
      */
      function Player(element) {
          var _this = this;
  
          var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
          _classCallCheck(this, Player);
  
          /* global jQuery */
          if (window.jQuery && element instanceof jQuery) {
              if (element.length > 1 && window.console && console.warn) {
                  console.warn('A jQuery object with multiple elements was passed, using the first element.');
              }
  
              element = element[0];
          }
  
          // Find an element by ID
          if (typeof document !== 'undefined' && typeof element === 'string') {
              element = document.getElementById(element);
          }
  
          // Not an element!
          if (!isDomElement(element)) {
              throw new TypeError('You must pass either a valid element or a valid id.');
          }
  
          // Already initialized an embed in this div, so grab the iframe
          if (element.nodeName !== 'IFRAME') {
              var iframe = element.querySelector('iframe');
  
              if (iframe) {
                  element = iframe;
              }
          }
  
          // iframe url is not a Vimeo url
          if (element.nodeName === 'IFRAME' && !isVimeoUrl(element.getAttribute('src') || '')) {
              throw new Error('The player element passed isn’t a Vimeo embed.');
          }
  
          // If there is already a player object in the map, return that
          if (playerMap.has(element)) {
              return playerMap.get(element);
          }
  
          this.element = element;
          this.origin = '*';
  
          var readyPromise = new npo_src(function (resolve, reject) {
              var onMessage = function onMessage(event) {
                  if (!isVimeoUrl(event.origin) || _this.element.contentWindow !== event.source) {
                      return;
                  }
  
                  if (_this.origin === '*') {
                      _this.origin = event.origin;
                  }
  
                  var data = parseMessageData(event.data);
                  var isReadyEvent = 'event' in data && data.event === 'ready';
                  var isPingResponse = 'method' in data && data.method === 'ping';
  
                  if (isReadyEvent || isPingResponse) {
                      _this.element.setAttribute('data-ready', 'true');
                      resolve();
                      return;
                  }
  
                  processData(_this, data);
              };
  
              if (window.addEventListener) {
                  window.addEventListener('message', onMessage, false);
              } else if (window.attachEvent) {
                  window.attachEvent('onmessage', onMessage);
              }
  
              if (_this.element.nodeName !== 'IFRAME') {
                  var params = getOEmbedParameters(element, options);
                  var url = getVimeoUrl(params);
  
                  getOEmbedData(url, params).then(function (data) {
                      var iframe = createEmbed(data, element);
                      // Overwrite element with the new iframe,
                      // but store reference to the original element
                      _this.element = iframe;
                      _this._originalElement = element;
  
                      swapCallbacks(element, iframe);
                      playerMap.set(_this.element, _this);
  
                      return data;
                  }).catch(function (error) {
                      return reject(error);
                  });
              }
          });
  
          // Store a copy of this Player in the map
          readyMap.set(this, readyPromise);
          playerMap.set(this.element, this);
  
          // Send a ping to the iframe so the ready promise will be resolved if
          // the player is already ready.
          if (this.element.nodeName === 'IFRAME') {
              postMessage(this, 'ping');
          }
  
          return this;
      }
  
      /**
       * Get a promise for a method.
       *
       * @param {string} name The API method to call.
       * @param {Object} [args={}] Arguments to send via postMessage.
       * @return {Promise}
       */
  
  
      _createClass(Player, [{
          key: 'callMethod',
          value: function callMethod(name) {
              var _this2 = this;
  
              var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
              return new npo_src(function (resolve, reject) {
                  // We are storing the resolve/reject handlers to call later, so we
                  // can’t return here.
                  // eslint-disable-next-line promise/always-return
                  return _this2.ready().then(function () {
                      storeCallback(_this2, name, {
                          resolve: resolve,
                          reject: reject
                      });
  
                      postMessage(_this2, name, args);
                  }).catch(function (error) {
                      reject(error);
                  });
              });
          }
  
          /**
           * Get a promise for the value of a player property.
           *
           * @param {string} name The property name
           * @return {Promise}
           */
  
      }, {
          key: 'get',
          value: function get(name) {
              var _this3 = this;
  
              return new npo_src(function (resolve, reject) {
                  name = getMethodName(name, 'get');
  
                  // We are storing the resolve/reject handlers to call later, so we
                  // can’t return here.
                  // eslint-disable-next-line promise/always-return
                  return _this3.ready().then(function () {
                      storeCallback(_this3, name, {
                          resolve: resolve,
                          reject: reject
                      });
  
                      postMessage(_this3, name);
                  });
              });
          }
  
          /**
           * Get a promise for setting the value of a player property.
           *
           * @param {string} name The API method to call.
           * @param {mixed} value The value to set.
           * @return {Promise}
           */
  
      }, {
          key: 'set',
          value: function set(name, value) {
              var _this4 = this;
  
              return npo_src.resolve(value).then(function (val) {
                  name = getMethodName(name, 'set');
  
                  if (val === undefined || val === null) {
                      throw new TypeError('There must be a value to set.');
                  }
  
                  return _this4.ready().then(function () {
                      return new npo_src(function (resolve, reject) {
                          storeCallback(_this4, name, {
                              resolve: resolve,
                              reject: reject
                          });
  
                          postMessage(_this4, name, val);
                      });
                  });
              });
          }
  
          /**
           * Add an event listener for the specified event. Will call the
           * callback with a single parameter, `data`, that contains the data for
           * that event.
           *
           * @param {string} eventName The name of the event.
           * @param {function(*)} callback The function to call when the event fires.
           * @return {void}
           */
  
      }, {
          key: 'on',
          value: function on(eventName, callback) {
              if (!eventName) {
                  throw new TypeError('You must pass an event name.');
              }
  
              if (!callback) {
                  throw new TypeError('You must pass a callback function.');
              }
  
              if (typeof callback !== 'function') {
                  throw new TypeError('The callback must be a function.');
              }
  
              var callbacks = getCallbacks(this, 'event:' + eventName);
              if (callbacks.length === 0) {
                  this.callMethod('addEventListener', eventName).catch(function () {
                      // Ignore the error. There will be an error event fired that
                      // will trigger the error callback if they are listening.
                  });
              }
  
              storeCallback(this, 'event:' + eventName, callback);
          }
  
          /**
           * Remove an event listener for the specified event. Will remove all
           * listeners for that event if a `callback` isn’t passed, or only that
           * specific callback if it is passed.
           *
           * @param {string} eventName The name of the event.
           * @param {function} [callback] The specific callback to remove.
           * @return {void}
           */
  
      }, {
          key: 'off',
          value: function off(eventName, callback) {
              if (!eventName) {
                  throw new TypeError('You must pass an event name.');
              }
  
              if (callback && typeof callback !== 'function') {
                  throw new TypeError('The callback must be a function.');
              }
  
              var lastCallback = removeCallback(this, 'event:' + eventName, callback);
  
              // If there are no callbacks left, remove the listener
              if (lastCallback) {
                  this.callMethod('removeEventListener', eventName).catch(function (e) {
                      // Ignore the error. There will be an error event fired that
                      // will trigger the error callback if they are listening.
                  });
              }
          }
  
          /**
           * A promise to load a new video.
           *
           * @promise LoadVideoPromise
           * @fulfill {number} The video with this id successfully loaded.
           * @reject {TypeError} The id was not a number.
           */
          /**
           * Load a new video into this embed. The promise will be resolved if
           * the video is successfully loaded, or it will be rejected if it could
           * not be loaded.
           *
           * @param {number} id The id of the video.
           * @return {LoadVideoPromise}
           */
  
      }, {
          key: 'loadVideo',
          value: function loadVideo(id) {
              return this.callMethod('loadVideo', id);
          }
  
          /**
           * A promise to perform an action when the Player is ready.
           *
           * @todo document errors
           * @promise LoadVideoPromise
           * @fulfill {void}
           */
          /**
           * Trigger a function when the player iframe has initialized. You do not
           * need to wait for `ready` to trigger to begin adding event listeners
           * or calling other methods.
           *
           * @return {ReadyPromise}
           */
  
      }, {
          key: 'ready',
          value: function ready() {
              var readyPromise = readyMap.get(this) || new npo_src(function (resolve, reject) {
                  reject('Unknown player. Probably unloaded.');
              });
              return npo_src.resolve(readyPromise);
          }
  
          /**
           * A promise to add a cue point to the player.
           *
           * @promise AddCuePointPromise
           * @fulfill {string} The id of the cue point to use for removeCuePoint.
           * @reject {RangeError} the time was less than 0 or greater than the
           *         video’s duration.
           * @reject {UnsupportedError} Cue points are not supported with the current
           *         player or browser.
           */
          /**
           * Add a cue point to the player.
           *
           * @param {number} time The time for the cue point.
           * @param {object} [data] Arbitrary data to be returned with the cue point.
           * @return {AddCuePointPromise}
           */
  
      }, {
          key: 'addCuePoint',
          value: function addCuePoint(time) {
              var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
              return this.callMethod('addCuePoint', { time: time, data: data });
          }
  
          /**
           * A promise to remove a cue point from the player.
           *
           * @promise AddCuePointPromise
           * @fulfill {string} The id of the cue point that was removed.
           * @reject {InvalidCuePoint} The cue point with the specified id was not
           *         found.
           * @reject {UnsupportedError} Cue points are not supported with the current
           *         player or browser.
           */
          /**
           * Remove a cue point from the video.
           *
           * @param {string} id The id of the cue point to remove.
           * @return {RemoveCuePointPromise}
           */
  
      }, {
          key: 'removeCuePoint',
          value: function removeCuePoint(id) {
              return this.callMethod('removeCuePoint', id);
          }
  
          /**
           * A representation of a text track on a video.
           *
           * @typedef {Object} VimeoTextTrack
           * @property {string} language The ISO language code.
           * @property {string} kind The kind of track it is (captions or subtitles).
           * @property {string} label The human‐readable label for the track.
           */
          /**
           * A promise to enable a text track.
           *
           * @promise EnableTextTrackPromise
           * @fulfill {VimeoTextTrack} The text track that was enabled.
           * @reject {InvalidTrackLanguageError} No track was available with the
           *         specified language.
           * @reject {InvalidTrackError} No track was available with the specified
           *         language and kind.
           */
          /**
           * Enable the text track with the specified language, and optionally the
           * specified kind (captions or subtitles).
           *
           * When set via the API, the track language will not change the viewer’s
           * stored preference.
           *
           * @param {string} language The two‐letter language code.
           * @param {string} [kind] The kind of track to enable (captions or subtitles).
           * @return {EnableTextTrackPromise}
           */
  
      }, {
          key: 'enableTextTrack',
          value: function enableTextTrack(language, kind) {
              if (!language) {
                  throw new TypeError('You must pass a language.');
              }
  
              return this.callMethod('enableTextTrack', {
                  language: language,
                  kind: kind
              });
          }
  
          /**
           * A promise to disable the active text track.
           *
           * @promise DisableTextTrackPromise
           * @fulfill {void} The track was disabled.
           */
          /**
           * Disable the currently-active text track.
           *
           * @return {DisableTextTrackPromise}
           */
  
      }, {
          key: 'disableTextTrack',
          value: function disableTextTrack() {
              return this.callMethod('disableTextTrack');
          }
  
          /**
           * A promise to pause the video.
           *
           * @promise PausePromise
           * @fulfill {void} The video was paused.
           */
          /**
           * Pause the video if it’s playing.
           *
           * @return {PausePromise}
           */
  
      }, {
          key: 'pause',
          value: function pause() {
              return this.callMethod('pause');
          }
  
          /**
           * A promise to play the video.
           *
           * @promise PlayPromise
           * @fulfill {void} The video was played.
           */
          /**
           * Play the video if it’s paused. **Note:** on iOS and some other
           * mobile devices, you cannot programmatically trigger play. Once the
           * viewer has tapped on the play button in the player, however, you
           * will be able to use this function.
           *
           * @return {PlayPromise}
           */
  
      }, {
          key: 'play',
          value: function play() {
              return this.callMethod('play');
          }
  
          /**
           * A promise to unload the video.
           *
           * @promise UnloadPromise
           * @fulfill {void} The video was unloaded.
           */
          /**
           * Return the player to its initial state.
           *
           * @return {UnloadPromise}
           */
  
      }, {
          key: 'unload',
          value: function unload() {
              return this.callMethod('unload');
          }
  
          /**
           * Cleanup the player and remove it from the DOM
           *
           * It won't be usable and a new one should be constructed
           *  in order to do any operations.
           *
           * @return {Promise}
           */
  
      }, {
          key: 'destroy',
          value: function destroy() {
              var _this5 = this;
  
              return new npo_src(function (resolve) {
                  readyMap.delete(_this5);
                  playerMap.delete(_this5.element);
                  if (_this5._originalElement) {
                      playerMap.delete(_this5._originalElement);
                      _this5._originalElement.removeAttribute('data-vimeo-initialized');
                  }
                  if (_this5.element && _this5.element.nodeName === 'IFRAME') {
                      _this5.element.remove();
                  }
                  resolve();
              });
          }
  
          /**
           * A promise to get the autopause behavior of the video.
           *
           * @promise GetAutopausePromise
           * @fulfill {boolean} Whether autopause is turned on or off.
           * @reject {UnsupportedError} Autopause is not supported with the current
           *         player or browser.
           */
          /**
           * Get the autopause behavior for this player.
           *
           * @return {GetAutopausePromise}
           */
  
      }, {
          key: 'getAutopause',
          value: function getAutopause() {
              return this.get('autopause');
          }
  
          /**
           * A promise to set the autopause behavior of the video.
           *
           * @promise SetAutopausePromise
           * @fulfill {boolean} Whether autopause is turned on or off.
           * @reject {UnsupportedError} Autopause is not supported with the current
           *         player or browser.
           */
          /**
           * Enable or disable the autopause behavior of this player.
           *
           * By default, when another video is played in the same browser, this
           * player will automatically pause. Unless you have a specific reason
           * for doing so, we recommend that you leave autopause set to the
           * default (`true`).
           *
           * @param {boolean} autopause
           * @return {SetAutopausePromise}
           */
  
      }, {
          key: 'setAutopause',
          value: function setAutopause(autopause) {
              return this.set('autopause', autopause);
          }
  
          /**
           * A promise to get the color of the player.
           *
           * @promise GetColorPromise
           * @fulfill {string} The hex color of the player.
           */
          /**
           * Get the color for this player.
           *
           * @return {GetColorPromise}
           */
  
      }, {
          key: 'getColor',
          value: function getColor() {
              return this.get('color');
          }
  
          /**
           * A promise to set the color of the player.
           *
           * @promise SetColorPromise
           * @fulfill {string} The color was successfully set.
           * @reject {TypeError} The string was not a valid hex or rgb color.
           * @reject {ContrastError} The color was set, but the contrast is
           *         outside of the acceptable range.
           * @reject {EmbedSettingsError} The owner of the player has chosen to
           *         use a specific color.
           */
          /**
           * Set the color of this player to a hex or rgb string. Setting the
           * color may fail if the owner of the video has set their embed
           * preferences to force a specific color.
           *
           * @param {string} color The hex or rgb color string to set.
           * @return {SetColorPromise}
           */
  
      }, {
          key: 'setColor',
          value: function setColor(color) {
              return this.set('color', color);
          }
  
          /**
           * A representation of a cue point.
           *
           * @typedef {Object} VimeoCuePoint
           * @property {number} time The time of the cue point.
           * @property {object} data The data passed when adding the cue point.
           * @property {string} id The unique id for use with removeCuePoint.
           */
          /**
           * A promise to get the cue points of a video.
           *
           * @promise GetCuePointsPromise
           * @fulfill {VimeoCuePoint[]} The cue points added to the video.
           * @reject {UnsupportedError} Cue points are not supported with the current
           *         player or browser.
           */
          /**
           * Get an array of the cue points added to the video.
           *
           * @return {GetCuePointsPromise}
           */
  
      }, {
          key: 'getCuePoints',
          value: function getCuePoints() {
              return this.get('cuePoints');
          }
  
          /**
           * A promise to get the current time of the video.
           *
           * @promise GetCurrentTimePromise
           * @fulfill {number} The current time in seconds.
           */
          /**
           * Get the current playback position in seconds.
           *
           * @return {GetCurrentTimePromise}
           */
  
      }, {
          key: 'getCurrentTime',
          value: function getCurrentTime() {
              return this.get('currentTime');
          }
  
          /**
           * A promise to set the current time of the video.
           *
           * @promise SetCurrentTimePromise
           * @fulfill {number} The actual current time that was set.
           * @reject {RangeError} the time was less than 0 or greater than the
           *         video’s duration.
           */
          /**
           * Set the current playback position in seconds. If the player was
           * paused, it will remain paused. Likewise, if the player was playing,
           * it will resume playing once the video has buffered.
           *
           * You can provide an accurate time and the player will attempt to seek
           * to as close to that time as possible. The exact time will be the
           * fulfilled value of the promise.
           *
           * @param {number} currentTime
           * @return {SetCurrentTimePromise}
           */
  
      }, {
          key: 'setCurrentTime',
          value: function setCurrentTime(currentTime) {
              return this.set('currentTime', currentTime);
          }
  
          /**
           * A promise to get the duration of the video.
           *
           * @promise GetDurationPromise
           * @fulfill {number} The duration in seconds.
           */
          /**
           * Get the duration of the video in seconds. It will be rounded to the
           * nearest second before playback begins, and to the nearest thousandth
           * of a second after playback begins.
           *
           * @return {GetDurationPromise}
           */
  
      }, {
          key: 'getDuration',
          value: function getDuration() {
              return this.get('duration');
          }
  
          /**
           * A promise to get the ended state of the video.
           *
           * @promise GetEndedPromise
           * @fulfill {boolean} Whether or not the video has ended.
           */
          /**
           * Get the ended state of the video. The video has ended if
           * `currentTime === duration`.
           *
           * @return {GetEndedPromise}
           */
  
      }, {
          key: 'getEnded',
          value: function getEnded() {
              return this.get('ended');
          }
  
          /**
           * A promise to get the loop state of the player.
           *
           * @promise GetLoopPromise
           * @fulfill {boolean} Whether or not the player is set to loop.
           */
          /**
           * Get the loop state of the player.
           *
           * @return {GetLoopPromise}
           */
  
      }, {
          key: 'getLoop',
          value: function getLoop() {
              return this.get('loop');
          }
  
          /**
           * A promise to set the loop state of the player.
           *
           * @promise SetLoopPromise
           * @fulfill {boolean} The loop state that was set.
           */
          /**
           * Set the loop state of the player. When set to `true`, the player
           * will start over immediately once playback ends.
           *
           * @param {boolean} loop
           * @return {SetLoopPromise}
           */
  
      }, {
          key: 'setLoop',
          value: function setLoop(loop) {
              return this.set('loop', loop);
          }
  
          /**
           * A promise to get the paused state of the player.
           *
           * @promise GetLoopPromise
           * @fulfill {boolean} Whether or not the video is paused.
           */
          /**
           * Get the paused state of the player.
           *
           * @return {GetLoopPromise}
           */
  
      }, {
          key: 'getPaused',
          value: function getPaused() {
              return this.get('paused');
          }
  
          /**
           * A promise to get the playback rate of the player.
           *
           * @promise GetPlaybackRatePromise
           * @fulfill {number} The playback rate of the player on a scale from 0.5 to 2.
           */
          /**
           * Get the playback rate of the player on a scale from `0.5` to `2`.
           *
           * @return {GetPlaybackRatePromise}
           */
  
      }, {
          key: 'getPlaybackRate',
          value: function getPlaybackRate() {
              return this.get('playbackRate');
          }
  
          /**
           * A promise to set the playbackrate of the player.
           *
           * @promise SetPlaybackRatePromise
           * @fulfill {number} The playback rate was set.
           * @reject {RangeError} The playback rate was less than 0.5 or greater than 2.
           */
          /**
           * Set the playback rate of the player on a scale from `0.5` to `2`. When set
           * via the API, the playback rate will not be synchronized to other
           * players or stored as the viewer's preference.
           *
           * @param {number} playbackRate
           * @return {SetPlaybackRatePromise}
           */
  
      }, {
          key: 'setPlaybackRate',
          value: function setPlaybackRate(playbackRate) {
              return this.set('playbackRate', playbackRate);
          }
  
          /**
           * A promise to get the text tracks of a video.
           *
           * @promise GetTextTracksPromise
           * @fulfill {VimeoTextTrack[]} The text tracks associated with the video.
           */
          /**
           * Get an array of the text tracks that exist for the video.
           *
           * @return {GetTextTracksPromise}
           */
  
      }, {
          key: 'getTextTracks',
          value: function getTextTracks() {
              return this.get('textTracks');
          }
  
          /**
           * A promise to get the embed code for the video.
           *
           * @promise GetVideoEmbedCodePromise
           * @fulfill {string} The `<iframe>` embed code for the video.
           */
          /**
           * Get the `<iframe>` embed code for the video.
           *
           * @return {GetVideoEmbedCodePromise}
           */
  
      }, {
          key: 'getVideoEmbedCode',
          value: function getVideoEmbedCode() {
              return this.get('videoEmbedCode');
          }
  
          /**
           * A promise to get the id of the video.
           *
           * @promise GetVideoIdPromise
           * @fulfill {number} The id of the video.
           */
          /**
           * Get the id of the video.
           *
           * @return {GetVideoIdPromise}
           */
  
      }, {
          key: 'getVideoId',
          value: function getVideoId() {
              return this.get('videoId');
          }
  
          /**
           * A promise to get the title of the video.
           *
           * @promise GetVideoTitlePromise
           * @fulfill {number} The title of the video.
           */
          /**
           * Get the title of the video.
           *
           * @return {GetVideoTitlePromise}
           */
  
      }, {
          key: 'getVideoTitle',
          value: function getVideoTitle() {
              return this.get('videoTitle');
          }
  
          /**
           * A promise to get the native width of the video.
           *
           * @promise GetVideoWidthPromise
           * @fulfill {number} The native width of the video.
           */
          /**
           * Get the native width of the currently‐playing video. The width of
           * the highest‐resolution available will be used before playback begins.
           *
           * @return {GetVideoWidthPromise}
           */
  
      }, {
          key: 'getVideoWidth',
          value: function getVideoWidth() {
              return this.get('videoWidth');
          }
  
          /**
           * A promise to get the native height of the video.
           *
           * @promise GetVideoHeightPromise
           * @fulfill {number} The native height of the video.
           */
          /**
           * Get the native height of the currently‐playing video. The height of
           * the highest‐resolution available will be used before playback begins.
           *
           * @return {GetVideoHeightPromise}
           */
  
      }, {
          key: 'getVideoHeight',
          value: function getVideoHeight() {
              return this.get('videoHeight');
          }
  
          /**
           * A promise to get the vimeo.com url for the video.
           *
           * @promise GetVideoUrlPromise
           * @fulfill {number} The vimeo.com url for the video.
           * @reject {PrivacyError} The url isn’t available because of the video’s privacy setting.
           */
          /**
           * Get the vimeo.com url for the video.
           *
           * @return {GetVideoUrlPromise}
           */
  
      }, {
          key: 'getVideoUrl',
          value: function getVideoUrl() {
              return this.get('videoUrl');
          }
  
          /**
           * A promise to get the volume level of the player.
           *
           * @promise GetVolumePromise
           * @fulfill {number} The volume level of the player on a scale from 0 to 1.
           */
          /**
           * Get the current volume level of the player on a scale from `0` to `1`.
           *
           * Most mobile devices do not support an independent volume from the
           * system volume. In those cases, this method will always return `1`.
           *
           * @return {GetVolumePromise}
           */
  
      }, {
          key: 'getVolume',
          value: function getVolume() {
              return this.get('volume');
          }
  
          /**
           * A promise to set the volume level of the player.
           *
           * @promise SetVolumePromise
           * @fulfill {number} The volume was set.
           * @reject {RangeError} The volume was less than 0 or greater than 1.
           */
          /**
           * Set the volume of the player on a scale from `0` to `1`. When set
           * via the API, the volume level will not be synchronized to other
           * players or stored as the viewer’s preference.
           *
           * Most mobile devices do not support setting the volume. An error will
           * *not* be triggered in that situation.
           *
           * @param {number} volume
           * @return {SetVolumePromise}
           */
  
      }, {
          key: 'setVolume',
          value: function setVolume(volume) {
              return this.set('volume', volume);
          }
      }]);
  
      return Player;
  }();
  
  if (!isNode) {
      initializeEmbeds();
      resizeEmbeds();
  }
  
  var pid = 0;
  
  function emitVueEvent(event) {
    var _this = this;
  
    this.player.on(event, function (data) {
      _this.$emit(event, data, _this.player);
    });
  }
  
  var eventsToEmit = ['play', 'pause', 'ended', 'timeupdate', 'progress', 'seeked', 'texttrackchange', 'cuechange', 'cuepoint', 'volumechange', 'error', 'loaded'];
  
  var vueVimeoPlayer = {
    props: {
      playerHeight: {
        default: 320
      },
      playerWidth: {
        default: 640
      },
      options: {
        default: function _default() {
          return {};
        }
      },
      videoId: {
        required: true
      },
      loop: {
        default: false
      },
      autoplay: {
        default: false
      }
    },
    render: function render(h) {
      return h('div', { attrs: { id: this.elementId } });
    },
  
    watch: {
      videoId: 'update'
    },
    data: function data() {
      pid += 1;
  
      return {
        elementId: 'vimeo-player-' + pid,
        player: null
      };
    },
  
    methods: {
      /**
       * Loads a new video ID.
       * Returns a promise
       * @param {Number} videoId
       * @return {LoadVideoPromise}
       */
      update: function update(videoId) {
        return this.player.loadVideo(videoId);
      },
      play: function play() {
        return this.player.play();
      },
      pause: function pause() {
        return this.player.pause();
      },
      mute: function mute() {
        return this.player.setVolume(0);
      },
      unmute: function unmute() {
        var volume = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.5;
  
        return this.player.setVolume(volume);
      },
      setEvents: function setEvents() {
        var vm = this;
  
        this.player.ready().then(function () {
          vm.$emit('ready', vm.player);
        });
  
        eventsToEmit.forEach(function (event) {
          return emitVueEvent.call(vm, event);
        });
      }
    },
    mounted: function mounted() {
      var options = {
        id: this.videoId,
        width: this.playerWidth,
        height: this.playerHeight,
        loop: this.loop,
        autoplay: this.autoplay
      };
  
      this.player = new Player(this.elementId, Object.assign(options, this.options));
  
      this.setEvents();
    },
    beforeDestroy: function beforeDestroy() {
      this.player.unload();
    }
  };
  
  function plugin(Vue, options) {
  	Vue.component('vimeo-player', vueVimeoPlayer);
  }
  
  plugin.version = '0.0.6';
  
  if (typeof window !== 'undefined' && window.Vue) {
  	window.Vue.use(plugin);
  }
  
  exports['default'] = plugin;
  exports.vueVimeoPlayer = vueVimeoPlayer;
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  })));
  