https://www.paloaltonetworks.it/etc/clientlibs/clean/dependencies/video-js/video-js-yt.js

1/**
2 * @license
3 * Video.js 6.12.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/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.12.0";
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) || /CriOS/i.test(USER_AGENT));
133var CHROME_VERSION = function () {
134  var match = USER_AGENT.match(/(Chrome|CriOS)\/(\d+)/);
135
136  if (match && match[2]) {
137    return parseFloat(match[2]);
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) && !IS_CHROME;
156
157var TOUCH_ENABLED = isReal() && ('ontouchstart' in window_1 || window_1.navigator.maxTouchPoints || 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 = 'info';
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  if (!window_1.console) {
455    return;
456  }
457
458  // Was setting these once outside of this function, but containing them
459  // in the function makes it easier to test cases where console doesn't exist
460  // when the module is executed.
461  var fn = window_1.console[type];
462
463  if (!fn && type === 'debug') {
464    // Certain browsers don't have support for console.debug. For those, we
465    // should default to the closest comparable log.
466    fn = window_1.console.info || window_1.console.log;
467  }
468
469  // Bail out if there's no console or if this type is not allowed by the
470  // current logging level.
471  if (!fn || !lvl || !lvlRegExp.test(type)) {
472    return;
473  }
474
475  // IEs previous to 11 log objects uselessly as "[object Object]"; so, JSONify
476  // objects and arrays for those less-capable browsers.
477  if (stringify) {
478    args = args.map(function (a) {
479      if (isObject(a) || Array.isArray(a)) {
480        try {
481          return JSON.stringify(a);
482        } catch (x) {
483          return String(a);
484        }
485      }
486
487      // Cast to string before joining, so we get null and undefined explicitly
488      // included in output (as we would in a modern console).
489      return String(a);
490    }).join(' ');
491  }
492
493  // Old IE versions do not allow .apply() for console methods (they are
494  // reported as objects rather than functions).
495  if (!fn.apply) {
496    fn(args);
497  } else {
498    fn[Array.isArray(args) ? 'apply' : 'call'](window_1.console, args);
499  }
500};
501
502/**
503 * Logs plain debug messages. Similar to `console.log`.
504 *
505 * @class
506 * @param    {Mixed[]} args
507 *           One or more messages or objects that should be logged.
508 */
509log = function log() {
510  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
511    args[_key] = arguments[_key];
512  }
513
514  logByType('log', args);
515};
516
517/**
518 * Enumeration of available logging levels, where the keys are the level names
519 * and the values are `|`-separated strings containing logging methods allowed
520 * in that logging level. These strings are used to create a regular expression
521 * matching the function name being called.
522 *
523 * Levels provided by video.js are:
524 *
525 * - `off`: Matches no calls. Any value that can be cast to `false` will have
526 *   this effect. The most restrictive.
527 * - `all`: Matches only Video.js-provided functions (`debug`, `log`,
528 *   `log.warn`, and `log.error`).
529 * - `debug`: Matches `log.debug`, `log`, `log.warn`, and `log.error` calls.
530 * - `info` (default): Matches `log`, `log.warn`, and `log.error` calls.
531 * - `warn`: Matches `log.warn` and `log.error` calls.
532 * - `error`: Matches only `log.error` calls.
533 *
534 * @type {Object}
535 */
536log.levels = {
537  all: 'debug|log|warn|error',
538  off: '',
539  debug: 'debug|log|warn|error',
540  info: 'log|warn|error',
541  warn: 'warn|error',
542  error: 'error',
543  DEFAULT: level
544};
545
546/**
547 * Get or set the current logging level. If a string matching a key from
548 * {@link log.levels} is provided, acts as a setter. Regardless of argument,
549 * returns the current logging level.
550 *
551 * @param  {string} [lvl]
552 *         Pass to set a new logging level.
553 *
554 * @return {string}
555 *         The current logging level.
556 */
557log.level = function (lvl) {
558  if (typeof lvl === 'string') {
559    if (!log.levels.hasOwnProperty(lvl)) {
560      throw new Error('"' + lvl + '" in not a valid log level');
561    }
562    level = lvl;
563  }
564  return level;
565};
566
567/**
568 * Returns an array containing everything that has been logged to the history.
569 *
570 * This array is a shallow clone of the internal history record. However, its
571 * contents are _not_ cloned; so, mutating objects inside this array will
572 * mutate them in history.
573 *
574 * @return {Array}
575 */
576log.history = function () {
577  return history ? [].concat(history) : [];
578};
579
580/**
581 * Clears the internal history tracking, but does not prevent further history
582 * tracking.
583 */
584log.history.clear = function () {
585  if (history) {
586    history.length = 0;
587  }
588};
589
590/**
591 * Disable history tracking if it is currently enabled.
592 */
593log.history.disable = function () {
594  if (history !== null) {
595    history.length = 0;
596    history = null;
597  }
598};
599
600/**
601 * Enable history tracking if it is currently disabled.
602 */
603log.history.enable = function () {
604  if (history === null) {
605    history = [];
606  }
607};
608
609/**
610 * Logs error messages. Similar to `console.error`.
611 *
612 * @param {Mixed[]} args
613 *        One or more messages or objects that should be logged as an error
614 */
615log.error = function () {
616  for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
617    args[_key2] = arguments[_key2];
618  }
619
620  return logByType('error', args);
621};
622
623/**

855  Object.getOwnPropertyNames(properties).forEach(function (propName) {
856    var val = properties[propName];
857
858    // See #2176
859    // We originally were accepting both properties and attributes in the
860    // same object, but that doesn't work so well.
861    if (propName.indexOf('aria-') !== -1 || propName === 'role' || propName === 'type') {
862      log$1.warn(tsml(_templateObject, propName, val));
863      el.setAttribute(propName, val);
864
865      // Handle textContent since it's not supported everywhere and we have a
866      // method for it.
867    } else if (propName === 'textContent') {
868      textContent(el, val);
869    } else {
870      el[propName] = val;
871    }
872  });
873
874  Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
875    el.setAttribute(attrName, attributes[attrName]);
876  });
877
878  if (content) {
879    appendContent(el, content);
880  }
881
882  return el;
883}
884
885/**
886 * Injects text into an element, replacing any existing contents entirely.
887 *
888 * @param {Element} el
889 *        The element to add text content into
890 *
891 * @param {string} text
892 *        The text content to add.
893 *
894 * @return {Element}
895 *         The element with added text content.
896 */
897function textContent(el, text) {
898  if (typeof el.textContent === 'undefined') {
899    el.innerText = text;
900  } else {
901    el.textContent = text;
902  }
903  return el;
904}
905
906/**
907 * Insert an element as the first child node of another
908 *
909 * @param {Element} child
910 *        Element to insert
911 *
912 * @param {Element} parent
913 *        Element to insert child into
914 */
915function prependTo(child, parent) {
916  if (parent.firstChild) {
917    parent.insertBefore(child, parent.firstChild);
918  } else {
919    parent.appendChild(child);
920  }
921}
922
923/**
924 * Check if an element has a CSS class
925 *
926 * @param {Element} element
927 *        Element to check
928 *
929 * @param {string} classToCheck
930 *        Class name to check for
931 *
932 * @return {boolean}
933 *         - True if the element had the class
934 *         - False otherwise.
935 *
936 * @throws {Error}
937 *         Throws an error if `classToCheck` has white space.
938 */
939function hasClass(element, classToCheck) {
940  throwIfWhitespace(classToCheck);
941  if (element.classList) {
942    return element.classList.contains(classToCheck);
943  }
944  return classRegExp(classToCheck).test(element.className);
945}
946
947/**
948 * Add a CSS class name to an element
949 *
950 * @param {Element} element
951 *        Element to add class name to.
952 *
953 * @param {string} classToAdd
954 *        Class name to add.
955 *
956 * @return {Element}
957 *         The dom element with the added class name.
958 */
959function addClass(element, classToAdd) {
960  if (element.classList) {
961    element.classList.add(classToAdd);
962
963    // Don't need to `throwIfWhitespace` here because `hasElClass` will do it
964    // in the case of classList not being supported.
965  } else if (!hasClass(element, classToAdd)) {
966    element.className = (element.className + ' ' + classToAdd).trim();
967  }
968
969  return element;
970}
971
972/**
973 * Remove a CSS class name from an element
974 *
975 * @param {Element} element
976 *        Element to remove a class name from.
977 *
978 * @param {string} classToRemove
979 *        Class name to remove
980 *
981 * @return {Element}
982 *         The dom element with class name removed.
983 */
984function removeClass(element, classToRemove) {
985  if (element.classList) {
986    element.classList.remove(classToRemove);
987  } else {
988    throwIfWhitespace(classToRemove);
989    element.className = element.className.split(/\s+/).filter(function (c) {
990      return c !== classToRemove;
991    }).join(' ');
992  }
993
994  return element;
995}
996
997/**
998 * The callback definition for toggleElClass.
999 *
1000 * @callback Dom~PredicateCallback
1001 * @param {Element} element
1002 *        The DOM element of the Component.
1003 *
1004 * @param {string} classToToggle
1005 *        The `className` that wants to be toggled
1006 *
1007 * @return {boolean|undefined}
1008 *         - If true the `classToToggle` will get added to `element`.
1009 *         - If false the `classToToggle` will get removed from `element`.
1010 *         - If undefined this callback will be ignored
1011 */
1012
1013/**
1014 * Adds or removes a CSS class name on an element depending on an optional
1015 * condition or the presence/absence of the class name.
1016 *
1017 * @param {Element} element
1018 *        The element to toggle a class name on.
1019 *
1020 * @param {string} classToToggle
1021 *        The class that should be toggled
1022 *
1023 * @param {boolean|PredicateCallback} [predicate]
1024 *        See the return value for {@link Dom~PredicateCallback}
1025 *
1026 * @return {Element}
1027 *         The element with a class that has been toggled.
1028 */
1029function toggleClass(element, classToToggle, predicate) {
1030
1031  // This CANNOT use `classList` internally because IE does not support the

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

1241/**
1242 * Offset Left.
1243 * getBoundingClientRect technique from
1244 * John Resig
1245 *
1246 * @see http://ejohn.org/blog/getboundingclientrect-is-awesome/
1247 *
1248 * @param {Element} el
1249 *        Element from which to get offset
1250 *
1251 * @return {module:dom~Position}
1252 *         The position of the element that was passed in.
1253 */
1254function findPosition(el) {
1255  var box = void 0;
1256
1257  if (el.getBoundingClientRect && el.parentNode) {
1258    box = el.getBoundingClientRect();
1259  }
1260
1261  if (!box) {
1262    return {
1263      left: 0,
1264      top: 0
1265    };
1266  }
1267
1268  var docEl = document_1.documentElement;
1269  var body = document_1.body;
1270
1271  var clientLeft = docEl.clientLeft || body.clientLeft || 0;
1272  var scrollLeft = window_1.pageXOffset || body.scrollLeft;
1273  var left = box.left + scrollLeft - clientLeft;
1274
1275  var clientTop = docEl.clientTop || body.clientTop || 0;
1276  var scrollTop = window_1.pageYOffset || body.scrollTop;
1277  var top = box.top + scrollTop - clientTop;
1278
1279  // Android sometimes returns slightly off decimal values, so need to round
1280  return {
1281    left: Math.round(left),
1282    top: Math.round(top)
1283  };
1284}
1285
1286/**
1287 * x and y coordinates for a dom element or mouse pointer
1288 *
1289 * @typedef {Object} Dom~Coordinates
1290 *
1291 * @property {number} x
1292 *           x coordinate in pixels
1293 *
1294 * @property {number} y
1295 *           y coordinate in pixels
1296 */
1297
1298/**
1299 * Get pointer position in element
1300 * Returns an object with x and y coordinates.
1301 * The base on the coordinates are the bottom left of the element.
1302 *
1303 * @param {Element} el
1304 *        Element on which to get the pointer position on
1305 *
1306 * @param {EventTarget~Event} event
1307 *        Event object
1308 *
1309 * @return {Dom~Coordinates}
1310 *         A Coordinates object corresponding to the mouse position.
1311 *
1312 */
1313function getPointerPosition(el, event) {
1314  var position = {};
1315  var box = findPosition(el);
1316  var boxW = el.offsetWidth;
1317  var boxH = el.offsetHeight;
1318
1319  var boxY = box.top;
1320  var boxX = box.left;
1321  var pageY = event.pageY;
1322  var pageX = event.pageX;
1323
1324  if (event.changedTouches) {
1325    pageX = event.changedTouches[0].pageX;
1326    pageY = event.changedTouches[0].pageY;
1327  }
1328
1329  position.y = Math.max(0, Math.min(1, (boxY - pageY + boxH) / boxH));
1330  position.x = Math.max(0, Math.min(1, (pageX - boxX) / boxW));
1331
1332  return position;
1333}
1334
1335/**
1336 * Determines, via duck typing, whether or not a value is a text node.
1337 *
1338 * @param {Mixed} value
1339 *        Check if this value is a text node.
1340 *
1341 * @return {boolean}
1342 *         - True if it is a text node
1343 *         - False otherwise
1344 */
1345function isTextNode(value) {
1346  return isObject(value) && value.nodeType === 3;
1347}
1348
1349/**
1350 * Empties the contents of an element.
1351 *
1352 * @param {Element} el
1353 *        The element to empty children from
1354 *
1355 * @return {Element}
1356 *         The element with no children
1357 */
1358function emptyEl(el) {
1359  while (el.firstChild) {
1360    el.removeChild(el.firstChild);
1361  }
1362  return el;
1363}
1364
1365/**
1366 * Normalizes content for eventual insertion into the DOM.
1367 *
1368 * This allows a wide range of content definition methods, but protects
1369 * from falling into the trap of simply writing to `innerHTML`, which is
1370 * an XSS concern.
1371 *
1372 * The content for an element can be passed in multiple types and
1373 * combinations, whose behavior is as follows:
1374 *
1375 * @param {String|Element|TextNode|Array|Function} content
1376 *        - String: Normalized into a text node.
1377 *        - Element/TextNode: Passed through.
1378 *        - Array: A one-dimensional array of strings, elements, nodes, or functions
1379 *          (which return single strings, elements, or nodes).
1380 *        - Function: If the sole argument, is expected to produce a string, element,
1381 *          node, or array as defined above.
1382 *
1383 * @return {Array}
1384 *         All of the content that was passed in normalized.
1385 */
1386function normalizeContent(content) {
1387
1388  // First, invoke content if it is a function. If it produces an array,
1389  // that needs to happen before normalization.
1390  if (typeof content === 'function') {
1391    content = content();
1392  }
1393
1394  // Next up, normalize to an array, so one or many items can be normalized,
1395  // filtered, and returned.

1396  return (Array.isArray(content) ? content : [content]).map(function (value) {
1397
1398    // First, invoke value if it is a function to produce a new value,
1399    // which will be subsequently normalized to a Node of some kind.
1400    if (typeof value === 'function') {
1401      value = value();
1402    }
1403
1404    if (isEl(value) || isTextNode(value)) {
1405      return value;
1406    }
1407
1408    if (typeof value === 'string' && /\S/.test(value)) {
1409      return document_1.createTextNode(value);
1410    }
1411  }).filter(function (value) {
1412    return value;
1413  });
1414}
1415
1416/**
1417 * Normalizes and appends content to an element.
1418 *
1419 * @param {Element} el
1420 *        Element to append normalized content to.
1421 *
1422 *
1423 * @param {String|Element|TextNode|Array|Function} content
1424 *        See the `content` argument of {@link dom:normalizeContent}
1425 *
1426 * @return {Element}
1427 *         The element with appended normalized content.
1428 */
1429function appendContent(el, content) {
1430  normalizeContent(content).forEach(function (node) {
1431    return el.appendChild(node);
1432  });
1433  return el;
1434}
1435
1436/**
1437 * Normalizes and inserts content into an element; this is identical to
1438 * `appendContent()`, except it empties the element first.
1439 *
1440 * @param {Element} el
1441 *        Element to insert normalized content into.
1442 *
1443 * @param {String|Element|TextNode|Array|Function} content
1444 *        See the `content` argument of {@link dom:normalizeContent}
1445 *
1446 * @return {Element}
1447 *         The element with inserted normalized content.
1448 *
1449 */
1450function insertContent(el, content) {
1451  return appendContent(emptyEl(el), content);
1452}
1453
1454/**
1455 * Check if event was a single left click
1456 *
1457 * @param {EventTarget~Event} event
1458 *        Event object
1459 *
1460 * @return {boolean}
1461 *         - True if a left click
1462 *         - False if not a left click
1463 */
1464function isSingleLeftClick(event) {
1465  // Note: if you create something draggable, be sure to
1466  // call it on both `mousedown` and `mousemove` event,
1467  // otherwise `mousedown` should be enough for a button
1468
1469  if (event.button === undefined && event.buttons === undefined) {
1470    // Why do we need `buttons` ?
1471    // Because, middle mouse sometimes have this:
1472    // e.button === 0 and e.buttons === 4
1473    // Furthermore, we want to prevent combination click, something like
1474    // HOLD middlemouse then left click, that would be
1475    // e.button === 0, e.buttons === 5
1476    // just `button` is not gonna work
1477
1478    // Alright, then what this block does ?
1479    // this is for chrome `simulate mobile devices`
1480    // I want to support this as well
1481
1482    return true;
1483  }
1484
1485  if (event.button === 0 && event.buttons === undefined) {
1486    // Touch screen, sometimes on some specific device, `buttons`
1487    // doesn't have anything (safari on ios, blackberry...)
1488
1489    return true;
1490  }
1491
1492  if (IE_VERSION === 9) {
1493    // Ignore IE9
1494
1495    return true;
1496  }
1497
1498  if (event.button !== 0 || event.buttons !== 1) {
1499    // This is the reason we have those if else block above
1500    // if any special case we can catch and let it slide
1501    // we do it above, when get to here, this definitely
1502    // is-not-left-click
1503
1504    return false;
1505  }
1506
1507  return true;
1508}
1509
1510/**
1511 * Finds a single DOM element matching `selector` within the optional
1512 * `context` of another DOM element (defaulting to `document`).
1513 *
1514 * @param {string} selector
1515 *        A valid CSS selector, which will be passed to `querySelector`.
1516 *
1517 * @param {Element|String} [context=document]
1518 *        A DOM element within which to query. Can also be a selector
1519 *        string in which case the first matching element will be used
1520 *        as context. If missing (or no element matches selector), falls
1521 *        back to `document`.
1522 *
1523 * @return {Element|null}
1524 *         The element that was found or null.
1525 */
1526var $ = createQuerier('querySelector');
1527
1528/**
1529 * Finds a all DOM elements matching `selector` within the optional
1530 * `context` of another DOM element (defaulting to `document`).
1531 *
1532 * @param {string} selector
1533 *           A valid CSS selector, which will be passed to `querySelectorAll`.
1534 *
1535 * @param {Element|String} [context=document]
1536 *           A DOM element within which to query. Can also be a selector

1537 *           string in which case the first matching element will be used
1538 *           as context. If missing (or no element matches selector), falls
1539 *           back to `document`.
1540 *
1541 * @return {NodeList}
1542 *         A element list of elements that were found. Will be empty if none were found.
1543 *
1544 */
1545var $$ = createQuerier('querySelectorAll');
1546
1547
1548
1549var Dom = (Object.freeze || Object)({
1550	isReal: isReal,
1551	isEl: isEl,
1552	isInFrame: isInFrame,
1553	createEl: createEl,
1554	textContent: textContent,
1555	prependTo: prependTo,
1556	hasClass: hasClass,
1557	addClass: addClass,
1558	removeClass: removeClass,
1559	toggleClass: toggleClass,
1560	setAttributes: setAttributes,
1561	getAttributes: getAttributes,
1562	getAttribute: getAttribute,
1563	setAttribute: setAttribute,
1564	removeAttribute: removeAttribute,
1565	blockTextSelection: blockTextSelection,
1566	unblockTextSelection: unblockTextSelection,
1567	getBoundingClientRect: getBoundingClientRect,
1568	findPosition: findPosition,
1569	getPointerPosition: getPointerPosition,
1570	isTextNode: isTextNode,
1571	emptyEl: emptyEl,
1572	normalizeContent: normalizeContent,
1573	appendContent: appendContent,
1574	insertContent: insertContent,
1575	isSingleLeftClick: isSingleLeftClick,
1576	$: $,
1577	$$: $$
1578});
1579
1580/**
1581 * @file guid.js
1582 * @module guid
1583 */
1584
1585/**
1586 * Unique ID for an element or function
1587 * @type {Number}
1588 */
1589var _guid = 1;
1590
1591/**
1592 * Get a unique auto-incrementing ID by number that has not been returned before.
1593 *
1594 * @return {number}
1595 *         A new unique ID.
1596 */
1597function newGUID() {
1598  return _guid++;
1599}
1600
1601/**
1602 * @file dom-data.js
1603 * @module dom-data
1604 */
1605/**
1606 * Element Data Store.
1607 *
1608 * Allows for binding data to an element without putting it directly on the
1609 * element. Ex. Event listeners are stored here.
1610 * (also from jsninja.com, slightly modified and updated for closure compiler)
1611 *
1612 * @type {Object}
1613 * @private
1614 */
1615var elData = {};
1616
1617/*
1618 * Unique attribute name to store an element's guid in
1619 *
1620 * @type {String}
1621 * @constant
1622 * @private
1623 */
1624var elIdAttr = 'vdata' + new Date().getTime();
1625
1626/**
1627 * Returns the cache object where data for an element is stored
1628 *
1629 * @param {Element} el
1630 *        Element to store data for.
1631 *
1632 * @return {Object}
1633 *         The cache object for that el that was passed in.
1634 */
1635function getData(el) {
1636  var id = el[elIdAttr];
1637
1638  if (!id) {
1639    id = el[elIdAttr] = newGUID();
1640  }
1641
1642  if (!elData[id]) {
1643    elData[id] = {};
1644  }
1645
1646  return elData[id];
1647}
1648
1649/**
1650 * Returns whether or not an element has cached data
1651 *
1652 * @param {Element} el
1653 *        Check if this element has cached data.
1654 *
1655 * @return {boolean}
1656 *         - True if the DOM element has cached data.
1657 *         - False otherwise.
1658 */
1659function hasData(el) {
1660  var id = el[elIdAttr];
1661
1662  if (!id) {
1663    return false;
1664  }
1665
1666  return !!Object.getOwnPropertyNames(elData[id]).length;
1667}
1668
1669/**
1670 * Delete data for the element from the cache and the guid attr from getElementById
1671 *
1672 * @param {Element} el
1673 *        Remove cached data for this element.
1674 */
1675function removeData(el) {
1676  var id = el[elIdAttr];
1677
1678  if (!id) {
1679    return;
1680  }
1681
1682  // Remove all stored data
1683  delete elData[id];
1684
1685  // Remove the elIdAttr property from the DOM node
1686  try {
1687    delete el[elIdAttr];
1688  } catch (e) {
1689    if (el.removeAttribute) {
1690      el.removeAttribute(elIdAttr);
1691    } else {
1692      // IE doesn't appear to support removeAttribute on the document element
1693      el[elIdAttr] = null;
1694    }
1695  }
1696}
1697
1698/**
1699 * @file events.js. An Event System (John Resig - Secrets of a JS Ninja http://jsninja.com/)
1700 * (Original book version wasn't completely usable, so fixed some things and made Closure Compiler compatible)
1701 * This should work very similarly to jQuery's events, however it's based off the book version which isn't as
1702 * robust as jquery's, so there's probably some differences.
1703 *
1704 * @module events
1705 */
1706
1707/**
1708 * Clean up the listener cache and dispatchers
1709 *
1710 * @param {Element|Object} elem
1711 *        Element to clean up
1712 *
1713 * @param {string} type
1714 *        Type of event to clean up
1715 */
1716function _cleanUpEvents(elem, type) {
1717  var data = getData(elem);
1718
1719  // Remove the events of a particular type if there are none left
1720  if (data.handlers[type].length === 0) {
1721    delete data.handlers[type];
1722    // data.handlers[type] = null;
1723    // Setting to null was causing an error with data.handlers
1724
1725    // Remove the meta-handler from the element
1726    if (elem.removeEventListener) {
1727      elem.removeEventListener(type, data.dispatcher, false);
1728    } else if (elem.detachEvent) {
1729      elem.detachEvent('on' + type, data.dispatcher);
1730    }
1731  }
1732
1733  // Remove the events object if there are no types left
1734  if (Object.getOwnPropertyNames(data.handlers).length <= 0) {
1735    delete data.handlers;
1736    delete data.dispatcher;
1737    delete data.disabled;
1738  }
1739
1740  // Finally remove the element data if there is no data left
1741  if (Object.getOwnPropertyNames(data).length === 0) {
1742    removeData(elem);
1743  }
1744}
1745
1746/**
1747 * Loops through an array of event types and calls the requested method for each type.
1748 *
1749 * @param {Function} fn
1750 *        The event method we want to use.
1751 *

1752 * @param {Element|Object} elem
1753 *        Element or object to bind listeners to
1754 *
1755 * @param {string} type
1756 *        Type of event to bind to.
1757 *
1758 * @param {EventTarget~EventListener} callback
1759 *        Event listener.
1760 */
1761function _handleMultipleEvents(fn, elem, types, callback) {
1762  types.forEach(function (type) {
1763    // Call the event method for each one of the types
1764    fn(elem, type, callback);
1765  });
1766}
1767
1768/**
1769 * Fix a native event to have standard property values
1770 *
1771 * @param {Object} event
1772 *        Event object to fix.
1773 *
1774 * @return {Object}
1775 *         Fixed event object.
1776 */
1777function fixEvent(event) {
1778
1779  function returnTrue() {
1780    return true;
1781  }
1782
1783  function returnFalse() {
1784    return false;
1785  }
1786
1787  // Test if fixing up is needed
1788  // Used to check if !event.stopPropagation instead of isPropagationStopped
1789  // But native events return true for stopPropagation, but don't have
1790  // other expected methods like isPropagationStopped. Seems to be a problem
1791  // with the Javascript Ninja code. So we're just overriding all events now.
1792  if (!event || !event.isPropagationStopped) {
1793    var old = event || window_1.event;
1794
1795    event = {};
1796    // Clone the old object so that we can modify the values event = {};
1797    // IE8 Doesn't like when you mess with native event properties
1798    // Firefox returns false for event.hasOwnProperty('type') and other props
1799    //  which makes copying more difficult.
1800    // TODO: Probably best to create a whitelist of event props
1801    for (var key in old) {
1802      // Safari 6.0.3 warns you if you try to copy deprecated layerX/Y
1803      // Chrome warns you if you try to copy deprecated keyboardEvent.keyLocation
1804      // and webkitMovementX/Y
1805      if (key !== 'layerX' && key !== 'layerY' && key !== 'keyLocation' && key !== 'webkitMovementX' && key !== 'webkitMovementY') {
1806        // Chrome 32+ warns if you try to copy deprecated returnValue, but
1807        // we still want to if preventDefault isn't supported (IE8).
1808        if (!(key === 'returnValue' && old.preventDefault)) {
1809          event[key] = old[key];
1810        }
1811      }
1812    }
1813
1814    // The event occurred on this element
1815    if (!event.target) {
1816      event.target = event.srcElement || document_1;
1817    }
1818
1819    // Handle which other element the event is related to
1820    if (!event.relatedTarget) {
1821      event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
1822    }
1823
1824    // Stop the default browser action
1825    event.preventDefault = function () {
1826      if (old.preventDefault) {
1827        old.preventDefault();
1828      }
1829      event.returnValue = false;
1830      old.returnValue = false;
1831      event.defaultPrevented = true;
1832    };
1833
1834    event.defaultPrevented = false;
1835
1836    // Stop the event from bubbling
1837    event.stopPropagation = function () {
1838      if (old.stopPropagation) {
1839        old.stopPropagation();
1840      }
1841      event.cancelBubble = true;
1842      old.cancelBubble = true;
1843      event.isPropagationStopped = returnTrue;
1844    };
1845
1846    event.isPropagationStopped = returnFalse;
1847
1848    // Stop the event from bubbling and executing other handlers
1849    event.stopImmediatePropagation = function () {
1850      if (old.stopImmediatePropagation) {
1851        old.stopImmediatePropagation();
1852      }
1853      event.isImmediatePropagationStopped = returnTrue;
1854      event.stopPropagation();
1855    };
1856
1857    event.isImmediatePropagationStopped = returnFalse;
1858
1859    // Handle mouse position
1860    if (event.clientX !== null && event.clientX !== undefined) {
1861      var doc = document_1.documentElement;
1862      var body = document_1.body;
1863
1864      event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1865      event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
1866    }
1867
1868    // Handle key presses
1869    event.which = event.charCode || event.keyCode;
1870
1871    // Fix button for mouse clicks:
1872    // 0 == left; 1 == middle; 2 == right
1873    if (event.button !== null && event.button !== undefined) {
1874
1875      // The following is disabled because it does not pass videojs-standard
1876      // and... yikes.
1877      /* eslint-disable */
1878      event.button = event.button & 1 ? 0 : event.button & 4 ? 1 : event.button & 2 ? 2 : 0;
1879      /* eslint-enable */
1880    }
1881  }
1882
1883  // Returns fixed-up instance
1884  return event;
1885}
1886

1887/**
1888 * Whether passive event listeners are supported
1889 */
1890var _supportsPassive = false;
1891
1892(function () {
1893  try {
1894    var opts = Object.defineProperty({}, 'passive', {
1895      get: function get() {
1896        _supportsPassive = true;
1897      }
1898    });
1899
1900    window_1.addEventListener('test', null, opts);
1901    window_1.removeEventListener('test', null, opts);
1902  } catch (e) {
1903    // disregard
1904  }
1905})();
1906
1907/**
1908 * Touch events Chrome expects to be passive
1909 */
1910var passiveEvents = ['touchstart', 'touchmove'];
1911
1912/**
1913 * Add an event listener to element
1914 * It stores the handler function in a separate cache object
1915 * and adds a generic handler to the element's event,
1916 * along with a unique id (guid) to the element.
1917 *
1918 * @param {Element|Object} elem
1919 *        Element or object to bind listeners to
1920 *
1921 * @param {string|string[]} type
1922 *        Type of event to bind to.
1923 *
1924 * @param {EventTarget~EventListener} fn
1925 *        Event listener.
1926 */
1927function on(elem, type, fn) {
1928  if (Array.isArray(type)) {
1929    return _handleMultipleEvents(on, elem, type, fn);
1930  }
1931
1932  var data = getData(elem);
1933
1934  // We need a place to store all our handler data
1935  if (!data.handlers) {
1936    data.handlers = {};
1937  }
1938
1939  if (!data.handlers[type]) {
1940    data.handlers[type] = [];
1941  }
1942
1943  if (!fn.guid) {
1944    fn.guid = newGUID();
1945  }
1946
1947  data.handlers[type].push(fn);
1948
1949  if (!data.dispatcher) {
1950    data.disabled = false;
1951
1952    data.dispatcher = function (event, hash) {
1953
1954      if (data.disabled) {
1955        return;
1956      }
1957
1958      event = fixEvent(event);
1959
1960      var handlers = data.handlers[event.type];
1961
1962      if (handlers) {
1963        // Copy handlers so if handlers are added/removed during the process it doesn't throw everything off.
1964        var handlersCopy = handlers.slice(0);
1965
1966        for (var m = 0, n = handlersCopy.length; m < n; m++) {
1967          if (event.isImmediatePropagationStopped()) {
1968            break;
1969          } else {
1970            try {
1971              handlersCopy[m].call(elem, event, hash);
1972            } catch (e) {
1973              log$1.error(e);
1974            }
1975          }
1976        }
1977      }
1978    };
1979  }
1980
1981  if (data.handlers[type].length === 1) {
1982    if (elem.addEventListener) {
1983      var options = false;
1984
1985      if (_supportsPassive && passiveEvents.indexOf(type) > -1) {
1986        options = { passive: true };
1987      }
1988      elem.addEventListener(type, data.dispatcher, options);
1989    } else if (elem.attachEvent) {
1990      elem.attachEvent('on' + type, data.dispatcher);
1991    }
1992  }
1993}
1994
1995/**
1996 * Removes event listeners from an element
1997 *
1998 * @param {Element|Object} elem
1999 *        Object to remove listeners from.
2000 *
2001 * @param {string|string[]} [type]
2002 *        Type of listener to remove. Don't include to remove all events from element.
2003 *
2004 * @param {EventTarget~EventListener} [fn]
2005 *        Specific listener to remove. Don't include to remove listeners for an event
2006 *        type.
2007 */
2008function off(elem, type, fn) {
2009  // Don't want to add a cache object through getElData if not needed
2010  if (!hasData(elem)) {
2011    return;
2012  }
2013
2014  var data = getData(elem);
2015
2016  // If no events exist, nothing to unbind
2017  if (!data.handlers) {
2018    return;
2019  }
2020
2021  if (Array.isArray(type)) {
2022    return _handleMultipleEvents(off, elem, type, fn);
2023  }
2024
2025  // Utility function
2026  var removeType = function removeType(el, t) {
2027    data.handlers[t] = [];
2028    _cleanUpEvents(el, t);
2029  };
2030
2031  // Are we removing all bound events?
2032  if (type === undefined) {
2033    for (var t in data.handlers) {
2034      if (Object.prototype.hasOwnProperty.call(data.handlers || {}, t)) {
2035        removeType(elem, t);
2036      }
2037    }
2038    return;
2039  }
2040
2041  var handlers = data.handlers[type];
2042
2043  // If no handlers exist, nothing to unbind
2044  if (!handlers) {
2045    return;
2046  }
2047
2048  // If no listener was provided, remove all listeners for type
2049  if (!fn) {
2050    removeType(elem, type);
2051    return;
2052  }
2053
2054  // We're only removing a single handler
2055  if (fn.guid) {
2056    for (var n = 0; n < handlers.length; n++) {
2057      if (handlers[n].guid === fn.guid) {
2058        handlers.splice(n--, 1);
2059      }
2060    }
2061  }
2062
2063  _cleanUpEvents(elem, type);
2064}
2065
2066/**
2067 * Trigger an event for an element
2068 *

2476 * An object containing event names as keys and booleans as values.
2477 *
2478 * > NOTE: If an event name is set to a true value here {@link EventTarget#trigger}
2479 *         will have extra functionality. See that function for more information.
2480 *
2481 * @property EventTarget.prototype.allowedEvents_
2482 * @private
2483 */
2484EventTarget.prototype.allowedEvents_ = {};
2485
2486/**
2487 * Adds an `event listener` to an instance of an `EventTarget`. An `event listener` is a
2488 * function that will get called when an event with a certain name gets triggered.
2489 *
2490 * @param {string|string[]} type
2491 *        An event name or an array of event names.
2492 *
2493 * @param {EventTarget~EventListener} fn
2494 *        The function to call with `EventTarget`s
2495 */
2496EventTarget.prototype.on = function (type, fn) {
2497  // Remove the addEventListener alias before calling Events.on
2498  // so we don't get into an infinite type loop
2499  var ael = this.addEventListener;
2500
2501  this.addEventListener = function () {};
2502  on(this, type, fn);
2503  this.addEventListener = ael;
2504};
2505
2506/**
2507 * An alias of {@link EventTarget#on}. Allows `EventTarget` to mimic
2508 * the standard DOM API.
2509 *
2510 * @function
2511 * @see {@link EventTarget#on}
2512 */
2513EventTarget.prototype.addEventListener = EventTarget.prototype.on;
2514
2515/**
2516 * Removes an `event listener` for a specific event from an instance of `EventTarget`.
2517 * This makes it so that the `event listener` will no longer get called when the
2518 * named event happens.
2519 *
2520 * @param {string|string[]} type
2521 *        An event name or an array of event names.
2522 *
2523 * @param {EventTarget~EventListener} fn
2524 *        The function to remove.
2525 */
2526EventTarget.prototype.off = function (type, fn) {
2527  off(this, type, fn);
2528};
2529
2530/**
2531 * An alias of {@link EventTarget#off}. Allows `EventTarget` to mimic
2532 * the standard DOM API.
2533 *
2534 * @function
2535 * @see {@link EventTarget#off}
2536 */
2537EventTarget.prototype.removeEventListener = EventTarget.prototype.off;
2538
2539/**
2540 * This function will add an `event listener` that gets triggered only once. After the
2541 * first trigger it will get removed. This is like adding an `event listener`
2542 * with {@link EventTarget#on} that calls {@link EventTarget#off} on itself.
2543 *
2544 * @param {string|string[]} type
2545 *        An event name or an array of event names.
2546 *
2547 * @param {EventTarget~EventListener} fn
2548 *        The function to be called once for each event name.
2549 */
2550EventTarget.prototype.one = function (type, fn) {
2551  // Remove the addEventListener alialing Events.on
2552  // so we don't get into an infinite type loop
2553  var ael = this.addEventListener;
2554
2555  this.addEventListener = function () {};
2556  one(this, type, fn);
2557  this.addEventListener = ael;
2558};
2559
2560/**
2561 * This function causes an event to happen. This will then cause any `event listeners`
2562 * that are waiting for that event, to get called. If there are no `event listeners`
2563 * for an event then nothing will happen.
2564 *
2565 * If the name of the `Event` that is being triggered is in `EventTarget.allowedEvents_`.
2566 * Trigger will also call the `on` + `uppercaseEventName` function.
2567 *
2568 * Example:
2569 * 'click' is in `EventTarget.allowedEvents_`, so, trigger will attempt to call
2570 * `onClick` if it exists.
2571 *
2572 * @param {string|EventTarget~Event|Object} event
2573 *        The name of the event, an `Event`, or an object with a key of type set to
2574 *        an event name.
2575 */
2576EventTarget.prototype.trigger = function (event) {
2577  var type = event.type || event;
2578
2579  if (typeof event === 'string') {
2580    event = { type: type };
2581  }
2582  event = fixEvent(event);
2583
2584  if (this.allowedEvents_[type] && this['on' + type]) {
2585    this['on' + type](event);
2586  }
2587
2588  trigger(this, event);
2589};
2590
2591/**
2592 * An alias of {@link EventTarget#trigger}. Allows `EventTarget` to mimic
2593 * the standard DOM API.
2594 *
2595 * @function
2596 * @see {@link EventTarget#trigger}
2597 */
2598EventTarget.prototype.dispatchEvent = EventTarget.prototype.trigger;
2599
2600/**
2601 * @file mixins/evented.js
2602 * @module evented
2603 */
2604/**
2605 * Returns whether or not an object has had the evented mixin applied.
2606 *
2607 * @param  {Object} object
2608 *         An object to test.
2609 *
2610 * @return {boolean}
2611 *         Whether or not the object appears to be evented.
2612 */
2613var isEvented = function isEvented(object) {
2614  return object instanceof EventTarget || !!object.eventBusEl_ && ['on', 'one', 'off', 'trigger'].every(function (k) {
2615    return typeof object[k] === 'function';
2616  });
2617};
2618
2619/**
2620 * Whether a value is a valid event type - non-empty string or array.
2621 *
2622 * @private
2623 * @param  {string|Array} type
2624 *         The type value to test.
2625 *
2626 * @return {boolean}
2627 *         Whether or not the type is a valid event type.
2628 */
2629var isValidEventType = function isValidEventType(type) {
2630  return (
2631    // The regex here verifies that the `type` contains at least one non-
2632    // whitespace character.
2633    typeof type === 'string' && /\S/.test(type) || Array.isArray(type) && !!type.length
2634  );
2635};
2636
2637/**
2638 * Validates a value to determine if it is a valid event target. Throws if not.
2639 *
2640 * @private
2641 * @throws {Error}
2642 *         If the target does not appear to be a valid event target.
2643 *
2644 * @param  {Object} target
2645 *         The object to test.
2646 */
2647var validateTarget = function validateTarget(target) {
2648  if (!target.nodeName && !isEvented(target)) {
2649    throw new Error('Invalid target; must be a DOM node or evented object.');
2650  }
2651};
2652
2653/**
2654 * Validates a value to determine if it is a valid event target. Throws if not.
2655 *
2656 * @private
2657 * @throws {Error}
2658 *         If the type does not appear to be a valid event type.
2659 *
2660 * @param  {string|Array} type
2661 *         The type to test.
2662 */
2663var validateEventType = function validateEventType(type) {
2664  if (!isValidEventType(type)) {
2665    throw new Error('Invalid event type; must be a non-empty string or array.');
2666  }
2667};
2668
2669/**
2670 * Validates a value to determine if it is a valid listener. Throws if not.
2671 *
2672 * @private
2673 * @throws {Error}
2674 *         If the listener is not a function.
2675 *
2676 * @param  {Function} listener
2677 *         The listener to test.
2678 */
2679var validateListener = function validateListener(listener) {
2680  if (typeof listener !== 'function') {
2681    throw new Error('Invalid listener; must be a function.');
2682  }
2683};
2684
2685/**
2686 * Takes an array of arguments given to `on()` or `one()`, validates them, and
2687 * normalizes them into an object.
2688 *
2689 * @private
2690 * @param  {Object} self
2691 *         The evented object on which `on()` or `one()` was called. This
2692 *         object will be bound as the `this` value for the listener.
2693 *
2694 * @param  {Array} args
2695 *         An array of arguments passed to `on()` or `one()`.
2696 *
2697 * @return {Object}
2698 *         An object containing useful values for `on()` or `one()` calls.
2699 */
2700var normalizeListenArgs = function normalizeListenArgs(self, args) {
2701
2702  // If the number of arguments is less than 3, the target is always the
2703  // evented object itself.
2704  var isTargetingSelf = args.length < 3 || args[0] === self || args[0] === self.eventBusEl_;
2705  var target = void 0;
2706  var type = void 0;
2707  var listener = void 0;
2708
2709  if (isTargetingSelf) {
2710    target = self.eventBusEl_;
2711
2712    // Deal with cases where we got 3 arguments, but we are still listening to
2713    // the evented object itself.
2714    if (args.length >= 3) {
2715      args.shift();
2716    }
2717
2718    type = args[0];
2719    listener = args[1];
2720  } else {
2721    target = args[0];
2722    type = args[1];
2723    listener = args[2];
2724  }
2725
2726  validateTarget(target);
2727  validateEventType(type);
2728  validateListener(listener);
2729
2730  listener = bind(self, listener);
2731
2732  return { isTargetingSelf: isTargetingSelf, target: target, type: type, listener: listener };
2733};
2734
2735/**
2736 * Adds the listener to the event type(s) on the target, normalizing for
2737 * the type of target.
2738 *
2739 * @private
2740 * @param  {Element|Object} target
2741 *         A DOM node or evented object.
2742 *
2743 * @param  {string} method
2744 *         The event binding method to use ("on" or "one").
2745 *
2746 * @param  {string|Array} type
2747 *         One or more event type(s).
2748 *
2749 * @param  {Function} listener
2750 *         A listener function.
2751 */
2752var listen = function listen(target, method, type, listener) {
2753  validateTarget(target);
2754
2755  if (target.nodeName) {
2756    Events[method](target, type, listener);
2757  } else {
2758    target[method](type, listener);
2759  }
2760};
2761
2762/**
2763 * Contains methods that provide event capabilit