https://udprf.ru/sites/all/libraries/video-js/video.js?swcj8p

1/**
2 * @license
3 * Video.js 6.2.8 <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/master/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/master/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.videojs = factory());
17}(this, (function () {
18
19var version = "6.2.8";
20
21var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
22
23
24
25
26
27function createCommonjsModule(fn, module) {
28	return module = { exports: {} }, fn(module, module.exports), module.exports;
29}
30
31var win;
32
33if (typeof window !== "undefined") {
34    win = window;
35} else if (typeof commonjsGlobal !== "undefined") {
36    win = commonjsGlobal;
37} else if (typeof self !== "undefined"){
38    win = self;
39} else {
40    win = {};
41}
42
43var window_1 = win;
44
45var empty = {};
46
47
48var empty$1 = (Object.freeze || Object)({
49	'default': empty
50});
51
52var minDoc = ( empty$1 && empty ) || empty$1;
53
54var topLevel = typeof commonjsGlobal !== 'undefined' ? commonjsGlobal :
55    typeof window !== 'undefined' ? window : {};
56
57
58var doccy;
59
60if (typeof document !== 'undefined') {
61    doccy = document;
62} else {
63    doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'];
64
65    if (!doccy) {
66        doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDoc;
67    }
68}
69
70var document_1 = doccy;
71
72/**
73 * @file browser.js
74 * @module browser
75 */
76var USER_AGENT = window_1.navigator && window_1.navigator.userAgent || '';
77var webkitVersionMap = /AppleWebKit\/([\d.]+)/i.exec(USER_AGENT);
78var appleWebkitVersion = webkitVersionMap ? parseFloat(webkitVersionMap.pop()) : null;
79
80/*
81 * Device is an iPhone
82 *
83 * @type {Boolean}
84 * @constant
85 * @private
86 */
87var IS_IPAD = /iPad/i.test(USER_AGENT);
88
89// The Facebook app's UIWebView identifies as both an iPhone and iPad, so
90// to identify iPhones, we need to exclude iPads.
91// http://artsy.github.io/blog/2012/10/18/the-perils-of-ios-user-agent-sniffing/
92var IS_IPHONE = /iPhone/i.test(USER_AGENT) && !IS_IPAD;
93var IS_IPOD = /iPod/i.test(USER_AGENT);
94var IS_IOS = IS_IPHONE || IS_IPAD || IS_IPOD;
95
96var IOS_VERSION = function () {
97  var match = USER_AGENT.match(/OS (\d+)_/i);
98
99  if (match && match[1]) {
100    return match[1];
101  }
102  return null;
103}();
104
105var IS_ANDROID = /Android/i.test(USER_AGENT);
106var ANDROID_VERSION = function () {
107  // This matches Android Major.Minor.Patch versions
108  // ANDROID_VERSION is Major.Minor as a Number, if Minor isn't available, then only Major is returned
109  var match = USER_AGENT.match(/Android (\d+)(?:\.(\d+))?(?:\.(\d+))*/i);
110
111  if (!match) {
112    return null;
113  }
114
115  var major = match[1] && parseFloat(match[1]);
116  var minor = match[2] && parseFloat(match[2]);
117
118  if (major && minor) {
119    return parseFloat(match[1] + '.' + match[2]);
120  } else if (major) {
121    return major;
122  }
123  return null;
124}();
125
126// Old Android is defined as Version older than 2.3, and requiring a webkit version of the android browser
127var IS_OLD_ANDROID = IS_ANDROID && /webkit/i.test(USER_AGENT) && ANDROID_VERSION < 2.3;
128var IS_NATIVE_ANDROID = IS_ANDROID && ANDROID_VERSION < 5 && appleWebkitVersion < 537;
129
130var IS_FIREFOX = /Firefox/i.test(USER_AGENT);
131var IS_EDGE = /Edge/i.test(USER_AGENT);
132var IS_CHROME = !IS_EDGE && /Chrome/i.test(USER_AGENT);
133var CHROME_VERSION = function () {
134  var match = USER_AGENT.match(/Chrome\/(\d+)/);
135
136  if (match && match[1]) {
137    return parseFloat(match[1]);
138  }
139  return null;
140}();
141var IS_IE8 = /MSIE\s8\.0/.test(USER_AGENT);
142var IE_VERSION = function () {
143  var result = /MSIE\s(\d+)\.\d/.exec(USER_AGENT);
144  var version = result && parseFloat(result[1]);
145
146  if (!version && /Trident\/7.0/i.test(USER_AGENT) && /rv:11.0/.test(USER_AGENT)) {
147    // IE 11 has a different user agent string than other IE versions
148    version = 11.0;
149  }
150
151  return version;
152}();
153
154var IS_SAFARI = /Safari/i.test(USER_AGENT) && !IS_CHROME && !IS_ANDROID && !IS_EDGE;
155var IS_ANY_SAFARI = IS_SAFARI || IS_IOS;
156
157var TOUCH_ENABLED = isReal() && ('ontouchstart' in window_1 || window_1.DocumentTouch && window_1.document instanceof window_1.DocumentTouch);
158
159var BACKGROUND_SIZE_SUPPORTED = isReal() && 'backgroundSize' in window_1.document.createElement('video').style;
160
161var browser = (Object.freeze || Object)({
162	IS_IPAD: IS_IPAD,
163	IS_IPHONE: IS_IPHONE,
164	IS_IPOD: IS_IPOD,
165	IS_IOS: IS_IOS,
166	IOS_VERSION: IOS_VERSION,
167	IS_ANDROID: IS_ANDROID,
168	ANDROID_VERSION: ANDROID_VERSION,
169	IS_OLD_ANDROID: IS_OLD_ANDROID,
170	IS_NATIVE_ANDROID: IS_NATIVE_ANDROID,
171	IS_FIREFOX: IS_FIREFOX,
172	IS_EDGE: IS_EDGE,
173	IS_CHROME: IS_CHROME,
174	CHROME_VERSION: CHROME_VERSION,
175	IS_IE8: IS_IE8,
176	IE_VERSION: IE_VERSION,
177	IS_SAFARI: IS_SAFARI,
178	IS_ANY_SAFARI: IS_ANY_SAFARI,
179	TOUCH_ENABLED: TOUCH_ENABLED,
180	BACKGROUND_SIZE_SUPPORTED: BACKGROUND_SIZE_SUPPORTED
181});
182
183var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
184  return typeof obj;
185} : function (obj) {
186  return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
187};
188
189
190
191
192
193
194
195
196
197
198
199var classCallCheck = function (instance, Constructor) {
200  if (!(instance instanceof Constructor)) {
201    throw new TypeError("Cannot call a class as a function");
202  }
203};
204
205
206
207
208
209
210
211
212
213
214
215var inherits = function (subClass, superClass) {
216  if (typeof superClass !== "function" && superClass !== null) {
217    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
218  }
219
220  subClass.prototype = Object.create(superClass && superClass.prototype, {
221    constructor: {
222      value: subClass,
223      enumerable: false,
224      writable: true,
225      configurable: true
226    }
227  });
228  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
229};
230
231
232
233
234
235
236
237
238
239
240
241var possibleConstructorReturn = function (self, call) {
242  if (!self) {
243    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
244  }
245
246  return call && (typeof call === "object" || typeof call === "function") ? call : self;
247};
248
249
250
251
252
253
254
255
256
257
258
259var taggedTemplateLiteralLoose = function (strings, raw) {
260  strings.raw = raw;
261  return strings;
262};
263
264/**
265 * @file obj.js
266 * @module obj
267 */
268
269/**
270 * @callback obj:EachCallback
271 *
272 * @param {Mixed} value
273 *        The current key for the object that is being iterated over.
274 *
275 * @param {string} key
276 *        The current key-value for object that is being iterated over
277 */
278
279/**
280 * @callback obj:ReduceCallback
281 *
282 * @param {Mixed} accum
283 *        The value that is accumulating over the reduce loop.
284 *
285 * @param {Mixed} value
286 *        The current key for the object that is being iterated over.
287 *
288 * @param {string} key
289 *        The current key-value for object that is being iterated over
290 *
291 * @return {Mixed}
292 *         The new accumulated value.
293 */
294var toString = Object.prototype.toString;
295
296/**
297 * Get the keys of an Object
298 *
299 * @param {Object}
300 *        The Object to get the keys from
301 *
302 * @return {string[]}
303 *         An array of the keys from the object. Returns an empty array if the
304 *         object passed in was invalid or had no keys.
305 *
306 * @private
307 */
308var keys = function keys(object) {
309  return isObject(object) ? Object.keys(object) : [];
310};
311
312/**
313 * Array-like iteration for objects.
314 *
315 * @param {Object} object
316 *        The object to iterate over
317 *
318 * @param {obj:EachCallback} fn
319 *        The callback function which is called for each key in the object.
320 */
321function each(object, fn) {
322  keys(object).forEach(function (key) {
323    return fn(object[key], key);
324  });
325}
326
327/**
328 * Array-like reduce for objects.
329 *
330 * @param {Object} object
331 *        The Object that you want to reduce.
332 *
333 * @param {Function} fn
334 *         A callback function which is called for each key in the object. It
335 *         receives the accumulated value and the per-iteration value and key
336 *         as arguments.
337 *
338 * @param {Mixed} [initial = 0]
339 *        Starting value
340 *
341 * @return {Mixed}
342 *         The final accumulated value.
343 */
344function reduce(object, fn) {
345  var initial = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
346
347  return keys(object).reduce(function (accum, key) {
348    return fn(accum, object[key], key);
349  }, initial);
350}
351
352/**
353 * Object.assign-style object shallow merge/extend.
354 *
355 * @param  {Object} target
356 * @param  {Object} ...sources
357 * @return {Object}
358 */
359function assign(target) {
360  for (var _len = arguments.length, sources = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
361    sources[_key - 1] = arguments[_key];
362  }
363
364  if (Object.assign) {
365    return Object.assign.apply(Object, [target].concat(sources));
366  }
367
368  sources.forEach(function (source) {
369    if (!source) {
370      return;
371    }
372
373    each(source, function (value, key) {
374      target[key] = value;
375    });
376  });
377
378  return target;
379}
380
381/**
382 * Returns whether a value is an object of any kind - including DOM nodes,
383 * arrays, regular expressions, etc. Not functions, though.
384 *
385 * This avoids the gotcha where using `typeof` on a `null` value
386 * results in `'object'`.
387 *
388 * @param  {Object} value
389 * @return {Boolean}
390 */
391function isObject(value) {
392  return !!value && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object';
393}
394
395/**
396 * Returns whether an object appears to be a "plain" object - that is, a
397 * direct instance of `Object`.
398 *
399 * @param  {Object} value
400 * @return {Boolean}
401 */
402function isPlain(value) {
403  return isObject(value) && toString.call(value) === '[object Object]' && value.constructor === Object;
404}
405
406/**
407 * @file log.js
408 * @module log
409 */
410var log = void 0;
411
412// This is the private tracking variable for logging level.
413var level = 'all';
414
415// This is the private tracking variable for the logging history.
416var history = [];
417
418/**
419 * Log messages to the console and history based on the type of message
420 *
421 * @private
422 * @param  {string} type
423 *         The name of the console method to use.
424 *
425 * @param  {Array} args
426 *         The arguments to be passed to the matching console method.
427 *
428 * @param  {boolean} [stringify]
429 *         By default, only old IEs should get console argument stringification,
430 *         but this is exposed as a parameter to facilitate testing.
431 */
432var logByType = function logByType(type, args) {
433  var stringify = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : !!IE_VERSION && IE_VERSION < 11;
434
435  var lvl = log.levels[level];
436  var lvlRegExp = new RegExp('^(' + lvl + ')$');
437
438  if (type !== 'log') {
439
440    // Add the type to the front of the message when it's not "log".
441    args.unshift(type.toUpperCase() + ':');
442  }
443
444  // Add a clone of the args at this point to history.
445  if (history) {
446    history.push([].concat(args));
447  }
448
449  // Add console prefix after adding to history.
450  args.unshift('VIDEOJS:');
451
452  // If there's no console then don't try to output messages, but they will
453  // still be stored in history.
454  //
455  // Was setting these once outside of this function, but containing them
456  // in the function makes it easier to test cases where console doesn't exist
457  // when the module is executed.
458  var fn = window_1.console && window_1.console[type];
459
460  // Bail out if there's no console or if this type is not allowed by the
461  // current logging level.
462  if (!fn || !lvl || !lvlRegExp.test(type)) {
463    return;
464  }
465
466  // IEs previous to 11 log objects uselessly as "[object Object]"; so, JSONify
467  // objects and arrays for those less-capable browsers.
468  if (stringify) {
469    args = args.map(function (a) {
470      if (isObject(a) || Array.isArray(a)) {
471        try {
472          return JSON.stringify(a);
473        } catch (x) {
474          return String(a);
475        }
476      }
477
478      // Cast to string before joining, so we get null and undefined explicitly
479      // included in output (as we would in a modern console).
480      return String(a);
481    }).join(' ');
482  }
483
484  // Old IE versions do not allow .apply() for console methods (they are
485  // reported as objects rather than functions).
486  if (!fn.apply) {
487    fn(args);
488  } else {
489    fn[Array.isArray(args) ? 'apply' : 'call'](window_1.console, args);
490  }
491};
492
493/**
494 * Logs plain debug messages. Similar to `console.log`.
495 *
496 * @class
497 * @param    {Mixed[]} args
498 *           One or more messages or objects that should be logged.
499 */
500log = function log() {
501  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
502    args[_key] = arguments[_key];
503  }
504
505  logByType('log', args);
506};
507
508/**
509 * Enumeration of available logging levels, where the keys are the level names
510 * and the values are `|`-separated strings containing logging methods allowed
511 * in that logging level. These strings are used to create a regular expression
512 * matching the function name being called.
513 *
514 * Levels provided by video.js are:
515 *
516 * - `off`: Matches no calls. Any value that can be cast to `false` will have
517 *   this effect. The most restrictive.
518 * - `all` (default): Matches only Video.js-provided functions (`log`,
519 *   `log.warn`, and `log.error`).
520 * - `warn`: Matches `log.warn` and `log.error` calls.
521 * - `error`: Matches only `log.error` calls.
522 *
523 * @type {Object}
524 */
525log.levels = {
526  all: 'log|warn|error',
527  error: 'error',
528  off: '',
529  warn: 'warn|error',
530  DEFAULT: level
531};
532
533/**
534 * Get or set the current logging level. If a string matching a key from
535 * {@link log.levels} is provided, acts as a setter. Regardless of argument,
536 * returns the current logging level.
537 *
538 * @param  {string} [lvl]
539 *         Pass to set a new logging level.
540 *
541 * @return {string}
542 *         The current logging level.
543 */
544log.level = function (lvl) {
545  if (typeof lvl === 'string') {
546    if (!log.levels.hasOwnProperty(lvl)) {
547      throw new Error('"' + lvl + '" in not a valid log level');
548    }
549    level = lvl;
550  }
551  return level;
552};
553
554/**
555 * Returns an array containing everything that has been logged to the history.
556 *
557 * This array is a shallow clone of the internal history record. However, its
558 * contents are _not_ cloned; so, mutating objects inside this array will
559 * mutate them in history.
560 *
561 * @return {Array}
562 */
563log.history = function () {
564  return history ? [].concat(history) : [];
565};
566
567/**
568 * Clears the internal history tracking, but does not prevent further history
569 * tracking.
570 */
571log.history.clear = function () {
572  if (history) {
573    history.length = 0;
574  }
575};
576
577/**
578 * Disable history tracking if it is currently enabled.
579 */
580log.history.disable = function () {
581  if (history !== null) {
582    history.length = 0;
583    history = null;
584  }
585};
586
587/**
588 * Enable history tracking if it is currently disabled.
589 */
590log.history.enable = function () {
591  if (history === null) {
592    history = [];
593  }
594};
595
596/**
597 * Logs error messages. Similar to `console.error`.
598 *
599 * @param {Mixed[]} args
600 *        One or more messages or objects that should be logged as an error
601 */
602log.error = function () {
603  for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
604    args[_key2] = arguments[_key2];
605  }
606
607  return logByType('error', args);
608};
609
610/**

810  Object.getOwnPropertyNames(properties).forEach(function (propName) {
811    var val = properties[propName];
812
813    // See #2176
814    // We originally were accepting both properties and attributes in the
815    // same object, but that doesn't work so well.
816    if (propName.indexOf('aria-') !== -1 || propName === 'role' || propName === 'type') {
817      log$1.warn(tsml(_templateObject, propName, val));
818      el.setAttribute(propName, val);
819
820      // Handle textContent since it's not supported everywhere and we have a
821      // method for it.
822    } else if (propName === 'textContent') {
823      textContent(el, val);
824    } else {
825      el[propName] = val;
826    }
827  });
828
829  Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
830    el.setAttribute(attrName, attributes[attrName]);
831  });
832
833  if (content) {
834    appendContent(el, content);
835  }
836
837  return el;
838}
839
840/**
841 * Injects text into an element, replacing any existing contents entirely.
842 *
843 * @param {Element} el
844 *        The element to add text content into
845 *
846 * @param {string} text
847 *        The text content to add.
848 *
849 * @return {Element}
850 *         The element with added text content.
851 */
852function textContent(el, text) {
853  if (typeof el.textContent === 'undefined') {
854    el.innerText = text;
855  } else {
856    el.textContent = text;
857  }
858  return el;
859}
860
861/**
862 * Insert an element as the first child node of another
863 *
864 * @param {Element} child
865 *        Element to insert
866 *
867 * @param {Element} parent
868 *        Element to insert child into
869 */
870function prependTo(child, parent) {
871  if (parent.firstChild) {
872    parent.insertBefore(child, parent.firstChild);
873  } else {
874    parent.appendChild(child);
875  }
876}
877
878/**
879 * Check if an element has a CSS class
880 *
881 * @param {Element} element
882 *        Element to check
883 *
884 * @param {string} classToCheck
885 *        Class name to check for
886 *
887 * @return {boolean}
888 *         - True if the element had the class
889 *         - False otherwise.
890 *
891 * @throws {Error}
892 *         Throws an error if `classToCheck` has white space.
893 */
894function hasClass(element, classToCheck) {
895  throwIfWhitespace(classToCheck);
896  if (element.classList) {
897    return element.classList.contains(classToCheck);
898  }
899  return classRegExp(classToCheck).test(element.className);
900}
901
902/**
903 * Add a CSS class name to an element
904 *
905 * @param {Element} element
906 *        Element to add class name to.
907 *
908 * @param {string} classToAdd
909 *        Class name to add.
910 *
911 * @return {Element}
912 *         The dom element with the added class name.
913 */
914function addClass(element, classToAdd) {
915  if (element.classList) {
916    element.classList.add(classToAdd);
917
918    // Don't need to `throwIfWhitespace` here because `hasElClass` will do it
919    // in the case of classList not being supported.
920  } else if (!hasClass(element, classToAdd)) {
921    element.className = (element.className + ' ' + classToAdd).trim();
922  }
923
924  return element;
925}
926
927/**
928 * Remove a CSS class name from an element
929 *
930 * @param {Element} element
931 *        Element to remove a class name from.
932 *
933 * @param {string} classToRemove
934 *        Class name to remove
935 *
936 * @return {Element}
937 *         The dom element with class name removed.
938 */
939function removeClass(element, classToRemove) {
940  if (element.classList) {
941    element.classList.remove(classToRemove);
942  } else {
943    throwIfWhitespace(classToRemove);
944    element.className = element.className.split(/\s+/).filter(function (c) {
945      return c !== classToRemove;
946    }).join(' ');
947  }
948
949  return element;
950}
951
952/**
953 * The callback definition for toggleElClass.
954 *
955 * @callback Dom~PredicateCallback
956 * @param {Element} element
957 *        The DOM element of the Component.
958 *
959 * @param {string} classToToggle
960 *        The `className` that wants to be toggled
961 *
962 * @return {boolean|undefined}
963 *         - If true the `classToToggle` will get added to `element`.
964 *         - If false the `classToToggle` will get removed from `element`.
965 *         - If undefined this callback will be ignored
966 */
967
968/**
969 * Adds or removes a CSS class name on an element depending on an optional
970 * condition or the presence/absence of the class name.
971 *
972 * @param {Element} element
973 *        The element to toggle a class name on.
974 *
975 * @param {string} classToToggle
976 *        The class that should be toggled
977 *
978 * @param {boolean|PredicateCallback} [predicate]
979 *        See the return value for {@link Dom~PredicateCallback}
980 *
981 * @return {Element}
982 *         The element with a class that has been toggled.
983 */
984function toggleClass(element, classToToggle, predicate) {
985
986  // This CANNOT use `classList` internally because IE does not support the

987  // second parameter to the `classList.toggle()` method! Which is fine because
988  // `classList` will be used by the add/remove functions.
989  var has = hasClass(element, classToToggle);
990
991  if (typeof predicate === 'function') {
992    predicate = predicate(element, classToToggle);
993  }
994
995  if (typeof predicate !== 'boolean') {
996    predicate = !has;
997  }
998
999  // If the necessary class operation matches the current state of the
1000  // element, no action is required.
1001  if (predicate === has) {
1002    return;
1003  }
1004
1005  if (predicate) {
1006    addClass(element, classToToggle);
1007  } else {
1008    removeClass(element, classToToggle);
1009  }
1010
1011  return element;
1012}
1013
1014/**
1015 * Apply attributes to an HTML element.
1016 *
1017 * @param {Element} el
1018 *        Element to add attributes to.
1019 *
1020 * @param {Object} [attributes]
1021 *        Attributes to be applied.
1022 */
1023function setAttributes(el, attributes) {
1024  Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
1025    var attrValue = attributes[attrName];
1026
1027    if (attrValue === null || typeof attrValue === 'undefined' || attrValue === false) {
1028      el.removeAttribute(attrName);
1029    } else {
1030      el.setAttribute(attrName, attrValue === true ? '' : attrValue);
1031    }
1032  });
1033}
1034
1035/**
1036 * Get an element's attribute values, as defined on the HTML tag
1037 * Attributes are not the same as properties. They're defined on the tag
1038 * or with setAttribute (which shouldn't be used with HTML)
1039 * This will return true or false for boolean attributes.
1040 *
1041 * @param {Element} tag
1042 *        Element from which to get tag attributes.
1043 *
1044 * @return {Object}
1045 *         All attributes of the element.
1046 */
1047function getAttributes(tag) {
1048  var obj = {};
1049
1050  // known boolean attributes
1051  // we can check for matching boolean properties, but older browsers
1052  // won't know about HTML5 boolean attributes that we still read from
1053  var knownBooleans = ',' + 'autoplay,controls,playsinline,loop,muted,default,defaultMuted' + ',';
1054
1055  if (tag && tag.attributes && tag.attributes.length > 0) {
1056    var attrs = tag.attributes;
1057
1058    for (var i = attrs.length - 1; i >= 0; i--) {
1059      var attrName = attrs[i].name;
1060      var attrVal = attrs[i].value;
1061
1062      // check for known booleans
1063      // the matching element property will return a value for typeof
1064      if (typeof tag[attrName] === 'boolean' || knownBooleans.indexOf(',' + attrName + ',') !== -1) {
1065        // the value of an included boolean attribute is typically an empty
1066        // string ('') which would equal false if we just check for a false value.
1067        // we also don't want support bad code like autoplay='false'
1068        attrVal = attrVal !== null ? true : false;
1069      }
1070
1071      obj[attrName] = attrVal;
1072    }
1073  }
1074
1075  return obj;
1076}
1077
1078/**
1079 * Get the value of an element's attribute
1080 *
1081 * @param {Element} el
1082 *        A DOM element
1083 *
1084 * @param {string} attribute
1085 *        Attribute to get the value of
1086 *
1087 * @return {string}
1088 *         value of the attribute
1089 */
1090function getAttribute(el, attribute) {
1091  return el.getAttribute(attribute);
1092}
1093
1094/**
1095 * Set the value of an element's attribute
1096 *
1097 * @param {Element} el
1098 *        A DOM element
1099 *
1100 * @param {string} attribute
1101 *        Attribute to set
1102 *
1103 * @param {string} value
1104 *        Value to set the attribute to
1105 */
1106function setAttribute(el, attribute, value) {
1107  el.setAttribute(attribute, value);
1108}
1109
1110/**
1111 * Remove an element's attribute
1112 *
1113 * @param {Element} el
1114 *        A DOM element
1115 *
1116 * @param {string} attribute
1117 *        Attribute to remove
1118 */
1119function removeAttribute(el, attribute) {
1120  el.removeAttribute(attribute);
1121}
1122
1123/**
1124 * Attempt to block the ability to select text while dragging controls
1125 */
1126function blockTextSelection() {
1127  document_1.body.focus();
1128  document_1.onselectstart = function () {
1129    return false;
1130  };
1131}
1132
1133/**
1134 * Turn off text selection blocking
1135 */
1136function unblockTextSelection() {
1137  document_1.onselectstart = function () {
1138    return true;
1139  };
1140}
1141
1142/**
1143 * Identical to the native `getBoundingClientRect` function, but ensures that
1144 * the method is supported at all (it is in all browsers we claim to support)
1145 * and that the element is in the DOM before continuing.
1146 *
1147 * This wrapper function also shims properties which are not provided by some
1148 * older browsers (namely, IE8).
1149 *
1150 * Additionally, some browsers do not support adding properties to a
1151 * `ClientRect`/`DOMRect` object; so, we shallow-copy it with the standard
1152 * properties (except `x` and `y` which are not widely supported). This helps
1153 * avoid implementations where keys are non-enumerable.
1154 *
1155 * @param  {Element} el
1156 *         Element whose `ClientRect` we want to calculate.
1157 *
1158 * @return {Object|undefined}
1159 *         Always returns a plain
1160 */
1161function getBoundingClientRect(el) {
1162  if (el && el.getBoundingClientRect && el.parentNode) {
1163    var rect = el.getBoundingClientRect();
1164    var result = {};
1165
1166    ['bottom', 'height', 'left', 'right', 'top', 'width'].forEach(function (k) {
1167      if (rect[k] !== undefined) {
1168        result[k] = rect[k];
1169      }
1170    });
1171
1172    if (!result.height) {
1173      result.height = parseFloat(computedStyle(el, 'height'));
1174    }
1175
1176    if (!result.width) {
1177      result.width = parseFloat(computedStyle(el, 'width'));
1178    }
1179
1180    return result;
1181  }
1182}
1183
1184/**
1185 * The postion of a DOM element on the page.
1186 *
1187 * @typedef {Object} module:dom~Position
1188 *
1189 * @property {number} left
1190 *           Pixels to the left
1191 *
1192 * @property {number} top
1193 *           Pixels on top
1194 */
1195

1196/**
1197 * Offset Left.
1198 * getBoundingClientRect technique from
1199 * John Resig
1200 *
1201 * @see http://ejohn.org/blog/getboundingclientrect-is-awesome/
1202 *
1203 * @param {Element} el
1204 *        Element from which to get offset
1205 *
1206 * @return {module:dom~Position}
1207 *         The position of the element that was passed in.
1208 */
1209function findPosition(el) {
1210  var box = void 0;
1211
1212  if (el.getBoundingClientRect && el.parentNode) {
1213    box = el.getBoundingClientRect();
1214  }
1215
1216  if (!box) {
1217    return {
1218      left: 0,
1219      top: 0
1220    };
1221  }
1222
1223  var docEl = document_1.documentElement;
1224  var body = document_1.body;
1225
1226  var clientLeft = docEl.clientLeft || body.clientLeft || 0;
1227  var scrollLeft = window_1.pageXOffset || body.scrollLeft;
1228  var left = box.left + scrollLeft - clientLeft;
1229
1230  var clientTop = docEl.clientTop || body.clientTop || 0;
1231  var scrollTop = window_1.pageYOffset || body.scrollTop;
1232  var top = box.top + scrollTop - clientTop;
1233
1234  // Android sometimes returns slightly off decimal values, so need to round
1235  return {
1236    left: Math.round(left),
1237    top: Math.round(top)
1238  };
1239}
1240
1241/**
1242 * x and y coordinates for a dom element or mouse pointer
1243 *
1244 * @typedef {Object} Dom~Coordinates
1245 *
1246 * @property {number} x
1247 *           x coordinate in pixels
1248 *
1249 * @property {number} y
1250 *           y coordinate in pixels
1251 */
1252
1253/**
1254 * Get pointer position in element
1255 * Returns an object with x and y coordinates.
1256 * The base on the coordinates are the bottom left of the element.
1257 *
1258 * @param {Element} el
1259 *        Element on which to get the pointer position on
1260 *
1261 * @param {EventTarget~Event} event
1262 *        Event object
1263 *
1264 * @return {Dom~Coordinates}
1265 *         A Coordinates object corresponding to the mouse position.
1266 *
1267 */
1268function getPointerPosition(el, event) {
1269  var position = {};
1270  var box = findPosition(el);
1271  var boxW = el.offsetWidth;
1272  var boxH = el.offsetHeight;
1273
1274  var boxY = box.top;
1275  var boxX = box.left;
1276  var pageY = event.pageY;
1277  var pageX = event.pageX;
1278
1279  if (event.changedTouches) {
1280    pageX = event.changedTouches[0].pageX;
1281    pageY = event.changedTouches[0].pageY;
1282  }
1283
1284  position.y = Math.max(0, Math.min(1, (boxY - pageY + boxH) / boxH));
1285  position.x = Math.max(0, Math.min(1, (pageX - boxX) / boxW));
1286
1287  return position;
1288}
1289
1290/**
1291 * Determines, via duck typing, whether or not a value is a text node.
1292 *
1293 * @param {Mixed} value
1294 *        Check if this value is a text node.
1295 *
1296 * @return {boolean}
1297 *         - True if it is a text node
1298 *         - False otherwise
1299 */
1300function isTextNode(value) {
1301  return isObject(value) && value.nodeType === 3;
1302}
1303
1304/**
1305 * Empties the contents of an element.
1306 *
1307 * @param {Element} el
1308 *        The element to empty children from
1309 *
1310 * @return {Element}
1311 *         The element with no children
1312 */
1313function emptyEl(el) {
1314  while (el.firstChild) {
1315    el.removeChild(el.firstChild);
1316  }
1317  return el;
1318}
1319
1320/**
1321 * Normalizes content for eventual insertion into the DOM.
1322 *
1323 * This allows a wide range of content definition methods, but protects
1324 * from falling into the trap of simply writing to `innerHTML`, which is
1325 * an XSS concern.
1326 *
1327 * The content for an element can be passed in multiple types and
1328 * combinations, whose behavior is as follows:
1329 *
1330 * @param {String|Element|TextNode|Array|Function} content
1331 *        - String: Normalized into a text node.
1332 *        - Element/TextNode: Passed through.
1333 *        - Array: A one-dimensional array of strings, elements, nodes, or functions
1334 *          (which return single strings, elements, or nodes).
1335 *        - Function: If the sole argument, is expected to produce a string, element,
1336 *          node, or array as defined above.
1337 *
1338 * @return {Array}
1339 *         All of the content that was passed in normalized.
1340 */
1341function normalizeContent(content) {
1342
1343  // First, invoke content if it is a function. If it produces an array,
1344  // that needs to happen before normalization.
1345  if (typeof content === 'function') {
1346    content = content();
1347  }
1348
1349  // Next up, normalize to an array, so one or many items can be normalized,
1350  // filtered, and returned.
1351  return (Array.isArray(content) ? content : [content]).map(function (value) {
1352
1353    // First, invoke value if it is a function to produce a new value,
1354    // which will be subsequently normalized to a Node of some kind.
1355    if (typeof value === 'function') {
1356      value = value();
1357    }
1358
1359    if (isEl(value) || isTextNode(value)) {
1360      return value;
1361    }
1362
1363    if (typeof value === 'string' && /\S/.test(value)) {
1364      return document_1.createTextNode(value);
1365    }
1366  }).filter(function (value) {
1367    return value;
1368  });
1369}
1370
1371/**
1372 * Normalizes and appends content to an element.
1373 *
1374 * @param {Element} el
1375 *        Element to append normalized content to.
1376 *
1377 *
1378 * @param {String|Element|TextNode|Array|Function} content
1379 *        See the `content` argument of {@link dom:normalizeContent}
1380 *
1381 * @return {Element}
1382 *         The element with appended normalized content.
1383 */
1384function appendContent(el, content) {
1385  normalizeContent(content).forEach(function (node) {
1386    return el.appendChild(node);
1387  });
1388  return el;
1389}
1390
1391/**
1392 * Normalizes and inserts content into an element; this is identical to
1393 * `appendContent()`, except it empties the element first.
1394 *
1395 * @param {Element} el
1396 *        Element to insert normalized content into.
1397 *
1398 * @param {String|Element|TextNode|Array|Function} content
1399 *        See the `content` argument of {@link dom:normalizeContent}
1400 *
1401 * @return {Element}
1402 *         The element with inserted normalized content.
1403 *
1404 */
1405function insertContent(el, content) {
1406  return appendContent(emptyEl(el), content);
1407}
1408
1409/**
1410 * Finds a single DOM element matching `selector` within the optional
1411 * `context` of another DOM element (defaulting to `document`).
1412 *
1413 * @param {string} selector
1414 *        A valid CSS selector, which will be passed to `querySelector`.
1415 *
1416 * @param {Element|String} [context=document]
1417 *        A DOM element within which to query. Can also be a selector
1418 *        string in which case the first matching element will be used
1419 *        as context. If missing (or no element matches selector), falls
1420 *        back to `document`.
1421 *
1422 * @return {Element|null}
1423 *         The element that was found or null.
1424 */
1425var $ = createQuerier('querySelector');
1426
1427/**
1428 * Finds a all DOM elements matching `selector` within the optional
1429 * `context` of another DOM element (defaulting to `document`).
1430 *
1431 * @param {string} selector
1432 *           A valid CSS selector, which will be passed to `querySelectorAll`.
1433 *
1434 * @param {Element|String} [context=document]
1435 *           A DOM element within which to query. Can also be a selector
1436 *           string in which case the first matching element will be used
1437 *           as context. If missing (or no element matches selector), falls
1438 *           back to `document`.
1439 *
1440 * @return {NodeList}
1441 *         A element list of elements that were found. Will be empty if none were found.
1442 *
1443 */
1444var $$ = createQuerier('querySelectorAll');
1445
1446
1447
1448var Dom = (Object.freeze || Object)({
1449	isReal: isReal,
1450	isEl: isEl,
1451	createEl: createEl,
1452	textContent: textContent,
1453	prependTo: prependTo,
1454	hasClass: hasClass,
1455	addClass: addClass,
1456	removeClass: removeClass,
1457	toggleClass: toggleClass,
1458	setAttributes: setAttributes,
1459	getAttributes: getAttributes,
1460	getAttribute: getAttribute,
1461	setAttribute: setAttribute,
1462	removeAttribute: removeAttribute,
1463	blockTextSelection: blockTextSelection,
1464	unblockTextSelection: unblockTextSelection,
1465	getBoundingClientRect: getBoundingClientRect,
1466	findPosition: findPosition,
1467	getPointerPosition: getPointerPosition,
1468	isTextNode: isTextNode,
1469	emptyEl: emptyEl,
1470	normalizeContent: normalizeContent,
1471	appendContent: appendContent,
1472	insertContent: insertContent,
1473	$: $,
1474	$$: $$
1475});
1476
1477/**
1478 * @file guid.js
1479 * @module guid
1480 */
1481
1482/**
1483 * Unique ID for an element or function
1484 * @type {Number}
1485 */
1486var _guid = 1;
1487
1488/**
1489 * Get a unique auto-incrementing ID by number that has not been returned before.
1490 *
1491 * @return {number}
1492 *         A new unique ID.
1493 */
1494function newGUID() {
1495  return _guid++;
1496}
1497
1498/**
1499 * @file dom-data.js
1500 * @module dom-data
1501 */
1502/**
1503 * Element Data Store.
1504 *
1505 * Allows for binding data to an element without putting it directly on the
1506 * element. Ex. Event listeners are stored here.
1507 * (also from jsninja.com, slightly modified and updated for closure compiler)
1508 *
1509 * @type {Object}
1510 * @private
1511 */
1512var elData = {};
1513
1514/*
1515 * Unique attribute name to store an element's guid in
1516 *
1517 * @type {String}
1518 * @constant
1519 * @private
1520 */
1521var elIdAttr = 'vdata' + new Date().getTime();
1522
1523/**
1524 * Returns the cache object where data for an element is stored
1525 *
1526 * @param {Element} el
1527 *        Element to store data for.
1528 *
1529 * @return {Object}
1530 *         The cache object for that el that was passed in.
1531 */
1532function getData(el) {
1533  var id = el[elIdAttr];
1534
1535  if (!id) {
1536    id = el[elIdAttr] = newGUID();
1537  }
1538
1539  if (!elData[id]) {
1540    elData[id] = {};
1541  }
1542
1543  return elData[id];
1544}
1545
1546/**
1547 * Returns whether or not an element has cached data
1548 *
1549 * @param {Element} el
1550 *        Check if this element has cached data.
1551 *
1552 * @return {boolean}
1553 *         - True if the DOM element has cached data.
1554 *         - False otherwise.
1555 */
1556function hasData(el) {
1557  var id = el[elIdAttr];
1558
1559  if (!id) {
1560    return false;
1561  }
1562
1563  return !!Object.getOwnPropertyNames(elData[id]).length;
1564}
1565
1566/**
1567 * Delete data for the element from the cache and the guid attr from getElementById
1568 *
1569 * @param {Element} el
1570 *        Remove cached data for this element.
1571 */
1572function removeData(el) {
1573  var id = el[elIdAttr];
1574
1575  if (!id) {
1576    return;
1577  }
1578
1579  // Remove all stored data
1580  delete elData[id];
1581
1582  // Remove the elIdAttr property from the DOM node
1583  try {
1584    delete el[elIdAttr];
1585  } catch (e) {
1586    if (el.removeAttribute) {
1587      el.removeAttribute(elIdAttr);
1588    } else {
1589      // IE doesn't appear to support removeAttribute on the document element
1590      el[elIdAttr] = null;
1591    }
1592  }
1593}
1594
1595/**
1596 * @file events.js. An Event System (John Resig - Secrets of a JS Ninja http://jsninja.com/)
1597 * (Original book version wasn't completely usable, so fixed some things and made Closure Compiler compatible)
1598 * This should work very similarly to jQuery's events, however it's based off the book version which isn't as
1599 * robust as jquery's, so there's probably some differences.
1600 *
1601 * @module events
1602 */
1603
1604/**
1605 * Clean up the listener cache and dispatchers
1606 *
1607 * @param {Element|Object} elem
1608 *        Element to clean up
1609 *
1610 * @param {string} type
1611 *        Type of event to clean up
1612 */
1613function _cleanUpEvents(elem, type) {
1614  var data = getData(elem);
1615
1616  // Remove the events of a particular type if there are none left
1617  if (data.handlers[type].length === 0) {
1618    delete data.handlers[type];
1619    // data.handlers[type] = null;
1620    // Setting to null was causing an error with data.handlers
1621
1622    // Remove the meta-handler from the element
1623    if (elem.removeEventListener) {
1624      elem.removeEventListener(type, data.dispatcher, false);
1625    } else if (elem.detachEvent) {
1626      elem.detachEvent('on' + type, data.dispatcher);
1627    }
1628  }
1629
1630  // Remove the events object if there are no types left
1631  if (Object.getOwnPropertyNames(data.handlers).length <= 0) {
1632    delete data.handlers;
1633    delete data.dispatcher;
1634    delete data.disabled;
1635  }
1636
1637  // Finally remove the element data if there is no data left
1638  if (Object.getOwnPropertyNames(data).length === 0) {
1639    removeData(elem);
1640  }
1641}
1642
1643/**
1644 * Loops through an array of event types and calls the requested method for each type.
1645 *
1646 * @param {Function} fn
1647 *        The event method we want to use.
1648 *
1649 * @param {Element|Object} elem
1650 *        Element or object to bind listeners to
1651 *
1652 * @param {string} type
1653 *        Type of event to bind to.
1654 *
1655 * @param {EventTarget~EventListener} callback
1656 *        Event listener.
1657 */
1658function _handleMultipleEvents(fn, elem, types, callback) {
1659  types.forEach(function (type) {
1660    // Call the event method for each one of the types
1661    fn(elem, type, callback);
1662  });
1663}
1664
1665/**
1666 * Fix a native event to have standard property values
1667 *
1668 * @param {Object} event
1669 *        Event object to fix.
1670 *
1671 * @return {Object}
1672 *         Fixed event object.
1673 */
1674function fixEvent(event) {
1675
1676  function returnTrue() {
1677    return true;
1678  }
1679
1680  function returnFalse() {
1681    return false;
1682  }
1683
1684  // Test if fixing up is needed
1685  // Used to check if !event.stopPropagation instead of isPropagationStopped
1686  // But native events return true for stopPropagation, but don't have
1687  // other expected methods like isPropagationStopped. Seems to be a problem
1688  // with the Javascript Ninja code. So we're just overriding all events now.
1689  if (!event || !event.isPropagationStopped) {
1690    var old = event || window_1.event;
1691
1692    event = {};
1693    // Clone the old object so that we can modify the values event = {};
1694    // IE8 Doesn't like when you mess with native event properties
1695    // Firefox returns false for event.hasOwnProperty('type') and other props
1696    //  which makes copying more difficult.
1697    // TODO: Probably best to create a whitelist of event props
1698    for (var key in old) {
1699      // Safari 6.0.3 warns you if you try to copy deprecated layerX/Y
1700      // Chrome warns you if you try to copy deprecated keyboardEvent.keyLocation
1701      // and webkitMovementX/Y
1702      if (key !== 'layerX' && key !== 'layerY' && key !== 'keyLocation' && key !== 'webkitMovementX' && key !== 'webkitMovementY') {
1703        // Chrome 32+ warns if you try to copy deprecated returnValue, but
1704        // we still want to if preventDefault isn't supported (IE8).
1705        if (!(key === 'returnValue' && old.preventDefault)) {
1706          event[key] = old[key];
1707        }
1708      }
1709    }
1710
1711    // The event occurred on this element
1712    if (!event.target) {
1713      event.target = event.srcElement || document_1;
1714    }
1715
1716    // Handle which other element the event is related to
1717    if (!event.relatedTarget) {
1718      event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
1719    }
1720
1721    // Stop the default browser action
1722    event.preventDefault = function () {
1723      if (old.preventDefault) {
1724        old.preventDefault();
1725      }
1726      event.returnValue = false;
1727      old.returnValue = false;
1728      event.defaultPrevented = true;
1729    };
1730
1731    event.defaultPrevented = false;
1732
1733    // Stop the event from bubbling
1734    event.stopPropagation = function () {
1735      if (old.stopPropagation) {
1736        old.stopPropagation();
1737      }
1738      event.cancelBubble = true;
1739      old.cancelBubble = true;
1740      event.isPropagationStopped = returnTrue;
1741    };
1742
1743    event.isPropagationStopped = returnFalse;
1744
1745    // Stop the event from bubbling and executing other handlers
1746    event.stopImmediatePropagation = function () {
1747      if (old.stopImmediatePropagation) {
1748        old.stopImmediatePropagation();
1749      }
1750      event.isImmediatePropagationStopped = returnTrue;
1751      event.stopPropagation();
1752    };
1753
1754    event.isImmediatePropagationStopped = returnFalse;
1755
1756    // Handle mouse position
1757    if (event.clientX !== null && event.clientX !== undefined) {
1758      var doc = document_1.documentElement;
1759      var body = document_1.body;
1760
1761      event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1762      event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
1763    }
1764
1765    // Handle key presses
1766    event.which = event.charCode || event.keyCode;
1767
1768    // Fix button for mouse clicks:
1769    // 0 == left; 1 == middle; 2 == right
1770    if (event.button !== null && event.button !== undefined) {
1771
1772      // The following is disabled because it does not pass videojs-standard
1773      // and... yikes.
1774      /* eslint-disable */
1775      event.button = event.button & 1 ? 0 : event.button & 4 ? 1 : event.button & 2 ? 2 : 0;
1776      /* eslint-enable */
1777    }
1778  }
1779
1780  // Returns fixed-up instance
1781  return event;
1782}
1783
1784/**
1785 * Whether passive event listeners are supported
1786 */
1787var _supportsPassive = false;
1788
1789(function () {
1790  try {
1791    var opts = Object.defineProperty({}, 'passive', {
1792      get: function get() {
1793        _supportsPassive = true;
1794      }
1795    });
1796
1797    window_1.addEventListener('test', null, opts);
1798  } catch (e) {
1799    // disregard
1800  }
1801})();
1802
1803/**
1804 * Touch events Chrome expects to be passive
1805 */
1806var passiveEvents = ['touchstart', 'touchmove'];
1807
1808/**
1809 * Add an event listener to element
1810 * It stores the handler function in a separate cache object
1811 * and adds a generic handler to the element's event,
1812 * along with a unique id (guid) to the element.
1813 *
1814 * @param {Element|Object} elem
1815 *        Element or object to bind listeners to
1816 *
1817 * @param {string|string[]} type
1818 *        Type of event to bind to.
1819 *
1820 * @param {EventTarget~EventListener} fn
1821 *        Event listener.
1822 */
1823function on(elem, type, fn) {
1824  if (Array.isArray(type)) {
1825    return _handleMultipleEvents(on, elem, type, fn);
1826  }
1827
1828  var data = getData(elem);
1829
1830  // We need a place to store all our handler data
1831  if (!data.handlers) {
1832    data.handlers = {};
1833  }
1834
1835  if (!data.handlers[type]) {
1836    data.handlers[type] = [];
1837  }
1838
1839  if (!fn.guid) {
1840    fn.guid = newGUID();
1841  }
1842
1843  data.handlers[type].push(fn);
1844
1845  if (!data.dispatcher) {
1846    data.disabled = false;
1847
1848    data.dispatcher = function (event, hash) {
1849
1850      if (data.disabled) {
1851        return;
1852      }
1853
1854      event = fixEvent(event);
1855
1856      var handlers = data.handlers[event.type];
1857
1858      if (handlers) {
1859        // Copy handlers so if handlers are added/removed during the process it doesn't throw everything off.
1860        var handlersCopy = handlers.slice(0);
1861
1862        for (var m = 0, n = handlersCopy.length; m < n; m++) {
1863          if (event.isImmediatePropagationStopped()) {
1864            break;
1865          } else {
1866            try {
1867              handlersCopy[m].call(elem, event, hash);
1868            } catch (e) {
1869              log$1.error(e);
1870            }
1871          }
1872        }
1873      }
1874    };
1875  }
1876
1877  if (data.handlers[type].length === 1) {
1878    if (elem.addEventListener) {
1879      var options = false;
1880
1881      if (_supportsPassive && passiveEvents.indexOf(type) > -1) {
1882        options = { passive: true };
1883      }
1884      elem.addEventListener(type, data.dispatcher, options);
1885    } else if (elem.attachEvent) {
1886      elem.attachEvent('on' + type, data.dispatcher);
1887    }
1888  }
1889}
1890
1891/**
1892 * Removes event listeners from an element
1893 *

2357EventTarget.prototype.off = function (type, fn) {
2358  off(this, type, fn);
2359};
2360
2361/**
2362 * An alias of {@link EventTarget#off}. Allows `EventTarget` to mimic
2363 * the standard DOM API.
2364 *
2365 * @function
2366 * @see {@link EventTarget#off}
2367 */
2368EventTarget.prototype.removeEventListener = EventTarget.prototype.off;
2369
2370/**
2371 * This function will add an `event listener` that gets triggered only once. After the
2372 * first trigger it will get removed. This is like adding an `event listener`
2373 * with {@link EventTarget#on} that calls {@link EventTarget#off} on itself.
2374 *
2375 * @param {string|string[]} type
2376 *        An event name or an array of event names.
2377 *
2378 * @param {EventTarget~EventListener} fn
2379 *        The function to be called once for each event name.
2380 */
2381EventTarget.prototype.one = function (type, fn) {
2382  // Remove the addEventListener alialing Events.on
2383  // so we don't get into an infinite type loop
2384  var ael = this.addEventListener;
2385
2386  this.addEventListener = function () {};
2387  one(this, type, fn);
2388  this.addEventListener = ael;
2389};
2390
2391/**
2392 * This function causes an event to happen. This will then cause any `event listeners`
2393 * that are waiting for that event, to get called. If there are no `event listeners`
2394 * for an event then nothing will happen.
2395 *
2396 * If the name of the `Event` that is being triggered is in `EventTarget.allowedEvents_`.
2397 * Trigger will also call the `on` + `uppercaseEventName` function.
2398 *
2399 * Example:
2400 * 'click' is in `EventTarget.allowedEvents_`, so, trigger will attempt to call
2401 * `onClick` if it exists.
2402 *
2403 * @param {string|EventTarget~Event|Object} event
2404 *        The name of the event, an `Event`, or an object with a key of type set to
2405 *        an event name.
2406 */
2407EventTarget.prototype.trigger = function (event) {
2408  var type = event.type || event;
2409
2410  if (typeof event === 'string') {
2411    event = { type: type };
2412  }
2413  event = fixEvent(event);
2414
2415  if (this.allowedEvents_[type] && this['on' + type]) {
2416    this['on' + type](event);
2417  }
2418
2419  trigger(this, event);
2420};
2421
2422/**
2423 * An alias of {@link EventTarget#trigger}. Allows `EventTarget` to mimic
2424 * the standard DOM API.
2425 *
2426 * @function
2427 * @see {@link EventTarget#trigger}
2428 */
2429EventTarget.prototype.dispatchEvent = EventTarget.prototype.trigger;
2430
2431/**
2432 * @file mixins/evented.js
2433 * @module evented
2434 */
2435/**
2436 * Returns whether or not an object has had the evented mixin applied.
2437 *
2438 * @param  {Object} object
2439 *         An object to test.
2440 *
2441 * @return {boolean}
2442 *         Whether or not the object appears to be evented.
2443 */
2444var isEvented = function isEvented(object) {
2445  return object instanceof EventTarget || !!object.eventBusEl_ && ['on', 'one', 'off', 'trigger'].every(function (k) {
2446    return typeof object[k] === 'function';
2447  });
2448};
2449
2450/**
2451 * Whether a value is a valid event type - non-empty string or array.
2452 *
2453 * @private
2454 * @param  {string|Array} type
2455 *         The type value to test.
2456 *
2457 * @return {boolean}
2458 *         Whether or not the type is a valid event type.
2459 */
2460var isValidEventType = function isValidEventType(type) {
2461  return (
2462    // The regex here verifies that the `type` contains at least one non-
2463    // whitespace character.
2464    typeof type === 'string' && /\S/.test(type) || Array.isArray(type) && !!type.length
2465  );
2466};
2467
2468/**
2469 * Validates a value to determine if it is a valid event target. Throws if not.
2470 *
2471 * @private
2472 * @throws {Error}
2473 *         If the target does not appear to be a valid event target.
2474 *
2475 * @param  {Object} target
2476 *         The object to test.
2477 */
2478var validateTarget = function validateTarget(target) {
2479  if (!target.nodeName && !isEvented(target)) {
2480    throw new Error('Invalid target; must be a DOM node or evented object.');
2481  }
2482};
2483
2484/**
2485 * Validates a value to determine if it is a valid event target. Throws if not.
2486 *
2487 * @private
2488 * @throws {Error}
2489 *         If the type does not appear to be a valid event type.
2490 *
2491 * @param  {string|Array} type
2492 *         The type to test.
2493 */
2494var validateEventType = function validateEventType(type) {
2495  if (!isValidEventType(type)) {
2496    throw new Error('Invalid event type; must be a non-empty string or array.');
2497  }
2498};
2499
2500/**
2501 * Validates a value to determine if it is a valid listener. Throws if not.
2502 *
2503 * @private
2504 * @throws {Error}
2505 *         If the listener is not a function.
2506 *
2507 * @param  {Function} listener
2508 *         The listener to test.
2509 */
2510var validateListener = function validateListener(listener) {
2511  if (typeof listener !== 'function') {
2512    throw new Error('Invalid listener; must be a function.');
2513  }
2514};
2515
2516/**
2517 * Takes an array of arguments given to `on()` or `one()`, validates them, and
2518 * normalizes them into an object.
2519 *
2520 * @private
2521 * @param  {Object} self
2522 *         The evented object on which `on()` or `one()` was called. This
2523 *         object will be bound as the `this` value for the listener.
2524 *
2525 * @param  {Array} args
2526 *         An array of arguments passed to `on()` or `one()`.
2527 *
2528 * @return {Object}
2529 *         An object containing useful values for `on()` or `one()` calls.
2530 */
2531var normalizeListenArgs = function normalizeListenArgs(self, args) {
2532
2533  // If the number of arguments is less than 3, the target is always the
2534  // evented object itself.
2535  var isTargetingSelf = args.length < 3 || args[0] === self || args[0] === self.eventBusEl_;
2536  var target = void 0;
2537  var type = void 0;
2538  var listener = void 0;
2539
2540  if (isTargetingSelf) {
2541    target = self.eventBusEl_;
2542
2543    // Deal with cases where we got 3 arguments, but we are still listening to
2544    // the evented object itself.
2545    if (args.length >= 3) {
2546      args.shift();
2547    }
2548
2549    type = args[0];
2550    listener = args[1];
2551  } else {
2552    target = args[0];
2553    type = args[1];
2554    listener = args[2];
2555  }
2556
2557  validateTarget(target);
2558  validateEventType(type);
2559  validateListener(listener);
2560
2561  listener = bind(self, listener);
2562
2563  return { isTargetingSelf: isTargetingSelf, target: target, type: type, listener: listener };
2564};
2565
2566/**
2567 * Adds the listener to the event type(s) on the target, normalizing for
2568 * the type of target.
2569 *
2570 * @private
2571 * @param  {Element|Object} target
2572 *         A DOM node or evented object.
2573 *
2574 * @param  {string} method
2575 *         The event binding method to use ("on" or "one").
2576 *
2577 * @param  {string|Array} type
2578 *         One or more event type(s).
2579 *
2580 * @param  {Function} listener
2581 *         A listener function.
2582 */
2583var listen = function listen(target, method, type, listener) {
2584  validateTarget(target);
2585
2586  if (target.nodeName) {
2587    Events[method](target, type, listener);
2588  } else {
2589    target[method](type, listener);
2590  }
2591};
2592
2593/**
2594 * Contains methods that provide event capabilit

2594es to an object which is passed
2595 * to {@link module:evented|evented}.
2596 *
2597 * @mixin EventedMixin
2598 */
2599var EventedMixin = {
2600
2601  /**
2602   * Add a listener to an event (or events) on this object or another evented
2603   * object.
2604   *
2605   * @param  {string|Array|Element|Object} targetOrType
2606   *         If this is a string or array, it represents the event type(s)
2607   *         that will trigger the listener.
2608   *
2609   *         Another evented object can be passed here instead, which will
2610   *         cause the listener to listen for events on _that_ object.
2611   *
2612   *         In either case, the listener's `this` value will be bound to
2613   *         this object.
2614   *
2615   * @param  {string|Array|Function} typeOrListener
2616   *         If the first argument was a string or array, this should be the
2617   *         listener function. Otherwise, this is a string or array of event
2618   *         type(s).
2619   *
2620   * @param  {Function} [listener]
2621   *         If the first argument was another evented object, this will be
2622   *         the listener function.
2623   */
2624  on: function on$$1() {
2625    var _this = this;
2626
2627    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
2628      args[_key] = arguments[_key];
2629    }
2630
2631    var _normalizeListenArgs = normalizeListenArgs(this, args),
2632        isTargetingSelf = _normalizeListenArgs.isTargetingSelf,
2633        target = _normalizeListenArgs.target,
2634        type = _normalizeListenArgs.type,
2635        listener = _normalizeListenArgs.listener;
2636
2637    listen(target, 'on', type, listener);
2638
2639    // If this object is listening to another evented object.
2640    if (!isTargetingSelf) {
2641
2642      // If this object is disposed, remove the listener.
2643      var removeListenerOnDispose = function removeListenerOnDispose() {
2644        return _this.off(target, type, listener);
2645      };
2646
2647      // Use the same function ID as the listener so we can remove it later it
2648      // using the ID of the original listener.
2649      removeListenerOnDispose.guid = listener.guid;
2650
2651      // Add a listener to the target's dispose event as well. This ensures
2652      // that if the target is disposed BEFORE this object, we remove the
2653      // removal listener that was just added. Otherwise, we create a memory leak.
2654      var removeRemoverOnTargetDispose = function removeRemoverOnTargetDispose() {
2655        return _this.off('dispose', removeListenerOnDispose);
2656      };
2657
2658      // Use the same function ID as the listener so we can remove it later
2659      // it using the ID of the original listener.
2660      removeRemoverOnTargetDispose.guid = listener.guid;
2661
2662      listen(this, 'on', 'dispose', removeListenerOnDispose);
2663      listen(target, 'on', 'dispose', removeRemoverOnTargetDispose);
2664    }
2665  },
2666
2667
2668  /**
2669   * Add a listener to an event (or events) on this object or another evented
2670   * object. The listener will only be called once and then removed.
2671   *
2672   * @param  {string|Array|Element|Object} targetOrType
2673   *         If this is a string or array, it represents the event type(s)
2674   *         that will trigger the listener.
2675   *
2676   *         Another evented object can be passed here instead, which will
2677   *         cause the listener to listen for events on _that_ object.
2678   *
2679   *         In either case, the listener's `this` value will be bound to
2680   *         this object.
2681   *
2682   * @param  {string|Array|Function} typeOrListener
2683   *         If the first argument was a string or array, this should be the
2684   *         listener function. Otherwise, this is a string or array of event
2685   *         type(s).
2686   *
2687   * @param  {Function} [listener]
2688   *         If the first argument was another evented object, this will be
2689   *         the listener function.
2690   */
2691  one: function one$$1() {
2692    var _this2 = this;
2693
2694    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
2695      args[_key2] = arguments[_key2];
2696    }
2697
2698    var _normalizeListenArgs2 = normalizeListenArgs(this, args),
2699        isTargetingSelf = _normalizeListenArgs2.isTargetingSelf,
2700        target = _normalizeListenArgs2.target,
2701        type = _normalizeListenArgs2.type,
2702        listener = _normalizeListenArgs2.listener;
2703
2704    // Targeting this evented object.
2705
2706
2707    if (isTargetingSelf) {
2708      listen(target, 'one', type, listener);
2709
2710      // Targeting another evented object.
2711    } else {
2712      var wrapper = function wrapper() {
2713        for (var _len3 = arguments.length, largs = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
2714          largs[_key3] = arguments[_key3];
2715        }
2716
2717        _this2.off(target, type, wrapper);
2718        listener.apply(null, largs);
2719      };
2720
2721      // Use the same function ID as the listener so we can remove it later
2722      // it using the ID of the original listener.
2723      wrapper.guid = listener.guid;
2724      listen(target, 'one', type, wrapper);
2725    }
2726  },
2727
2728
2729  /**
2730   * Removes listener(s) from event(s) on an evented object.
2731   *
2732   * @param  {string|Array|Element|Object} [targetOrType]
2733   *         If this is a string or array, it represents the event type(s).
2734   *
2735   *         Another evented object can be passed here instead, in which case
2736   *         ALL 3 arguments are _required_.
2737   *
2738   * @param  {string|Array|Function} [typeOrListener]
2739   *         If the first argument was a string or array, this may be the
2740   *         listener function. Otherwise, this is a string or array of event
2741   *         type(s).
2742   *
2743   * @param  {Function} [listener]
2744   *         If the first argument was another evented object, this will be
2745   *         the listener function; otherwise, _all_ listeners bound to the
2746   *         event type(s) will be removed.
2747   */
2748  off: function off$$1(targetOrType, typeOrListener, listener) {
2749
2750    // Targeting this evented object.
2751    if (!targetOrType || isValidEventType(targetOrType)) {
2752      off(this.eventBusEl_, targetOrType, typeOrListener);
2753
2754      // Targeting another evented object.
2755    } else {
2756      var target = targetOrType;
2757      var type = typeOrListener;
2758
2759      // Fail fast and in a meaningful way!
2760      validateTarget(target);
2761      validateEventType(type);
2762      validateListener(listener);
2763
2764      // Ensure there's at least a guid, even if the function hasn't been used
2765      listener = bind(this, listener);
2766
2767      // Remove the dispose listener on this evented object, which was given
2768      // the same guid as the event listener in on().
2769      this.off('dispose', listener);
2770
2771      if (target.nodeName) {
2772        off(target, type, listener);
2773        off(target, 'dispose', listener);
2774      } else if (isEvented(target)) {
2775        target.off(type, listener);
2776        target.off('dispose', listener);
2777      }
2778    }
2779  },
2780
2781
2782  /**
2783   * Fire an event on this evented object, causing its listeners to be called.
2784   *
2785   * @param   {string|Object} event
2786   *          An event type or an object with a type property.
2787   *
2788   * @param   {Object} [hash]
2789   *          An additional object to pass along to listeners.
2790   *
2791   * @returns {boolean}
2792   *          Whether or not the default behavior was prevented.
2793   */
2794  trigger: function trigger$$1(event, hash) {
2795    return trigger(this.eventBusEl_, event, hash);
2796  }
2797};
2798
2799/**
2800 * Applies {@link module:evented~EventedMixin|EventedMixin} to a target object.
2801 *
2802 * @param  {Object} target
2803 *         The object to which to add event methods.
2804 *
2805 * @param  {Object} [options={}]
2806 *         Options for customizing the mixin behavior.
2807 *
2808 * @param  {String} [options.eventBusKey]
2809 *         By default, adds a `eventBusEl_` DOM element to the target object,
2810 *         which is used as an event bus. If the target object already has a
2811 *         DOM element that should be used, pass its key here.
2812 *
2813 * @return {Object}
2814 *         The target object.
2815 */
2816function evented(target) {
2817  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
2818  var eventBusKey = options.eventBusKey;
2819
2820  // Set or create the eventBusEl_.
2821
2822  if (eventBusKey) {
2823    if (!target[eventBusKey].nodeName) {
2824      throw new Error('The eventBusKey "' + eventBusKey + '" does not refer to an element.');
2825    }
2826    target.eventBusEl_ = target[eventBusKey];
2827  } else {
2828    target.eventBusEl_ = createEl('span', { className: 'vjs-event-bus' });
2829  }
2830
2831  assign(target, EventedMixin);
2832
2833  // When any evented object is disposed, it removes all its listeners.
2834  target.on('dispose', function () {
2835