https://laziar.com/assets/videojs/video.cjs.js

1/**
2 * @license
3 * Video.js 8.20.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'use strict';
14
15var window$1 = require('global/window');
16var document$1 = require('global/document');
17var XHR = require('@videojs/xhr');
18var vtt = require('videojs-vtt.js');
19var _extends = require('@babel/runtime/helpers/extends');
20var _resolveUrl = require('@videojs/vhs-utils/cjs/resolve-url.js');
21var m3u8Parser = require('m3u8-parser');
22var codecs_js = require('@videojs/vhs-utils/cjs/codecs.js');
23var mediaTypes_js = require('@videojs/vhs-utils/cjs/media-types.js');
24var byteHelpers = require('@videojs/vhs-utils/cjs/byte-helpers');
25var mpdParser = require('mpd-parser');
26var parseSidx = require('mux.js/lib/tools/parse-sidx');
27var id3Helpers = require('@videojs/vhs-utils/cjs/id3-helpers');
28var containers = require('@videojs/vhs-utils/cjs/containers');
29var clock = require('mux.js/lib/utils/clock');
30
31function _interopDefaultLegacy(e) {
32  return e && typeof e === 'object' && 'default' in e ? e : { default: e };
33}
34
35var window__default = /*#__PURE__*/ _interopDefaultLegacy(window$1);
36var document__default = /*#__PURE__*/ _interopDefaultLegacy(document$1);
37var XHR__default = /*#__PURE__*/ _interopDefaultLegacy(XHR);
38var vtt__default = /*#__PURE__*/ _interopDefaultLegacy(vtt);
39var _extends__default = /*#__PURE__*/ _interopDefaultLegacy(_extends);
40var _resolveUrl__default = /*#__PURE__*/ _interopDefaultLegacy(_resolveUrl);
41var parseSidx__default = /*#__PURE__*/ _interopDefaultLegacy(parseSidx);
42
43var version$6 = '8.20.0';
44
45/**
46 * An Object that contains lifecycle hooks as keys which point to an array
47 * of functions that are run when a lifecycle is triggered
48 *
49 * @private
50 */
51const hooks_ = {};
52
53/**
54 * Get a list of hooks for a specific lifecycle
55 *
56 * @param  {string} type
57 *         the lifecycle to get hooks from
58 *
59 * @param  {Function|Function[]} [fn]
60 *         Optionally add a hook (or hooks) to the lifecycle that your are getting.
61 *
62 * @return {Array}
63 *         an array of hooks, or an empty array if there are none.
64 */
65const hooks = function (type, fn) {
66  hooks_[type] = hooks_[type] || [];
67  if (fn) {
68    hooks_[type] = hooks_[type].concat(fn);
69  }
70  return hooks_[type];
71};
72
73/**
74 * Add a function hook to a specific videojs lifecycle.
75 *
76 * @param {string} type
77 *        the lifecycle to hook the function to.
78 *
79 * @param {Function|Function[]}
80 *        The function or array of functions to attach.
81 */
82const hook = function (type, fn) {
83  hooks(type, fn);
84};
85
86/**
87 * Remove a hook from a specific videojs lifecycle.
88 *
89 * @param  {string} type
90 *         the lifecycle that the function hooked to
91 *
92 * @param  {Function} fn
93 *         The hooked function to remove
94 *
95 * @return {boolean}
96 *         The function that was removed or undef
97 */
98const removeHook = function (type, fn) {
99  const index = hooks(type).indexOf(fn);
100  if (index <= -1) {
101    return false;
102  }
103  hooks_[type] = hooks_[type].slice();
104  hooks_[type].splice(index, 1);
105  return true;
106};
107
108/**
109 * Add a function hook that will only run once to a specific videojs lifecycle.
110 *
111 * @param {string} type
112 *        the lifecycle to hook the function to.
113 *
114 * @param {Function|Function[]}
115 *        The function or array of functions to attach.
116 */
117const hookOnce = function (type, fn) {
118  hooks(
119    type,
120    [].concat(fn).map((original) => {
121      const wrapper = (...args) => {
122        removeHook(type, wrapper);
123        return original(...args);
124      };
125      return wrapper;
126    })
127  );
128};
129
130/**
131 * @file fullscreen-api.js
132 * @module fullscreen-api
133 */
134
135/**
136 * Store the browser-specific methods for the fullscreen API.
137 *
138 * @type {Object}
139 * @see [Specification]{@link https://fullscreen.spec.whatwg.org}
140 * @see [Map Approach From Screenfull.js]{@link https://github.com/sindresorhus/screenfull.js}
141 */
142const FullscreenApi = {
143  prefixed: true,
144};
145
146// browser API methods
147const apiMap = [
148  [
149    'requestFullscreen',
150    'exitFullscreen',
151    'fullscreenElement',
152    'fullscreenEnabled',
153    'fullscreenchange',
154    'fullscreenerror',
155    'fullscreen',
156  ],
157  // WebKit
158  [
159    'webkitRequestFullscreen',
160    'webkitExitFullscreen',
161    'webkitFullscreenElement',
162    'webkitFullscreenEnabled',
163    'webkitfullscreenchange',
164    'webkitfullscreenerror',
165    '-webkit-full-screen',
166  ],
167];
168const specApi = apiMap[0];
169let browserApi;
170
171// determine the supported set of functions
172for (let i = 0; i < apiMap.length; i++) {
173  // check for exitFullscreen function
174  if (apiMap[i][1] in document__default['default']) {
175    browserApi = apiMap[i];
176    break;
177  }
178}
179
180// map the browser API names to the spec API names
181if (browserApi) {
182  for (let i = 0; i < browserApi.length; i++) {
183    FullscreenApi[specApi[i]] = browserApi[i];
184  }
185  FullscreenApi.prefixed = browserApi[0] !== specApi[0];
186}
187
188/**
189 * @file create-logger.js
190 * @module create-logger
191 */
192
193// This is the private tracking variable for the logging history.
194let history = [];
195
196/**
197 * Log messages to the console and history based on the type of message
198 *
199 * @private
200 * @param  {string} name
201 *         The name of the console method to use.
202 *
203 * @param  {Object} log
204 *         The arguments to be passed to the matching console method.
205 *
206 * @param {string} [styles]
207 *        styles for name
208 */
209const LogByTypeFactory = (name, log, styles) => (type, level, args) => {
210  const lvl = log.levels[level];
211  const lvlRegExp = new RegExp(`^(${lvl})$`);
212  let resultName = name;
213  if (type !== 'log') {
214    // Add the type to the front of the message when it's not "log".
215    args.unshift(type.toUpperCase() + ':');
216  }
217  if (styles) {
218    resultName = `%c${name}`;
219    args.unshift(styles);
220  }
221
222  // Add console prefix after adding to history.
223  args.unshift(resultName + ':');
224
225  // Add a clone of the args at this point to history.
226  if (history) {
227    history.push([].concat(args));
228
229    // only store 1000 history entries
230    const splice = history.length - 1000;
231    history.splice(0, splice > 0 ? splice : 0);
232  }
233
234  // If there's no console then don't try to output messages, but they will
235  // still be stored in history.
236  if (!window__default['default'].console) {
237    return;
238  }
239
240  // Was setting these once outside of this function, but containing them
241  // in the function makes it easier to test cases where console doesn't exist
242  // when the module is executed.
243  let fn = window__default['default'].console[type];
244  if (!fn && type === 'debug') {
245    // Certain browsers don't have support for console.debug. For those, we
246    // should default to the closest comparable log.
247    fn = window__default['default'].console.info || window__default['default'].console.log;
248  }
249
250  // Bail out if there's no console or if this type is not allowed by the
251  // current logging level.
252  if (!fn || !lvl || !lvlRegExp.test(type)) {
253    return;
254  }
255  fn[Array.isArray(args) ? 'apply' : 'call'](window__default['default'].console, args);
256};
257function createLogger$1(name, delimiter = ':', styles = '') {
258  // This is the private tracking variable for logging level.
259  let level = 'info';
260
261  // the curried logByType bound to the specific log and history
262  let logByType;
263
264  /**
265   * Logs plain debug messages. Similar to `console.log`.
266   *
267   * Due to [limitations](https://github.com/jsdoc3/jsdoc/issues/955#issuecomment-313829149)
268   * of our JSDoc template, we cannot properly document this as both a function
269   * and a namespace, so its function signature is documented here.
270   *
271   * #### Arguments
272   * ##### *args
273   * *[]
274   *
275   * Any combination of values that could be passed to `console.log()`.
276   *
277   * #### Return Value
278   *
279   * `undefined`
280   *
281   * @namespace
282   * @param    {...*} args
283   *           One or more messages or objects that should be logged.
284   */
285  function log(...args) {
286    logByType('log', level, args);
287  }
288
289  // This is the logByType helper that the logging methods below use
290  logByType = LogByTypeFactory(name, log, styles);
291
292  /**
293   * Create a new subLogger which chains the old name to the new name.
294   *
295   * For example, doing `mylogger = videojs.log.createLogger('player')` and then using that logger will log the following:
296   * ```js
297   *  mylogger('foo');
298   *  // > VIDEOJS: player: foo
299   * ```
300   *
301   * @param {string} subName
302   *        The name to add call the new logger
303   * @param {string} [subDelimiter]
304   *        Optional delimiter
305   * @param {string} [subStyles]
306   *        Optional styles
307   * @return {Object}
308   */
309  log.createLogger = (subName, subDelimiter, subStyles) => {
310    const resultDelimiter = subDelimiter !== undefined ? subDelimiter : delimiter;
311    const resultStyles = subStyles !== undefined ? subStyles : styles;
312    const resultName = `${name} ${resultDelimiter} ${subName}`;
313    return createLogger$1(resultName, resultDelimiter, resultStyles);
314  };
315
316  /**
317   * Create a new logger.
318   *
319   * @param {string} newName
320   *        The name for the new logger
321   * @param {string} [newDelimiter]
322   *        Optional delimiter
323   * @param {string} [newStyles]
324   *        Optional styles
325   * @return {Object}
326   */
327  log.createNewLogger = (newName, newDelimiter, newStyles) => {
328    return createLogger$1(newName, newDelimiter, newStyles);
329  };
330
331  /**
332   * Enumeration of available logging levels, where the keys are the level names
333   * and the values are `|`-separated strings containing logging methods allowed
334   * in that logging level. These strings are used to create a regular expression
335   * matching the function name being called.
336   *
337   * Levels provided by Video.js are:
338   *
339   * - `off`: Matches no calls. Any value that can be cast to `false` will have
340   *   this effect. The most restrictive.
341   * - `all`: Matches only Video.js-provided functions (`debug`, `log`,
342   *   `log.warn`, and `log.error`).
343   * - `debug`: Matches `log.debug`, `log`, `log.warn`, and `log.error` calls.
344   * - `info` (default): Matches `log`, `log.warn`, and `log.error` calls.
345   * - `warn`: Matches `log.warn` and `log.error` calls.
346   * - `error`: Matches only `log.error` calls.
347   *
348   * @type {Object}
349   */
350  log.levels = {
351    all: 'debug|log|warn|error',
352    off: '',
353    debug: 'debug|log|warn|error',
354    info: 'log|warn|error',
355    warn: 'warn|error',
356    error: 'error',
357    DEFAULT: level,
358  };
359
360  /**
361   * Get or set the current logging level.
362   *
363   * If a string matching a key from {@link module:log.levels} is provided, acts
364   * as a setter.
365   *
366   * @param  {'all'|'debug'|'info'|'warn'|'error'|'off'} [lvl]
367   *         Pass a valid level to set a new logging level.
368   *
369   * @return {string}
370   *         The current logging level.
371   */
372  log.level = (lvl) => {
373    if (typeof lvl === 'string') {
374      if (!log.levels.hasOwnProperty(lvl)) {
375        throw new Error(`"${lvl}" in not a valid log level`);
376      }
377      level = lvl;
378    }
379    return level;
380  };
381
382  /**
383   * Returns an array containing everything that has been logged to the history.
384   *
385   * This array is a shallow clone of the internal history record. However, its
386   * contents are _not_ cloned; so, mutating objects inside this array will
387   * mutate them in history.
388   *
389   * @return {Array}
390   */
391  log.history = () => (history ? [].concat(history) : []);
392
393  /**
394   * Allows you to filter the history by the given logger name
395   *
396   * @param {string} fname
397   *        The name to filter by
398   *
399   * @return {Array}
400   *         The filtered list to return
401   */
402  log.history.filter = (fname) => {
403    return (history || []).filter((historyItem) => {
404      // if the first item in each historyItem includes `fname`, then it's a match
405      return new RegExp(`.*${fname}.*`).test(historyItem[0]);
406    });
407  };
408
409  /**
410   * Clears the internal history tracking, but does not prevent further history
411   * tracking.
412   */
413  log.history.clear = () => {
414    if (history) {
415      history.length = 0;
416    }
417  };
418
419  /**
420   * Disable history tracking if it is currently enabled.
421   */
422  log.history.disable = () => {
423    if (history !== null) {
424      history.length = 0;
425      history = null;
426    }
427  };
428
429  /**
430   * Enable history tracking if it is currently disabled.
431   */
432  log.history.enable = () => {
433    if (history === null) {
434      history = [];
435    }
436  };
437
438  /**
439   * Logs error messages. Similar to `console.error`.
440   *
441   * @param {...*} args
442   *        One or more messages or objects that should be logged as an error
443   */
444  log.error = (...args) =>

899    // ANDROID_VERSION is Major.Minor as a Number, if Minor isn't available, then only Major is returned
900    const match = USER_AGENT.match(/Android (\d+)(?:\.(\d+))?(?:\.(\d+))*/i);
901    if (!match) {
902      return null;
903    }
904    const major = match[1] && parseFloat(match[1]);
905    const minor = match[2] && parseFloat(match[2]);
906    if (major && minor) {
907      return parseFloat(match[1] + '.' + match[2]);
908    } else if (major) {
909      return major;
910    }
911    return null;
912  })();
913  IS_FIREFOX = /Firefox/i.test(USER_AGENT);
914  IS_EDGE = /Edg/i.test(USER_AGENT);
915  IS_CHROMIUM = /Chrome/i.test(USER_AGENT) || /CriOS/i.test(USER_AGENT);
916  IS_CHROME = !IS_EDGE && IS_CHROMIUM;
917  CHROMIUM_VERSION = CHROME_VERSION = (function () {
918    const match = USER_AGENT.match(/(Chrome|CriOS)\/(\d+)/);
919    if (match && match[2]) {
920      return parseFloat(match[2]);
921    }
922    return null;
923  })();
924  IE_VERSION = (function () {
925    const result = /MSIE\s(\d+)\.\d/.exec(USER_AGENT);
926    let version = result && parseFloat(result[1]);
927    if (!version && /Trident\/7.0/i.test(USER_AGENT) && /rv:11.0/.test(USER_AGENT)) {
928      // IE 11 has a different user agent string than other IE versions
929      version = 11.0;
930    }
931    return version;
932  })();
933  IS_TIZEN = /Tizen/i.test(USER_AGENT);
934  IS_WEBOS = /Web0S/i.test(USER_AGENT);
935  IS_SMART_TV = IS_TIZEN || IS_WEBOS;
936  IS_SAFARI = /Safari/i.test(USER_AGENT) && !IS_CHROME && !IS_ANDROID && !IS_EDGE && !IS_SMART_TV;
937  IS_WINDOWS = /Windows/i.test(USER_AGENT);
938  IS_IPAD = /iPad/i.test(USER_AGENT) || (IS_SAFARI && TOUCH_ENABLED && !/iPhone/i.test(USER_AGENT));
939  IS_IPHONE = /iPhone/i.test(USER_AGENT) && !IS_IPAD;
940}
941
942/**
943 * Whether or not this is an iOS device.
944 *
945 * @static
946 * @const
947 * @type {Boolean}
948 */
949const IS_IOS = IS_IPHONE || IS_IPAD || IS_IPOD;
950
951/**
952 * Whether or not this is any flavor of Safari - including iOS.
953 *
954 * @static
955 * @const
956 * @type {Boolean}
957 */
958const IS_ANY_SAFARI = (IS_SAFARI || IS_IOS) && !IS_CHROME;
959
960var browser = /*#__PURE__*/ Object.freeze({
961  __proto__: null,
962  get IS_IPOD() {
963    return IS_IPOD;
964  },
965  get IOS_VERSION() {
966    return IOS_VERSION;
967  },
968  get IS_ANDROID() {
969    return IS_ANDROID;
970  },
971  get ANDROID_VERSION() {
972    return ANDROID_VERSION;
973  },
974  get IS_FIREFOX() {
975    return IS_FIREFOX;
976  },
977  get IS_EDGE() {
978    return IS_EDGE;
979  },
980  get IS_CHROMIUM() {
981    return IS_CHROMIUM;
982  },
983  get IS_CHROME() {
984    return IS_CHROME;
985  },
986  get CHROMIUM_VERSION() {
987    return CHROMIUM_VERSION;
988  },
989  get CHROME_VERSION() {
990    return CHROME_VERSION;
991  },
992  IS_CHROMECAST_RECEIVER: IS_CHROMECAST_RECEIVER,
993  get IE_VERSION() {
994    return IE_VERSION;
995  },
996  get IS_SAFARI() {
997    return IS_SAFARI;
998  },
999  get IS_WINDOWS() {
1000    return IS_WINDOWS;
1001  },
1002  get IS_IPAD() {
1003    return IS_IPAD;
1004  },
1005  get IS_IPHONE() {
1006    return IS_IPHONE;
1007  },
1008  get IS_TIZEN() {
1009    return IS_TIZEN;
1010  },
1011  get IS_WEBOS() {
1012    return IS_WEBOS;
1013  },
1014  get IS_SMART_TV() {
1015    return IS_SMART_TV;
1016  },
1017  TOUCH_ENABLED: TOUCH_ENABLED,
1018  IS_IOS: IS_IOS,
1019  IS_ANY_SAFARI: IS_ANY_SAFARI,
1020});
1021
1022/**
1023 * @file dom.js
1024 * @module dom
1025 */
1026
1027/**
1028 * Detect if a value is a string with any non-whitespace characters.
1029 *
1030 * @private
1031 * @param  {string} str
1032 *         The string to check
1033 *
1034 * @return {boolean}
1035 *         Will be `true` if the string is non-blank, `false` otherwise.
1036 *
1037 */
1038function isNonBlankString(str) {
1039  // we use str.trim as it will trim any whitespace characters
1040  // from the front or back of non-whitespace characters. aka
1041  // Any string that contains non-whitespace characters will
1042  // still contain them after `trim` but whitespace only strings
1043  // will have a length of 0, failing this check.
1044  return typeof str === 'string' && Boolean(str.trim());
1045}
1046
1047/**
1048 * Throws an error if the passed string has whitespace. This is used by
1049 * class methods to be relatively consistent with the classList API.
1050 *
1051 * @private
1052 * @param  {string} str
1053 *         The string to check for whitespace.
1054 *
1055 * @throws {Error}
1056 *         Throws an error if there is whitespace in the string.
1057 */
1058function throwIfWhitespace(str) {
1059  // str.indexOf instead of regex because str.indexOf is faster performance wise.
1060  if (str.indexOf(' ') >= 0) {
1061    throw new Error('class has illegal whitespace characters');
1062  }
1063}
1064
1065/**
1066 * Whether the current DOM interface appears to be real (i.e. not simulated).
1067 *
1068 * @return {boolean}
1069 *         Will be `true` if the DOM appears to be real, `false` otherwise.
1070 */
1071function isReal() {
1072  // Both document and window will never be undefined thanks to `global`.
1073  return document__default['default'] === window__default['default'].document;
1074}
1075
1076/**
1077 * Determines, via duck typing, whether or not a value is a DOM element.
1078 *
1079 * @param  {*} value
1080 *         The value to check.
1081 *
1082 * @return {boolean}
1083 *         Will be `true` if the value is a DOM element, `false` otherwise.
1084 */
1085function isEl(value) {
1086  return isObject(value) && value.nodeType === 1;
1087}
1088
1089/**
1090 * Determines if the current DOM is embedded in an iframe.
1091 *
1092 * @return {boolean}
1093 *         Will be `true` if the DOM is embedded in an iframe, `false`
1094 *         otherwise.
1095 */
1096function isInFrame() {
1097  // We need a try/catch here because Safari will throw errors when attempting
1098  // to get either `parent` or `self`
1099  try {
1100    return window__default['default'].parent !== window__default['default'].self;
1101  } catch (x) {
1102    return true;
1103  }
1104}
1105
1106/**
1107 * Creates functions to query the DOM using a given method.
1108 *
1109 * @private
1110 * @param   {string} method
1111 *          The method to create the query with.
1112 *
1113 * @return  {Function}
1114 *          The query method
1115 */
1116function createQuerier(method) {
1117  return function (selector, context) {
1118    if (!isNonBlankString(selector)) {
1119      return document__default['default'][method](null);
1120    }
1121    if (isNonBlankString(context)) {
1122      context = document__default['default'].querySelector(context);
1123    }
1124    const ctx = isEl(context) ? context : document__default['default'];
1125    return ctx[method] && ctx[method](selector);
1126  };
1127}
1128
1129/**
1130 * Creates an element and applies properties, attributes, and inserts content.
1131 *
1132 * @param  {string} [tagName='div']
1133 *         Name of tag to be created.
1134 *
1135 * @param  {Object} [properties={}]
1136 *         Element properties to be applied.
1137 *
1138 * @param  {Object} [attributes={}]
1139 *         Element attributes to be applied.
1140 *
1141 * @param {ContentDescriptor} [content]
1142 *        A content descriptor object.
1143 *
1144 * @return {Element}
1145 *         The element that was created.
1146 */
1147function createEl(tagName = 'div', properties = {}, attributes = {}, content) {
1148  const el = document__default['default'].createElement(tagName);
1149  Object.getOwnPropertyNames(properties).forEach(function (propName) {
1150    const val = properties[propName];
1151
1152    // Handle textContent since it's not supported everywhere and we have a
1153    // method for it.
1154    if (propName === 'textContent') {
1155      textContent(el, val);
1156    } else if (el[propName] !== val || propName === 'tabIndex') {
1157      el[propName] = val;
1158    }
1159  });
1160  Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
1161    el.setAttribute(attrName, attributes[attrName]);
1162  });
1163  if (content) {
1164    appendContent(el, content);
1165  }
1166  return el;
1167}
1168
1169/**
1170 * Injects text into an element, replacing any existing contents entirely.
1171 *
1172 * @param  {HTMLElement} el
1173 *         The element to add text content into
1174 *
1175 * @param  {string} text
1176 *         The text content to add.
1177 *
1178 * @return {Element}
1179 *         The element with added text content.
1180 */
1181function textContent(el, text) {
1182  if (typeof el.textContent === 'undefined') {
1183    el.innerText = text;
1184  } else {
1185    el.textContent = text;
1186  }
1187  return el;
1188}
1189
1190/**
1191 * Insert an element as the first child node of another
1192 *
1193 * @param {Element} child
1194 *        Element to insert
1195 *
1196 * @param {Element} parent
1197 *        Element to insert child into
1198 */
1199function prependTo(child, parent) {
1200  if (parent.firstChild) {
1201    parent.insertBefore(child, parent.firstChild);
1202  } else {
1203    parent.appendChild(child);
1204  }
1205}
1206
1207/**
1208 * Check if an element has a class name.
1209 *
1210 * @param  {Element} element
1211 *         Element to check
1212 *
1213 * @param  {string} classToCheck
1214 *         Class name to check for
1215 *
1216 * @return {boolean}
1217 *         Will be `true` if the element has a class, `false` otherwise.
1218 *
1219 * @throws {Error}
1220 *         Throws an error if `classToCheck` has white space.
1221 */
1222function hasClass(element, classToCheck) {
1223  throwIfWhitespace(classToCheck);
1224  return element.classList.contains(classToCheck);
1225}
1226
1227/**
1228 * Add a class name to an element.
1229 *
1230 * @param  {Element} element
1231 *         Element to add class name to.
1232 *
1233 * @param  {...string} classesToAdd
1234 *         One or more class name to add.
1235 *
1236 * @return {Element}
1237 *         The DOM element with the added class name.
1238 */
1239function addClass(element, ...classesToAdd) {
1240  element.classList.add(
1241    ...classesToAdd.reduce((prev, current) => prev.concat(current.split(/\s+/)), [])
1242  );
1243  return element;
1244}
1245

1246/**
1247 * Remove a class name from an element.
1248 *
1249 * @param  {Element} element
1250 *         Element to remove a class name from.
1251 *
1252 * @param  {...string} classesToRemove
1253 *         One or more class name to remove.
1254 *
1255 * @return {Element}
1256 *         The DOM element with class name removed.
1257 */
1258function removeClass(element, ...classesToRemove) {
1259  // Protect in case the player gets disposed
1260  if (!element) {
1261    log$1.warn("removeClass was called with an element that doesn't exist");
1262    return null;
1263  }
1264  element.classList.remove(
1265    ...classesToRemove.reduce((prev, current) => prev.concat(current.split(/\s+/)), [])
1266  );
1267  return element;
1268}
1269
1270/**
1271 * The callback definition for toggleClass.
1272 *
1273 * @callback PredicateCallback
1274 * @param    {Element} element
1275 *           The DOM element of the Component.
1276 *
1277 * @param    {string} classToToggle
1278 *           The `className` that wants to be toggled
1279 *
1280 * @return   {boolean|undefined}
1281 *           If `true` is returned, the `classToToggle` will be added to the
1282 *           `element`, but not removed. If `false`, the `classToToggle` will be removed from
1283 *           the `element`, but not added. If `undefined`, the callback will be ignored.
1284 *
1285 */
1286
1287/**
1288 * Adds or removes a class name to/from an element depending on an optional
1289 * condition or the presence/absence of the class name.
1290 *
1291 * @param  {Element} element
1292 *         The element to toggle a class name on.
1293 *
1294 * @param  {string} classToToggle
1295 *         The class that should be toggled.
1296 *
1297 * @param  {boolean|PredicateCallback} [predicate]
1298 *         See the return value for {@link module:dom~PredicateCallback}
1299 *
1300 * @return {Element}
1301 *         The element with a class that has been toggled.
1302 */
1303function toggleClass(element, classToToggle, predicate) {
1304  if (typeof predicate === 'function') {
1305    predicate = predicate(element, classToToggle);
1306  }
1307  if (typeof predicate !== 'boolean') {
1308    predicate = undefined;
1309  }
1310  classToToggle.split(/\s+/).forEach((className) => element.classList.toggle(className, predicate));
1311  return element;
1312}
1313
1314/**
1315 * Apply attributes to an HTML element.
1316 *
1317 * @param {Element} el
1318 *        Element to add attributes to.
1319 *
1320 * @param {Object} [attributes]
1321 *        Attributes to be applied.
1322 */
1323function setAttributes(el, attributes) {
1324  Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
1325    const attrValue = attributes[attrName];
1326    if (attrValue === null || typeof attrValue === 'undefined' || attrValue === false) {
1327      el.removeAttribute(attrName);
1328    } else {
1329      el.setAttribute(attrName, attrValue === true ? '' : attrValue);
1330    }
1331  });
1332}
1333
1334/**
1335 * Get an element's attribute values, as defined on the HTML tag.
1336 *
1337 * Attributes are not the same as properties. They're defined on the tag
1338 * or with setAttribute.
1339 *
1340 * @param  {Element} tag
1341 *         Element from which to get tag attributes.
1342 *
1343 * @return {Object}
1344 *         All attributes of the element. Boolean attributes will be `true` or
1345 *         `false`, others will be strings.
1346 */
1347function getAttributes(tag) {
1348  const obj = {};
1349
1350  // known boolean attributes
1351  // we can check for matching boolean properties, but not all browsers
1352  // and not all tags know about these attributes, so, we still want to check them manually
1353  const knownBooleans = [
1354    'autoplay',
1355    'controls',
1356    'playsinline',
1357    'loop',
1358    'muted',
1359    'default',
1360    'defaultMuted',
1361  ];
1362  if (tag && tag.attributes && tag.attributes.length > 0) {
1363    const attrs = tag.attributes;
1364    for (let i = attrs.length - 1; i >= 0; i--) {
1365      const attrName = attrs[i].name;
1366      /** @type {boolean|string} */
1367      let attrVal = attrs[i].value;
1368
1369      // check for known booleans
1370      // the matching element property will return a value for typeof
1371      if (knownBooleans.includes(attrName)) {
1372        // the value of an included boolean attribute is typically an empty
1373        // string ('') which would equal false if we just check for a false value.
1374        // we also don't want support bad code like autoplay='false'
1375        attrVal = attrVal !== null ? true : false;

1376      }
1377      obj[attrName] = attrVal;
1378    }
1379  }
1380  return obj;
1381}
1382
1383/**
1384 * Get the value of an element's attribute.
1385 *
1386 * @param {Element} el
1387 *        A DOM element.
1388 *
1389 * @param {string} attribute
1390 *        Attribute to get the value of.
1391 *
1392 * @return {string}
1393 *         The value of the attribute.
1394 */
1395function getAttribute(el, attribute) {
1396  return el.getAttribute(attribute);
1397}
1398
1399/**
1400 * Set the value of an element's attribute.
1401 *
1402 * @param {Element} el
1403 *        A DOM element.
1404 *
1405 * @param {string} attribute
1406 *        Attribute to set.
1407 *
1408 * @param {string} value
1409 *        Value to set the attribute to.
1410 */
1411function setAttribute(el, attribute, value) {
1412  el.setAttribute(attribute, value);
1413}
1414
1415/**
1416 * Remove an element's attribute.
1417 *
1418 * @param {Element} el
1419 *        A DOM element.
1420 *
1421 * @param {string} attribute
1422 *        Attribute to remove.
1423 */
1424function removeAttribute(el, attribute) {
1425  el.removeAttribute(attribute);
1426}
1427
1428/**
1429 * Attempt to block the ability to select text.
1430 */
1431function blockTextSelection() {
1432  document__default['default'].body.focus();
1433  document__default['default'].onselectstart = function () {
1434    return false;
1435  };
1436}
1437
1438/**
1439 * Turn off text selection blocking.
1440 */
1441function unblockTextSelection() {
1442  document__default['default'].onselectstart = function () {
1443    return true;
1444  };
1445}
1446
1447/**
1448 * Identical to the native `getBoundingClientRect` function, but ensures that
1449 * the method is supported at all (it is in all browsers we claim to support)
1450 * and that the element is in the DOM before continuing.
1451 *
1452 * This wrapper function also shims properties which are not provided by some
1453 * older browsers (namely, IE8).
1454 *
1455 * Additionally, some browsers do not support adding properties to a
1456 * `ClientRect`/`DOMRect` object; so, we shallow-copy it with the standard
1457 * properties (except `x` and `y` which are not widely supported). This helps
1458 * avoid implementations where keys are non-enumerable.
1459 *
1460 * @param  {Element} el
1461 *         Element whose `ClientRect` we want to calculate.
1462 *
1463 * @return {Object|undefined}
1464 *         Always returns a plain object - or `undefined` if it cannot.
1465 */
1466function getBoundingClientRect(el) {
1467  if (el && el.getBoundingClientRect && el.parentNode) {
1468    const rect = el.getBoundingClientRect();
1469    const result = {};
1470    ['bottom', 'height', 'left', 'right', 'top', 'width'].forEach((k) => {
1471      if (rect[k] !== undefined) {
1472        result[k] = rect[k];
1473      }
1474    });
1475    if (!result.height) {
1476      result.height = parseFloat(computedStyle(el, 'height'));
1477    }
1478    if (!result.width) {
1479      result.width = parseFloat(computedStyle(el, 'width'));
1480    }
1481    return result;
1482  }
1483}
1484
1485/**
1486 * Represents the position of a DOM element on the page.
1487 *
1488 * @typedef  {Object} module:dom~Position
1489 *
1490 * @property {number} left
1491 *           Pixels to the left.
1492 *
1493 * @property {number} top
1494 *           Pixels from the top.
1495 */
1496
1497/**
1498 * Get the position of an element in the DOM.
1499 *
1500 * Uses `getBoundingClientRect` technique from John Resig.
1501 *
1502 * @see http://ejohn.org/blog/getboundingclientrect-is-awesome/
1503 *
1504 * @param  {Element} el
1505 *         Element from which to get offset.
1506 *
1507 * @return {module:dom~Position}
1508 *         The position of the element that was passed in.
1509 */
1510function findPosition(el) {
1511  if (!el || (el && !el.offsetParent)) {
1512    return {
1513      left: 0,
1514      top: 0,
1515      width: 0,
1516      height: 0,
1517    };
1518  }
1519  const width = el.offsetWidth;
1520  const height = el.offsetHeight;
1521  let left = 0;
1522  let top = 0;
1523  while (el.offsetParent && el !== document__default['default'][FullscreenApi.fullscreenElement]) {
1524    left += el.offsetLeft;
1525    top += el.offsetTop;
1526    el = el.offsetParent;
1527  }
1528  return {
1529    left,
1530    top,
1531    width,
1532    height,
1533  };
1534}
1535
1536/**
1537 * Represents x and y coordinates for a DOM element or mouse pointer.
1538 *
1539 * @typedef  {Object} module:dom~Coordinates
1540 *
1541 * @property {number} x
1542 *           x coordinate in pixels
1543 *
1544 * @property {number} y
1545 *           y coordinate in pixels
1546 */
1547
1548/**
1549 * Get the pointer position within an element.
1550 *
1551 * The base on the coordinates are the bottom left of the element.
1552 *
1553 * @param  {Element} el
1554 *         Element on which to get the pointer position on.
1555 *
1556 * @param  {Event} event
1557 *         Event object.
1558 *
1559 * @return {module:dom~Coordinates}
1560 *         A coordinates object corresponding to the mouse position.
1561 *
1562 */
1563function getPointerPosition(el, event) {
1564  const translated = {
1565    x: 0,
1566    y: 0,
1567  };
1568  if (IS_IOS) {
1569    let item = el;
1570    while (item && item.nodeName.toLowerCase() !== 'html') {
1571      const transform = computedStyle(item, 'transform');
1572      if (/^matrix/.test(transform)) {
1573        const values = transform.slice(7, -1).split(/,\s/).map(Number);
1574        translated.x += values[4];
1575        translated.y += values[5];
1576      } else if (/^matrix3d/.test(transform)) {
1577        const values = transform.slice(9, -1).split(/,\s/).map(Number);
1578        translated.x += values[12];
1579        translated.y += values[13];
1580      }
1581      if (
1582        item.assignedSlot &&
1583        item.assignedSlot.parentElement &&
1584        window__default['default'].WebKitCSSMatrix
1585      ) {
1586        const transformValue = window__default['default'].getComputedStyle(
1587          item.assignedSlot.parentElement
1588        ).transform;
1589        const matrix = new window__default['default'].WebKitCSSMatrix(transformValue);
1590        translated.x += matrix.m41;
1591        translated.y += matrix.m42;
1592      }
1593      item = item.parentNode || item.host;
1594    }
1595  }
1596  const position = {};
1597  const boxTarget = findPosition(event.target);
1598  const box = findPosition(el);
1599  const boxW = box.width;
1600  const boxH = box.height;
1601  let offsetY = event.offsetY - (box.top - boxTarget.top);
1602  let offsetX = event.offsetX - (box.left - boxTarget.left);
1603  if (event.changedTouches) {
1604    offsetX = event.changedTouches[0].pageX - box.left;
1605    offsetY = event.changedTouches[0].pageY + box.top;
1606    if (IS_IOS) {
1607      offsetX -= translated.x;
1608      offsetY -= translated.y;
1609    }
1610  }
1611  position.y = 1 - Math.max(0, Math.min(1, offsetY / boxH));
1612  position.x = Math.max(0, Math.min(1, offsetX / boxW));
1613  return position;
1614}
1615
1616/**
1617 * Determines, via duck typing, whether or not a value is a text node.
1618 *
1619 * @param  {*} value
1620 *         Check if this value is a text node.
1621 *
1622 * @return {boolean}
1623 *         Will be `true` if the value is a text node, `false` otherwise.
1624 */
1625function isTextNode(value) {
1626  return isObject(value) && value.nodeType === 3;
1627}
1628
1629/**
1630 * Empties the contents of an element.
1631 *
1632 * @param  {Element} el
1633 *         The element to empty children from
1634 *
1635 * @return {Element}
1636 *         The element with no children
1637 */
1638function emptyEl(el) {
1639  while (el.firstChild) {
1640    el.removeChild(el.firstChild);
1641  }
1642  return el;
1643}
1644
1645/**
1646 * This is a mixed value that describes content to be injected into the DOM
1647 * via some method. It can be of the following types:
1648 *
1649 * Type       | Description
1650 * -----------|-------------
1651 * `string`   | The value will be normalized into a text node.
1652 * `Element`  | The value will be accepted as-is.
1653 * `Text`     | A TextNode. The value will be accepted as-is.
1654 * `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).
1655 * `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.
1656 *
1657 * @typedef {string|Element|Text|Array|Function} ContentDescriptor
1658 */
1659
1660/**
1661 * Normalizes content for eventual insertion into the DOM.
1662 *
1663 * This allows a wide range of content definition methods, but helps protect
1664 * from falling into the trap of simply writing to `innerHTML`, which could
1665 * be an XSS concern.
1666 *
1667 * The content for an element can be passed in multiple types and
1668 * combinations, whose behavior is as follows:
1669 *
1670 * @param {ContentDescriptor} content
1671 *        A content descriptor value.
1672 *
1673 * @return {Array}
1674 *         All of the content that was passed in, normalized to an array of
1675 *         elements or text nodes.
1676 */
1677function normalizeContent(content) {
1678  // First, invoke content if it is a function. If it produces an array,
1679  // that needs to happen before normalization.
1680  if (typeof content === 'function') {
1681    content = content();
1682  }
1683
1684  // Next up, normalize to an array, so one or many items can be normalized,

1821 *         string in which case the first matching element will be used
1822 *         as context. If missing (or no element matches selector), falls
1823 *         back to `document`.
1824 *
1825 * @return {NodeList}
1826 *         A element list of elements that were found. Will be empty if none
1827 *         were found.
1828 *
1829 */
1830const $$ = createQuerier('querySelectorAll');
1831
1832/**
1833 * A safe getComputedStyle.
1834 *
1835 * This is needed because in Firefox, if the player is loaded in an iframe with
1836 * `display:none`, then `getComputedStyle` returns `null`, so, we do a
1837 * null-check to make sure that the player doesn't break in these cases.
1838 *
1839 * @param    {Element} el
1840 *           The element you want the computed style of
1841 *
1842 * @param    {string} prop
1843 *           The property name you want
1844 *
1845 * @see      https://bugzilla.mozilla.org/show_bug.cgi?id=548397
1846 */
1847function computedStyle(el, prop) {
1848  if (!el || !prop) {
1849    return '';
1850  }
1851  if (typeof window__default['default'].getComputedStyle === 'function') {
1852    let computedStyleValue;
1853    try {
1854      computedStyleValue = window__default['default'].getComputedStyle(el);
1855    } catch (e) {
1856      return '';
1857    }
1858    return computedStyleValue
1859      ? computedStyleValue.getPropertyValue(prop) || computedStyleValue[prop]
1860      : '';
1861  }
1862  return '';
1863}
1864
1865/**
1866 * Copy document style sheets to another window.
1867 *
1868 * @param    {Window} win
1869 *           The window element you want to copy the document style sheets to.
1870 *
1871 */
1872function copyStyleSheetsToWindow(win) {
1873  [...document__default['default'].styleSheets].forEach((styleSheet) => {
1874    try {
1875      const cssRules = [...styleSheet.cssRules].map((rule) => rule.cssText).join('');
1876      const style = document__default['default'].createElement('style');
1877      style.textContent = cssRules;
1878      win.document.head.appendChild(style);
1879    } catch (e) {
1880      const link = document__default['default'].createElement('link');
1881      link.rel = 'stylesheet';
1882      link.type = styleSheet.type;
1883      // For older Safari this has to be the string; on other browsers setting the MediaList works
1884      link.media = styleSheet.media.mediaText;
1885      link.href = styleSheet.href;
1886      win.document.head.appendChild(link);
1887    }
1888  });
1889}
1890
1891var Dom = /*#__PURE__*/ Object.freeze({
1892  __proto__: null,
1893  isReal: isReal,
1894  isEl: isEl,
1895  isInFrame: isInFrame,
1896  createEl: createEl,
1897  textContent: textContent,
1898  prependTo: prependTo,
1899  hasClass: hasClass,
1900  addClass: addClass,
1901  removeClass: removeClass,
1902  toggleClass: toggleClass,
1903  setAttributes: setAttributes,
1904  getAttributes: getAttributes,
1905  getAttribute: getAttribute,
1906  setAttribute: setAttribute,
1907  removeAttribute: removeAttribute,
1908  blockTextSelection: blockTextSelection,
1909  unblockTextSelection: unblockTextSelection,
1910  getBoundingClientRect: getBoundingClientRect,
1911  findPosition: findPosition,
1912  getPointerPosition: getPointerPosition,
1913  isTextNode: isTextNode,
1914  emptyEl: emptyEl,
1915  normalizeContent: normalizeContent,
1916  appendContent: appendContent,
1917  insertContent: insertContent,
1918  isSingleLeftClick: isSingleLeftClick,
1919  $: $,
1920  $$: $$,
1921  computedStyle: computedStyle,
1922  copyStyleSheetsToWindow: copyStyleSheetsToWindow,
1923});
1924
1925/**
1926 * @file setup.js - Functions for setting up a player without
1927 * user interaction based on the data-setup `attribute` of the video tag.
1928 *
1929 * @module setup
1930 */
1931let _windowLoaded = false;
1932let videojs$1;
1933
1934/**
1935 * Set up any tags that have a data-setup `attribute` when the player is started.
1936 */
1937const autoSetup = function () {
1938  if (videojs$1.options.autoSetup === false) {
1939    return;
1940  }
1941  const vids = Array.prototype.slice.call(
1942    document__default['default'].getElementsByTagName('video')
1943  );
1944  const audios = Array.prototype.slice.call(
1945    document__default['default'].getElementsByTagName('audio')
1946  );
1947  const divs = Array.prototype.slice.call(
1948    document__default['default'].getElementsByTagName('video-js')
1949  );
1950  const mediaEls = vids.concat(audios, divs);
1951
1952  // Check if any media elements exist
1953  if (mediaEls && mediaEls.length > 0) {
1954    for (let i = 0, e = mediaEls.length; i < e; i++) {
1955      const mediaEl = mediaEls[i];
1956
1957      // Check if element exists, has getAttribute func.
1958      if (mediaEl && mediaEl.getAttribute) {
1959        // Make sure this player hasn't already been set up.
1960        if (mediaEl.player === undefined) {
1961          const options = mediaEl.getAttribute('data-setup');
1962
1963          // Check if data-setup attr exists.
1964          // We only auto-setup if they've added the data-setup attr.
1965          if (options !== null) {
1966            // Create new video.js instance.
1967            videojs$1(mediaEl);
1968          }
1969        }
1970
1971        // If getAttribute isn't defined, we need to wait for the DOM.
1972      } else {
1973        autoSetupTimeout(1);
1974        break;
1975      }
1976    }
1977
1978    // No videos were found, so keep looping unless page is finished loading.
1979  } else if (!_windowLoaded) {
1980    autoSetupTimeout(1);
1981  }
1982};
1983
1984/**
1985 * Wait until the page is loaded before running autoSetup. This will be called in
1986 * autoSetup if `hasLoaded` returns false.
1987 *
1988 * @param {number} wait
1989 *        How long to wait in ms
1990 *
1991 * @param {module:videojs} [vjs]
1992 *        The videojs library function
1993 */
1994function autoSetupTimeout(wait, vjs) {
1995  // Protect against breakage in non-browser environments
1996  if (!isReal()) {
1997    return;
1998  }
1999  if (vjs) {
2000    videojs$1 = vjs;
2001  }
2002  window__default['default'].setTimeout(autoSetup, wait);
2003}
2004
2005/**
2006 * Used to set the internal tracking of window loaded state to true.
2007 *
2008 * @private
2009 */
2010function setWindowLoaded() {
2011  _windowLoaded = true;
2012  window__default['default'].removeEventListener('load', setWindowLoaded);
2013}
2014if (isReal()) {
2015  if (document__default['default'].readyState === 'complete') {
2016    setWindowLoaded();
2017  } else {
2018    /**
2019     * Listen for the load event on window, and set _windowLoaded to true.
2020     *
2021     * We use a standard event listener here to avoid incrementing the GUID
2022     * before any players are created.
2023     *
2024     * @listens load
2025     */
2026    window__default['default'].addEventListener('load', setWindowLoaded);
2027  }
2028}
2029
2030/**
2031 * @file stylesheet.js
2032 * @module stylesheet
2033 */
2034
2035/**
2036 * Create a DOM style element given a className for it.
2037 *
2038 * @param {string} className
2039 *        The className to add to the created style element.
2040 *
2041 * @return {Element}
2042 *         The element that was created.
2043 */
2044const createStyleElement = function (className) {
2045  const style = document__default['default'].createElement('style');
2046  style.className = className;
2047  return style;
2048};
2049
2050/**
2051 * Add text to a DOM element.
2052 *
2053 * @param {Element} el
2054 *        The Element to add text content to.
2055 *
2056 * @param {string} content
2057 *        The text to add to the element.
2058 */
2059const setTextContent = function (el, content) {
2060  if (el.styleSheet) {
2061    el.styleSheet.cssText = content;
2062  } else {
2063    el.textContent = content;
2064  }
2065};
2066
2067/**
2068 * @file dom-data.js
2069 * @module dom-data
2070 */
2071
2072/**
2073 * Element Data Store.
2074 *
2075 * Allows for binding data to an element without putting it directly on the
2076 * element. Ex. Event listeners are stored here.
2077 * (also from jsninja.com, slightly modified and updated for closure compiler)
2078 *
2079 * @type {Object}
2080 * @private
2081 */
2082var DomData = new WeakMap();
2083
2084/**
2085 * @file guid.js
2086 * @module guid
2087 */
2088
2089// Default value for GUIDs. This allows us to reset the GUID counter in tests.
2090//
2091// The initial GUID is 3 because some users have come to rely on the first
2092// default player ID ending up as `vjs_video_3`.
2093//
2094// See: https://github.com/videojs/video.js/pull/6216
2095const _initialGuid = 3;
2096
2097/**
2098 * Unique ID for an element or function
2099 *
2100 * @type {Number}
2101 */
2102let _guid = _initialGuid;
2103
2104/**
2105 * Get a unique auto-incrementing ID by number that has not been returned before.
2106 *
2107 * @return {number}
2108 *         A new unique ID.
2109 */
2110function newGUID() {
2111  return _guid++;
2112}
2113
2114/**
2115 * @file events.js. An Event System (John Resig - Secrets of a JS Ninja http://jsninja.com/)
2116 * (Original book version wasn't completely usable, so fixed some things and made Closure Compiler compatible)
2117 * This should work very similarly to jQuery's events, however it's based off the book version which isn't as
2118 * robust as jquery's, so there's probably some differences.
2119 *
2120 * @file events.js
2121 * @module events
2122 */
2123
2124/**
2125 * Clean up the listener cache and dispatchers
2126 *
2127 * @param {Element|Object} elem
2128 *        Element to clean up
2129 *
2130 * @param {string} type
2131 *        Type of event to clean up
2132 */
2133function _cleanUpEvents(elem, type) {
2134  if (!DomData.has(elem)) {
2135    return;
2136  }
2137  const data = DomData.get(elem);
2138
2139  // Remove the events of a particular type if there are none left
2140  if (data.handlers[type].length === 0) {
2141    delete data.handlers[type];
2142    // data.handlers[type] = null;
2143    // Setting to null was causing an error with data.handlers
2144
2145    // Remove the meta-handler from the element
2146    if (elem.removeEventListener) {
2147      elem.removeEventListener(type, data.dispatcher, false);
2148    } else if (elem.detachEvent) {
2149      elem.detachEvent('on' + type, data.dispatcher);
2150    }
2151  }
2152
2153  // Remove the events object if there are no types left
2154  if (Object.getOwnPropertyNames(data.handlers).length <= 0) {
2155    delete data.handlers;
2156    delete data.dispatcher;
2157    delete data.disabled;
2158  }
2159
2160  // Finally remove the element data if there is no data left
2161  if (Object.getOwnPropertyNames(data).length === 0) {
2162    DomData.delete(elem);
2163  }
2164}
2165
2166/**
2167 * Loops through an array of event types and calls the requested method for each type.
2168 *
2169 * @param {Function} fn
2170 *        The event method we want to use.
2171 *
2172 * @param {Element|Object} elem
2173 *        Element or object to bind listeners to
2174 *
2175 * @param {string[]} types
2176 *        Type of event to bind to.
2177 *
2178 * @param {Function} callback
2179 *        Event listener.
2180 */
2181function _handleMultipleEvents(fn, elem, types, callback) {
2182  types.forEach(function (type) {
2183    // Call the event method for each one of the types
2184    fn(elem, type, callback);
2185  });
2186}
2187
2188/**
2189 * Fix a native event to have standard property values
2190 *
2191 * @param {Object} event
2192 *        Event object to fix.
2193 *
2194 * @return {Object}
2195 *         Fixed event object.
2196 */
2197function fixEvent(event) {
2198  if (event.fixed_) {
2199    return event;
2200  }
2201  function returnTrue() {
2202    return true;
2203  }
2204  function returnFalse() {
2205    return false;
2206  }
2207
2208  // Test if fixing up is needed
2209  // Used to check if !event.stopPropagation instead of isPropagationStopped
2210  // But native events return true for stopPropagation, but don't have
2211  // other expected methods like isPropagationStopped. Seems to be a problem
2212  // with the Javascript Ninja code. So we're just overriding all events now.
2213  if (!event || !event.isPropagationStopped || !event.isImmediatePropagationStopped) {
2214    const old = event || window__default['default'].event;
2215    event = {};
2216    // Clone the old object so that we can modify the values event = {};
2217    // IE8 Doesn't like when you mess with native event properties
2218    // Firefox returns false for event.hasOwnProperty('type') and other props
2219    //  which makes copying more difficult.
2220
2221    // TODO: Probably best to create an allowlist of event props
2222    const deprecatedProps = [
2223      'layerX',
2224      'layerY',
2225      'keyLocation',
2226      'path',
2227      'webkitMovementX',
2228      'webkitMovementY',
2229      'mozPressure',
2230      'mozInputSource',
2231    ];
2232    for (const key in old) {
2233      // Safari 6.0.3 warns you if you try to copy deprecated layerX/Y
2234      // Chrome warns you if you try to copy deprecated keyboardEvent.keyLocation
2235      // and webkitMovementX/Y
2236      // Lighthouse complains if Event.path is copied
2237      if (!deprecatedProps.includes(key)) {
2238        // Chrome 32+ warns if you try to copy deprecated returnValue, but
2239        // we still want to if preventDefault isn't supported (IE8).
2240        if (!(key === 'returnValue' && old.preventDefault)) {
2241          event[key] = old[key];
2242        }
2243      }
2244    }
2245
2246    // The event occurred on this element
2247    if (!event.target) {
2248      event.target = event.srcElement || document__default['default'];
2249    }
2250
2251    // Handle which other element the event is related to
2252    if (!event.relatedTarget) {
2253      event.relatedTarget =
2254        event.fromElement === event.target ? event.toElement : event.fromElement;
2255    }
2256
2257    // Stop the default browser action
2258    event.preventDefault = function () {
2259      if (old.preventDefault) {
2260        old.preventDefault();
2261      }
2262      event.returnValue = false;
2263      old.returnValue = false;
2264      event.defaultPrevented = true;
2265    };
2266    event.defaultPrevented = false;
2267
2268    // Stop the event from bubbling
2269    event.stopPropagation = function () {
2270      if (old.stopPropagation) {
2271        old.stopPropagation();
2272      }
2273      event.cancelBubble = true;
2274      old.cancelBubble = true;
2275      event.isPropagationStopped = returnTrue;
2276    };
2277    event.isPropagationStopped = returnFalse;
2278
2279    // Stop the event from bubbling and executing other handlers
2280    event.stopImmediatePropagation = function () {
2281      if (old.stopImmediatePropagation) {
2282        old.stopImmediatePropagation();
2283      }
2284      event.isImmediatePropagationStopped = returnTrue;
2285      event.stopPropagation();
2286    };
2287    event.isImmediatePropagationStopped = returnFalse;
2288
2289    // Handle mouse position
2290    if (event.clientX !== null && event.clientX !== undefined) {
2291      const doc = document__default['default'].documentElement;
2292      const body = document__default['default'].body;
2293      event.pageX =
2294        event.clientX +
2295        ((doc && doc.scrollLeft) || (body && body.scrollLeft) || 0) -
2296        ((doc && doc.clientLeft) || (body && body.clientLeft) || 0);
2297      event.pageY =
2298        event.clientY +
2299        ((doc && doc.scrollTop) || (body && body.scrollTop) || 0) -
2300        ((doc && doc.clientTop) || (body && body.clientTop) || 0);
2301    }
2302
2303    // Handle key presses
2304    event.which = event.charCode || event.keyCode;
2305
2306    // Fix button for mouse clicks:
2307    // 0 == left; 1 == middle; 2 == right
2308    if (event.button !== null && event.button !== undefined) {
2309      // The following is disabled because it does not pass videojs-standard
2310      // and... yikes.
2311      /* eslint-disable */
2312      event.button = event.button & 1 ? 0 : event.button & 4 ? 1 : event.button & 2 ? 2 : 0;
2313      /* eslint-enable */
2314    }
2315  }
2316  event.fixed_ = true;
2317  // Returns fixed-up instance
2318  return event;
2319}
2320
2321/**
2322 * Whether passive event listeners are supported
2323 */
2324let _supportsPassive;
2325const supportsPassive = function () {
2326  if (typeof _supportsPassive !== 'boolean') {
2327    _supportsPassive = false;
2328    try {
2329      const opts = Object.defineProperty({}, 'passive', {
2330        get() {
2331          _supportsPassive = true;
2332        },
2333      });
2334      window__default['default'].addEventListener('test', null, opts);
2335      window__default['default'].removeEventListener('test', null, opts);
2336    } catch (e) {
2337      // disregard
2338    }
2339  }
2340  return _supportsPassive;
2341};
2342
2343/**
2344 * Touch events Chrome expects to be passive
2345 */
2346const passiveEvents = ['touchstart', 'touchmove'];
2347
2348/**
2349 * Add an event listener to element
2350 * It stores the handler function in a separate cache object
2351 * and adds a generic handler to the element's event,
2352 * along with a unique id (guid) to the element.
2353 *
2354 * @param {Element|Object} elem
2355 *        Element or object to bind listeners to
2356 *
2357 * @param {string|string[]} type
2358 *        Type of event to bind to.
2359 *
2360 * @param {Function} fn
2361 *        Event listener.
2362 */
2363function on(elem, type, fn) {
2364  if (Array.isArray(type)) {
2365    return _handleMultipleEvents(on, elem, type, fn);
2366  }
2367  if (!DomData.has(elem)) {
2368    DomData.set(elem, {});
2369  }
2370  const data = DomData.get(elem);
2371
2372  // We need a place to store all our handler data
2373  if (!data.handlers) {
2374    data.handlers = {};
2375  }
2376  if (!data.handlers[type]) {
2377    data.handlers[type] = [];
2378  }
2379  if (!fn.guid) {
2380    fn.guid = newGUID();
2381  }
2382  data.handlers[type].push(fn);
2383  if (!data.dispatcher) {
2384    data.disabled = false;
2385    data.dispatcher = function (event, hash) {
2386      if (data.disabled) {
2387        return;
2388      }
2389      event = fixEvent(event);
2390      const handlers = data.handlers[event.type];
2391      if (handlers) {
2392        // Copy handlers so if handlers are added/removed during the process it doesn't throw everything off.
2393        const handlersCopy = handlers.slice(0);
2394        for (let m = 0, n = handlersCopy.length; m < n; m++) {
2395          if (event.isImmediatePropagationStopped()) {
2396            break;
2397          } else {
2398            try {
2399              handlersCopy[m].call(elem, event, hash);
2400            } catch (e) {
2401              log$1.error(e);
2402            }
2403          }
2404        }
2405      }
2406    };
2407  }
2408  if (data.handlers[type].length === 1) {
2409    if (elem.addEventListener) {
2410      let options = false;

2411      if (supportsPassive() && passiveEvents.indexOf(type) > -1) {
2412        options = {
2413          passive: true,
2414        };
2415      }
2416      elem.addEventListener(type, data.dispatcher, options);
2417    } else if (elem.attachEvent) {
2418      elem.attachEvent('on' + type, data.dispatcher);
2419    }
2420  }
2421}
2422
2423/**
2424 * Removes event listeners from an element
2425 *
2426 * @param {Element|Object} elem
2427 *        Object to remove listeners from.
2428 *
2429 * @param {string|string[]} [type]
2430 *        Type of listener to remove. Don't include to remove all events from element.
2431 *
2432 * @param {Function} [fn]
2433 *        Specific listener to remove. Don't include to remove listeners for an event
2434 *        type.
2435 */
2436function off(elem, type, fn) {
2437  // Don't want to add a cache object through getElData if not needed
2438  if (!DomData.has(elem)) {
2439    return;
2440  }
2441  const data = DomData.get(elem);
2442
2443  // If no events exist, nothing to unbind
2444  if (!data.handlers) {
2445    return;
2446  }
2447  if (Array.isArray(type)) {
2448    return _handleMultipleEvents(off, elem, type, fn);
2449  }
2450
2451  // Utility function
2452  const removeType = function (el, t) {
2453    data.handlers[t] = [];
2454    _cleanUpEvents(el, t);
2455  };
2456
2457  // Are we removing all bound events?
2458  if (type === undefined) {
2459    for (const t in data.handlers) {
2460      if (Object.prototype.hasOwnProperty.call(data.handlers || {}, t)) {
2461        removeType(elem, t);
2462      }
2463    }
2464    return;
2465  }
2466  const handlers = data.handlers[type];
2467
2468  // If no handlers exist, nothing to unbind
2469  if (!handlers) {
2470    return;
2471  }
2472
2473  // If no listener was provided, remove all listeners for type
2474  if (!fn) {
2475    removeType(elem, type);
2476    return;
2477  }
2478
2479  // We're only removing a single handler
2480  if (fn.guid) {
2481    for (let n = 0; n < handlers.length; n++) {
2482      if (handlers[n].guid === fn.guid) {
2483        handlers.splice(n--, 1);
2484      }
2485    }
2486  }
2487  _cleanUpEvents(elem, type);
2488}
2489
2490/**
2491 * Trigger an event for an element
2492 *
2493 * @param {Element|Object} elem
2494 *        Element to trigger an event on
2495 *
2496 * @param {EventTarget~Event|string} event
2497 *        A string (the type) or an event object with a type attribute
2498 *
2499 * @param {Object} [hash]
2500 *        data hash to pass along with the event
2501 *
2502 * @return {boolean|undefined}
2503 *         Returns the opposite of `defaultPrevented` if default was
2504 *         prevented. Otherwise, returns `undefined`
2505 */
2506function trigger(elem, event, hash) {
2507  // Fetches element data and a reference to the parent (for bubbling).
2508  // Don't want to add a data object to cache for every parent,
2509  // so checking hasElData first.
2510  const elemData = DomData.has(elem) ? DomData.get(elem) : {};
2511  const parent = elem.parentNode || elem.ownerDocument;
2512  // type = event.type || event,
2513  // handler;
2514
2515  // If an event name was passed as a string, creates an event out of it
2516  if (typeof event === 'string') {
2517    event = {
2518      type: event,
2519      target: elem,
2520    };
2521  } else if (!event.target) {
2522    event.target = elem;
2523  }
2524
2525  // Normalizes the event properties.
2526  event = fixEvent(event);
2527
2528  // If the passed element has a dispatcher, executes the established handlers.
2529  if (elemData.dispatcher) {
2530    elemData.dispatcher.call(elem, event, hash);
2531  }
2532
2533  // Unless explicitly stopped or the event does not bubble (e.g. media events)
2534  // recursively calls this function to bubble the event up the DOM.
2535  if (parent && !event.isPropagationStopped() && event.bubbles === true) {
2536    trigger.call(null, parent, event, hash);
2537
2538    // If at the top of the DOM, triggers the default action unless disabled.
2539  } else if (!parent && !event.defaultPrevented && event.target && event.target[event.type]) {
2540    if (!DomData.has(event.target)) {
2541      DomData.set(event.target, {});
2542    }
2543    const targetData = DomData.get(event.target);
2544
2545    // Checks if the target has a default action for this event.
2546    if (event.target[event.type]) {
2547      // Temporarily disables event dispatching on the target as we have already executed the handler.
2548      targetData.disabled = true;
2549      // Executes the default action.
2550      if (typeof event.target[event.type] === 'function') {
2551        event.target[event.type]();
2552      }
2553      // Re-enables event dispatching.
2554      targetData.disabled = false;

2555    }
2556  }
2557
2558  // Inform the triggerer if the default was prevented by returning false
2559  return !event.defaultPrevented;
2560}
2561
2562/**
2563 * Trigger a listener only once for an event.
2564 *
2565 * @param {Element|Object} elem
2566 *        Element or object to bind to.
2567 *
2568 * @param {string|string[]} type
2569 *        Name/type of event
2570 *
2571 * @param {Event~EventListener} fn
2572 *        Event listener function
2573 */
2574function one(elem, type, fn) {
2575  if (Array.isArray(type)) {
2576    return _handleMultipleEvents(one, elem, type, fn);
2577  }
2578  const func = function () {
2579    off(elem, type, func);
2580    fn.apply(this, arguments);
2581  };
2582
2583  // copy the guid to the new function so it can removed using the original function's ID
2584  func.guid = fn.guid = fn.guid || newGUID();
2585  on(elem, type, func);
2586}
2587
2588/**
2589 * Trigger a listener only once and then turn if off for all
2590 * configured events
2591 *
2592 * @param {Element|Object} elem
2593 *        Element or object to bind to.
2594 *
2595 * @param {string|string[]} type
2596 *        Name/type of event
2597 *
2598 * @param {Event~EventListener} fn
2599 *        Event listener function
2600 */
2601function any(elem, type, fn) {
2602  const func = function () {
2603    off(elem, type, func);
2604    fn.apply(this, arguments);
2605  };
2606
2607  // copy the guid to the new function so it can removed using the original function's ID
2608  func.guid = fn.guid = fn.guid || newGUID();
2609
2610  // multiple ons, but one off for everything
2611  on(elem, type, func);
2612}
2613
2614var Events = /*#__PURE__*/ Object.freeze({
2615  __proto__: null,
2616  fixEvent: fixEvent,
2617  on: on,
2618  off: off,
2619  trigger: trigger,
2620  one: one,
2621  any: any,
2622});
2623
2624/**
2625 * @file fn.js
2626 * @module fn
2627 */
2628const UPDATE_REFRESH_INTERVAL = 30;
2629
2630/**
2631 * A private, internal-only function for changing the context of a function.
2632 *
2633 * It also stores a unique id on the function so it can be easily removed from
2634 * events.
2635 *
2636 * @private
2637 * @function
2638 * @param    {*} context
2639 *           The object to bind as scope.
2640 *
2641 * @param    {Function} fn
2642 *           The function to be bound to a scope.
2643 *
2644 * @param    {number} [uid]
2645 *           An optional unique ID for the function to be set
2646 *
2647 * @return   {Function}
2648 *           The new function that will be bound into the context given
2649 */
2650const bind_ = function (context, fn, uid) {
2651  // Make sure the function has a unique ID
2652  if (!fn.guid) {
2653    fn.guid = newGUID();
2654  }
2655
2656  // Create the new function that changes the context
2657  const bound = fn.bind(context);
2658
2659  // Allow for the ability to individualize this function
2660  // Needed in the case where multiple objects might share the same prototype
2661  // IF both items add an event listener with the same function, then you try to remove just one
2662  // it will remove both because they both have the same guid.
2663  // when using this, you need to use the bind method when you remove the listener as well.
2664  // currently used in text tracks
2665  bound.guid = uid ? uid + '_' + fn.guid : fn.guid;
2666  return bound;
2667};
2668
2669/**
2670 * Wraps the given function, `fn`, with a new function that only invokes `fn`
2671 * at most once per every `wait` milliseconds.
2672 *
2673 * @function
2674 * @param    {Function} fn
2675 *           The function to be throttled.
2676 *
2677 * @param    {number}   wait
2678 *           The number of milliseconds by which to throttle.
2679 *
2680 * @return   {Function}
2681 */
2682const throttle = function (fn, wait) {
2683  let last = window__default['default'].performance.now();
2684  const throttled = function (...args) {
2685    const now = window__default['default'].performance.now();
2686    if (now - last >= wait) {
2687      fn(...args);
2688      last = now;
2689    }
2690  };
2691  return throttled;
2692};
2693
2694/**
2695 * Creates a debounced function that delays invoking `func` until after `wait`
2696 * milliseconds have elapsed since the last time the debounced function was
2697 * invoked.
2698 *
2699 * Inspired by lodash and underscore implementations.
2700 *
2701 * @function
2702 * @param    {Function} func
2703 *           The function to wrap with debounce behavior.
2704 *
2705 * @param    {number} wait
2706 *           The number of milliseconds to wait after the last invocation.
2707 *
2708 * @param    {boolean} [immediate]
2709 *           Whether or not to invoke the function immediately upon creation.
2710 *
2711 * @param    {Object} [context=window]
2712 *           The "context" in which the debounced function should debounce. For
2713 *           example, if this function should be tied to a Video.js player,
2714 *           the player can be passed here. Alternatively, defaults to the
2715 *           global `window` object.
2716 *
2717 * @return   {Function}
2718 *           A debounced function.
2719 */
2720const debounce = function (func, wait, immediate, context = window__default['default']) {
2721  let timeout;
2722  const cancel = () => {
2723    context.clearTimeout(timeout);
2724    timeout = null;
2725  };
2726
2727  /* eslint-disable consistent-this */
2728  const debounced = function () {
2729    const self = this;
2730    const args = arguments;
2731    let later = function () {
2732      timeout = null;
2733      later = null;
2734      if (!immediate) {
2735        func.apply(self, args);
2736      }
2737    };
2738    if (!timeout && immediate) {
2739      func.apply(self, args);
2740    }
2741    context.clearTimeout(timeout);
2742    timeout = context.setTimeout(later, wait);
2743  };
2744  /* eslint-enable consistent-this */
2745
2746  debounced.cancel = cancel;
2747  return debounced;
2748};
2749
2750var Fn = /*#__PURE__*/ Object.freeze({
2751  __proto__: null,
2752  UPDATE_REFRESH_INTERVAL: UPDATE_REFRESH_INTERVAL,
2753  bind_: bind_,
2754  throttle: throttle,
2755  debounce: debounce,
2756});
2757
2758/**
2759 * @file src/js/event-target.js
2760 */
2761let EVENT_MAP;
2762
2763/**
2764 * `EventTarget` is a class that can have the same API as the DOM `EventTarget`. It
2765 * adds shorthand functions that wrap around lengthy functions. For example:
2766 * the `on` function is a wrapper around `addEventListener`.
2767 *
2768 * @see [EventTarget Spec]{@link https://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-EventTarget}
2769 * @class EventTarget
2770 */
2771class EventTarget$2 {
2772  /**
2773   * Adds an `event listener` to an instance of an `EventTarget`. An `event listener` is a
2774   * function that will get called when an event with a certain