https://www.arenastage.org/Static/dist/global.js

1(function webpackUniversalModuleDefinition(root, factory) {
2	if(typeof exports === 'object' && typeof module === 'object')
3		module.exports = factory(require("_"));
4	else if(typeof define === 'function' && define.amd)
5		define(["_"], factory);
6	else if(typeof exports === 'object')
7		exports["Library"] = factory(require("_"));
8	else
9		root["Library"] = factory(root["_"]);
10})(self, (__WEBPACK_EXTERNAL_MODULE_lodash__) => {
11return /******/ (() => { // webpackBootstrap
12/******/ 	var __webpack_modules__ = ({
13
14/***/ "./node_modules/@splidejs/splide-extension-video/dist/js/splide-extension-video.esm.js"
15/*!*********************************************************************************************!*\
16  !*** ./node_modules/@splidejs/splide-extension-video/dist/js/splide-extension-video.esm.js ***!
17  \*********************************************************************************************/
18(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
19
20"use strict";
21__webpack_require__.r(__webpack_exports__);
22/* harmony export */ __webpack_require__.d(__webpack_exports__, {
23/* harmony export */   Video: () => (/* binding */ Video)
24/* harmony export */ });
25/* provided dependency */ var Promise = __webpack_require__(/*! es6-promise */ "./node_modules/es6-promise/dist/es6-promise.js");
26/*!
27 * Splide.js
28 * Version  : 0.8.0
29 * License  : MIT
30 * Copyright: 2022 Naotoshi Fujita
31 */
32function empty(array) {
33  array.length = 0;
34}
35
36function slice$1(arrayLike, start, end) {
37  return Array.prototype.slice.call(arrayLike, start, end);
38}
39
40function apply$1(func) {
41  return func.bind.apply(func, [null].concat(slice$1(arguments, 1)));
42}
43
44function typeOf$1(type, subject) {
45  return typeof subject === type;
46}
47
48var isArray$1 = Array.isArray;
49apply$1(typeOf$1, "function");
50apply$1(typeOf$1, "string");
51apply$1(typeOf$1, "undefined");
52
53function toArray$1(value) {
54  return isArray$1(value) ? value : [value];
55}
56
57function forEach$1(values, iteratee) {
58  toArray$1(values).forEach(iteratee);
59}
60
61function includes(array, value) {
62  return array.indexOf(value) > -1;
63}
64
65var ownKeys$1 = Object.keys;
66
67function forOwn$1(object, iteratee, right) {
68  if (object) {
69    var keys = ownKeys$1(object);
70    keys = right ? keys.reverse() : keys;
71
72    for (var i = 0; i < keys.length; i++) {
73      var key = keys[i];
74
75      if (key !== "__proto__") {
76        if (iteratee(object[key], key) === false) {
77          break;
78        }
79      }
80    }
81  }
82
83  return object;
84}
85
86function assign$1(object) {
87  slice$1(arguments, 1).forEach(function (source) {
88    forOwn$1(source, function (value, key) {
89      object[key] = source[key];
90    });
91  });
92  return object;
93}
94
95var PROJECT_CODE$1 = "splide";
96
97function EventBinder() {
98  var listeners = [];
99
100  function bind(targets, events, callback, options) {
101    forEachEvent(targets, events, function (target, event, namespace) {
102      var isEventTarget = ("addEventListener" in target);
103      var remover = isEventTarget ? target.removeEventListener.bind(target, event, callback, options) : target["removeListener"].bind(target, callback);
104      isEventTarget ? target.addEventListener(event, callback, options) : target["addListener"](callback);
105      listeners.push([target, event, namespace, callback, remover]);
106    });
107  }
108
109  function unbind(targets, events, callback) {
110    forEachEvent(targets, events, function (target, event, namespace) {
111      listeners = listeners.filter(function (listener) {
112        if (listener[0] === target && listener[1] === event && listener[2] === namespace && (!callback || listener[3] === callback)) {
113          listener[4]();
114          return false;
115        }
116
117        return true;
118      });
119    });
120  }
121
122  function dispatch(target, type, detail) {
123    var e;
124    var bubbles = true;
125
126    if (typeof CustomEvent === "function") {
127      e = new CustomEvent(type, {
128        bubbles: bubbles,
129        detail: detail
130      });
131    } else {
132      e = document.createEvent("CustomEvent");
133      e.initCustomEvent(type, bubbles, false, detail);
134    }
135
136    target.dispatchEvent(e);
137    return e;
138  }
139
140  function forEachEvent(targets, events, iteratee) {
141    forEach$1(targets, function (target) {
142      target && forEach$1(events, function (events2) {
143        events2.split(" ").forEach(function (eventNS) {
144          var fragment = eventNS.split(".");
145          iteratee(target, fragment[0], fragment[1]);
146        });
147      });
148    });
149  }
150
151  function destroy() {
152    listeners.forEach(function (data) {
153      data[4]();
154    });
155    empty(listeners);
156  }
157
158  return {
159    bind: bind,
160    unbind: unbind,
161    dispatch: dispatch,
162    destroy: destroy
163  };
164}
165
166var EVENT_MOUNTED = "mounted";
167var EVENT_MOVE = "move";
168var EVENT_MOVED = "moved";
169var EVENT_DRAG = "drag";
170var EVENT_DRAGGING = "dragging";
171var EVENT_SCROLL = "scroll";
172var EVENT_SCROLLED = "scrolled";
173var EVENT_DESTROY = "destroy";
174
175function EventInterface(Splide2) {
176  var bus = Splide2 ? Splide2.event.bus : document.createDocumentFragment();
177  var binder = EventBinder();
178
179  function on(events, callback) {
180    binder.bind(bus, toArray$1(events).join(" "), function (e) {
181      callback.apply(callback, isArray$1(e.detail) ? e.detail : []);
182    });
183  }
184
185  function emit(event) {
186    binder.dispatch(bus, event, slice$1(arguments, 1));
187  }
188
189  if (Splide2) {
190    Splide2.event.on(EVENT_DESTROY, binder.destroy);
191  }
192
193  return assign$1(binder, {
194    bus: bus,
195    on: on,
196    off: apply$1(binder.unbind, bus),
197    emit: emit
198  });
199}
200
201function State(initialState) {
202  var state = initialState;
203
204  function set(value) {
205    state = value;
206  }
207
208  function is(states) {
209    return includes(toArray$1(states), state);
210  }
211
212  return {
213    set: set,
214    is: is
215  };
216}
217var CLASS_SLIDE = PROJECT_CODE$1 + "__slide";
218var CLASS_CONTAINER = CLASS_SLIDE + "__container";
219
220function slice(arrayLike, start, end) {
221  return Array.prototype.slice.call(arrayLike, start, end);
222}
223
224function find(arrayLike, predicate) {
225  return slice(arrayLike).filter(predicate)[0];
226}
227
228function apply(func) {
229  return func.bind(null, ...slice(arguments, 1));
230}
231
232function typeOf(type, subject) {
233  return typeof subject === type;
234}
235function isObject(subject) {
236  return !isNull(subject) && typeOf("object", subject);
237}
238const isArray = Array.isArray;
239const isFunction = apply(typeOf, "function");
240const isString = apply(typeOf, "string");
241const isUndefined = apply(typeOf, "undefined");
242function isNull(subject) {
243  return subject === null;
244}
245function isHTMLElement(subject) {
246  return subject instanceof HTMLElement;
247}
248
249function toArray(value) {
250  return isArray(value) ? value : [value];
251}
252
253function forEach(values, iteratee) {
254  toArray(values).forEach(iteratee);
255}
256
257function toggleClass(elm, classes, add) {
258  if (elm) {
259    forEach(classes, (name) => {
260      if (name) {
261        elm.classList[add ? "add" : "remove"](name);
262      }
263    });
264  }
265}
266
267function addClass(elm, classes) {
268  toggleClass(elm, isString(classes) ? classes.split(" ") : classes, true);
269}
270
271function append(parent, children) {
272  forEach(children, parent.appendChild.bind(parent));
273}
274
275function matches(elm, selector) {
276  return isHTMLElement(elm) && (elm["msMatchesSelector"] || elm.matches).call(elm, selector);
277}
278
279function children(parent, selector) {
280  const children2 = parent ? slice(parent.children) : [];
281  return selector ? children2.filter((child) => matches(child, selector)) : children2;
282}
283
284function child(parent, selector) {
285  return selector ? children(parent, selector)[0] : parent.firstElementChild;
286}
287
288const ownKeys = Object.keys;
289
290function forOwn(object, iteratee, right) {
291  if (object) {
292    let keys = ownKeys(object);
293    keys = right ? keys.reverse() : keys;
294    for (let i = 0; i < keys.length; i++) {
295      const key = keys[i];
296      if (key !== "__proto__") {
297        if (iteratee(object[key], key) === false) {
298          break;
299        }
300      }
301    }
302  }
303  return object;
304}
305
306function assign(object) {
307  slice(arguments, 1).forEach((source) => {
308    forOwn(source, (value, key) => {
309      object[key] = source[key];
310    });
311  });
312  return object;
313}
314
315function merge(object) {
316  slice(arguments, 1).forEach((source) => {
317    forOwn(source, (value, key) => {
318      if (isArray(value)) {
319        object[key] = value.slice();
320      } else if (isObject(value)) {
321        object[key] = merge({}, isObject(object[key]) ? object[key] : {}, value);
322      } else {
323        object[key] = value;
324      }
325    });
326  });
327  return object;
328}
329
330function removeAttribute(elms, attrs) {
331  forEach(elms, (elm) => {
332    forEach(attrs, (attr) => {
333      elm && elm.removeAttribute(attr);
334    });
335  });
336}
337
338function setAttribute(elms, attrs, value) {
339  if (isObject(attrs)) {
340    forOwn(attrs, (value2, name) => {
341      setAttribute(elms, name, value2);
342    });
343  } else {
344    forEach(elms, (elm) => {
345      isNull(value) || value === "" ? removeAttribute(elm, attrs) : elm.setAttribute(attrs, String(value));
346    });
347  }
348}
349
350function create(tag, attrs, parent) {
351  const elm = document.createElement(tag);
352  if (attrs) {
353    isString(attrs) ? addClass(elm, attrs) : setAttribute(elm, attrs);
354  }
355  parent && append(parent, elm);
356  return elm;
357}
358
359function style(elm, prop, value) {
360  if (isUndefined(value)) {
361    return getComputedStyle(elm)[prop];
362  }
363  if (!isNull(value)) {
364    elm.style[prop] = `${value}`;
365  }
366}
367
368function display(elm, display2) {
369  style(elm, "display", display2);
370}
371
372function getAttribute(elm, attr) {
373  return elm.getAttribute(attr);
374}
375
376function hasClass(elm, className) {
377  return elm && elm.classList.contains(className);
378}
379
380function remove(nodes) {
381  forEach(nodes, (node) => {
382    if (node && node.parentNode) {
383      node.parentNode.removeChild(node);
384    }
385  });
386}
387
388function queryAll(parent, selector) {
389  return selector ? slice(parent.querySelectorAll(selector)) : [];
390}
391
392function removeClass(elm, classes) {
393  toggleClass(elm, classes, false);
394}
395
396const PROJECT_CODE = "splide";
397
398function error(message) {
399  console.error(`[${PROJECT_CODE}] ${message}`);
400}
401
402const { min, max, floor, ceil, abs } = Math;
403
404function clamp(number, x, y) {
405  const minimum = min(x, y);
406  const maximum = max(x, y);
407  return min(max(minimum, number), maximum);
408}
409
410const CLASS_VIDEO = "splide__video";
411const CLASS_VIDEO_WRAPPER = `${CLASS_VIDEO}__wrapper`;
412const CLASS_VIDEO_PLAY_BUTTON = `${CLASS_VIDEO}__play`;
413const CLASS_PLAYING = "is-playing";
414const CLASS_ERROR = "is-error";
415const CLASS_VIDEO_DISABLED = "is-video-disabled";
416const MODIFIER_HAS_VIDEO = "--has-video";
417
418const YOUTUBE_DATA_ATTRIBUTE = "data-splide-youtube";
419const VIMEO_DATA_ATTRIBUTE = "data-splide-vimeo";
420const HTML_VIDEO__DATA_ATTRIBUTE = "data-splide-html-video";
421
422const DEFAULTS = {
423  hideControls: false,
424  loop: false,
425  mute: false,
426  volume: 0.2
427};
428
429const EVENT_VIDEO_PLAY = "video:play";
430const EVENT_VIDEO_PAUSE = "video:pause";
431const EVENT_VIDEO_ENDED = "video:ended";
432const EVENT_VIDEO_ERROR = "video:error";
433const EVENT_VIDEO_CLICK = "video:click";
434
435const NOT_INITIALIZED = 1;
436const INITIALIZING = 2;
437const INITIALIZED = 3;
438const PENDING_PLAY = 4;
439const IDLE = 5;
440const LOADING = 6;
441const PLAY_REQUEST_ABORTED = 7;
442const PLAYING = 8;
443const ERROR = 9;
444
445class AbstractVideoPlayer {
446  constructor(target, videoId, options) {
447    this.state = State(NOT_INITIALIZED);
448    this.event = EventInterface();
449    this.target = target;
450    this.videoId = videoId;
451    this.options = options || {};
452    this.onPlay = this.onPlay.bind(this);
453    this.onPause = this.onPause.bind(this);
454    this.onEnded = this.onEnded.bind(this);
455    this.onPlayerReady = this.onPlayerReady.bind(this);
456    this.onError = this.onError.bind(this);
457  }
458  on(events, callback) {
459    this.event.on(events, callback);
460  }
461  play() {
462    const { state } = this;
463    if (state.is(ERROR)) {
464      error("Can not play this video.");
465      return;
466    }
467    this.event.emit("play");
468    if (state.is(INITIALIZING)) {
469      return state.set(PENDING_PLAY);
470    }
471    if (state.is(INITIALIZED)) {
472      this.player = this.createPlayer(this.videoId);
473      return state.set(PENDING_PLAY);
474    }
475    if (state.is([PENDING_PLAY, PLAYING])) {
476      return;
477    }
478    if (state.is(IDLE)) {
479      state.set(LOADING);
480      this.playVideo();
481    }
482  }
483  pause() {
484    const { state } = this;
485    if (state.is(ERROR)) {
486      return;
487    }
488    this.event.emit("pause");
489    if (state.is(PENDING_PLAY)) {
490      return state.set(INITIALIZING);
491    }
492    if (state.is(LOADING)) {
493      return state.set(PLAY_REQUEST_ABORTED);
494    }
495    if (state.is(PLAYING)) {
496      this.pauseVideo();
497      this.state.set(IDLE);
498    }
499  }
500  isPaused() {
501    return !this.state.is(PLAYING);
502  }
503  destroy() {
504    this.event.destroy();
505  }
506  onPlayerReady() {
507    const { state } = this;
508    const isPending = state.is(PENDING_PLAY);
509    state.set(IDLE);
510    if (isPending) {
511      this.play();
512    }
513  }
514  onPlay() {
515    const { state } = this;
516    const aborted = state.is(PLAY_REQUEST_ABORTED);
517    state.set(PLAYING);
518    if (aborted) {
519      this.pause();
520    } else {
521      this.event.emit("played");
522    }
523  }
524  onPause() {
525    this.state.set(IDLE);
526    this.event.emit("paused");
527  }
528  onEnded() {
529    this.state.set(IDLE);
530    this.event.emit("ended");
531  }
532  onError() {
533    this.state.set(ERROR);
534    this.event.emit("error");
535  }
536}
537
538class HTMLVideoPlayer extends AbstractVideoPlayer {
539  constructor(target, videoId, options = {}) {
540    super(target, videoId, options);
541    this.state.set(INITIALIZED);
542  }
543  createPlayer(videoId) {
544    const { options, options: { playerOptions = {} } } = this;
545    const player = create("video", { src: videoId }, this.target);
546    const on = player.addEventListener.bind(player);
547    assign(player, {
548      controls: !options.hideControls,
549      loop: options.loop,
550      volume: clamp(options.volume, 0, 1),
551      muted: options.mute
552    }, playerOptions.htmlVideo || {});
553    on("play", this.onPlay);
554    on("pause", this.onPause);
555    on("ended", this.onEnded);
556    on("loadeddata", this.onPlayerReady);
557    on("error", this.onError);
558    return player;
559  }
560  playVideo() {
561    const promise = this.player.play();
562    promise && promise.catch(this.onError.bind(this));
563  }
564  pauseVideo() {
565    this.player.pause();
566  }
567  onError() {
568    if (this.state.is(PLAY_REQUEST_ABORTED)) {
569      this.state.set(IDLE);
570    } else {
571      super.onError();
572    }
573  }
574  destroy() {
575    super.destroy();
576    const { player } = this;
577    const off = player.addEventListener.bind(player);
578    off("play", this.onPlay);
579    off("pause", this.onPause);
580    off("ended", this.onEnded);
581    off("loadeddata", this.onPlayerReady);
582  }
583}
584
585/*! @vimeo/player v2.17.1 | (c) 2022 Vimeo | MIT License | https://github.com/vimeo/player.js */
586function _classCallCheck(instance, Constructor) {
587  if (!(instance instanceof Constructor)) {
588    throw new TypeError("Cannot call a class as a function");
589  }
590}
591
592function _defineProperties(target, props) {
593  for (var i = 0; i < props.length; i++) {
594    var descriptor = props[i];
595    descriptor.enumerable = descriptor.enumerable || false;
596    descriptor.configurable = true;
597    if ("value" in descriptor) descriptor.writable = true;
598    Object.defineProperty(target, descriptor.key, descriptor);
599  }
600}
601
602function _createClass(Constructor, protoProps, staticProps) {
603  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
604  if (staticProps) _defineProperties(Constructor, staticProps);
605  return Constructor;
606}
607
608/**
609 * @module lib/functions
610 */
611
612/**
613 * Check to see this is a node environment.
614 * @type {Boolean}
615 */
616
617/* global global */
618var isNode = typeof __webpack_require__.g !== 'undefined' && {}.toString.call(__webpack_require__.g) === '[object global]';
619/**
620 * Get the name of the method for a given getter or setter.
621 *
622 * @param {string} prop The name of the property.
623 * @param {string} type Either “get” or “set”.
624 * @return {string}
625 */
626
627function getMethodName(prop, type) {
628  if (prop.indexOf(type.toLowerCase()) === 0) {
629    return prop;
630  }
631
632  return "".concat(type.toLowerCase()).concat(prop.substr(0, 1).toUpperCase()).concat(prop.substr(1));
633}
634/**
635 * Check to see if the object is a DOM Element.
636 *
637 * @param {*} element The object to check.
638 * @return {boolean}
639 */
640
641function isDomElement(element) {
642  return Boolean(element && element.nodeType === 1 && 'nodeName' in element && element.ownerDocument && element.ownerDocument.defaultView);
643}
644/**
645 * Check to see whether the value is a number.
646 *
647 * @see http://dl.dropboxusercontent.com/u/35146/js/tests/isNumber.html
648 * @param {*} value The value to check.
649 * @param {boolean} integer Check if the value is an integer.
650 * @return {boolean}
651 */
652
653function isInteger(value) {
654  // eslint-disable-next-line eqeqeq
655  return !isNaN(parseFloat(value)) && isFinite(value) && Math.floor(value) == value;
656}
657/**
658 * Check to see if the URL is a Vimeo url.
659 *
660 * @param {string} url The url string.
661 * @return {boolean}
662 */
663
664function isVimeoUrl(url) {
665  return /^(https?:)?\/\/((player|www)\.)?vimeo\.com(?=$|\/)/.test(url);
666}
667/**
668 * Check to see if the URL is for a Vimeo embed.
669 *
670 * @param {string} url The url string.
671 * @return {boolean}
672 */
673
674function isVimeoEmbed(url) {
675  var expr = /^https:\/\/player\.vimeo\.com\/video\/\d+/;
676  return expr.test(url);
677}
678/**
679 * Get the Vimeo URL from an element.
680 * The element must have either a data-vimeo-id or data-vimeo-url attribute.
681 *
682 * @param {object} oEmbedParameters The oEmbed parameters.
683 * @return {string}
684 */
685
686function getVimeoUrl() {
687  var oEmbedParameters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
688  var id = oEmbedParameters.id;
689  var url = oEmbedParameters.url;
690  var idOrUrl = id || url;
691
692  if (!idOrUrl) {
693    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.');
694  }
695
696  if (isInteger(idOrUrl)) {
697    return "https://vimeo.com/".concat(idOrUrl);
698  }
699
700  if (isVimeoUrl(idOrUrl)) {
701    return idOrUrl.replace('http:', 'https:');
702  }
703
704  if (id) {
705    throw new TypeError("\u201C".concat(id, "\u201D is not a valid video id."));
706  }
707
708  throw new TypeError("\u201C".concat(idOrUrl, "\u201D is not a vimeo.com url."));
709}
710
711var arrayIndexOfSupport = typeof Array.prototype.indexOf !== 'undefined';
712var postMessageSupport = typeof window !== 'undefined' && typeof window.postMessage !== 'undefined';
713
714if (!isNode && (!arrayIndexOfSupport || !postMessageSupport)) {
715  throw new Error('Sorry, the Vimeo Player API is not available in this browser.');
716}
717
718var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof __webpack_require__.g !== 'undefined' ? __webpack_require__.g : typeof self !== 'undefined' ? self : {};
719
720function createCommonjsModule(fn, module) {
721	return module = { exports: {} }, fn(module, module.exports), module.exports;
722}
723
724/*!
725 * weakmap-polyfill v2.0.4 - ECMAScript6 WeakMap polyfill
726 * https://github.com/polygonplanet/weakmap-polyfill
727 * Copyright (c) 2015-2021 polygonplanet <[email protected]>
728 * @license MIT
729 */
730(function (self) {
731
732  if (self.WeakMap) {
733    return;
734  }
735
736  var hasOwnProperty = Object.prototype.hasOwnProperty;
737
738  var hasDefine = Object.defineProperty && function () {
739    try {
740      // Avoid IE8's broken Object.defineProperty
741      return Object.defineProperty({}, 'x', {
742        value: 1
743      }).x === 1;
744    } catch (e) {}
745  }();
746
747  var defineProperty = function (object, name, value) {
748    if (hasDefine) {
749      Object.defineProperty(object, name, {
750        configurable: true,
751        writable: true,
752        value: value
753      });
754    } else {
755      object[name] = value;
756    }
757  };
758
759  self.WeakMap = function () {
760    // ECMA-262 23.3 WeakMap Objects
761    function WeakMap() {
762      if (this === void 0) {
763        throw new TypeError("Constructor WeakMap requires 'new'");
764      }
765
766      defineProperty(this, '_id', genId('_WeakMap')); // ECMA-262 23.3.1.1 WeakMap([iterable])
767
768      if (arguments.length > 0) {
769        // Currently, WeakMap `iterable` argument is not supported
770        throw new TypeError('WeakMap iterable is not supported');
771      }
772    } // ECMA-262 23.3.3.2 WeakMap.prototype.delete(key)
773
774
775    defineProperty(WeakMap.prototype, 'delete', function (key) {
776      checkInstance(this, 'delete');
777
778      if (!isObject(key)) {
779        return false;
780      }
781
782      var entry = key[this._id];
783
784      if (entry && entry[0] === key) {
785        delete key[this._id];
786        return true;
787      }
788
789      return false;
790    }); // ECMA-262 23.3.3.3 WeakMap.prototype.get(key)
791
792    defineProperty(WeakMap.prototype, 'get', function (key) {
793      checkInstance(this, 'get');
794
795      if (!isObject(key)) {
796        return void 0;
797      }
798
799      var entry = key[this._id];
800
801      if (entry && entry[0] === key) {
802        return entry[1];
803      }
804
805      return void 0;
806    }); // ECMA-262 23.3.3.4 WeakMap.prototype.has(key)
807
808    defineProperty(WeakMap.prototype, 'has', function (key) {
809      checkInstance(this, 'has');
810
811      if (!isObject(key)) {
812        return false;
813      }
814
815      var entry = key[this._id];
816
817      if (entry && entry[0] === key) {
818        return true;
819      }
820
821      return false;
822    }); // ECMA-262 23.3.3.5 WeakMap.prototype.set(key, value)
823
824    defineProperty(WeakMap.prototype, 'set', function (key, value) {
825      checkInstance(this, 'set');
826
827      if (!isObject(key)) {
828        throw new TypeError('Invalid value used as weak map key');
829      }
830
831      var entry = key[this._id];
832
833      if (entry && entry[0] === key) {
834        entry[1] = value;
835        return this;
836      }
837
838      defineProperty(key, this._id, [key, value]);
839      return this;
840    });
841
842    function checkInstance(x, methodName) {
843      if (!isObject(x) || !hasOwnProperty.call(x, '_id')) {
844        throw new TypeError(methodName + ' method called on incompatible receiver ' + typeof x);
845      }
846    }
847
848    function genId(prefix) {
849      return prefix + '_' + rand() + '.' + rand();
850    }
851
852    function rand() {
853      return Math.random().toString().substring(2);
854    }
855
856    defineProperty(WeakMap, '_polyfill', true);
857    return WeakMap;
858  }();
859
860  function isObject(x) {
861    return Object(x) === x;
862  }
863})(typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : commonjsGlobal);
864
865var npo_src = createCommonjsModule(function (module) {
866/*! Native Promise Only
867    v0.8.1 (c) Kyle Simpson
868    MIT License: http://getify.mit-license.org
869*/
870(function UMD(name, context, definition) {
871  // special form of UMD for polyfilling across evironments
872  context[name] = context[name] || definition();
873
874  if ( module.exports) {
875    module.exports = context[name];
876  }
877})("Promise", typeof commonjsGlobal != "undefined" ? commonjsGlobal : commonjsGlobal, function DEF() {
878
879  var builtInProp,
880      cycle,
881      scheduling_queue,
882      ToString = Object.prototype.toString,
883      timer = typeof setImmediate != "undefined" ? function timer(fn) {
884    return setImmediate(fn);
885  } : setTimeout; // dammit, IE8.
886
887  try {
888    Object.defineProperty({}, "x", {});
889
890    builtInProp = function builtInProp(obj, name, val, config) {
891      return Object.defineProperty(obj, name, {
892        value: val,
893        writable: true,
894        configurable: config !== false
895      });
896    };
897  } catch (err) {
898    builtInProp = function builtInProp(obj, name, val) {
899      obj[name] = val;
900      return obj;
901    };
902  } // Note: using a queue instead of array for efficiency
903
904
905  scheduling_queue = function Queue() {
906    var first, last, item;
907
908    function Item(fn, self) {
909      this.fn = fn;
910      this.self = self;
911      this.next = void 0;
912    }
913
914    return {
915      add: function add(fn, self) {
916        item = new Item(fn, self);
917
918        if (last) {
919          last.next = item;
920        } else {
921          first = item;
922        }
923
924        last = item;
925        item = void 0;
926      },
927      drain: function drain() {
928        var f = first;
929        first = last = cycle = void 0;
930
931        while (f) {
932          f.fn.call(f.self);
933          f = f.next;
934        }
935      }
936    };
937  }();
938
939  function schedule(fn, self) {
940    scheduling_queue.add(fn, self);
941
942    if (!cycle) {
943      cycle = timer(scheduling_queue.drain);
944    }
945  } // promise duck typing
946
947
948  function isThenable(o) {
949    var _then,
950        o_type = typeof o;
951
952    if (o != null && (o_type == "object" || o_type == "function")) {
953      _then = o.then;
954    }
955
956    return typeof _then == "function" ? _then : false;
957  }
958
959  function notify() {
960    for (var i = 0; i < this.chain.length; i++) {
961      notifyIsolated(this, this.state === 1 ? this.chain[i].success : this.chain[i].failure, this.chain[i]);
962    }
963
964    this.chain.length = 0;
965  } // NOTE: This is a separate function to isolate
966  // the `try..catch` so that other code can be
967  // optimized better
968
969
970  function notifyIsolated(self, cb, chain) {
971    var ret, _then;
972
973    try {
974      if (cb === false) {
975        chain.reject(self.msg);
976      } else {
977        if (cb === true) {
978          ret = self.msg;
979        } else {
980          ret = cb.call(void 0, self.msg);
981        }
982
983        if (ret === chain.promise) {
984          chain.reject(TypeError("Promise-chain cycle"));
985        } else if (_then = isThenable(ret)) {
986          _then.call(ret, chain.resolve, chain.reject);
987        } else {
988          chain.resolve(ret);
989        }
990      }
991    } catch (err) {
992      chain.reject(err);
993    }
994  }
995
996  function resolve(msg) {
997    var _then,
998        self = this; // already triggered?
999
1000
1001    if (self.triggered) {
1002      return;
1003    }
1004
1005    self.triggered = true; // unwrap
1006
1007    if (self.def) {
1008      self = self.def;
1009    }
1010
1011    try {
1012      if (_then = isThenable(msg)) {
1013        schedule(function () {
1014          var def_wrapper = new MakeDefWrapper(self);
1015
1016          try {
1017            _then.call(msg, function $resolve$() {
1018              resolve.apply(def_wrapper, arguments);
1019            }, function $reject$() {
1020              reject.apply(def_wrapper, arguments);
1021            });
1022          } catch (err) {
1023            reject.call(def_wrapper, err);
1024          }
1025        });
1026      } else {
1027        self.msg = msg;
1028        self.state = 1;
1029
1030        if (self.chain.length > 0) {
1031          schedule(notify, self);
1032        }
1033      }
1034    } catch (err) {
1035      reject.call(new MakeDefWrapper(self), err);
1036    }
1037  }
1038
1039  function reject(msg) {
1040    var self = this; // already triggered?
1041
1042    if (self.triggered) {
1043      return;
1044    }
1045
1046    self.triggered = true; // unwrap
1047
1048    if (self.def) {
1049      self = self.def;
1050    }
1051
1052    self.msg = msg;
1053    self.state = 2;
1054
1055    if (self.chain.length > 0) {
1056      schedule(notify, self);
1057    }
1058  }
1059
1060  function iteratePromises(Constructor, arr, resolver, rejecter) {
1061    for (var idx = 0; idx < arr.length; idx++) {
1062      (function IIFE(idx) {
1063        Constructor.resolve(arr[idx]).then(function $resolver$(msg) {
1064          resolver(idx, msg);
1065        }, rejecter);
1066      })(idx);
1067    }
1068  }
1069
1070  function MakeDefWrapper(self) {
1071    this.def = self;
1072    this.triggered = false;
1073  }
1074
1075  function MakeDef(self) {
1076    this.promise = self;
1077    this.state = 0;
1078    this.triggered = false;
1079    this.chain = [];
1080    this.msg = void 0;
1081  }
1082
1083  function Promise(executor) {
1084    if (typeof executor != "function") {
1085      throw TypeError("Not a function");
1086    }
1087
1088    if (this.__NPO__ !== 0) {
1089      throw TypeError("Not a promise");
1090    } // instance shadowing the inherited "brand"
1091    // to signal an already "initialized" promise
1092
1093
1094    this.__NPO__ = 1;
1095    var def = new MakeDef(this);
1096
1097    this["then"] = function then(success, failure) {
1098      var o = {
1099        success: typeof success == "function" ? success : true,
1100        failure: typeof failure == "function" ? failure : false
1101      }; // Note: `then(..)` itself can be borrowed to be used against
1102      // a different promise constructor for making the chained promise,
1103      // by substituting a different `this` binding.
1104
1105      o.promise = new this.constructor(function extractChain(resolve, reject) {
1106        if (typeof resolve != "function" || typeof reject != "function") {
1107          throw TypeError("Not a function");
1108        }
1109
1110        o.resolve = resolve;
1111        o.reject = reject;
1112      });
1113      def.chain.push(o);
1114
1115      if (def.state !== 0) {
1116        schedule(notify, def);
1117      }
1118
1119      return o.promise;
1120    };
1121
1122    this["catch"] = function $catch$(failure) {
1123      return this.then(void 0, failure);
1124    };
1125
1126    try {
1127      executor.call(void 0, function publicResolve(msg) {
1128        resolve.call(def, msg);
1129      }, function publicReject(msg) {
1130        reject.call(def, msg);
1131      });
1132    } catch (err) {
1133      reject.call(def, err);
1134    }
1135  }
1136
1137  var PromisePrototype = builtInProp({}, "constructor", Promise,
1138  /*configurable=*/
1139  false); // Note: Android 4 cannot use `Object.defineProperty(..)` here
1140
1141  Promise.prototype = PromisePrototype; // built-in "brand" to signal an "uninitialized" promise
1142
1143  builtInProp(PromisePrototype, "__NPO__", 0,
1144  /*configurable=*/
1145  false);
1146  builtInProp(Promise, "resolve", function Promise$resolve(msg) {
1147    var Constructor = this; // spec mandated checks
1148    // note: best "isPromise" check that's practical for now
1149
1150    if (msg && typeof msg == "object" && msg.__NPO__ === 1) {
1151      return msg;
1152    }
1153
1154    return new Constructor(function executor(resolve, reject) {
1155      if (typeof resolve != "function" || typeof reject != "function") {
1156        throw TypeError("Not a function");
1157      }
1158
1159      resolve(msg);
1160    });
1161  });
1162  builtInProp(Promise, "reject", function Promise$reject(msg) {
1163    return new this(function executor(resolve, reject) {
1164      if (typeof resolve != "function" || typeof reject != "function") {
1165        throw TypeError("Not a function");
1166      }
1167
1168      reject(msg);
1169    });
1170  });
1171  builtInProp(Promise, "all", function Promise$all(arr) {
1172    var Constructor = this; // spec mandated checks
1173
1174    if (ToString.call(arr) != "[object Array]") {
1175      return Constructor.reject(TypeError("Not an array"));
1176    }
1177
1178    if (arr.length === 0) {
1179      return Constructor.resolve([]);
1180    }
1181
1182    return new Constructor(function executor(resolve, reject) {
1183      if (typeof resolve != "function" || typeof reject != "function") {
1184        throw TypeError("Not a function");
1185      }
1186
1187      var len = arr.length,
1188          msgs = Array(len),
1189          count = 0;
1190      iteratePromises(Constructor, arr, function resolver(idx, msg) {
1191        msgs[idx] = msg;
1192
1193        if (++count === len) {
1194          resolve(msgs);
1195        }
1196      }, reject);
1197    });
1198  });
1199  builtInProp(Promise, "race", function Promise$race(arr) {
1200    var Constructor = this; // spec mandated checks
1201
1202    if (ToString.call(arr) != "[object Array]") {
1203      return Constructor.reject(TypeError("Not an array"));
1204    }
1205
1206    return new Constructor(function executor(resolve, reject) {
1207      if (typeof resolve != "function" || typeof reject != "function") {
1208        throw TypeError("Not a function");
1209      }
1210
1211      iteratePromises(Constructor, arr, function resolver(idx, msg) {
1212        resolve(msg);
1213      }, reject);
1214    });
1215  });
1216  return Promise;
1217});
1218});
1219
1220/**
1221 * @module lib/callbacks
1222 */
1223var callbackMap = new WeakMap();
1224/**
1225 * Store a callback for a method or event for a player.
1226 *
1227 * @param {Player} player The player object.
1228 * @param {string} name The method or event name.
1229 * @param {(function(this:Player, *): void|{resolve: function, reject: function})} callback
1230 *        The callback to call or an object with resolve and reject functions for a promise.
1231 * @return {void}
1232 */
1233
1234function storeCallback(player, name, callback) {
1235  var playerCallbacks = callbackMap.get(player.element) || {};
1236
1237  if (!(name in playerCallbacks)) {
1238    playerCallbacks[name] = [];
1239  }
1240
1241  playerCallbacks[name].push(callback);
1242  callbackMap.set(player.element, playerCallbacks);
1243}
1244/**
1245 * Get the callbacks for a player and event or method.
1246 *
1247 * @param {Player} player The player object.
1248 * @param {string} name The method or event name
1249 * @return {function[]}
1250 */
1251
1252function getCallbacks(player, name) {
1253  var playerCallbacks = callbackMap.get(player.element) || {};
1254  return playerCallbacks[name] || [];
1255}
1256/**
1257 * Remove a stored callback for a method or event for a player.
1258 *
1259 * @param {Player} player The player object.
1260 * @param {string} name The method or event name
1261 * @param {function} [callback] The specific callback to remove.
1262 * @return {boolean} Was this the last callback?
1263 */
1264
1265function removeCallback(player, name, callback) {
1266  var playerCallbacks = callbackMap.get(player.element) || {};
1267
1268  if (!playerCallbacks[name]) {
1269    return true;
1270  } // If no callback is passed, remove all callbacks for the event
1271
1272
1273  if (!callback) {
1274    playerCallbacks[name] = [];
1275    callbackMap.set(player.element, playerCallbacks);
1276    return true;
1277  }
1278
1279  var index = playerCallbacks[name].indexOf(callback);
1280
1281  if (index !== -1) {
1282    playerCallbacks[name].splice(index, 1);
1283  }
1284
1285  callbackMap.set(player.element, playerCallbacks);
1286  return playerCallbacks[name] && playerCallbacks[name].length === 0;
1287}
1288/**
1289 * Return the first stored callback for a player and event or method.
1290 *
1291 * @param {Player} player The player object.
1292 * @param {string} name The method or event name.
1293 * @return {function} The callback, or false if there were none
1294 */
1295
1296function shiftCallbacks(player, name) {
1297  var playerCallbacks = getCallbacks(player, name);
1298
1299  if (playerCallbacks.length < 1) {
1300    return false;
1301  }
1302
1303  var callback = playerCallbacks.shift();
1304  removeCallback(player, name, callback);
1305  return callback;
1306}
1307/**
1308 * Move callbacks associated with an element to another element.
1309 *
1310 * @param {HTMLElement} oldElement The old element.
1311 * @param {HTMLElement} newElement The new element.
1312 * @return {void}
1313 */
1314
1315function swapCallbacks(oldElement, newElement) {
1316  var playerCallbacks = callbackMap.get(oldElement);
1317  callbackMap.set(newElement, playerCallbacks);
1318  callbackMap.delete(oldElement);
1319}
1320
1321/**
1322 * @module lib/postmessage
1323 */
1324/**
1325 * Parse a message received from postMessage.
1326 *
1327 * @param {*} data The data received from postMessage.
1328 * @return {object}
1329 */
1330
1331function parseMessageData(data) {
1332  if (typeof data === 'string') {
1333    try {
1334      data = JSON.parse(data);
1335    } catch (error) {
1336      // If the message cannot be parsed, throw the error as a warning
1337      console.warn(error);
1338      return {};
1339    }
1340  }
1341
1342  return data;
1343}
1344/**
1345 * Post a message to the specified target.
1346 *
1347 * @param {Player} player The player object to use.
1348 * @param {string} method The API method to call.
1349 * @param {object} params The parameters to send to the player.
1350 * @return {void}
1351 */
1352
1353function postMessage(player, method, params) {
1354  if (!player.element.contentWindow || !player.element.contentWindow.postMessage) {
1355    return;
1356  }
1357
1358  var message = {
1359    method: method
1360  };
1361
1362  if (params !== undefined) {
1363    message.value = params;
1364  } // IE 8 and 9 do not support passing messages, so stringify them
1365
1366
1367  var ieVersion = parseFloat(navigator.userAgent.toLowerCase().replace(/^.*msie (\d+).*$/, '$1'));
1368
1369  if (ieVersion >= 8 && ieVersion < 10) {
1370    message = JSON.stringify(message);
1371  }
1372
1373  player.element.contentWindow.postMessage(message, player.origin);
1374}
1375/**
1376 * Parse the data received from a message event.
1377 *
1378 * @param {Player} player The player that received the message.
1379 * @param {(Object|string)} data The message data. Strings will be parsed into JSON.
1380 * @return {void}
1381 */
1382
1383function processData(player, data) {
1384  data = parseMessageData(data);
1385  var callbacks = [];
1386  var param;
1387
1388  if (data.event) {
1389    if (data.event === 'error') {
1390      var promises = getCallbacks(player, data.data.method);
1391      promises.forEach(function (promise) {
1392        var error = new Error(data.data.message);
1393        error.name = data.data.name;
1394        promise.reject(error);
1395        removeCallback(player, data.data.method, promise);
1396      });
1397    }
1398
1399    callbacks = getCallbacks(player, "event:".concat(data.event));
1400    param = data.data;
1401  } else if (data.method) {
1402    var callback = shiftCallbacks(player, data.method);
1403
1404    if (callback) {
1405      callbacks.push(callback);
1406      param = data.value;
1407    }
1408  }
1409
1410  callbacks.forEach(function (callback) {
1411    try {
1412      if (typeof callback === 'function') {
1413        callback.call(player, param);
1414        return;
1415      }
1416
1417      callback.resolve(param);
1418    } catch (e) {// empty
1419    }
1420  });
1421}
1422
1423/**
1424 * @module lib/embed
1425 */
1426var oEmbedParameters = ['autopause', 'autoplay', 'background', 'byline', 'color', 'controls', 'dnt', 'height', 'id', 'interactive_params', 'keyboard', 'loop', 'maxheight', 'maxwidth', 'muted', 'playsinline', 'portrait', 'responsive', 'speed', 'texttrack', 'title', 'transparent', 'url', 'width'];
1427/**
1428 * Get the 'data-vimeo'-prefixed attributes from an element as an object.
1429 *
1430 * @param {HTMLElement} element The element.
1431 * @param {Object} [defaults={}] The default values to use.
1432 * @return {Object<string, string>}
1433 */
1434
1435function getOEmbedParameters(element) {
1436  var defaults = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1437  return oEmbedParameters.reduce(function (params, param) {
1438    var value = element.getAttribute("data-vimeo-".concat(param));
1439
1440    if (value || value === '') {
1441      params[param] = value === '' ? 1 : value;
1442    }
1443
1444    return params;
1445  }, defaults);
1446}
1447/**
1448 * Create an embed from oEmbed data inside an element.
1449 *
1450 * @param {object} data The oEmbed data.
1451 * @param {HTMLElement} element The element to put the iframe in.
1452 * @return {HTMLIFrameElement} The iframe embed.
1453 */
1454
1455function createEmbed(_ref, element) {
1456  var html = _ref.html;
1457
1458  if (!element) {
1459    throw new TypeError('An element must be provided');
1460  }
1461
1462  if (element.getAttribute('data-vimeo-initialized') !== null) {
1463    return element.querySelector('iframe');
1464  }
1465
1466  var div = document.createElement('div');
1467  div.innerHTML = html;
1468  element.appendChild(div.firstChild);
1469  element.setAttribute('data-vimeo-initialized', 'true');
1470  return element.querySelector('iframe');
1471}
1472/**
1473 * Make an oEmbed call for the specified URL.
1474 *
1475 * @param {string} videoUrl The vimeo.com url for the video.
1476 * @param {Object} [params] Parameters to pass to oEmbed.
1477 * @param {HTMLElement} element The element.
1478 * @return {Promise}
1479 */
1480
1481function getOEmbedData(videoUrl) {
1482  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1483  var element = arguments.length > 2 ? arguments[2] : undefined;
1484  return new Promise(function (resolve, reject) {
1485    if (!isVimeoUrl(videoUrl)) {
1486      throw new TypeError("\u201C".concat(videoUrl, "\u201D is not a vimeo.com url."));
1487    }
1488
1489    var url = "https://vimeo.com/api/oembed.json?url=".concat(encodeURIComponent(videoUrl));
1490
1491    for (var param in params) {
1492      if (params.hasOwnProperty(param)) {
1493        url += "&".concat(param, "=").concat(encodeURIComponent(params[param]));
1494      }
1495    }
1496
1497    var xhr = 'XDomainRequest' in window ? new XDomainRequest() : new XMLHttpRequest();
1498    xhr.open('GET', url, true);
1499
1500    xhr.onload = function () {
1501      if (xhr.status === 404) {
1502        reject(new Error("\u201C".concat(videoUrl, "\u201D was not found.")));
1503        return;
1504      }
1505
1506      if (xhr.status === 403) {
1507        reject(new Error("\u201C".concat(videoUrl, "\u201D is not embeddable.")));
1508        return;
1509      }
1510
1511      try {
1512        var json = JSON.parse(xhr.responseText); // Check api response for 403 on oembed
1513
1514        if (json.domain_status_code === 403) {
1515          // We still want to create the embed to give users visual feedback
1516          createEmbed(json, element);
1517          reject(new Error("\u201C".concat(videoUrl, "\u201D is not embeddable.")));
1518          return;
1519        }
1520
1521        resolve(json);
1522      } catch (error) {
1523        reject(error);
1524      }
1525    };
1526
1527    xhr.onerror = function () {
1528      var status = xhr.status ? " (".concat(xhr.status, ")") : '';
1529      reject(new Error("There was an error fetching the embed code from Vimeo".concat(status, ".")));
1530    };
1531
1532    xhr.send();
1533  });
1534}
1535/**
1536 * Initialize all embeds within a specific element
1537 *
1538 * @param {HTMLElement} [parent=document] The parent element.
1539 * @return {void}
1540 */
1541
1542function initializeEmbeds() {
1543  var parent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
1544  var elements = [].slice.call(parent.querySelectorAll('[data-vimeo-id], [data-vimeo-url]'));
1545
1546  var handleError = function handleError(error) {
1547    if ('console' in window && console.error) {
1548      console.error("There was an error creating an embed: ".concat(error));
1549    }
1550  };
1551
1552  elements.forEach(function (element) {
1553    try {
1554      // Skip any that have data-vimeo-defer
1555      if (element.getAttribute('data-vimeo-defer') !== null) {
1556        return;
1557      }
1558
1559      var params = getOEmbedParameters(element);
1560      var url = getVimeoUrl(params);
1561      getOEmbedData(url, params, element).then(function (data) {
1562        return createEmbed(data, element);
1563      }).catch(handleError);
1564    } catch (error) {
1565      handleError(error);
1566    }
1567  });
1568}
1569/**
1570 * Resize embeds when messaged by the player.
1571 *
1572 * @param {HTMLElement} [parent=document] The parent element.
1573 * @return {void}
1574 */
1575
1576function resizeEmbeds() {
1577  var parent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
1578
1579  // Prevent execution if users include the player.js script multiple times.
1580  if (window.VimeoPlayerResizeEmbeds_) {
1581    return;
1582  }
1583
1584  window.VimeoPlayerResizeEmbeds_ = true;
1585
1586  var onMessage = function onMessage(event) {
1587    if (!isVimeoUrl(event.origin)) {
1588      return;
1589    } // 'spacechange' is fired only on embeds with cards
1590
1591
1592    if (!event.data || event.data.event !== 'spacechange') {
1593      return;
1594    }
1595
1596    var iframes = parent.querySelectorAll('iframe');
1597
1598    for (var i = 0; i < iframes.length; i++) {
1599      if (iframes[i].contentWindow !== event.source) {
1600        continue;
1601      } // Change padding-bottom of the enclosing div to accommodate
1602      // card carousel without distorting aspect ratio
1603
1604
1605      var space = iframes[i].parentElement;
1606      space.style.paddingBottom = "".concat(event.data.data[0].bottom, "px");
1607      break;
1608    }
1609  };
1610
1611  window.addEventListener('message', onMessage);
1612}
1613/**
1614 * Add chapters to existing metadata for Google SEO
1615 *
1616 * @param {HTMLElement} [parent=document] The parent element.
1617 * @return {void}
1618 */
1619
1620function initAppendVideoMetadata() {
1621  var parent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
1622
1623  //  Prevent execution if users include the player.js script multiple times.
1624  if (window.VimeoSeoMetadataAppended) {
1625    return;
1626  }
1627
1628  window.VimeoSeoMetadataAppended = true;
1629
1630  var onMessage = function onMessage(event) {
1631    if (!isVimeoUrl(event.origin)) {
1632      return;
1633    }
1634
1635    var data = parseMessageData(event.data);
1636
1637    if (!data || data.event !== 'ready') {
1638      return;
1639    }
1640
1641    var iframes = parent.querySelectorAll('iframe');
1642
1643    for (var i = 0; i < iframes.length; i++) {
1644      var iframe = iframes[i]; // Initiate appendVideoMetadata if iframe is a Vimeo embed
1645
1646      var isValidMessageSource = iframe.contentWindow === event.source;
1647
1648      if (isVimeoEmbed(iframe.src) && isValidMessageSource) {
1649        var player = new Player$1(iframe);
1650        player.callMethod('appendVideoMetadata', window.location.href);
1651      }
1652    }
1653  };
1654
1655  window.addEventListener('message', onMessage);
1656}
1657
1658/* MIT License
1659
1660Copyright (c) Sindre Sorhus <[email protected]> (sindresorhus.com)
1661
1662Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
1663
1664The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
1665
1666THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
1667Terms */
1668function initializeScreenfull() {
1669  var fn = function () {
1670    var val;
1671    var fnMap = [['requestFullscreen', 'exitFullscreen', 'fullscreenElement', 'fullscreenEnabled', 'fullscreenchange', 'fullscreenerror'], // New WebKit
1672    ['webkitRequestFullscreen', 'webkitExitFullscreen', 'webkitFullscreenElement', 'webkitFullscreenEnabled', 'webkitfullscreenchange', 'webkitfullscreenerror'], // Old WebKit
1673    ['webkitRequestFullScreen', 'webkitCancelFullScreen', 'webkitCurrentFullScreenElement', 'webkitCancelFullScreen', 'webkitfullscreenchange', 'webkitfullscreenerror'], ['mozRequestFullScreen', 'mozCancelFullScreen', 'mozFullScreenElement', 'mozFullScreenEnabled', 'mozfullscreenchange', 'mozfullscreenerror'], ['msRequestFullscreen', 'msExitFullscreen', 'msFullscreenElement', 'msFullscreenEnabled', 'MSFullscreenChange', 'MSFullscreenError']];
1674    var i = 0;
1675    var l = fnMap.length;
1676    var ret = {};
1677
1678    for (; i < l; i++) {
1679      val = fnMap[i];
1680
1681      if (val && val[1] in document) {
1682        for (i = 0; i < val.length; i++) {
1683          ret[fnMap[0][i]] = val[i];
1684        }
1685
1686        return ret;
1687      }
1688    }
1689
1690    return false;
1691  }();
1692
1693  var eventNameMap = {
1694    fullscreenchange: fn.fullscreenchange,
1695    fullscreenerror: fn.fullscreenerror
1696  };
1697  var screenfull = {
1698    request: function request(element) {
1699      return new Promise(function (resolve, reject) {
1700        var onFullScreenEntered = function onFullScreenEntered() {
1701          screenfull.off('fullscreenchange', onFullScreenEntered);
1702          resolve();
1703        };
1704
1705        screenfull.on('fullscreenchange', onFullScreenEntered);
1706        element = element || document.documentElement;
1707        var returnPromise = element[fn.requestFullscreen]();
1708
1709        if (returnPromise instanceof Promise) {
1710          returnPromise.then(onFullScreenEntered).catch(reject);
1711        }
1712      });
1713    },
1714    exit: function exit() {
1715      return new Promise(function (resolve, reject) {
1716        if (!screenfull.isFullscreen) {
1717          resolve();
1718          return;
1719        }
1720
1721        var onFullScreenExit = function onFullScreenExit() {
1722          screenfull.off('fullscreenchange', onFullScreenExit);
1723          resolve();
1724        };
1725
1726        screenfull.on('fullscreenchange', onFullScreenExit);
1727        var returnPromise = document[fn.exitFullscreen]();
1728
1729        if (returnPromise instanceof Promise) {
1730          returnPromise.then(onFullScreenExit).catch(reject);
1731        }
1732      });
1733    },
1734    on: function on(event, callback) {
1735      var eventName = eventNameMap[event];
1736
1737      if (eventName) {
1738        document.addEventListener(eventName, callback);
1739      }
1740    },
1741    off: function off(event, callback) {
1742      var eventName = eventNameMap[event];
1743
1744      if (eventName) {
1745        document.removeEventListener(eventName, callback);
1746      }
1747    }
1748  };
1749  Object.defineProperties(screenfull, {
1750    isFullscreen: {
1751      get: function get() {
1752        return Boolean(document[fn.fullscreenElement]);
1753      }
1754    },
1755    element: {
1756      enumerable: true,
1757      get: function get() {
1758        return document[fn.fullscreenElement];
1759      }
1760    },
1761    isEnabled: {
1762      enumerable: true,
1763      get: function get() {
1764        // Coerce to boolean in case of old WebKit
1765        return Boolean(document[fn.fullscreenEnabled]);
1766      }
1767    }
1768  });
1769  return screenfull;
1770}
1771
1772var playerMap = new WeakMap();
1773var readyMap = new WeakMap();
1774var screenfull = {};
1775
1776var Player$1 = /*#__PURE__*/function () {
1777  /**
1778   * Create a Player.
1779   *
1780   * @param {(HTMLIFrameElement|HTMLElement|string|jQuery)} element A reference to the Vimeo
1781   *        player iframe, and id, or a jQuery object.
1782   * @param {object} [options] oEmbed parameters to use when creating an embed in the element.
1783   * @return {Player}
1784   */
1785  function Player(element) {
1786    var _this = this;
1787
1788    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1789
1790    _classCallCheck(this, Player);
1791
1792    /* global jQuery */
1793    if (window.jQuery && element instanceof jQuery) {
1794      if (element.length > 1 && window.console && console.warn) {
1795        console.warn('A jQuery object with multiple elements was passed, using the first element.');
1796      }
1797
1798      element = element[0];
1799    } // Find an element by ID
1800
1801
1802    if (typeof document !== 'undefined' && typeof element === 'string') {
1803      element = document.getElementById(element);
1804    } // Not an element!
1805
1806
1807    if (!isDomElement(element)) {
1808      throw new TypeError('You must pass either a valid element or a valid id.');
1809    } // Already initialized an embed in this div, so grab the iframe
1810
1811
1812    if (element.nodeName !== 'IFRAME') {
1813      var iframe = element.querySelector('iframe');
1814
1815      if (iframe) {
1816        element = iframe;
1817      }
1818    } // iframe url is not a Vimeo url
1819
1820
1821    if (element.nodeName === 'IFRAME' && !isVimeoUrl(element.getAttribute('src') || '')) {
1822      throw new Error('The player element passed isn’t a Vimeo embed.');
1823    } // If there is already a player object in the map, return that
1824
1825
1826    if (playerMap.has(element)) {
1827      return playerMap.get(element);
1828    }
1829
1830    this._window = element.ownerDocument.defaultView;
1831    this.element = element;
1832    this.origin = '*';
1833    var readyPromise = new npo_src(function (resolve, reject) {
1834      _this._onMessage = function (event) {
1835        if (!isVimeoUrl(event.origin) || _this.element.contentWindow !== event.source) {
1836          return;
1837        }
1838
1839        if (_this.origin === '*') {
1840          _this.origin = event.origin;
1841        }
1842
1843        var data = parseMessageData(event.data);
1844        var isError = data && data.event === 'error';
1845        var isReadyError = isError && data.data && data.data.method === 'ready';
1846
1847        if (isReadyError) {
1848          var error = new Error(data.data.message);
1849          error.name = data.data.name;
1850          reject(error);
1851          return;
1852        }
1853
1854        var isReadyEvent = data && data.event === 'ready';
1855        var isPingResponse = data && data.method === 'ping';
1856
1857        if (isReadyEvent || isPingResponse) {
1858          _this.element.setAttribute('data-ready', 'true');
1859
1860          resolve();
1861          return;
1862        }
1863
1864        processData(_this, data);
1865      };
1866
1867      _this._window.addEventListener('message', _this._onMessage);
1868
1869      if (_this.element.nodeName !== 'IFRAME') {
1870        var params = getOEmbedParameters(element, options);
1871        var url = getVimeoUrl(params);
1872        getOEmbedData(url, params, element).then(function (data) {
1873          var iframe = createEmbed(data, element); // Overwrite element with the new iframe,
1874          // but store reference to the original element
1875
1876          _this.element = iframe;
1877          _this._originalElement = element;
1878          swapCallbacks(element, iframe);
1879          playerMap.set(_this.element, _this);
1880          return data;
1881        }).catch(reject);
1882      }
1883    }); // Store a copy of this Player in the map
1884
1885    readyMap.set(this, readyPromise);
1886    playerMap.set(this.element, this); // Send a ping to the iframe so the ready promise will be resolved if
1887    // the player is already ready.
1888
1889    if (this.element.nodeName === 'IFRAME') {
1890      postMessage(this, 'ping');
1891    }
1892
1893    if (screenfull.isEnabled) {
1894      var exitFullscreen = function exitFullscreen() {
1895        return screenfull.exit();
1896      };
1897
1898      this.fullscreenchangeHandler = function () {
1899        if (screenfull.isFullscreen) {
1900          storeCallback(_this, 'event:exitFullscreen', exitFullscreen);
1901        } else {
1902          removeCallback(_this, 'event:exitFullscreen', exitFullscreen);
1903        } // eslint-disable-next-line
1904
1905
1906        _this.ready().then(function () {
1907          postMessage(_this, 'fullscreenchange', screenfull.isFullscreen);
1908        });
1909      };
1910
1911      screenfull.on('fullscreenchange', this.fullscreenchangeHandler);
1912    }
1913
1914    return this;
1915  }
1916  /**
1917   * Get a promise for a method.
1918   *
1919   * @param {string} name The API method to call.
1920   * @param {Object} [args={}] Arguments to send via postMessage.
1921   * @return {Promise}
1922   */
1923
1924
1925  _createClass(Player, [{
1926    key: "callMethod",
1927    value: function callMethod(name) {
1928      var _this2 = this;
1929
1930      var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
1931      return new npo_src(function (resolve, reject) {
1932        // We are storing the resolve/reject handlers to call later, so we
1933        // can’t return here.
1934        // eslint-disable-next-line promise/always-return
1935        return _this2.ready().then(function () {
1936          storeCallback(_this2, name, {
1937            resolve: resolve,
1938            reject: reject
1939          });
1940          postMessage(_this2, name, args);
1941        }).catch(reject);
1942      });
1943    }
1944    /**
1945     * Get a promise for the value of a player property.
1946     *
1947     * @param {string} name The property name
1948     * @return {Promise}
1949     */
1950
1951  }, {
1952    key: "get",
1953    value: function get(name) {
1954      var _this3 = this;
1955
1956      return new npo_src(function (resolve, reject) {
1957        name = getMethodName(name, 'get'); // We are storing the resolve/reject handlers to call later, so we
1958        // can’t return here.
1959        // eslint-disable-next-line promise/always-return
1960
1961        return _this3.ready().then(function () {
1962          storeCallback(_this3, name, {
1963            resolve: resolve,
1964            reject: reject
1965          });
1966          postMessage(_this3, name);
1967        }).catch(reject);
1968      });
1969    }
1970    /**
1971     * Get a promise for setting the value of a player property.
1972     *
1973     * @param {string} name The API method to call.
1974     * @param {mixed} value The value to set.
1975     * @return {Promise}
1976     */
1977
1978  }, {
1979    key: "set",
1980    value: function set(name, value) {
1981      var _this4 = this;
1982
1983      return new npo_src(function (resolve, reject) {
1984        name = getMethodName(name, 'set');
1985
1986        if (value === undefined || value === null) {
1987          throw new TypeError('There must be a value to set.');
1988        } // We are storing the resolve/reject handlers to call later, so we
1989        // can’t return here.
1990        // eslint-disable-next-line promise/always-return
1991
1992
1993        return _this4.ready().then(function () {
1994          storeCallback(_this4, name, {
1995            resolve: resolve,
1996            reject: reject
1997          });
1998          postMessage(_this4, name, value);
1999        }).catch(reject);
2000      });
2001    }
2002    /**
2003     * Add an event listener for the specified event. Will call the

2251     * Play the video if it’s paused. **Note:** on iOS and some other
2252     * mobile devices, you cannot programmatically trigger play. Once the
2253     * viewer has tapped on the play button in the player, however, you
2254     * will be able to use this function.
2255     *
2256     * @return {PlayPromise}
2257     */
2258
2259  }, {
2260    key: "play",
2261    value: function play() {
2262      return this.callMethod('play');
2263    }
2264    /**
2265     * Request that the player enters fullscreen.
2266     * @return {Promise}
2267     */
2268
2269  }, {
2270    key: "requestFullscreen",
2271    value: function requestFullscreen() {
2272      if (screenfull.isEnabled) {
2273        return screenfull.request(this.element);
2274      }
2275
2276      return this.callMethod('requestFullscreen');
2277    }
2278    /**
2279     * Request that the player exits fullscreen.
2280     * @return {Promise}
2281     */
2282
2283  }, {
2284    key: "exitFullscreen",
2285    value: function exitFullscreen() {
2286      if (screenfull.isEnabled) {
2287        return screenfull.exit();
2288      }
2289
2290      return this.callMethod('exitFullscreen');
2291    }
2292    /**
2293     * Returns true if the player is currently fullscreen.
2294     * @return {Promise}
2295     */
2296
2297  }, {
2298    key: "getFullscreen",
2299    value: function getFullscreen() {
2300      if (screenfull.isEnabled) {
2301        return npo_src.resolve(screenfull.isFullscreen);
2302      }
2303
2304      return this.get('fullscreen');
2305    }
2306    /**
2307     * Request that the player enters picture-in-picture.
2308     * @return {Promise}
2309     */
2310
2311  }, {
2312    key: "requestPictureInPicture",
2313    value: function requestPictureInPicture() {
2314      return this.callMethod('requestPictureInPicture');
2315    }
2316    /**
2317     * Request that the player exits picture-in-picture.
2318     * @return {Promise}
2319     */
2320
2321  }, {
2322    key: "exitPictureInPicture",
2323    value: function exitPictureInPicture() {
2324      return this.callMethod('exitPictureInPicture');
2325    }
2326    /**
2327     * Returns true if the player is currently picture-in-picture.
2328     * @return {Promise}
2329     */
2330
2331  }, {
2332    key: "getPictureInPicture",
2333    value: function getPictureInPicture() {
2334      return this.get('pictureInPicture');
2335    }
2336    /**
2337     * A promise to unload the video.
2338     *
2339     * @promise UnloadPromise
2340     * @fulfill {void} The video was unloaded.
2341     */
2342
2343    /**
2344     * Return the player to its initial state.
2345     *
2346     * @return {UnloadPromise}
2347     */
2348
2349  }, {
2350    key: "unload",
2351    value: function unload() {
2352      return this.callMethod('unload');
2353    }
2354    /**
2355     * Cleanup the player and remove it from the DOM
2356     *
2357     * It won't be usable and a new one should be constructed
2358     *  in order to do any operations.
2359     *
2360     * @return {Promise}
2361     */
2362
2363  }, {
2364    key: "destroy",
2365    value: function destroy() {
2366      var _this5 = this;
2367
2368      return new npo_src(function (resolve) {
2369        readyMap.delete(_this5);
2370        playerMap.delete(_this5.element);
2371
2372        if (_this5._originalElement) {
2373          playerMap.delete(_this5._originalElement);
2374
2375          _this5._originalElement.removeAttribute('data-vimeo-initialized');
2376        }
2377
2378        if (_this5.element && _this5.element.nodeName === 'IFRAME' && _this5.element.parentNode) {
2379          // If we've added an additional wrapper div, remove that from the DOM.
2380          // If not, just remove the iframe element.
2381          if (_this5.element.parentNode.parentNode && _this5._originalElement && _this5._originalElement !== _this5.element.parentNode) {
2382            _this5.element.parentNode.parentNode.removeChild(_this5.element.parentNode);
2383          } else {
2384            _this5.element.parentNode.removeChild(_this5.element);
2385          }
2386        } // If the clip is private there is a case where the element stays the
2387        // div element. Destroy should reset the div and remove the iframe child.
2388
2389
2390        if (_this5.element && _this5.element.nodeName === 'DIV' && _this5.element.parentNode) {
2391          _this5.element.removeAttribute('data-vimeo-initialized');
2392
2393          var iframe = _this5.element.querySelector('iframe');
2394
2395          if (iframe && iframe.parentNode) {
2396            // If we've added an additional wrapper div, remove that from the DOM.
2397            // If not, just remove the iframe element.
2398            if (iframe.parentNode.parentNode && _this5._originalElement && _this5._originalElement !== iframe.parentNode) {
2399              iframe.parentNode.parentNode.removeChild(iframe.parentNode);
2400            } else {
2401              iframe.parentNode.removeChild(iframe);
2402            }
2403          }
2404        }
2405
2406        _this5._window.removeEventListener('message', _this5._onMessage);
2407
2408        if (screenfull.isEnabled) {
2409          screenfull.off('fullscreenchange', _this5.fullscreenchangeHandler);
2410        }
2411
2412        resolve();
2413      });
2414    }
2415    /**
2416     * A promise to get the autopause behavior of the video.
2417     *
2418     * @promise GetAutopausePromise
2419     * @fulfill {boolean} Whether autopause is turned on or off.
2420     * @reject {UnsupportedError} Autopause is not supported with the current
2421     *         player or browser.
2422     */
2423
2424    /**
2425     * Get the autopause behavior for this player.
2426     *
2427     * @return {GetAutopausePromise}
2428     */
2429
2430  }, {
2431    key: "getAutopause",
2432    value: function getAutopause() {
2433      return this.get('autopause');
2434    }
2435    /**
2436     * A promise to set the autopause behavior of the video.
2437     *
2438     * @promise SetAutopausePromise
2439     * @fulfill {boolean} Whether autopause is turned on or off.
2440     * @reject {UnsupportedError} Autopause is not supported with the current
2441     *         player or browser.
2442     */
2443
2444    /**
2445     * Enable or disable the autopause behavior of this player.
2446     *
2447     * By default, when another video is played in the same browser, this
2448     * player will automatically pause. Unless you have a specific reason
2449     * for doing so, we recommend that you leave autopause set to the
2450     * default (`true`).
2451     *
2452     * @param {boolean} autopause
2453     * @return {SetAutopausePromise}
2454     */
2455
2456  }, {
2457    key: "setAutopause",
2458    value: function setAutopause(autopause) {
2459      return this.set('autopause', autopause);
2460    }
2461    /**
2462     * A promise to get the buffered property of the video.
2463     *
2464     * @promise GetBufferedPromise
2465     * @fulfill {Array} Buffered Timeranges converted to an Array.
2466     */
2467
2468    /**
2469     * Get the buffered property of the video.
2470     *
2471     * @return {GetBufferedPromise}
2472     */
2473
2474  }, {
2475    key: "getBuffered",
2476    value: function getBuffered() {
2477      return this.get('buffered');
2478    }
2479    /**
2480     * @typedef {Object} CameraProperties
2481     * @prop {number} props.yaw - Number between 0 and 360.
2482     * @prop {number} props.pitch - Number between -90 and 90.
2483     * @prop {number} props.roll - Number between -180 and 180.
2484     * @prop {number} props.fov - The field of view in degrees.
2485     */
2486
2487    /**
2488     * A promise to get the camera properties of the player.
2489     *
2490     * @promise GetCameraPromise
2491     * @fulfill {CameraProperties} The camera properties.
2492     */
2493
2494    /**
2495     * For 360° videos get the camera properties for this player.
2496     *
2497     * @return {GetCameraPromise}
2498     */
2499
2500  }, {
2501    key: "getCameraProps",
2502    value: function getCameraProps() {
2503      return this.get('cameraProps');
2504    }
2505    /**
2506     * A promise to set the camera properties of the player.
2507     *
2508     * @promise SetCameraPromise
2509     * @fulfill {Object} The camera was successfully set.
2510     * @reject {RangeError} The range was out of bounds.
2511     */
2512
2513    /**
2514     * For 360° videos set the camera properties for this player.
2515     *
2516     * @param {CameraProperties} camera The camera properties
2517     * @return {SetCameraPromise}
2518     */
2519
2520  }, {
2521    key: "setCameraProps",
2522    value: function setCameraProps(camera) {
2523      return this.set('cameraProps', camera);
2524    }
2525    /**
2526     * A representation of a chapter.
2527     *
2528     * @typedef {Object} VimeoChapter
2529     * @property {number} startTime The start time of the chapter.
2530     * @property {object} title The title of the chapter.
2531     * @property {number} index The place in the order of Chapters. Starts at 1.
2532     */
2533
2534    /**
2535     * A promise to get chapters for the video.
2536     *
2537     * @promise GetChaptersPromise
2538     * @fulfill {VimeoChapter[]} The chapters for the video.
2539     */
2540
2541    /**
2542     * Get an array of all the chapters for the video.
2543     *
2544     * @return {GetChaptersPromise}
2545     */
2546
2547  }, {
2548    key: "getChapters",
2549    value: function getChapters() {
2550      return this.get('chapters');
2551    }
2552    /**
2553     * A promise to get the currently active chapter.
2554     *
2555     * @promise GetCurrentChaptersPromise
2556     * @fulfill {VimeoChapter|undefined} The current chapter for the video.
2557     */
2558
2559    /**
2560     * Get the currently active chapter for the video.
2561     *
2562     * @return {GetCurrentChaptersPromise}
2563     */
2564
2565  }, {
2566    key: "getCurrentChapter",
2567    value: function getCurrentChapter() {
2568      return this.get('currentChapter');
2569    }
2570    /**
2571     * A promise to get the color of the player.
2572     *
2573     * @promise GetColorPromise
2574     * @fulfill {string} The hex color of the player.
2575     */
2576
2577    /**
2578     * Get the color for this player.
2579     *
2580     * @return {GetColorPromise}
2581     */
2582
2583  }, {
2584    key: "getColor",
2585    value: function getColor() {
2586      return this.get('color');
2587    }
2588    /**
2589     * A promise to set the color of the player.
2590     *
2591     * @promise SetColorPromise
2592     * @fulfill {string} The color was successfully set.
2593     * @reject {TypeError} The string was not a valid hex or rgb color.
2594     * @reject {ContrastError} The color was set, but the contrast is
2595     *         outside of the acceptable range.
2596     * @reject {EmbedSettingsError} The owner of the player has chosen to
2597     *         use a specific color.
2598     */
2599
2600    /**
2601     * Set the color of this player to a hex or rgb string. Setting the
2602     * color may fail if the owner of the video has set their embed
2603     * preferences to force a specific color.
2604     *
2605     * @param {string} color The hex or rgb color string to set.
2606     * @return {SetColorPromise}
2607     */
2608
2609  }, {
2610    key: "setColor",
2611    value: function setColor(color) {
2612      return this.set('color', color);
2613    }
2614    /**
2615     * A representation of a cue point.
2616     *
2617     * @typedef {Object} VimeoCuePoint
2618     * @property {number} time The time of the cue point.
2619     * @property {object} data The data passed when adding the cue point.
2620     * @property {string} id The unique id for use with removeCuePoint.
2621     */
2622
2623    /**
2624     * A promise to get the cue points of a video.
2625     *
2626     * @promise GetCuePointsPromise
2627     * @fulfill {VimeoCuePoint[]} The cue points added to the video.
2628     * @reject {UnsupportedError} Cue points are not supported with the current
2629     *         player or browser.
2630     */
2631
2632    /**
2633     * Get an array of the cue points added to the video.
2634     *
2635     * @return {GetCuePointsPromise}
2636     */
2637
2638  }, {
2639    key: "getCuePoints",
2640    value: function getCuePoints() {
2641      return this.get('cuePoints');
2642    }
2643    /**
2644     * A promise to get the current time of the video.
2645     *
2646     * @promise GetCurrentTimePromise
2647     * @fulfill {number} The current time in seconds.
2648     */
2649
2650    /**
2651     * Get the current playback position in seconds.
2652     *
2653     * @return {GetCurrentTimePromise}
2654     */
2655
2656  }, {
2657    key: "getCurrentTime",
2658    value: function getCurrentTime() {
2659      return this.get('currentTime');
2660    }
2661    /**
2662     * A promise to set the current time of the video.
2663     *
2664     * @promise SetCurrentTimePromise
2665     * @fulfill {number} The actual current time that was set.
2666     * @reject {RangeError} the time was less than 0 or greater than the
2667     *         video’s duration.
2668     */
2669
2670    /**
2671     * Set the current playback position in seconds. If the player was
2672     * paused, it will remain paused. Likewise, if the player was playing,
2673     * it will resume playing once the video has buffered.
2674     *
2675     * You can provide an accurate time and the player will attempt to seek
2676     * to as close to that time as possible. The exact time will be the
2677     * fulfilled value of the promise.
2678     *
2679     * @param {number} currentTime
2680     * @return {SetCurrentTimePromise}
2681     */
2682
2683  }, {
2684    key: "setCurrentTime",
2685    value: function setCurrentTime(currentTime) {
2686      return this.set('currentTime', currentTime);
2687    }
2688    /**
2689     * A promise to get the duration of the video.
2690     *
2691     * @promise GetDurationPromise
2692     * @fulfill {number} The duration in seconds.
2693     */
2694
2695    /**
2696     * Get the duration of the video in seconds. It will be rounded to the
2697     * nearest second before playback begins, and to the nearest thousandth
2698     * of a second after playback begins.
2699     *
2700     * @return {GetDurationPromise}
2701     */
2702
2703  }, {
2704    key: "getDuration",
2705    value: function getDuration() {
2706      return this.get('duration');
2707    }
2708    /**
2709     * A promise to get the ended state of the video.
2710     *
2711     * @promise GetEndedPromise
2712     * @fulfill {boolean} Whether or not the video has ended.
2713     */
2714
2715    /**
2716     * Get the ended state of the video. The video has ended if
2717     * `currentTime === duration`.
2718     *
2719     * @return {GetEndedPromise}
2720     */
2721
2722  }, {
2723    key: "getEnded",
2724    value: function getEnded() {
2725      return this.get('ended');
2726    }
2727    /**
2728     * A promise to get the loop state of the player.
2729     *
2730     * @promise GetLoopPromise
2731     * @fulfill {boolean} Whether or not the player is set to loop.
2732     */
2733
2734    /**
2735     * Get the loop state of the player.
2736     *
2737     * @return {GetLoopPromise}
2738     */
2739
2740  }, {
2741    key: "getLoop",
2742    value: function getLoop() {
2743      return this.get('loop');
2744    }
2745    /**
2746     * A promise to set the loop state of the player.
2747     *
2748     * @promise SetLoopPromise
2749     * @fulfill {boolean} The loop state that was set.
2750     */
2751
2752    /**
2753     * Set the loop state of the player. When set to `true`, the player
2754     * will start over immediately once playback ends.
2755     *
2756     * @param {boolean} loop
2757     * @return {SetLoopPromise}
2758     */
2759
2760  }, {
2761    key: "setLoop",
2762    value: function setLoop(loop) {
2763      return this.set('loop', loop);
2764    }
2765    /**
2766     * A promise to set the muted state of the player.
2767     *
2768     * @promise SetMutedPromise
2769     * @fulfill {boolean} The muted state that was set.
2770     */
2771
2772    /**
2773     * Set the muted state of the player. When set to `true`, the player
2774     * volume will be muted.
2775     *
2776     * @param {boolean} muted
2777     * @return {SetMutedPromise}
2778     */
2779
2780  }, {
2781    key: "setMuted",
2782    value: function setMuted(muted) {
2783      return this.set('muted', muted);
2784    }
2785    /**
2786     * A promise to get the muted state of the player.
2787     *
2788     * @promise GetMutedPromise
2789     * @fulfill {boolean} Whether or not the player is muted.
2790     */
2791
2792    /**
2793     * Get the muted state of the player.
2794     *
2795     * @return {GetMutedPromise}
2796     */
2797
2798  }, {
2799    key: "getMuted",
2800    value: function getMuted() {
2801      return this.get('muted');
2802    }
2803    /**
2804     * A promise to get the paused state of the player.
2805     *
2806     * @promise GetLoopPromise
2807     * @fulfill {boolean} Whether or not the video is paused.
2808     */
2809
2810    /**
2811     * Get the paused state of the player.
2812     *
2813     * @return {GetLoopPromise}
2814     */
2815
2816  }, {
2817    key: "getPaused",
2818    value: function getPaused() {
2819      return this.get('paused');
2820    }
2821    /**
2822     * A promise to get the playback rate of the player.
2823     *
2824     * @promise GetPlaybackRatePromise
2825     * @fulfill {number} The playback rate of the player on a scale from 0.5 to 2.
2826     */
2827
2828    /**
2829     * Get the playback rate of the player on a scale from `0.5` to `2`.
2830     *
2831     * @return {GetPlaybackRatePromise}
2832     */
2833
2834  }, {
2835    key: "getPlaybackRate",
2836    value: function getPlaybackRate() {
2837      return this.get('playbackRate');
2838    }
2839    /**
2840     * A promise to set the playbackrate of the player.
2841     *
2842     * @promise SetPlaybackRatePromise
2843     * @fulfill {number} The playback rate was set.
2844     * @reject {RangeError} The playback rate was less than 0.5 or greater than 2.
2845     */
2846
2847    /**
2848     * Set the playback rate of the player on a scale from `0.5` to `2`. When set
2849     * via the API, the playback rate will not be synchronized to other
2850     * players or stored as the viewer's preference.
2851     *
2852     * @param {number} playbackRate
2853     * @return {SetPlaybackRatePromise}
2854     */
2855
2856  }, {
2857    key: "setPlaybackRate",
2858    value: function setPlaybackRate(playbackRate) {
2859      return this.set('playbackRate', playbackRate);
2860    }
2861    /**
2862     * A promise to get the played property of the video.
2863     *
2864     * @promise GetPlayedPromise
2865     * @fulfill {Array} Played Timeranges converted to an Array.
2866     */
2867
2868    /**
2869     * Get the played property of the video.
2870     *
2871     * @return {GetPlayedPromise}
2872     */
2873
2874  }, {
2875    key: "getPlayed",
2876    value: function getPlayed() {
2877      return this.get('played');
2878    }
2879    /**
2880     * A promise to get the qualities available of the current video.
2881     *
2882     * @promise GetQualitiesPromise
2883     * @fulfill {Array} The qualities of the video.
2884     */
2885
2886    /**
2887     * Get the qualities of the current video.
2888     *
2889     * @return {GetQualitiesPromise}
2890     */
2891
2892  }, {
2893    key: "getQualities",
2894    value: function getQualities() {
2895      return this.get('qualities');
2896    }
2897    /**
2898     * A promise to get the current set quality of the video.
2899     *
2900     * @promise GetQualityPromise
2901     * @fulfill {string} The current set quality.
2902     */
2903
2904    /**
2905     * Get the current set quality of the video.
2906     *
2907     * @return {GetQualityPromise}
2908     */
2909
2910  }, {
2911    key: "getQuality",
2912    value: function getQuality() {
2913      return this.get('quality');
2914    }
2915    /**
2916     * A promise to set the video quality.
2917     *
2918     * @promise SetQualityPromise
2919     * @fulfill {number} The quality was set.
2920     * @reject {RangeError} The quality is not available.
2921     */
2922
2923    /**
2924     * Set a video quality.
2925     *
2926     * @param {string} quality
2927     * @return {SetQualityPromise}
2928     */
2929
2930  }, {
2931    key: "setQuality",
2932    value: function setQuality(quality) {
2933      return this.set('quality', quality);
2934    }
2935    /**
2936     * A promise to get the seekable property of the video.
2937     *
2938     * @promise GetSeekablePromise
2939     * @fulfill {Array} Seekable Timeranges converted to an Array.
2940     */
2941
2942    /**
2943     * Get the seekable property of the video.
2944     *
2945     * @return {GetSeekablePromise}
2946     */
2947
2948  }, {
2949    key: "getSeekable",
2950    value: function getSeekable() {
2951      return this.get('seekable');
2952    }
2953    /**
2954     * A promise to get the seeking property of the player.
2955     *
2956     * @promise GetSeekingPromise
2957     * @fulfill {boolean} Whether or not the player is currently seeking.
2958     */
2959
2960    /**
2961     * Get if the player is currently seeking.
2962     *
2963     * @return {GetSeekingPromise}
2964     */
2965
2966  }, {
2967    key: "getSeeking",
2968    value: function getSeeking() {
2969      return this.get('seeking');
2970    }
2971    /**
2972     * A promise to get the text tracks of a video.
2973     *
2974     * @promise GetTextTracksPromise
2975     * @fulfill {VimeoTextTrack[]} The text tracks associated with the video.
2976     */
2977
2978    /**
2979     * Get an array of the text tracks that exist for the video.
2980     *
2981     * @return {GetTextTracksPromise}
2982     */
2983
2984  }, {
2985    key: "getTextTracks",
2986    value: function getTextTracks() {
2987      return this.get('textTracks');
2988    }
2989    /**
2990     * A promise to get the embed code for the video.
2991     *
2992     * @promise GetVideoEmbedCodePromise
2993     * @fulfill {string} The `<iframe>` embed code for the video.
2994     */
2995
2996    /**
2997     * Get the `<iframe>` embed code for the video.
2998     *
2999     * @return {GetVideoEmbedCodePromise}
3000     */
3001
3002  }, {
3003    key: "getVideoEmbedCode",
3004    value: function getVideoEmbedCode() {
3005      return this.get('videoEmbedCode');
3006    }
3007    /**
3008     * A promise to get the id of the video.
3009     *
3010     * @promise GetVideoIdPromise
3011     * @fulfill {number} The id of the video.
3012     */
3013
3014    /**
3015     * Get the id of the video.
3016     *
3017     * @return {GetVideoIdPromise}
3018     */
3019
3020  }, {
3021    key: "getVideoId",
3022    value: function getVideoId() {
3023      return this.get('videoId');
3024    }
3025    /**
3026     * A promise to get the title of the video.
3027     *
3028     * @promise GetVideoTitlePromise
3029     * @fulfill {number} The title of the video.
3030     */
3031
3032    /**
3033     * Get the title of the video.
3034     *
3035     * @return {GetVideoTitlePromise}
3036     */
3037
3038  }, {
3039    key: "getVideoTitle",
3040    value: function getVideoTitle() {
3041      return this.get('videoTitle');
3042    }
3043    /**
3044     * A promise to get the native width of the video.
3045     *
3046     * @promise GetVideoWidthPromise
3047     * @fulfill {number} The native width of the video.
3048     */
3049
3050    /**
3051     * Get the native width of the currently‐playing video. The width of
3052     * the highest‐resolution available will be used before playback begins.
3053     *
3054     * @return {GetVideoWidthPromise}
3055     */
3056
3057  }, {
3058    key: "getVideoWidth",
3059    value: function getVideoWidth() {
3060      return this.get('videoWidth');
3061    }
3062    /**
3063     * A promise to get the native height of the video.
3064     *
3065     * @promise GetVideoHeightPromise
3066     * @fulfill {number} The native height of the video.
3067     */
3068
3069    /**
3070     * Get the native height of the currently‐playing video. The height of
3071     * the highest‐resolution available will be used before playback begins.
3072     *
3073     * @return {GetVideoHeightPromise}
3074     */
3075
3076  }, {
3077    key: "getVideoHeight",
3078    value: function getVideoHeight() {
3079      return this.get('videoHeight');
3080    }
3081    /**
3082     * A promise to get the vimeo.com url for the video.
3083     *
3084     * @promise GetVideoUrlPromise
3085     * @fulfill {number} The vimeo.com url for the video.
3086     * @reject {PrivacyError} The url isn’t available because of the video’s privacy setting.
3087     */
3088
3089    /**
3090     * Get the vimeo.com url for the video.
3091     *
3092     * @return {GetVideoUrlPromise}
3093     */
3094
3095  }, {
3096    key: "getVideoUrl",
3097    value: function getVideoUrl() {
3098      return this.get('videoUrl');
3099    }
3100    /**
3101     * A promise to get the volume level of the player.
3102     *
3103     * @promise GetVolumePromise
3104     * @fulfill {number} The volume level of the player on a scale from 0 to 1.
3105     */
3106
3107    /**
3108     * Get the current volume level of the player on a scale from `0` to `1`.
3109     *
3110     * Most mobile devices do not support an independent volume from the
3111     * system volume. In those cases, this method will always return `1`.
3112     *
3113     * @return {GetVolumePromise}
3114     */
3115
3116  }, {
3117    key: "getVolume",
3118    value: function getVolume() {
3119      return this.get('volume');
3120    }
3121    /**
3122     * A promise to set the volume level of the player.
3123     *
3124     * @promise SetVolumePromise
3125     * @fulfill {number} The volume was set.
3126     * @reject {RangeError} The volume was less than 0 or greater than 1.
3127     */
3128
3129    /**
3130     * Set the volume of the player on a scale from `0` to `1`. When set
3131     * via the API, the volume level will not be synchronized to other
3132     * players or stored as the viewer’s preference.
3133     *
3134     * Most mobile devices do not support setting the volume. An error will
3135     * *not* be triggered in that situation.
3136     *
3137     * @param {number} volume
3138     * @return {SetVolumePromise}
3139     */
3140
3141  }, {
3142    key: "setVolume",
3143    value: function setVolume(volume) {
3144      return this.set('volume', volume);
3145    }
3146  }]);
3147
3148  return Player;
3149}(); // Setup embed only if this is not a node environment
3150
3151
3152if (!isNode) {
3153  screenfull = initializeScreenfull();
3154  initializeEmbeds();
3155  resizeEmbeds();
3156  initAppendVideoMetadata();
3157}
3158
3159class VimeoPlayer extends AbstractVideoPlayer {
3160  constructor(target, videoId, options = {}) {
3161    super(target, videoId, options);
3162    this.state.set(INITIALIZED);
3163  }
3164  createPlayer(videoId) {
3165    const { options, options: { playerOptions = {} } } = this;
3166    const vimeoOptions = videoId.indexOf("http") === 0 ? { url: videoId } : { id: +videoId };
3167    const player = new Player$1(this.target, assign(vimeoOptions, {
3168      controls: !options.hideControls,
3169      loop: options.loop,
3170      muted: options.mute
3171    }, playerOptions.vimeo || {}));
3172    player.on("play", this.onPlay);
3173    player.on("pause", this.onPause);
3174    player.on("ended", this.onEnded);
3175    player.ready().then(this.onPlayerReady, this.onError);
3176    if (!player.getMuted()) {
3177      player.setVolume(clamp(options.volume, 0, 1));
3178    }
3179    return player;
3180  }
3181  playVideo() {
3182    this.player.play().catch(() => {
3183      if (this.state.is(PLAY_REQUEST_ABORTED)) {
3184        this.state.set(IDLE);
3185      }
3186    });
3187  }
3188  pauseVideo() {
3189    this.player.pause();
3190  }
3191}
3192
3193const YOUTUBE_API_SRC = "//www.youtube.com/player_api";
3194class YouTubeIframeAPILoader {
3195  load(callback) {
3196    if (window.YT && isFunction(window.YT.Player)) {
3197      return callback();
3198    }
3199    this.attachCallback(callback);
3200    if (this.shouldLoad()) {
3201      create("script", { src: `${location.protocol}${YOUTUBE_API_SRC}` }, document.head);
3202    }
3203  }
3204  shouldLoad() {
3205    return !queryAll(document, "script").some((script) => script.src.replace(/^https?:/, "") === YOUTUBE_API_SRC);
3206  }
3207  attachCallback(callback) {
3208    let oldCallback;
3209    if (!isUndefined(window.onYouTubeIframeAPIReady)) {
3210      oldCallback = window.onYouTubeIframeAPIReady;
3211    }
3212    window.onYouTubeIframeAPIReady = () => {
3213      oldCallback && oldCallback();
3214      callback();
3215    };
3216  }
3217}
3218
3219class YouTubePlayer extends AbstractVideoPlayer {
3220  constructor(target, videoId, options = {}) {
3221    super(target, videoId, options);
3222    this.videoId = this.parseVideoId(videoId);
3223    if (this.videoId) {
3224      this.state.set(INITIALIZING);
3225      new YouTubeIframeAPILoader().load(this.onAPIReady.bind(this));
3226    }
3227  }
3228  onAPIReady() {
3229    const { state } = this;
3230    const isPending = state.is(PENDING_PLAY);
3231    state.set(INITIALIZED);
3232    if (isPending) {
3233      this.play();
3234    }
3235  }
3236  createPlayer(videoId) {
3237    const { options, options: { playerOptions = {} } } = this;
3238    return new YT.Player(this.target, {
3239      videoId,
3240      host: options.host,
3241      playerVars: assign({
3242        controls: options.hideControls ? 0 : 1,
3243        iv_load_policy: 3,
3244        loop: options.loop ? 1 : 0,
3245        playlist: options.loop ? videoId : void 0,
3246        rel: 0,
3247        autoplay: 0,
3248        mute: options.mute ? 1 : 0
3249      }, playerOptions.youtube || {}),
3250      events: {
3251        onReady: this.onPlayerReady.bind(this),
3252        onStateChange: this.onPlayerStateChange.bind(this),
3253        onError: this.onError.bind(this)
3254      }
3255    });
3256  }
3257  onPlayerReady() {
3258    super.onPlayerReady();
3259    this.player.setVolume(clamp(this.options.volume, 0, 1) * 100);
3260  }
3261  onPlayerStateChange(e) {
3262    const { PLAYING, PAUSED, ENDED } = YT.PlayerState;
3263    switch (true) {
3264      case e.data === PLAYING:
3265        this.onPlay();
3266        break;
3267      case e.data === PAUSED:
3268        this.onPause();
3269        break;
3270      case e.data === ENDED:
3271        this.onEnded();
3272        break;
3273    }
3274  }
3275  playVideo() {
3276    this.player.playVideo();
3277  }
3278  pauseVideo() {
3279    this.player.pauseVideo();
3280  }
3281  parseVideoId(id) {
3282    return id.indexOf("http") === 0 ? this.parseUrl(id) : id;
3283  }
3284  parseUrl(url) {
3285    const [, search] = url.split(/[#?]/);
3286    const query = find(search.split("&"), (query2) => query2.indexOf("v=") === 0);
3287    return query && query.replace("v=", "");
3288  }
3289}
3290
3291const I18N = {
3292  playVideo: "Play Video"
3293};
3294
3295class PlayerUI {
3296  constructor(Splide2, slide) {
3297    this.event = EventInterface();
3298    this.Splide = Splide2;
3299    this.slide = slide;
3300    this.container = child(this.slide, `.${CLASS_CONTAINER}`);
3301    this.parent = this.container || this.slide;
3302    this.init();
3303    this.create();
3304    this.show();
3305    this.listen();
3306  }
3307  init() {
3308    addClass(this.slide, `${CLASS_SLIDE}${MODIFIER_HAS_VIDEO}`);
3309    addClass(this.container, `${CLASS_CONTAINER}${MODIFIER_HAS_VIDEO}`);
3310  }
3311  create() {
3312    this.video = create("div", CLASS_VIDEO, this.parent);
3313    this.playButton = create("button", {
3314      class: CLASS_VIDEO_PLAY_BUTTON,
3315      type: "button",
3316      "aria-label": this.Splide.options.i18n.playVideo || I18N.playVideo
3317    }, this.video);
3318    this.wrapper = create("div", CLASS_VIDEO_WRAPPER, this.video);
3319    this.placeholder = create("div", null, this.wrapper);
3320  }
3321  listen() {
3322    this.parent.addEventListener("click", () => {
3323      this.event.emit("click");
3324    });
3325  }
3326  toggleButton(show) {
3327    display(this.playButton, show ? "" : "none");
3328  }
3329  toggleWrapper(show) {
3330    display(this.wrapper, show ? "" : "none");
3331  }
3332  getPlaceholder() {
3333    return this.placeholder;
3334  }
3335  hide() {
3336    this.toggleButton(false);
3337    this.toggleWrapper(true);
3338  }
3339  show() {
3340    if (!this.disabled) {
3341      this.toggleButton(true);
3342    }
3343    this.toggleWrapper(false);
3344  }
3345  disable(disabled) {
3346    this.disabled = disabled;
3347    if (disabled) {
3348      this.toggleButton(false);
3349    }
3350  }
3351  on(events, callback) {
3352    this.event.on(events, callback);
3353  }
3354  destroy() {
3355    removeClass(this.slide, `${CLASS_SLIDE}${MODIFIER_HAS_VIDEO}`);
3356    removeClass(this.container, `${CLASS_CONTAINER}${MODIFIER_HAS_VIDEO}`);
3357    remove(this.video);
3358    this.event.destroy();
3359  }
3360}
3361
3362const VIDEO_PLAYER_MAP = [
3363  [YOUTUBE_DATA_ATTRIBUTE, YouTubePlayer],
3364  [VIMEO_DATA_ATTRIBUTE, VimeoPlayer],
3365  [HTML_VIDEO__DATA_ATTRIBUTE, HTMLVideoPlayer]
3366];
3367class Player {
3368  constructor(Splide2, slide) {
3369    this.Splide = Splide2;
3370    this.slide = slide;
3371    this.event = EventInterface(Splide2);
3372    this.options = merge(merge({}, DEFAULTS), this.Splide.options.video);
3373    this.createPlayer(slide);
3374    if (this.player) {
3375      this.listen();
3376    }
3377  }
3378  createPlayer(slide) {
3379    VIDEO_PLAYER_MAP.forEach(([attr, Constructor]) => {
3380      const id = getAttribute(slide, attr);
3381      if (id) {
3382        this.ui = new PlayerUI(this.Splide, slide);
3383        this.player = new Constructor(this.ui.getPlaceholder(), id, this.options);
3384        this.ui.disable(this.options.disableOverlayUI);
3385      }
3386    });
3387  }
3388  listen() {
3389    const { player, event } = this;
3390    this.ui.on("click", this.onClick.bind(this));
3391    player.on("play", this.onPlay.bind(this));
3392    player.on("played", this.onPlayed.bind(this));
3393    player.on("pause", this.onPause.bind(this));
3394    player.on("paused", this.onPaused.bind(this));
3395    player.on("ended", this.onEnded.bind(this));
3396    player.on("error", this.onError.bind(this));
3397    event.on([EVENT_MOVE, EVENT_SCROLL], this.pause.bind(this));
3398    event.on(EVENT_VIDEO_CLICK, this.onVideoClick.bind(this));
3399    event.on(EVENT_DRAG, () => {
3400      event.off(EVENT_DRAGGING);
3401      event.on(EVENT_DRAGGING, () => {
3402        this.pause();
3403        event.off(EVENT_DRAGGING);
3404      });
3405    });
3406    if (this.options.autoplay) {
3407      event.on([EVENT_MOUNTED, EVENT_MOVED, EVENT_SCROLLED], this.onAutoplayRequested.bind(this));
3408    }
3409  }
3410  onClick() {
3411    this.isPaused() ? this.play() : this.pause();
3412    this.event.emit(EVENT_VIDEO_CLICK, this);
3413  }
3414  onVideoClick(player) {
3415    if (this !== player) {
3416      this.pause();
3417    }
3418  }
3419  onPlay() {
3420    this.ui.hide();
3421  }
3422  onPlayed() {
3423    this.ui.hide();
3424    this.togglePlaying(true);
3425    this.event.emit(EVENT_VIDEO_PLAY, this);
3426  }
3427  onPause() {
3428    this.ui.show();
3429  }
3430  onPaused() {
3431    this.togglePlaying(false);
3432    this.event.emit(EVENT_VIDEO_PAUSE, this);
3433  }
3434  onEnded() {
3435    this.togglePlaying(false);
3436    this.event.emit(EVENT_VIDEO_ENDED, this);
3437  }
3438  onError() {
3439    addClass(this.slide, CLASS_ERROR);
3440    this.ui.show();
3441    this.event.emit(EVENT_VIDEO_ERROR, this);
3442  }
3443  onAutoplayRequested() {
3444    const activeSlide = this.Splide.Components.Slides.getAt(this.Splide.index);
3445    if (activeSlide.slide === this.slide) {
3446      this.play();
3447    }
3448  }
3449  togglePlaying(add) {
3450    toggleClass(this.Splide.root, CLASS_PLAYING, add);
3451  }
3452  play() {
3453    if (this.player && !this.disabled) {
3454      this.player.play();
3455    }
3456  }
3457  pause() {
3458    if (this.player && !this.disabled) {
3459      this.player.pause();
3460    }
3461  }
3462  destroy() {
3463    if (this.player) {
3464      this.ui.destroy();
3465      this.player.destroy();
3466    }
3467    this.disable(false);
3468  }
3469  disable(disabled) {
3470    this.disabled = disabled;
3471    toggleClass(this.Splide.root, CLASS_VIDEO_DISABLED, disabled);
3472  }
3473  isPaused() {
3474    return this.player.isPaused();
3475  }
3476}
3477
3478function Video(Splide2, Components2) {
3479  const { on } = EventInterface(Splide2);
3480  const { Slides } = Components2;
3481  const players = {};
3482  function mount() {
3483    create();
3484    on("refresh", create);
3485  }
3486  function create() {