https://catalog.lindahall.org/discovery/lib/bower_components/video.js/dist/video.js

1/**
2 * @license
3 * Video.js 8.9.0 <http://videojs.com/>
4 * Copyright Brightcove, Inc. <https://www.brightcove.com/>
5 * Available under Apache License Version 2.0
6 * <https://github.com/videojs/video.js/blob/main/LICENSE>
7 *
8 * Includes vtt.js <https://github.com/mozilla/vtt.js>
9 * Available under Apache License Version 2.0
10 * <https://github.com/mozilla/vtt.js/blob/main/LICENSE>
11 */
12
13(function (global, factory) {
14  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
15  typeof define === 'function' && define.amd ? define(factory) :
16  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.videojs = factory());
17})(this, (function () { 'use strict';
18
19  var version$5 = "8.9.0";
20
21  /**
22   * An Object that contains lifecycle hooks as keys which point to an array
23   * of functions that are run when a lifecycle is triggered
24   *
25   * @private
26   */
27  const hooks_ = {};
28
29  /**
30   * Get a list of hooks for a specific lifecycle
31   *
32   * @param  {string} type
33   *         the lifecycle to get hooks from
34   *
35   * @param  {Function|Function[]} [fn]
36   *         Optionally add a hook (or hooks) to the lifecycle that your are getting.
37   *
38   * @return {Array}
39   *         an array of hooks, or an empty array if there are none.
40   */
41  const hooks = function (type, fn) {
42    hooks_[type] = hooks_[type] || [];
43    if (fn) {
44      hooks_[type] = hooks_[type].concat(fn);
45    }
46    return hooks_[type];
47  };
48
49  /**
50   * Add a function hook to a specific videojs lifecycle.
51   *
52   * @param {string} type
53   *        the lifecycle to hook the function to.
54   *
55   * @param {Function|Function[]}
56   *        The function or array of functions to attach.
57   */
58  const hook = function (type, fn) {
59    hooks(type, fn);
60  };
61
62  /**
63   * Remove a hook from a specific videojs lifecycle.
64   *
65   * @param  {string} type
66   *         the lifecycle that the function hooked to
67   *
68   * @param  {Function} fn
69   *         The hooked function to remove
70   *
71   * @return {boolean}
72   *         The function that was removed or undef
73   */
74  const removeHook = function (type, fn) {
75    const index = hooks(type).indexOf(fn);
76    if (index <= -1) {
77      return false;
78    }
79    hooks_[type] = hooks_[type].slice();
80    hooks_[type].splice(index, 1);
81    return true;
82  };
83
84  /**
85   * Add a function hook that will only run once to a specific videojs lifecycle.
86   *
87   * @param {string} type
88   *        the lifecycle to hook the function to.
89   *
90   * @param {Function|Function[]}
91   *        The function or array of functions to attach.
92   */
93  const hookOnce = function (type, fn) {
94    hooks(type, [].concat(fn).map(original => {
95      const wrapper = (...args) => {
96        removeHook(type, wrapper);
97        return original(...args);
98      };
99      return wrapper;
100    }));
101  };
102
103  /**
104   * @file fullscreen-api.js
105   * @module fullscreen-api
106   */
107
108  /**
109   * Store the browser-specific methods for the fullscreen API.
110   *
111   * @type {Object}
112   * @see [Specification]{@link https://fullscreen.spec.whatwg.org}
113   * @see [Map Approach From Screenfull.js]{@link https://github.com/sindresorhus/screenfull.js}
114   */
115  const FullscreenApi = {
116    prefixed: true
117  };
118
119  // browser API methods
120  const apiMap = [['requestFullscreen', 'exitFullscreen', 'fullscreenElement', 'fullscreenEnabled', 'fullscreenchange', 'fullscreenerror', 'fullscreen'],
121  // WebKit
122  ['webkitRequestFullscreen', 'webkitExitFullscreen', 'webkitFullscreenElement', 'webkitFullscreenEnabled', 'webkitfullscreenchange', 'webkitfullscreenerror', '-webkit-full-screen']];
123  const specApi = apiMap[0];
124  let browserApi;
125
126  // determine the supported set of functions
127  for (let i = 0; i < apiMap.length; i++) {
128    // check for exitFullscreen function
129    if (apiMap[i][1] in document) {
130      browserApi = apiMap[i];
131      break;
132    }
133  }
134
135  // map the browser API names to the spec API names
136  if (browserApi) {
137    for (let i = 0; i < browserApi.length; i++) {
138      FullscreenApi[specApi[i]] = browserApi[i];
139    }
140    FullscreenApi.prefixed = browserApi[0] !== specApi[0];
141  }
142
143  /**
144   * @file create-logger.js
145   * @module create-logger
146   */
147
148  // This is the private tracking variable for the logging history.
149  let history = [];
150
151  /**
152   * Log messages to the console and history based on the type of message
153   *
154   * @private
155   * @param  {string} name
156   *         The name of the console method to use.
157   *
158   * @param  {Object} log
159   *         The arguments to be passed to the matching console method.
160   *
161   * @param {string} [styles]
162   *        styles for name
163   */
164  const LogByTypeFactory = (name, log, styles) =>

164 (type, level, args) => {
165    const lvl = log.levels[level];
166    const lvlRegExp = new RegExp(`^(${lvl})$`);
167    let resultName = name;
168    if (type !== 'log') {
169      // Add the type to the front of the message when it's not "log".
170      args.unshift(type.toUpperCase() + ':');
171    }
172    if (styles) {
173      resultName = `%c${name}`;
174      args.unshift(styles);
175    }
176
177    // Add console prefix after adding to history.
178    args.unshift(resultName + ':');
179
180    // Add a clone of the args at this point to history.
181    if (history) {
182      history.push([].concat(args));
183
184      // only store 1000 history entries
185      const splice = history.length - 1000;
186      history.splice(0, splice > 0 ? splice : 0);
187    }
188
189    // If there's no console then don't try to output messages, but they will
190    // still be stored in history.
191    if (!window.console) {
192      return;
193    }
194
195    // Was setting these once outside of this function, but containing them
196    // in the function makes it easier to test cases where console doesn't exist
197    // when the module is executed.
198    let fn = window.console[type];
199    if (!fn && type === 'debug') {
200      // Certain browsers don't have support for console.debug. For those, we
201      // should default to the closest comparable log.
202      fn = window.console.info || window.console.log;
203    }
204
205    // Bail out if there's no console or if this type is not allowed by the
206    // current logging level.
207    if (!fn || !lvl || !lvlRegExp.test(type)) {
208      return;
209    }
210    fn[Array.isArray(args) ? 'apply' : 'call'](window.console, args);
211  };
212  function createLogger$1(name, delimiter = ':', styles = '') {
213    // This is the private tracking variable for logging level.
214    let level = 'info';
215
216    // the curried logByType bound to the specific log and history
217    let logByType;
218
219    /**
220     * Logs plain debug messages. Similar to `console.log`.
221     *
222     * Due to [limitations](https://github.com/jsdoc3/jsdoc/issues/955#issuecomment-313829149)
223     * of our JSDoc template, we cannot properly document this as both a function
224     * and a namespace, so its function signature is documented here.
225     *
226     * #### Arguments
227     * ##### *args
228     * *[]
229     *
230     * Any combination of values that could be passed to `console.log()`.
231     *
232     * #### Return Value
233     *
234     * `undefined`
235     *
236     * @namespace
237     * @param    {...*} args
238     *           One or more messages or objects that should be logged.
239     */
240    const log = function (...args) {
241      logByType('log', level, args);
242    };
243
244    // This is the logByType helper that the logging methods below use
245    logByType = LogByTypeFactory(name, log, styles);
246
247    /**
248     * Create a new subLogger which chains the old name to the new name.
249     *
250     * For example, doing `

250videojs.log.createLogger('player')` and then using that logger will log the following:
251     * ```js
252     *  mylogger('foo');
253     *  // > VIDEOJS: player: foo
254     * ```
255     *
256     * @param {string} subName
257     *        The name to add call the new logger
258     * @param {string} [subDelimiter]
259     *        Optional delimiter
260     * @param {string} [subStyles]
261     *        Optional styles
262     * @return {Object}
263     */
264    log.createLogger = (subName, subDelimiter, subStyles) => {
265      const resultDelimiter = subDelimiter !== undefined ? subDelimiter : delimiter;
266      const resultStyles = subStyles !== undefined ? subStyles : styles;
267      const resultName = `${name} ${resultDelimiter} ${subName}`;
268      return createLogger$1(resultName, resultDelimiter, resultStyles);
269    };
270
271    /**
272     * Create a new logger.
273     *
274     * @param {string} newName
275     *        The name for the new logger
276     * @param {string} [newDelimiter]
277     *        Optional delimiter
278     * @param {string} [newStyles]
279     *        Optional styles
280     * @return {Object}
281     */
282    log.createNewLogger = (newName, newDelimiter, newStyles) => {
283      return createLogger$1(newName, newDelimiter, newStyles);
284    };
285
286    /**
287     * Enumeration of available logging levels, where the keys are the level names
288     * and the values are `|`-separated strings containing logging methods allowed
289     * in that logging level. These strings are used to create a regular expression
290     * matching the function name being called.
291     *
292     * Levels provided by Video.js are:
293     *
294     * - `off`: Matches no calls. Any value that can be cast to `false` will have
295     *   this effect. The most restrictive.
296     * - `all`: Matches only Video.js-provided functions (`debug`, `log`,
297     *   `log.warn`, and `log.error`).
298     * - `debug`: Matches `log.debug`, `log`, `log.warn`, and `log.error` calls.
299     * - `info` (default): Matches `log`, `log.warn`, and `log.error` calls.
300     * - `warn`: Matches `log.warn` and `log.error` calls.
301     * - `error`: Matches only `log.error` calls.
302     *
303     * @type {Object}
304     */
305    log.levels = {
306      all: 'debug|log|warn|error',
307      off: '',
308      debug: 'debug|log|warn|error',
309      info: 'log|warn|error',
310      warn: 'warn|error',
311      error: 'error',
312      DEFAULT: level
313    };
314
315    /**
316     * Get or set the current logging level.
317     *
318     * If a string matching a key from {@link module:log.levels} is provided, acts
319     * as a setter.
320     *
321     * @param  {'all'|'debug'|'info'|'warn'|'error'|'off'} [lvl]
322     *         Pass a valid level to set a new logging level.
323     *
324     * @return {string}
325     *         The current logging level.
326     */
327    log.level = lvl => {
328      if (typeof lvl === 'string') {
329        if (!log.levels.hasOwnProperty(lvl)) {
330          throw new Error(`"${lvl}" in not a valid log level`);
331        }
332        level = lvl;
333      }
334      return level;
335    };
336
337    /**
338     * Returns an array containing everything that has been logged to the history.
339     *
340     * This array is a shallow clone of the internal history record. However, its
341     * contents are _not_ cloned; so, mutating objects inside this array will
342     * mutate them in history.
343     *
344     * @return {Array}
345     */
346    log.history = () => history ? [].concat(history) : [];
347
348    /**
349     * Allows you to filter the history by the given logger name
350     *
351     * @param {string} fname
352     *        The name to filter by
353     *
354     * @return {Array}
355     *         The filtered list to return
356     */
357    log.history.filter = fname => {
358      return (history || []).filter(historyItem => {
359        // if the first item in each historyItem includes `fname`, then it's a match
360        return new RegExp(`.*${fname}.*`).test(historyItem[0]);
361      });
362    };
363
364    /**
365     * Clears the internal history tracking, but does not prevent further history
366     * tracking.
367     */
368    log.history.clear = () => {
369      if (history) {
370        history.length = 0;
371      }
372    };
373
374    /**
375     * Disable history tracking if it is currently enabled.
376     */
377    log.history.disable = () => {
378      if (history !== null) {
379        history.length = 0;
380        history = null;
381      }
382    };
383
384    /**
385     * Enable history tracking if it is currently disabled.
386     */
387    log.history.enable = () => {
388      if (history === null) {
389        history = [];
390      }
391    };
392
393    /**
394     * Logs error messages. Similar to `console.error`.
395     *
396     * @param {...*} args
397     *        One or more messages or objects that should be logged as an error
398     */
399    log.error = (...args) => logByType('error', level, args);
400
401    /**
402     * Logs warning messages. Similar to `console.warn`.
403     *
404     * @param {...*} args
405     *        One or more messages or objects that should be logged as a warning.
406     */
407    log.warn = (...args) => logByType('warn', level, args);
408
409    /**
410     * Logs debug messages. Similar to `console.debug`, but may also act as a comparable
411     * log if `console.debug` is not available
412     *
413     * @param {...*} args
414     *        One or more messages or objects that should be logged as debug.
415     */
416    log.debug = (...args) => logByType('debug', level, args);
417    return log;
418  }
419
420  /**
421   * @file log.js
422   * @module log
423   */
424  const log$1 = createLogger$1('VIDEOJS');
425  const createLogger = log$1.createLogger;
426
427  /**
428   * @file obj.js
429   * @module obj
430   */
431
432  /**
433   * @callback obj:EachCallback
434   *
435   * @param {*} value
436   *        The current key for the object that is being iterated over.
437   *
438   * @param {string} key
439   *        The current key-value for object that is being iterated over
440   */
441
442  /**
443   * @callback obj:ReduceCallback
444   *
445   * @param {*} accum
446   *        The value that is accumulating over the reduce loop.
447   *
448   * @param {*} value
449   *        The current key for the object that is being iterated over.
450   *
451   * @param {string} key
452   *        The current key-value for object that is being iterated over
453   *
454   * @return {*}
455   *         The new accumulated value.
456   */
457  const toString$1 = Object.prototype.toString;
458
459  /**
460   * Get the keys of an Object
461   *
462   * @param {Object}
463   *        The Object to get the keys from
464   *
465   * @return {string[]}
466   *         An array of the keys from the object. Returns an empty array if the
467   *         object passed in was invalid or had no keys.
468   *
469   * @private
470   */
471  const keys = function (object) {
472    return isObject$1(object) ? Object.keys(object) : [];
473  };
474
475  /**
476   * Array-like iteration for objects.
477   *
478   * @param {Object} object
479   *        The object to iterate over
480   *
481   * @param {obj:EachCallback} fn
482   *        The callback function which is called for each key in the object.
483   */
484  function each(object, fn) {
485    keys(object).forEach(key => fn(object[key], key));
486  }
487
488  /**
489   * Array-like reduce for objects.
490   *
491   * @param {Object} object
492   *        The Object that you want to reduce.
493   *
494   * @param {Function} fn
495   *         A callback function which is called for each key in the object. It
496   *         receives the accumulated value and the per-iteration value and key
497   *         as arguments.
498   *
499   * @param {*} [initial = 0]
500   *        Starting value
501   *
502   * @return {*}
503   *         The final accumulated value.
504   */
505  function reduce(object, fn, initial = 0) {
506    return keys(object).reduce((accum, key) => fn(accum, object[key], key), initial);
507  }
508
509  /**
510   * Returns whether a value is an object of any kind - including DOM nodes,
511   * arrays, regular expressions, etc. Not functions, though.
512   *
513   * This avoids the gotcha where using `typeof` on a `null` value
514   * results in `'object'`.
515   *
516   * @param  {Object} value
517   * @return {boolean}
518   */
519  function isObject$1(value) {
520    return !!value && typeof value === 'object';
521  }
522
523  /**
524   * Returns whether an object appears to be a "plain" object - that is, a
525   * direct instance of `Object`.
526   *
527   * @param  {Object} value
528   * @return {boolean}
529   */
530  function isPlain(value) {
531    return isObject$1(value) && toString$1.call(value) === '[object Object]' && value.constructor === Object;
532  }
533
534  /**
535   * Merge two objects recursively.
536   *
537   * Performs a deep merge like
538   * {@link https://lodash.com/docs/4.17.10#merge|lodash.merge}, but only merges
539   * plain objects (not arrays, elements, or anything else).
540   *
541   * Non-plain object values will be copied directly from the right-most
542   * argument.
543   *
544   * @param   {Object[]} sources
545   *          One or more objects to merge into a new object.
546   *
547   * @return {Object}
548   *          A new object that is the merged result of all sources.
549   */
550  function merge$2(...sources) {
551    const result = {};
552    sources.forEach(source => {
553      if (!source) {
554        return;
555      }
556      each(source, (value, key) => {
557        if (!isPlain(value)) {
558          result[key] = value;
559          return;
560        }
561        if (!isPlain(result[key])) {
562          result[key] = {};
563        }
564        result[key] = merge$2(result[key], value);
565      });
566    });
567    return result;
568  }
569
570  /**
571   * Returns an array of values for a given object
572   *
573   * @param  {Object} source - target object
574   * @return {Array<unknown>} - object values
575   */
576  function values$1(source = {}) {
577    const result = [];
578    for (const key in source) {
579      if (source.hasOwnProperty(key)) {
580        const value = source[key];
581        result.push(value);
582      }
583    }
584    return result;
585  }
586
587  /**
588   * Object.defineProperty but "lazy", which means that the value is only set after
589   * it is retrieved the first time, rather than being set right away.
590   *
591   * @param {Object} obj the object to set the property on
592   * @param {string} key the key for the property to set
593   * @param {Function} getValue the function used to get the value when it is needed.
594   * @param {boolean} setter whether a setter should be allowed or not
595   */
596  function defineLazyProperty(obj, key, getValue, setter = true) {
597    const set = value => Object.defineProperty(obj, key, {
598      value,
599      enumerable: true,
600      writable: true
601    });
602    const options = {
603      configurable: true,
604      enumerable: true,
605      get() {
606        const value = getValue();
607        set(value);
608        return value;
609      }
610    };
611    if (setter) {
612      options.set = set;
613    }
614    return Object.defineProperty(obj, key, options);
615  }
616
617  var Obj = /*#__PURE__*/Object.freeze({
618    __proto__: null,
619    each: each,
620    reduce: reduce,
621    isObject: isObject$1,
622    isPlain: isPlain,
623    merge: merge$2,
624    values: values$1,
625    defineLazyProperty: defineLazyProperty
626  });
627
628  /**
629   * @file browser.js
630   * @module browser
631   */
632
633  /**
634   * Whether or not this device is an iPod.
635   *
636   * @static
637   * @type {Boolean}
638   */
639  let IS_IPOD = false;
640
641  /**
642   * The detected iOS version - or `null`.
643   *
644   * @static
645   * @type {string|null}
646   */
647  let IOS_VERSION = null;
648
649  /**
650   * Whether or not this is an Android device.
651   *
652   * @static
653   * @type {Boolean}
654   */
655  let IS_ANDROID = false;
656
657  /**
658   * The detected Android version - or `null` if not Android or indeterminable.
659   *
660   * @static
661   * @type {number|string|null}
662   */
663  let ANDROID_VERSION;
664
665  /**
666   * Whether or not this is Mozilla Firefox.
667   *
668   * @static
669   * @type {Boolean}
670   */
671  let IS_FIREFOX = false;
672
673  /**
674   * Whether or not this is Microsoft Edge.
675   *
676   * @static
677   * @type {Boolean}
678   */
679  let IS_EDGE = false;
680
681  /**
682   * Whether or not this is any Chromium Browser
683   *
684   * @static
685   * @type {Boolean}
686   */
687  let IS_CHROMIUM = false;
688
689  /**
690   * Whether or not this is any Chromium browser that is not Edge.
691   *
692   * This will also be `true` for Chrome on iOS, which will have different support
693   * as it is actually Safari under the hood.
694   *
695   * Deprecated, as the behaviour to not match Edge was to prevent Legacy Edge's UA matching.
696   * IS_CHROMIUM should be used instead.
697   * "Chromium but not Edge" could be explicitly tested with IS_CHROMIUM && !IS_EDGE
698   *
699   * @static
700   * @deprecated
701   * @type {Boolean}
702   */
703  let IS_CHROME = false;
704
705  /**
706   * The detected Chromium version - or `null`.
707   *
708   * @static
709   * @type {number|null}
710   */
711  let CHROMIUM_VERSION = null;
712
713  /**
714   * The detected Google Chrome version - or `null`.
715   * This has always been the _Chromium_ version, i.e. would return on Chromium Edge.
716   * Deprecated, use CHROMIUM_VERSION instead.
717   *
718   * @static
719   * @deprecated
720   * @type {number|null}
721   */
722  let CHROME_VERSION = null;
723
724  /**
725   * 

740
741  /**
742   * Whether or not this is a Windows machine.
743   *
744   * @static
745   * @type {Boolean}
746   */
747  let IS_WINDOWS = false;
748
749  /**
750   * Whether or not this device is an iPad.
751   *
752   * @static
753   * @type {Boolean}
754   */
755  let IS_IPAD = false;
756
757  /**
758   * Whether or not this device is an iPhone.
759   *
760   * @static
761   * @type {Boolean}
762   */
763  // The Facebook app's UIWebView identifies as both an iPhone and iPad, so
764  // to identify iPhones, we need to exclude iPads.
765  // http://artsy.github.io/blog/2012/10/18/the-perils-of-ios-user-agent-sniffing/
766  let IS_IPHONE = false;
767
768  /**
769   * Whether or not this device is touch-enabled.
770   *
771   * @static
772   * @const
773   * @type {Boolean}
774   */
775  const TOUCH_ENABLED = Boolean(isReal() && ('ontouchstart' in window || window.navigator.maxTouchPoints || window.DocumentTouch && window.document instanceof window.DocumentTouch));
776  const UAD = window.navigator && window.navigator.userAgentData;
777  if (UAD && UAD.platform && UAD.brands) {
778    // If userAgentData is present, use it instead of userAgent to avoid warnings
779    // Currently only implemented on Chromium
780    // userAgentData does not expose Android version, so ANDROID_VERSION remains `null`
781
782    IS_ANDROID = UAD.platform === 'Android';
783    IS_EDGE = Boolean(UAD.brands.find(b => b.brand === 'Microsoft Edge'));
784    IS_CHROMIUM = Boolean(UAD.brands.find(b => b.brand === 'Chromium'));
785    IS_CHROME = !IS_EDGE && IS_CHROMIUM;
786    CHROMIUM_VERSION = CHROME_VERSION = (UAD.brands.find(b => b.brand === 'Chromium') || {}).version || null;
787    IS_WINDOWS = UAD.platform === 'Windows';
788  }
789
790  // If the browser is not Chromium, either userAgentData is not present which could be an old Chromium browser,
791  //  or it's a browser that has added userAgentData since that we don't have tests for yet. In either case,
792  // the checks need to be made agiainst the regular userAgent string.
793  if (!IS_CHROMIUM) {
794    const USER_AGENT = window.navigator && window.navigator.userAgent || '';
795    IS_IPOD = /iPod/i.test(USER_AGENT);
796    IOS_VERSION = function () {
797      const match = USER_AGENT.match(/OS (\d+)_/i);
798      if (match && match[1]) {
799        return match[1];
800      }
801      return null;
802    }();
803    IS_ANDROID = /Android/i.test(USER_AGENT);
804    ANDROID_VERSION = function () {
805      // This matches Android Major.Minor.Patch versions
806      // ANDROID_VERSION is Major.Minor as a Number, if Minor isn't available, then only Major is returned
807      const match = USER_AGENT.match(/Android (\d+)(?:\.(\d+))?(?:\.(\d+))*/i);
808      if (!match) {
809        return null;
810      }
811      const major = match[1] && parseFloat(match[1]);
812      const minor = match[2] && parseFloat(match[2]);
813      if (major && minor) {
814        return parseFloat(match[1] + '.' + match[2]);
815      } else if (major) {
816        return major;
817      }
818      return null;
819    }();
820    IS_FIREFOX = /Firefox/i.test(USER_AGENT);
821    IS_EDGE = /Edg/i.test(USER_AGENT);
822    IS_CHROMIUM = /Chrome/i.test(USER_AGENT) || /CriOS/i.test(USER_AGENT);
823    IS_CHROME = !IS_EDGE && IS_CHROMIUM;
824    CHROMIUM_VERSION = CHROME_VERSION = function () {
825      const match = USER_AGENT.match(/(Chrome|CriOS)\/(\d+)/);
826      if (match && match[2]) {
827        return parseFloat(match[2]);
828      }
829      return null;
830    }();
831    IE_VERSION = function () {
832      const result = /MSIE\s(\d+)\.\d/.exec(USER_AGENT);
833      let version = result && parseFloat(result[1]);
834      if (!version && /Trident\/7.0/i.test(USER_AGENT) && /rv:11.0/.test(USER_AGENT)) {
835        // IE 11 has a different user agent string than other IE versions
836        version = 11.0;
837      }
838      return version;
839    }();
840    IS_SAFARI = /Safari/i.test(USER_AGENT) && !IS_CHROME && !IS_ANDROID && !IS_EDGE;
841    IS_WINDOWS = /Windows/i.test(USER_AGENT);
842    IS_IPAD = /iPad/i.test(USER_AGENT) || IS_SAFARI && TOUCH_ENABLED && !/iPhone/i.test(USER_AGENT);
843    IS_IPHONE = /iPhone/i.test(USER_AGENT) && !IS_IPAD;
844  }
845
846  /**
847   * Whether or not this is an iOS device.
848   *
849   * @static
850   * @const
851   * @type {Boolean}
852   */
853  const IS_IOS = IS_IPHONE || IS_IPAD || IS_IPOD;
854
855  /**
856   * Whether or not this is any flavor of Safari - including iOS.
857   *
858   * @static
859   * @const
860   * @type {Boolean}
861   */
862  const IS_ANY_SAFARI = (IS_SAFARI || IS_IOS) && !IS_CHROME;
863
864  var browser = /*#__PURE__*/Object.freeze({
865    __proto__: null,
866    get IS_IPOD () { return IS_IPOD; },
867    get IOS_VERSION () { return IOS_VERSION; },
868    get IS_ANDROID () { return IS_ANDROID; },
869    get ANDROID_VERSION () { return ANDROID_VERSION; },
870    get IS_FIREFOX () { return IS_FIREFOX; },
871    get IS_EDGE () { return IS_EDGE; },
872    get IS_CHROMIUM () { return IS_CHROMIUM; },
873    get IS_CHROME () { return IS_CHROME; },
874    get CHROMIUM_VERSION () { return CHROMIUM_VERSION; },
875    get CHROME_VERSION () { return CHROME_VERSION; },
876    get IE_VERSION () { return IE_VERSION; },
877    get IS_SAFARI () { return IS_SAFARI; },
878    get IS_WINDOWS () { return IS_WINDOWS; },
879    get IS_IPAD () { return IS_IPAD; },
880    get IS_IPHONE () { return IS_IPHONE

880; },
881    TOUCH_ENABLED: TOUCH_ENABLED,
882    IS_IOS: IS_IOS,
883    IS_ANY_SAFARI: IS_ANY_SAFARI
884  });
885
886  /**
887   * @file dom.js
888   * @module dom
889   */
890
891  /**
892   * Detect if a value is a string with any non-whitespace characters.
893   *
894   * @private
895   * @param  {string} str
896   *         The string to check
897   *
898   * @return {boolean}
899   *         Will be `true` if the string is non-blank, `false` otherwise.
900   *
901   */
902  function isNonBlankString(str) {
903    // we use str.trim as it will trim any whitespace characters
904    // from the front or back of non-whitespace characters. aka
905    // Any string that contains non-whitespace characters will
906    // still contain them after `trim` but whitespace only strings
907    // will have a length of 0, failing this check.
908    return typeof str === 'string' && Boolean(str.trim());
909  }
910
911  /**
912   * Throws an error if the passed string has whitespace. This is used by
913   * class methods to be relatively consistent with the classList API.
914   *
915   * @private
916   * @param  {string} str
917   *         The string to check for whitespace.
918   *
919   * @throws {Error}
920   *         Throws an error if there is whitespace in the string.
921   */
922  function throwIfWhitespace(str) {
923    // str.indexOf instead of regex because str.indexOf is faster performance wise.
924    if (str.indexOf(' ') >= 0) {
925      throw new Error('class has illegal whitespace characters');
926    }
927  }
928
929  /**
930   * Whether the current DOM interface appears to be real (i.e. not simulated).
931   *
932   * @return {boolean}
933   *         Will be `true` if the DOM appears to be real, `false` otherwise.
934   */
935  function isReal() {
936    // Both document and window will never be undefined thanks to `global`.
937    return document === window.document;
938  }
939
940  /**
941   * Determines, via duck typing, whether or not a value is a DOM element.
942   *
943   * @param  {*} value
944   *         The value to check.
945   *
946   * @return {boolean}
947   *         Will be `true` if the value is a DOM element, `false` otherwise.
948   */
949  function isEl(value) {
950    return isObject$1(value) && value.nodeType === 1;
951  }
952
953  /**
954   * Determines if the current DOM is embedded in an iframe.
955   *
956   * @return {boolean}
957   *         Will be `true` if the DOM is embedded in an iframe, `false`
958   *         otherwise.
959   */
960  function isInFrame() {
961    // We need a try/catch here because Safari will throw errors when attempting
962    // to get either `parent` or `self`
963    try {
964      return window.parent !== window.self;
965    } catch (x) {
966      return true;
967    }
968  }
969
970  /**
971   * Creates functions to query the DOM using a given method.
972   *
973   * @private
974   * @param   {string} method
975   *          The method to create the query with.
976   *
977   * @return  {Function}
978   *          The query method
979   */
980  function createQuerier(method) {
981    return function (selector, context) {
982      if (!isNonBlankString(selector)) {
983        return document[method](null);
984      }
985      if (isNonBlankString(context)) {
986        context = document.querySelector(context);
987      }
988      const ctx = isEl(context) ? context : document;
989      return ctx[method] && ctx[method](selector);
990    };
991  }
992
993  /**
994   * Creates an element and applies properties, attributes, and inserts content.
995   *
996   * @param  {string} [tagName='div']
997   *         Name of tag to be created.
998   *
999   * @param  {Object} [properties={}]
1000   *         Element properties to be applied.
1001   *
1002   * @param  {Object} [attributes={}]
1003   *         Element attributes to be applied.
1004   *
1005   * @param {ContentDescriptor} [content]
1006   *        A content descriptor object.
1007   *
1008   * @return {Element}
1009   *         The element that was created.
1010   */
1011  function createEl(tagName = 'div', properties = {}, attributes = {}, content) {
1012    const el = document.createElement(tagName);
1013    Object.getOwnPropertyNames(properties).forEach(function (propName) {
1014      const val = properties[propName];
1015
1016      // Handle textContent since it's not supported everywhere and we have a
1017      // method for it.
1018      if (propName === 'textContent') {
1019        textContent(el, val);
1020      } else if (el[propName] !== val || propName === 'tabIndex') {
1021        el[propName] = val;
1022      }
1023    });
1024    Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
1025      el.setAttribute(attrName, attributes[attrName]);
1026    });
1027    if (content) {
1028      appendContent(el, content);
1029    }
1030    return el;
1031  }
1032
1033  /**
1034   * Injects text into an element, replacing any existing contents entirely.
1035   *
1036   * @param  {HTMLElement} el
1037   *         The element to add text content into
1038   *
1039   * @param  {string} text
1040   *         The text content to add.
1041   *
1042   * @return {Element}
1043   *         The element with added text content.
1044   */
1045  function textContent(el, text) {
1046    if (typeof el.textContent === 'undefined') {
1047      el.innerText = text;
1048    } else {
1049      el.textContent = text;
1050    }
1051    return el;
1052  }
1053
1054  /**
1055   * Insert an element as the first child node of another
1056   *
1057   * @param {Element} child
1058   *        Element to insert
1059   *
1060   * @param {Element} parent
1061   *        Element to insert child into
1062   */
1063  function prependTo(child, parent) {
1064    if (parent.firstChild) {
1065      parent.insertBefore(child, parent.firstChild);
1066    } else {
1067      parent.appendChild(child);
1068    }
1069  }
1070
1071  /**
1072   * Check if an element has a class name.
1073   *
1074   * @param  {Element} element
1075   *         Element to check
1076   *
1077   * @param  {string} classToCheck
1078   *         Class name to check for
1079   *
1080   * @return {boolean}
1081   *         Will be `true` if the element has a class, `false` otherwise.
1082   *
1083   * @throws {Error}
1084   *         Throws an error if `classToCheck` has white space.
1085   */
1086  function hasClass(element, classToCheck) {
1087    throwIfWhitespace(classToCheck);
1088    return element.classList.contains(classToCheck);
1089  }
1090
1091  /**
1092   * Add a class name to an element.
1093   *
1094   * @param  {Element} element
1095   *         Element to add class name to.
1096   *
1097   * @param  {...string} classesToAdd
1098   *         One or more class name to add.
1099   *
1100   * @return {Element}
1101   *         The DOM element with the added class name.
1102   */
1103  function addClass(element, ...classesToAdd) {
1104    element.classList.add(...classesToAdd.reduce((prev, current) => prev.concat(current.split(/\s+/)), []));
1105    return element;
1106  }
1107
1108  /**
1109   * Remove a class name from an element.
1110   *
1111   * @param  {Element} element
1112   *         Element to remove a class name from.
1113   *
1114   * @param  {...string} classesToRemove
1115   *         One or more class name to remove.
1116   *
1117   * @return {Element}
1118   *         The DOM element with class name removed.
1119   */
1120  function removeClass(element, ...classesToRemove) {
1121    // Protect in case the player gets disposed
1122    if (!element) {
1123      log$1.warn("removeClass was called with an element that doesn't exist");
1124      return null;
1125    }
1126    element.classList.remove(...classesToRemove.reduce((prev, current) => prev.concat(current.split(/\s+/)), []));
1127    return element;
1128  }
1129
1130  /**
1131   * The callback definition for toggleClass.
1132   *
1133   * @callback 

1156PredicateCallback} [predicate]
1157   *         See the return value for {@link module:dom~PredicateCallback}
1158   *
1159   * @return {Element}
1160   *         The element with a class that has been toggled.
1161   */
1162  function toggleClass(element, classToToggle, predicate) {
1163    if (typeof predicate === 'function') {
1164      predicate = predicate(element, classToToggle);
1165    }
1166    if (typeof predicate !== 'boolean') {
1167      predicate = undefined;
1168    }
1169    classToToggle.split(/\s+/).forEach(className => element.classList.toggle(className, predicate));
1170    return element;
1171  }
1172
1173  /**
1174   * Apply attributes to an HTML element.
1175   *
1176   * @param {Element} el
1177   *        Element to add attributes to.
1178   *
1179   * @param {Object} [attributes]
1180   *        Attributes to be applied.
1181   */
1182  function setAttributes(el, attributes) {
1183    Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
1184      const attrValue = attributes[attrName];
1185      if (attrValue === null || typeof attrValue === 'undefined' || attrValue === false) {
1186        el.removeAttribute(attrName);
1187      } else {
1188        el.setAttribute(attrName, attrValue === true ? '' : attrValue);
1189      }
1190    });
1191  }
1192
1193  /**
1194   * Get an element's attribute values, as defined on the HTML tag.
1195   *
1196   * Attributes are not the same as properties. They're defined on the tag
1197   * or with setAttribute.
1198   *
1199   * @param  {Element} tag
1200   *         Element from which to get tag attributes.
1201   *
1202   * @return {Object}
1203   *         All attributes of the element. Boolean attributes will be `true` or
1204   *         `false`, others will be strings.
1205   */
1206  function getAttributes(tag) {
1207    const obj = {};
1208
1209    // known boolean attributes
1210    // we can check for matching boolean properties, but not all browsers
1211    // and not all tags know about these attributes, so, we still want to check them manually
1212    const knownBooleans = ['autoplay', 'controls', 'playsinline', 'loop', 'muted', 'default', 'defaultMuted'];
1213    if (tag && tag.attributes && tag.attributes.length > 0) {
1214      const attrs = tag.attributes;
1215      for (let i = attrs.length - 1; i >= 0; i--) {
1216        const attrName = attrs[i].name;
1217        /** @type {boolean|string} */
1218        let attrVal = attrs[i].value;
1219
1220        // check for known booleans
1221        // the matching element property will return a value for typeof
1222        if (knownBooleans.includes(attrName)) {
1223          // the value of an included boolean attribute is typically an empty
1224          // string ('') which would equal false if we just check for a false value.
1225          // we also don't want support bad code like autoplay='false'
1226          attrVal = attrVal !== null ? true : false;
1227        }
1228        obj[attrName] = attrVal;
1229      }
1230    }
1231    return obj;
1232  }
1233
1234  /**
1235   * Get the value of an element's attribute.
1236   *
1237   * @param {Element} el
1238   *        A DOM element.
1239   *
1240   * @param {string} attribute
1241   *        Attribute to get the value of.
1242   *
1243   * @return {string}
1244   *         The value of the attribute.
1245   */
1246  function getAttribute(el, attribute) {
1247    return el.getAttribute(attribute);
1248  }
1249
1250  /**
1251   * Set the value of an element's attribute.
1252   *
1253   * @param {Element} el
1254   *        A DOM element.
1255   *
1256   * @param {string} attribute
1257   *        Attribute to set.
1258   *
1259   * @param {string} value
1260   *        Value to set the attribute to.
1261   */
1262  function setAttribute(el, attribute, value) {
1263    el.setAttribute(attribute, value);
1264  }
1265
1266  /**
1267   * Remove an element's attribute.
1268   *
1269   * @param {Element} el
1270   *        A DOM element.
1271   *
1272   * @param {string} attribute
1273   *        Attribute to remove.
1274   */
1275  function removeAttribute(el, attribute) {
1276    el.removeAttribute(attribute);
1277  }
1278
1279  /**
1280   * Attempt to block the ability to select text.
1281   */
1282  function blockTextSelection() {
1283    document.body.focus();
1284    document.onselectstart = function () {
1285      return false;
1286    };
1287  }
1288
1289  /**
1290   * Turn off text selection blocking.
1291   */
1292  function unblockTextSelection() {
1293    document.onselectstart = function () {
1294      return true;
1295    };
1296  }
1297
1298  /**
1299   * Identical to the native `getBoundingClientRect` function, but ensures that
1300   * the method is supported at all (it is in all browsers we claim to support)
1301   * and that the element is in the DOM before continuing.
1302   *
1303   * This wrapper function also shims properties which are not provided by some
1304   * older browsers (namely, IE8).
1305   *
1306   * Additionally, some browsers do not support adding properties to a
1307   * `ClientRect`/`DOMRect` object; so, we shallow-copy it with the standard
1308   * properties (except `x` and `y` which are not widely supported). This helps
1309   * avoid implementations where keys are non-enumerable.
1310   *
1311   * @param  {Element} el
1312   *         Element whose `ClientRect` we want to calculate.
1313   *
1314   * @return {Object|undefined}
1315   *         Always returns a plain object - or `undefined` if it cannot.
1316   */
1317  function getBoundingClientRect(el) {
1318    if (el && el.getBoundingClientRect && el.parentNode) {
1319      const rect = el.getBoundingClientRect();
1320      const result = {};
1321      ['bottom', 'height', 'left', 'right', 'top', 'width'].forEach(k => {
1322        if (rect[k] !== undefined) {
1323          result[k] = rect[k];
1324        }
1325      });
1326      if (!result.height) {
1327        result.height = parseFloat(computedStyle(el, 'height'));
1328      }
1329      if (!result.width) {
1330        result.width = parseFloat(computedStyle(el, 'width'));
1331      }
1332      return result;
1333    }
1334  }
1335
1336  /**
1337   * Represents the position of a DOM element on the page.
1338   *
1339   * @typedef  {Object} module:dom~Position
1340   *
1341   * @property {number} left
1342   *           Pixels to the left.
1343   *
1344   * @property {number} top
1345   *           Pixels from the top.
1346   */
1347
1348  /**
1349   * Get the position of an element in the DOM.
1350   *
1351   * Uses `getBoundingClientRect` technique from John Resig.
1352   *
1353   * @see http://ejohn.org/blog/getboundingclientrect-is-awesome/
1354   *
1355   * @param  {Element} el
1356   *         Element from which to get offset.
1357   *
1358   * @return {module:dom~Position}
1359   *         The position of the element that was passed in.
1360   */
1361  function findPosition(el) {
1362    if (!el || el && !el.offsetParent) {
1363      return {
1364        left: 0,
1365        top: 0,
1366        width: 0,
1367        height: 0
1368      };
1369    }
1370    const width = el.offsetWidth;
1371    const height = el.offsetHeight;
1372    let left = 0;
1373    let top = 0;
1374    while (el.offsetParent && el !== document[FullscreenApi.fullscreenElement]) {
1375      left += el.offsetLeft;
1376      top += el.offsetTop;
1377      el = el.offsetParent;
1378    }
1379    return {
1380      left,
1381      top,
1382      width,
1383      height
1384    };
1385  }
1386
1387  /**
1388   * Represents x and y coordinates for a DOM element or mouse pointer.
1389   *
1390   * @typedef  {Object} module:dom~Coordinates
1391   *
1392   * @property {number} x
1393   *           x coordinate in pixels
1394   *
1395   * @property {number} y
1396   *           y coordinate in pixels
1397   */
1398
1399  /**
1400   * Get the pointer position within an element.
1401   *
1402   * The base on the coordinates are the bottom left of the element.
1403   *
1404   * @param  {Element} el
1405   *         Element on which to get the pointer position on.
1406   *
1407   * @param  {Event} event
1408   *         Event object.
1409   *
1410   * @return {module:dom~Coordinates}
1411   *         A coordinates object corresponding to the mouse position.
1412   *
1413   */
1414  function getPointerPosition(el, event) {
1415    const translated = {
1416      x: 0,
1417      y: 0
1418    };
1419    if (IS_IOS) {
1420      let item = el;
1421      while (item && item.nodeName.toLowerCase() !== 'html') {
1422        const transform = computedStyle(item, 'transform');
1423        if (/^matrix/.test(transform)) {
1424          const values = transform.slice(7, -1).split(/,\s/).map(Number);
1425          translated.x += values[4];
1426          translated.y += values[5];
1427        } else if (/^matrix3d/.test(transform)) {
1428          const values = transform.slice(9, -1).split(/,\s/).map(Number);
1429          translated.x += values[12];
1430          translated.y += values[13];
1431        }
1432        i

1432tem = item.parentNode;
1433      }
1434    }
1435    const position = {};
1436    const boxTarget = findPosition(event.target);
1437    const box = findPosition(el);
1438    const boxW = box.width;
1439    const boxH = box.height;
1440    let offsetY = event.offsetY - (box.top - boxTarget.top);
1441    let offsetX = event.offsetX - (box.left - boxTarget.left);
1442    if (event.changedTouches) {
1443      offsetX = event.changedTouches[0].pageX - box.left;
1444      offsetY = event.changedTouches[0].pageY + box.top;
1445      if (IS_IOS) {
1446        offsetX -= translated.x;
1447        offsetY -= translated.y;
1448      }
1449    }
1450    position.y = 1 - Math.max(0, Math.min(1, offsetY / boxH));
1451    position.x = Math.max(0, Math.min(1, offsetX / boxW));
1452    return position;
1453  }
1454
1455  /**
1456   * Determines, via duck typing, whether or not a value is a text node.
1457   *
1458   * @param  {*} value
1459   *         Check if this value is a text node.
1460   *
1461   * @return {boolean}
1462   *         Will be `true` if the value is a text node, `false` otherwise.
1463   */
1464  function isTextNode$1(value) {
1465    return isObject$1(value) && value.nodeType === 3;
1466  }
1467
1468  /**
1469   * Empties the contents of an element.
1470   *
1471   * @param  {Element} el
1472   *         The element to empty children from
1473   *
1474   * @return {Element}
1475   *         The element with no children
1476   */
1477  function emptyEl(el) {
1478    while (el.firstChild) {
1479      el.removeChild(el.firstChild);
1480    }
1481    return el;
1482  }
1483
1484  /**
1485   * This is a mixed value that describes content to be injected into the DOM
1486   * via some method. It can be of the following types:
1487   *
1488   * Type       | Description
1489   * -----------|-------------
1490   * `string`   | The value will be normalized into a text node.
1491   * `Element`  | The value will be accepted as-is.
1492   * `Text`     | A TextNode. The value will be accepted as-is.
1493   * `Array`    | A one-dimensional array of strings, elements, text nodes, or functions. These functions should return a string, element, or text node (any other return value, like an array, will be ignored).
1494   * `Function` | A function, which is expected to return a string, element, text node, or array - any of the other possible values described above. This means that a content descriptor could be a function that returns an array of functions, but those second-level functions must return strings, elements, or text nodes.
1495   *
1496   * @typedef {string|Element|Text|Array|Function} ContentDescriptor
1497   */
1498
1499  /**
1500   * Normalizes content for eventual insertion into the DOM.
1501   *
1502   * This allows a wide range of content definition methods, but helps protect
1503   * from falling into the trap of simply writing to `innerHTML`, which could
1504   * be an XSS concern.
1505   *
1506   * The content for an element can be passed in multiple types and
1507   * combinations, whose behavior is as follows:
1508   *
1509   * @param {ContentDescriptor} content
1510   *        A content descriptor value.
1511   *
1512   * @return {Array}
1513   *         All of the content that was passed in, normalized to an array of
1514   *         elements or text nodes.
1515   */
1516  function normalizeContent(content) {
1517    // First, invoke content if it is a function. If it produces an array,
1518    // that needs to happen before normalization.
1519    if (typeof content === 'function') {
1520      content = content();
1521    }
1522
1523    // Next up, normalize to an array, so one or many items can be normalized,
1524    // filtered, and returned.
1525    return (Array.isArray(content) ? content : [content]).map(value => {
1526      // First, invoke value if it is a function to produce a new value,
1527      // which will be subsequently normalized to a Node of some kind.
1528      if (typeof value === 'function') {
1529        value = value();
1530      }
1531      if (isEl(value) || isTextNode$1(value)) {
1532        return value;
1533      }
1534      if (typeof value === 'string' && /\S/.test(value)) {
1535        return document.createTextNode(value);
1536      }
1537    }).filter(value => value);
1538  }
1539
1540  /**
1541   * Normalizes and appends content to an element.
1542   *
1543   * @param  {Element} el
1544   *         Element to append normalized content to.
1545   *
1546   * @param {ContentDescriptor} content
1547   *        A content descriptor value.
1548   *
1549   * @return {Element}
1550   *         The element with appended normalized content.
1551   */
1552  function appendContent(el, content) {
1553    normalizeContent(content).forEach(node => el.appendChild(node));
1554    return el;
1555  }
1556
1557  /**
1558   * Normalizes and inserts content into an element; this is identical to
1559   * `appendContent()`, except it empties the element first.
1560   *
1561   * @param {Element} el
1562   *        Element to insert normalized content into.
1563   *
1564   * @param {ContentDescriptor} content
1565   *        A content descriptor value.
1566   *
1567   * @return {Element}
1568   *         The element with inserted normalized content.
1569   */
1570  function insertContent(el, content) {
1571    return appendContent(emptyEl(el), content);
1572  }
1573
1574  /**
1575   * Check if an event was a single left click.
1576   *
1577   * @param  {MouseEvent} event
1578   *         Event object.
1579   *
1580   * @return {boolean}
1581   *         Will be `true` if a single left click, `false` otherwise.
1582   */
1583  function isSingleLeftClick(event) {
1584    // Note: if you create something draggable, be sure to
1585    // call it on both `mousedown` and `mousemove` event,
1586    // otherwise `mousedown` should be enough for a button
1587
1588    if (event.button === undefined && event.buttons === undefined) {
1589      // Why do we need `buttons` ?
1590      // Because, middle mouse sometimes have this:
1591      // e.button === 0 and e.buttons === 4
1592      // Furthermore, we want to prevent combination click, something like
1593      // HOLD middlemouse then left click, that would be
1594      // e.button === 0, e.buttons === 5
1595      // just `button` is not gonna work
1596
1597      // Alright, then what this block does ?
1598      // this is for chrome `simulate mobile devices`
1599      // I want to support this as well
1600
1601      return true;
1602    }
1603    if (event.button === 0 && event.buttons === undefined) {
1604      // Touch screen, sometimes on some specific device, `buttons`
1605      // doesn't have anything (safari on ios, blackberry...)
1606
1607      return true;
1608    }
1609
1610    // `mouseup` event on a single left click has
1611    // `button` and `buttons` equal to 0
1612    if (event.type === 'mouseup

1612' && event.button === 0 && event.buttons === 0) {
1613      return true;
1614    }
1615    if (event.button !== 0 || event.buttons !== 1) {
1616      // This is the reason we have those if else block above
1617      // if any special case we can catch and let it slide
1618      // we do it above, when get to here, this definitely
1619      // is-not-left-click
1620
1621      return false;
1622    }
1623    return true;
1624  }
1625
1626  /**
1627   * Finds a single DOM element matching `selector` within the optional
1628   * `context` of another DOM element (defaulting to `document`).
1629   *
1630   * @param  {string} selector
1631   *         A valid CSS selector, which will be passed to `querySelector`.
1632   *
1633   * @param  {Element|String} [context=document]
1634   *         A DOM element within which to query. Can also be a selector
1635   *         string in which case the first matching element will be used
1636   *         as context. If missing (or no element matches selector), falls
1637   *         back to `document`.
1638   *
1639   * @return {Element|null}
1640   *         The element that was found or null.
1641   */
1642  const $ = createQuerier('querySelector');
1643
1644  /**
1645   * Finds a all DOM elements matching `selector` within the optional
1646   * `context` of another DOM element (defaulting to `document`).
1647   *
1648   * @param  {string} selector
1649   *         A valid CSS selector, which will be passed to `querySelectorAll`.
1650   *
1651   * @param  {Element|String} [context=document]
1652   *         A DOM element within which to query. Can also be a selector
1653   *         string in which case the first matching element will be used
1654   *         as context. If missing (or no element matches selector), falls
1655   *         back to `document`.
1656   *
1657   * @return {NodeList}
1658   *         A element list of elements that were found. Will be empty if none
1659   *         were found.
1660   *
1661   */
1662  const $$ = createQuerier('querySelectorAll');
1663
1664  /**
1665   * A safe getComputedStyle.
1666   *
1667   * This is needed because in Firefox, if the player is loaded in an iframe with
1668   * `display:none`, then `getComputedStyle` returns `null`, so, we do a
1669   * null-check to make sure that the player doesn't break in these cases.
1670   *
1671   * @param    {Element} el
1672   *           The element you want the computed style of
1673   *
1674   * @param    {string} prop
1675   *           The property name you want
1676   *
1677   * @see      https://bugzilla.mozilla.org/show_bug.cgi?id=548397
1678   */
1679  function computedStyle(el, prop) {
1680    if (!el || !prop) {
1681      return '';
1682    }
1683    if (typeof window.getComputedStyle === 'function') {
1684      let computedStyleValue;
1685      try {
1686        computedStyleValue = window.getComputedStyle(el);
1687      } catch (e) {
1688        return '';
1689      }
1690      return computedStyleValue ? computedStyleValue.getPropertyValue(prop) || computedStyleValue[prop] : '';
1691    }
1692    return '';
1693  }
1694
1695  /**
1696   * Copy document style sheets to another window.
1697   *
1698   * @param    {Window} win
1699   *           The window element you want to copy the document style sheets to.
1700   *
1701   */
1702  function copyStyleSheetsToWindow(win) {
1703    [...document.styleSheets].forEach(styleSheet => {
1704      try {
1705        const cssRules = [...styleSheet.cssRules].map(rule => rule.cssText).join('');
1706        const style = document.createElement('style');
1707        style.textContent = cssRules;
1708        win.document.head.appendChild(style);
1709      } catch (e) {
1710        const link = document.createElement('link');
1711        link.rel = 'stylesheet';
1712        link.type = styleSheet.type;
1713        // For older Safari this has to be the string; on other browsers setting the MediaList works
1714        link.media = styleSheet.media.mediaText;
1715        link.href = styleSheet.href;
1716        win.document.head.appendChild(link);
1717      }
1718    });
1719  }
1720
1721  var Dom = /*#__PURE__*/Object.freeze({
1722    __proto__: null,
1723    isReal: isReal,
1724    isEl: isEl,
1725    isInFrame: isInFrame,
1726    createEl: createEl,
1727    textContent: textContent,
1728    prependTo: prependTo,
1729    hasClass: hasClass,
1730    addClass: addClass,
1731    removeClass: removeClass,
1732    toggleClass: toggleClass,
1733    setAttributes: setAttributes,
1734    getAttributes: getAttributes,
1735    getAttribute: getAttribute,
1736    setAttribute: setAttribute,
1737    removeAttribute: removeAttribute,
1738    blockTextSelection: blockTextSelection,
1739    unblockTextSelection: unblockTextSelection,
1740    getBoundingClientRect: getBoundingClientRect,
1741    findPosition: findPosition,
1742    getPointerPosition: getPointerPosition,
1743    isTextNode: isTextNode$1,
1744    emptyEl: emptyEl,
1745    normalizeContent: normalizeContent,
1746    appendContent: appendContent,
1747    insertContent: insertContent,
1748    isSingleLeftClick: isSingleLeftClick,
1749    $: $,
1750    $$: $$,
1751    computedStyle: computedStyle,
1752    copyStyleSheetsToWindow: copyStyleSheetsToWindow
1753  });
1754
1755  /**
1756   * @file setup.js - Functions for setting up a player without
1757   * user interaction based on the data-setup `attribute` of the video tag.
1758   *
1759   * @module setup
1760   */
1761  let _windowLoaded = false;
1762  let videojs$1;
1763
1764  /**
1765   * Set up any tags that have a data-setup `attribute` when the player is started.
1766   */
1767  const autoSetup = function () {
1768    if (videojs$1.options.autoSetup === false) {
1769      return;
1770    }
1771    const vids = Array.prototype.slice.call(document.getElementsByTagName('video'));
1772    const audios = Array.prototype.slice.call(document.getElementsByTagName('audio'));
1773    const divs = Array.prototype.slice.call(document.getElementsByTagName('video-js'));
1774    const mediaEls = vids.concat(audios, divs);
1775
1776    // Check if any media elements exist
1777    if (mediaEls && mediaEls.length > 0) {
1778      for (let i = 0, e = mediaEls.length; i < e; i++) {
1779        const mediaEl = mediaEls[i];
1780
1781        // Check if element exists, has getAttribute func.
1782        if (mediaEl && mediaEl.getAttribute) {
1783          // Make sure this player hasn't already been set up.
1784          if (mediaEl.player === undefined) {
1785            const options = mediaEl.getAttribute('data-setup');
1786
1787            // Check if data-setup attr exists.
1788            // We only auto-setup if they've added the data-setup attr.
1789            if (options !== null) {
1790              // Create new video.js instance.
1791              videojs$1(mediaEl);
1792            }
1793          }
1794
1795          // If getAttribute isn't defined, we need to wait for the DOM.
1796        } else {
1797          autoSetupTimeout(1);
1798          break;
1799        }
1800      }
1801
1802      // No videos were found, so keep looping unless page is finished loading.
1803    } else if (!_windowLoaded) {
1804      autoSetupTimeout(1);
1805    }
1806  };
1807
1808  /**
1809   * Wait until the page is loaded before running autoSetup. This will be called in
1810   * autoSetup if `hasLoaded` returns false.
1811   *
1812   * @param {number} wait
1813   *        How long to wait in ms
1814   *
1815   * @param {module:videojs} [vjs]
1816   *        The videojs library function
1817   */
1818  function autoSetupTimeout(wait, vjs) {
1819    // Protect against breakage in non-browser environments
1820    if (!isReal()) {
1821      return;
1822    }
1823    if (vjs) {
1824      videojs$1 = vjs;
1825    }
1826    window.setTimeout(autoSetup, wait);
1827  }
1828
1829  /**
1830   * Used to set the internal tracking of window loaded state to true.
1831   *
1832   * @private
1833   */
1834  function setWindowLoaded() {
1835    _windowLoaded = true;
1836    window.removeEventListener('load', setWindowLoaded);
1837  }
1838  if (isReal()) {
1839    if (document.readyState === 'complete') {
1840      setWindowLoaded();
1841    } else {
1842      /**
1843       * Listen for the load event on window, and set _windowLoaded to true.
1844       *
1845       * We use a standard event listener here to avoid incrementing the GUID
1846       * before any players are created.
1847       *
1848       * @listens load
1849       */
1850      window.addEventListener('load', setWindowLoaded);
1851    }
1852  }
1853
1854  /**
1855   * @file stylesheet.js
1856   * @module stylesheet
1857   */
1858
1859  /**
1860   * Create a DOM style element given a className for it.
1861   *
1862   * @param {string} className
1863   *        The className to add to the created style element.
1864   *
1865   * @return {Element}
1866   *         The element that was created.
1867   */
1868  const createStyleElement = function (className) {
1869    const style = document.createElement('style');
1870    style.className = className;
1871    return style;
1872  };
1873
1874  /**
1875   * Add text to a DOM element.
1876   *
1877   * @param {Element} el
1878   *        The Element to add text content to.
1879   *
1880   * @param {string} content
1881   *        The text to add to the element.
1882   */
1883  const setTextContent = function (el, content) {
1884    if (el.styleSheet) {
1885      el.styleSheet.cssText = content;
1886    } else {
1887      el.textContent = content;
1888    }
1889  };
1890
1891  /**
1892   * @file dom-data.js
1893   * @module dom-data
1894   */
1895
1896  /**
1897   * Element Data Store.
1898   *
1899   * Allows for binding data to an element without putting it directly on the
1900   * element. Ex. Event listeners are stored here.
1901   * (also from jsninja.com, slightly modified and updated for closure compiler)
1902   *
1903   * @type {Object}
1904   * @private
1905   */
1906  var DomData = new WeakMap();
1907
1908  /**
1909   * @file guid.js
1910   * @module guid
1911   */
1912
1913  // Default value for GUIDs. This allows us to reset the GUID counter in tests.
1914  //
1915  // The initial GUID is 3 because some users have come to rely on the first
1916  // default player ID ending up as `vjs_video_3`.
1917  //
1918  // See: https://github.com/videojs/video.js/pull/6216
1919  const _initialGuid = 3;
1920
1921  /**
1922   * Unique ID for an element or function
1923   *
1924   * @type {Number}
1925   */
1926  let _guid = _initialGuid;
1927
1928  /**
1929   * Get a unique auto-incrementing ID by number that has not been returned before.
1930   *
1931   * @return {number}
1932   *         A new unique ID.
1933   */
1934  function newGUID() {
1935    return _guid++;
1936  }
1937
1938  /**
1939   * @file events.js. An Event System (John Resig - Secrets of a JS Ninja http://jsninja.com/)
1940   * (Original book version wasn't completely usable, so fixed some things and made Closure Compiler compatible)
1941   * This should work very similarly to jQuery's events, however it's based off the book version which isn't as
1942   * robust as jquery's, so there's probably some differences.
1943   *
1944   * @file events.js
1945   * @module events
1946   */
1947
1948  /**
1949   * Clean up the listener cache and dispatchers
1950   *
1951   * @param {Element|Object} elem
1952   *        Element to clean up
1953   *
1954   * @param {string} type
1955   *        Type of event to clean up
1956   */
1957  function _cleanUpEvents(elem, type) {
1958    if (!DomData.has(elem)) {
1959      return;
1960    }
1961    const data = DomData.get(elem);
1962
1963    // Remove the events of a particular type if there are none left
1964    if (data.handlers[type].length === 0) {
1965      delete data.handlers[type];
1966      // data.handlers[type] = null;
1967      // Setting to null was causing an error with data.handlers
1968
1969      // Remove the meta-handler from the element
1970      if (elem.removeEventListener) {
1971        elem.removeEventListener(type, data.dispatcher, false);
1972      } else if (elem.detachEvent) {
1973        elem.detachEvent('on' + type, data.dispatcher);
1974      }
1975    }
1976
1977    // Remove the events object if there are no types left
1978    if (Object.getOwnPropertyNames(data.handlers).length <= 0) {
1979      delete data.handlers;
1980      delete data.dispatcher;
1981      delete data.disabled;
1982    }
1983
1984    // Finally remove the element data if there is no data left
1985    if (Object.getOwnPropertyNames(data).length === 0) {
1986      DomData.delete(elem);
1987    }
1988  }
1989
1990  /**
1991   * Loops through an array of event types and calls the requested method for each type.
1992   *
1993   * @param {Function} fn
1994   *        The event method we want to use.
1995   *
1996   * @param {Element|Object} elem
1997   *        Element or object to bind listeners to
1998   *
1999   * @param {string[]} types
2000   *        Type of event to bind to.
2001   *
2002   * @param {Function} callback
2003   *        Event listener.
2004   */
2005  function _handleMultipleEvents(fn, elem, types, callback) {
2006    types.forEach(function (type) {
2007      // Call the event method for each one of the types
2008      fn(elem, type, callback);
2009    });
2010  }
2011
2012  /**
2013   * Fix a native event to have standard property values
2014   *
2015   * @param {Object} event
2016   *        Event object to fix.
2017   *
2018   * @return {Object}
2019   *         Fixed event object.
2020   */
2021  function fixEvent(event) {
2022    if (event.fixed_) {
2023      return event;
2024    }
2025    function returnTrue() {
2026      return true;
2027    }
2028    function returnFalse() {
2029      return false;
2030    }
2031
2032    // Test if fixing up is needed
2033    // Used to check if !event.stopPropagation instead of isPropagationStopped
2034    // But native events return true for stopPropagation, but don't have
2035    // other expected methods like isPropagationStopped. Seems to be a problem
2036    // with the Javascript Ninja code. So we're just overriding all events now.
2037    if (!event || !event.isPropagationStopped || !event.isImmediatePropagationStopped) {
2038      const old = event || window.event;
2039      event = {};
2040      // Clone the old object so that we can modify the values event = {};
2041      // IE8 Doesn't like when you mess with native event properties
2042      // Firefox returns false for event.hasOwnProperty('type') and other props
2043      //  which makes copying more difficult.

2075        old.returnValue = false;
2076        event.defaultPrevented = true;
2077      };
2078      event.defaultPrevented = false;
2079
2080      // Stop the event from bubbling
2081      event.stopPropagation = function () {
2082        if (old.stopPropagation) {
2083          old.stopPropagation();
2084        }
2085        event.cancelBubble = true;
2086        old.cancelBubble = true;
2087        event.isPropagationStopped = returnTrue;
2088      };
2089      event.isPropagationStopped = returnFalse;
2090
2091      // Stop the event from bubbling and executing other handlers
2092      event.stopImmediatePropagation = function () {
2093        if (old.stopImmediatePropagation) {
2094          old.stopImmediatePropagation();
2095        }
2096        event.isImmediatePropagationStopped = returnTrue;
2097        event.stopPropagation();
2098      };
2099      event.isImmediatePropagationStopped = returnFalse;
2100
2101      // Handle mouse position
2102      if (event.clientX !== null && event.clientX !== undefined) {
2103        const doc = document.documentElement;
2104        const body = document.body;
2105        event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
2106        event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
2107      }
2108
2109      // Handle key presses
2110      event.which = event.charCode || event.keyCode;
2111
2112      // Fix button for mouse clicks:
2113      // 0 == left; 1 == middle; 2 == right
2114      if (event.button !== null && event.button !== undefined) {
2115        // The following is disabled because it does not pass videojs-standard
2116        // and... yikes.
2117        /* eslint-disable */
2118        event.button = event.button & 1 ? 0 : event.button & 4 ? 1 : event.button & 2 ? 2 : 0;
2119        /* eslint-enable */
2120      }
2121    }
2122
2123    event.fixed_ = true;
2124    // Returns fixed-up instance
2125    return event;
2126  }
2127
2128  /**
2129   * Whether passive event listeners are supported
2130   */
2131  let _supportsPassive;
2132  const supportsPassive = function () {
2133    if (typeof _supportsPassive !== 'boolean') {
2134      _supportsPassive = false;
2135      try {
2136        const opts = Object.defineProperty({}, 'passive', {
2137          get() {
2138            _supportsPassive = true;
2139          }
2140        });
2141        window.addEventListener('test', null, opts);
2142        window

2142.removeEventListener('test', null, opts);
2143      } catch (e) {
2144        // disregard
2145      }
2146    }
2147    return _supportsPassive;
2148  };
2149
2150  /**
2151   * Touch events Chrome expects to be passive
2152   */
2153  const passiveEvents = ['touchstart', 'touchmove'];
2154
2155  /**
2156   * Add an event listener to element
2157   * It stores the handler function in a separate cache object
2158   * and adds a generic handler to the element's event,
2159   * along with a unique id (guid) to the element.
2160   *
2161   * @param {Element|Object} elem
2162   *        Element or object to bind listeners to
2163   *
2164   * @param {string|string[]} type
2165   *        Type of event to bind to.
2166   *
2167   * @param {Function} fn
2168   *        Event listener.
2169   */
2170  function on(elem, type, fn) {
2171    if (Array.isArray(type)) {
2172      return _handleMultipleEvents(on, elem, type, fn);
2173    }
2174    if (!DomData.has(elem)) {
2175      DomData.set(elem, {});
2176    }
2177    const data = DomData.get(elem);
2178
2179    // We need a place to store all our handler data
2180    if (!data.handlers) {
2181      data.handlers = {};
2182    }
2183    if (!data.handlers[type]) {
2184      data.handlers[type] = [];
2185    }
2186    if (!fn.guid) {
2187      fn.guid = newGUID();
2188    }
2189    data.handlers[type].push(fn);
2190    if (!data.dispatcher) {
2191      data.disabled = false;
2192      data.dispatcher = function (event, hash) {
2193        if (data.disabled) {
2194          return;
2195        }
2196        event = fixEvent(event);
2197        const handlers = data.handlers[event.type];
2198        if (handlers) {
2199          // Copy handlers so if handlers are added/removed during the process it doesn't throw everything off.
2200          const handlersCopy = handlers.slice(0);
2201          for (let m = 0, n = handlersCopy.length; m < n; m++) {
2202            if (event.isImmediatePropagationStopped()) {
2203              break;
2204            } else {
2205              try {
2206                handlersCopy[m].call(elem, event, hash);
2207              } catch (e) {
2208                log$1.error(e);
2209              }
2210            }
2211          }
2212        }
2213      };
2214    }
2215    if (data.handlers[type].length === 1) {
2216      if (elem.addEventListener) {
2217        let options = false;
2218        if (supportsPassive() && passiveEvents.indexOf(type) > -1) {
2219          options = {
2220            passive: true
2221          };
2222        }
2223        elem.addEventListener(type, data.dispatcher, options);
2224      } else if (elem.attachEvent) {
2225        elem.attachEvent('on' + type, data.dispatcher);
2226      }
2227    }
2228  }
2229
2230  /**
2231   * Removes event listeners from an element
2232   *
2233   * @param {Element|Object} elem
2234   *        Object to remove listeners from.
2235   *
2236   * @param {string|string[]} [type]
2237   *        Type of listener to remove. Don't include to remove all events from element.
2238   *
2239   * @param {Function} [fn]
2240   *        Specific listener to remove. Don't include to remove listeners for an event
2241   *        type.
2242   */
2243  function off(elem, type, fn) {
2244    // Don't want to add a cache object through getElData if not needed
2245    if (!DomData.has(elem)) {
2246      return;
2247    }
2248    const data = DomData.get(elem);
2249
2250    // If no events exist, nothing to unbind
2251    if (!data.handlers) {
2252      return;
2253    }
2254    if (Array.isArray(type)) {
2255      return _handleMultipleEvents(off, elem, type, fn);
2256    }
2257
2258    // Utility function
2259    const removeType = function (el, t) {
2260      data.handlers[t] = [];
2261      _cleanUpEvents(el, t);
2262    };
2263
2264    // Are we removing all bound events?
2265    if (type === undefined) {
2266      for (const t in data.handlers) {
2267        if (Object.prototype.hasOwnProperty.call(data.handlers || {}, t)) {
2268          removeType(elem, t);
2269        }
2270      }
2271      return;
2272    }
2273    const handlers = data.handlers[type];
2274
2275    // If no handlers exist, nothing to unbind
2276    if (!handlers) {
2277      return;
2278    }
2279
2280    // If no listener was provided, remove all listeners for type
2281    if (!fn) {
2282      removeType(elem, type);
2283      return;
2284    }
2285
2286    // We're only removing a single handler
2287    if (fn.guid) {
2288      for (let n = 0; n < handlers.length; n++) {
2289        if (handlers[n].guid === fn.guid) {
2290          handlers.splice(n--, 1);
2291        }
2292      }
2293    }
2294    _cleanUpEvents(elem, type);
2295  }
2296
2297  /**
2298   * Trigger an event for an element
2299   *
2300   * @param {Element|Object} elem
2301   *        Element to trigger an event on
2302   *
2303   * @param {EventTarget~Event|string} event
2304   *        A string (the type) or an event object with a type attribute
2305   *
2306   * @param {Object} [hash]
2307   *        data hash to pass along with the event
2308   *
2309   * @return {boolean|undefined}
2310   *         Returns the opposite of `defaultPrevented` if default was
2311   *         prevented. Otherwise, returns `undefined`
2312   */
2313  function trigger(elem, event, hash) {
2314    // Fetches element data and a reference to the parent (for bubbling).
2315    // Don't want to add a data object to cache for every parent,
2316    // so checking hasElData first.
2317    const elemData = DomData.has(elem) ? DomData.get(elem) : {};
2318    const parent = elem.parentNode || elem.ownerDocument;
2319    // type = event.type || event,
2320    // handler;
2321
2322    // If an event name was passed as a string, creates an event out of it
2323    if (typeof event === 'string') {
2324      event = {
2325        type: event,
2326        target: elem
2327      };
2328    } else if (!event.target) {
2329      event.target = elem;
2330    }
2331
2332    // Normalizes the event properties.
2333    event = fixEvent(event);
2334
2335    // If the passed element has a dispatcher, executes the established handlers.
2336    if (elemData.dispatcher) {
2337      elemData.dispatcher.call(elem, event, hash);
2338    }
2339
2340    // Unless explicitly stopped or the event does not bubble (e.g. media events)
2341    // recursively calls this function to bubble the event up the DOM.
2342    if (parent && !event.isPropagationStopped() && event.bubbles === true) {
2343      trigger.call(null, parent, event, hash);
2344
2345      // If at the top of the DOM, triggers the default action unless disabled.
2346    } else if (!parent && !event.defaultPrevented && event.target && event.target[event.type]) {
2347      if (!DomData.has(event.target)) {
2348        DomData.set(event.target, {});
2349      }
2350      const targetData = DomData.get(event.target);
2351
2352      // Checks if the target has a default action for this event.
2353      if (event.target[event.type]) {
2354        // Temporarily disables event dispatching on the target as we have already executed the handler.
2355        targetData.disabled = true;
2356        // Executes the default action.
2357        if (typeof event.target[event.type] === 'function') {
2358          event.target[event.type]();
2359        }
2360        // Re-enables event dispatching.
2361        targetData.disabled = false;
2362      }
2363    }
2364
2365    // Inform the triggerer if the default was prevented by returning false
2366    return !event.defaultPrevented;
2367  }
2368
2369  /**
2370   * Trigger a listener only once for an event.
2371   *
2372   * @param {Element|Object} elem
2373   *        Element or object to bind to.
2374   *
2375   * @param {string|string[]} type
2376   *        Name/type of event
2377   *
2378   * @param {Event~EventListener} fn
2379   *        Event listener function
2380   */
2381  function one(elem, type, fn) {
2382    if (Array.isArray(type)) {
2383      return _handleMultipleEvents(one, elem, type, fn);
2384    }
2385    const func = function () {
2386      off(elem, type, func);
2387      fn.apply(this, arguments);
2388    };
2389
2390    // copy the guid to the new function so it can removed using the original function's ID
2391    func.guid = fn.guid = fn.guid || newGUID();
2392    on(elem, type, func);
2393  }
2394
2395  /**
2396   * Trigger a listener only once and then turn if off for all
2397   * configured events
2398   *
2399   * @param {Element|Object} elem
2400   *        Element or object to bind to.
2401   *
2402   * @param {string|string[]} type
2403   *        Name/type of event
2404   *
2405   * @param {Event~EventListener} fn
2406   *        Event listener function
2407   */
2408  function any(elem, type, fn) {
2409    const func = function () {
2410      off(elem, type, func);
2411      fn.apply(this, arguments);
2412    };
2413
2414    // copy the guid to the new function so it can removed using the original function's ID
2415    func.guid = fn.guid = fn.guid || newGUID();
2416
2417    // multiple ons, but one off for everything
2418    on(elem, type, func);
2419  }
2420
2421  var Events = /*#__PURE__*/Object.freeze({
2422    __proto__: null,
2423    fixEvent: fixEvent,
2424    on: on,
2425    off: off,
2426    trigger: trigger,
2427    one: one,
2428    any: any
2429  });
2430
2431  /**
2432   * @file fn.js
2433   * @module fn
2434   */
2435  const UPDATE_REFRESH_INTERVAL = 30;
2436
2437  /**
2438   * A private, internal-only function for changing the context of a function.
2439   *
2440   * It also stores a unique id on the function so it can be easily removed from
2441   * events.
2442   *
2443   * @private
2444   * @function
2445   * @param    {*} context
2446   *           The object to bind as scope.
2447   *
2448   * @param    {Function} fn
2449   *           The function to be bound to a scope.
2450   *
2451   * @param    {number} [uid]
2452   *           An optional unique ID for the function to be set
2453   *
2454   * @return   {Function}
2455   *           The new function that will be bound into the context given
2456   */
2457  const bind_ = function (context, fn, uid) {
2458    // Make sure the function has a unique ID
2459    if (!fn.guid) {
2460      fn.guid = newGUID();
2461    }
2462
2463    // Create the new function that changes the context
2464    const bound = fn.bind(context);
2465
2466    // Allow for the ability to individualize this function
2467    // Needed in the case where multiple objects might share the same prototype
2468    // IF both items add an event listener with the same function, then you try to remove just one
2469    // it will remove both because they both have the same guid.
2470    // when using this, you need to use the bind method when you remove the listener as well.
2471    // currently used in text tracks
2472    bound.guid = uid ? uid + '_' + fn.guid : fn.guid;
2473    return bound;
2474  };
2475
2476  /**
2477   * Wraps the given function, `fn`, with a new function that only invokes `fn`
2478   * at most once per every `wait` milliseconds.
2479   *
2480   * @function
2481   * @param    {Function} fn
2482   *           The function to be throttled.
2483   *
2484   * @param    {number}   wait
2485   *           The number of milliseconds by which to throttle.
2486   *
2487   * @return   {Function}
2488   */
2489  const throttle = function (fn, wait) {
2490    let last = window

2490.performance.now();
2491    const throttled = function (...args) {
2492      const now = window.performance.now();
2493      if (now - last >= wait) {
2494        fn(...args);
2495        last = now;
2496      }
2497    };
2498    return throttled;
2499  };
2500
2501  /**
2502   * Creates a debounced function that delays invoking `func` until after `wait`
2503   * milliseconds have elapsed since the last time the debounced function was
2504   * invoked.
2505   *
2506   * Inspired by lodash and underscore implementations.
2507   *
2508   * @function
2509   * @param    {Function} func
2510   *           The function to wrap with debounce behavior.
2511   *
2512   * @param    {number} wait
2513   *           The number of milliseconds to wait after the last invocation.
2514   *
2515   * @param    {boolean} [immediate]
2516   *           Whether or not to invoke the function immediately upon creation.
2517   *
2518   * @param    {Object} [context=window]
2519   *           The "context" in which the debounced function should debounce. For
2520   *           example, if this function should be tied to a Video.js player,
2521   *           the player can be passed here. Alternatively, defaults to the
2522   *           global `window` object.
2523   *
2524   * @return   {Function}
2525   *           A debounced function.
2526   */
2527  const debounce = function (func, wait, immediate, context = window) {
2528    let timeout;
2529    const cancel = () => {
2530      context.clearTimeout(timeout);
2531      timeout = null;
2532    };
2533
2534    /* eslint-disable consistent-this */
2535    const debounced = function () {
2536      const self = this;
2537      const args = arguments;
2538      let later = function () {
2539        timeout = null;
2540        later = null;
2541        if (!immediate) {
2542          func.apply(self, args);
2543        }
2544      };
2545      if (!timeout && immediate) {
2546        func.apply(self, args);
2547      }
2548      context.clearTimeout(timeout);
2549      timeout = context.setTimeout(later, wait);
2550    };
2551    /* eslint-enable consistent-this */
2552
2553    debounced.cancel = cancel;
2554    return debounced;
2555  };
2556
2557  var Fn = /*#__PURE__*/Object.freeze({
2558    __proto__: null,
2559    UPDATE_REFRESH_INTERVAL: UPDATE_REFRESH_INTERVAL,
2560    bind_: bind_,
2561    throttle: throttle,
2562    debounce: debounce
2563  });
2564
2565  /**
2566   * @file src/js/event-target.js
2567   */
2568  let EVENT_MAP;
2569
2570  /**
2571   * `EventTarget` is a class that can have the same API as the DOM `EventTarget`. It
2572   * adds shorthand functions that wrap around lengthy functions. For example:
2573   * the `on` function is a wrapper around `addEventListener`.
2574   *
2575   * @see [EventTarget Spec]{@link https://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-EventTarget}
2576   * @class EventTarget
2577   */
2578  class EventTarget$2

2578 {
2579    /**
2580     * Adds an `event listener` to an instance of an `EventTarget`. An `event listener` is a
2581     * function that will get called when an event with a certain name gets triggered.
2582     *
2583     * @param {string|string[]} type
2584     *        An event name or an array of event names.
2585     *
2586     * @param {Function} fn
2587     *        The function to call with `EventTarget`s
2588     */
2589    on(type, fn) {
2590      // Remove the addEventListener alias before calling Events.on
2591      // so we don't get into an infinite type loop
2592      const ael = this.addEventListener;
2593      this.addEventListener = () => {};
2594      on(this, type, fn);
2595      this.addEventListener = ael;
2596    }
2597    /**
2598     * Removes an `event listener` for a specific event from an instance of `EventTarget`.
2599     * This makes it so that the `event listener` will no longer get called when the
2600     * named event happens.
2601     *
2602     * @param {string|string[]} type
2603     *        An event name or an array of event names.
2604     *
2605     * @param {Function} fn
2606     *        The function to remove.
2607     */
2608    off(type, fn) {
2609      off(this, type, fn);
2610    }
2611    /**
2612     * This function will add an `event listener` that gets triggered only once. After the
2613     * first trigger it will get removed. This is like adding an `event listener`
2614     * with {@link EventTarget#on} that calls {@link EventTarget#off} on itself.
2615     *
2616     * @param {string|string[]} type
2617     *        An event name or an array of event names.
2618     *
2619     * @param {Function} fn
2620     *        The function to be called once for each event name.
2621     */
2622    one(type, fn) {
2623      // Remove the addEventListener aliasing Events.on
2624      // so we don't get into an infinite type loop
2625      const ael = this.addEventListener;
2626      this.addEventListener = () => {};
2627      one(this, type, fn);
2628      this.addEventListener = ael;
2629    }
2630    /**
2631     * This function will add an `event listener` that gets triggered only once and is
2632     * removed from all events. This is like adding an array of `event listener`s
2633     * with {@link EventTarget#on} that calls {@link EventTarget#off} on all events the
2634     * first time it is triggered.
2635     *
2636     * @param {string|string[]} type
2637     *        An event name or an array of event names.
2638     *
2639     * @param {Function} fn
2640     *        The function to be called once for each event name.
2641     */
2642    any(type, fn) {
2643      // Remove the addEventListener aliasing Events.on
2644      // so we don't get into an infinite type loop
2645      const ael = this.addEventListener;
2646      this.addEventListener = () => {};
2647      any(this, type, fn);
2648      this.addEventListener = ael;
2649    }
2650    /**
2651     * This function causes an event to happen. This will then cause any `event listeners`
2652     * that are waiting for that event, to get called. If there are no `event listeners`
2653     * for an event then nothing will happen.
2654     *
2655     * If the name of the `Event` that is being triggered is in `EventTarget.allowedEvents_`.
2656     * Trigger will also call the `on` + `uppercaseEventName` function.
2657     *
2658     * Example:
2659     * 'click' is in `EventTarget.allowedEvents_`, so, trigger will attempt to call
2660     * `onClick` if it exists.
2661     *
2662     * @param {string|EventTarget~Event|Object} event
2663     *        The name of the event, an `Event`, or an object with a key of type set to
2664     *        an event name.
2665     */
2666    trigger(event) {
2667      const type = event.type || event;
2668
2669      // deprecation
2670      // In a future version we should default target to `this`
2671      // similar to how we default the target to `elem` in
2672      // `Events.trigger`. Right now the default `target` will be
2673      // `document` due to the `Event.fixEvent` call.
2674      if (typeof event === 'string') {
2675        event = {
2676          type
2677        };
2678      }
2679      event = fixEvent(event);
2680      if (this.allowedEvents_[type] && this['on' + type]) {
2681        this['on' + type](event);
2682      }
2683      trigger(this, event);
2684    }
2685    queueTrigger(event) {
2686      // only set up EVENT_MAP if it'll be used
2687      if (!EVENT_MAP) {
2688        EVENT_MAP = new Map();
2689      }
2690      const type = event.type || event;
2691      let map = EVENT_MAP.get(this);
2692      if (!map) {
2693        map = new Map();
2694        EVENT_MAP.set(this, map);
2695      }
2696      const oldTimeout = map.get(type);
2697      map.delete(type);
2698      window.clearTimeout(oldTimeout);
2699      const timeout = window.setTimeout(() => {
2700        map.delete(type);
2701        // if we cleared out all timeouts for the current target, delete its map
2702        if (map.size === 0) {
2703          map = null;
2704          EVENT_MAP.delete(this);
2705        }
2706        this.trigger(event);
2707      }, 0);
2708      map.set(type, timeout);
2709    }
2710  }
2711
2712  /**