https://cdn.iol.pt/js/utils/video-js-7.0.5/video.js

1/**
2 * @license
3 * Video.js 7.0.5 <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  var version = "7.0.5";
19
20  var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
21
22  function createCommonjsModule(fn, module) {
23  	return module = { exports: {} }, fn(module, module.exports), module.exports;
24  }
25
26  var win;
27
28  if (typeof window !== "undefined") {
29      win = window;
30  } else if (typeof commonjsGlobal !== "undefined") {
31      win = commonjsGlobal;
32  } else if (typeof self !== "undefined") {
33      win = self;
34  } else {
35      win = {};
36  }
37
38  var window_1 = win;
39
40  var empty = {};
41
42  var empty$1 = /*#__PURE__*/Object.freeze({
43    default: empty
44  });
45
46  var minDoc = ( empty$1 && empty ) || empty$1;
47
48  var topLevel = typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : typeof window !== 'undefined' ? window : {};
49
50  var doccy;
51
52  if (typeof document !== 'undefined') {
53      doccy = document;
54  } else {
55      doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'];
56
57      if (!doccy) {
58          doccy = topLevel['__GLOBAL_DOCUMENT_CACHE@4'] = minDoc;
59      }
60  }
61
62  var document_1 = doccy;
63
64  /**
65   * @file log.js
66   * @module log
67   */
68
69  var log = void 0;
70
71  // This is the private tracking variable for logging level.
72  var level = 'info';
73
74  // This is the private tracking variable for the logging history.
75  var history = [];
76
77  /**
78   * Log messages to the console and history based on the type of message
79   *
80   * @private
81   * @param  {string} type
82   *         The name of the console method to use.
83   *
84   * @param  {Array} args
85   *         The arguments to be passed to the matching console method.
86   */
87  var logByType = function logByType(type, args) {
88    var lvl = log.levels[level];
89    var lvlRegExp = new RegExp('^(' + lvl + ')$');
90
91    if (type !== 'log') {
92
93      // Add the type to the front of the message when it's not "log".
94      args.unshift(type.toUpperCase() + ':');
95    }
96
97    // Add a clone of the args at this point to history.
98    if (history) {
99      history.push([].concat(args));
100    }
101
102    // Add console prefix after adding to history.
103    args.unshift('VIDEOJS:');
104
105    // If there's no console then don't try to output messages, but they will
106    // still be stored in history.
107    if (!window_1.console) {
108      return;
109    }
110
111    // Was setting these once outside of this function, but containing them
112    // in the function makes it easier to test cases where console doesn't exist
113    // when the module is executed.
114    var fn = window_1.console[type];
115
116    if (!fn && type === 'debug') {
117      // Certain browsers don't have support for console.debug. For those, we
118      // should default to the closest comparable log.
119      fn = window_1.console.info || window_1.console.log;
120    }
121
122    // Bail out if there's no console or if this type is not allowed by the
123    // current logging level.
124    if (!fn || !lvl || !lvlRegExp.test(type)) {
125      return;
126    }
127
128    fn[Array.isArray(args) ? 'apply' : 'call'](window_1.console, args);
129  };
130
131  /**
132   * Logs plain debug messages. Similar to `console.log`.
133   *
134   * @class
135   * @param    {Mixed[]} args
136   *           One or more messages or objects that should be logged.
137   */
138  log = function log() {
139    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
140      args[_key] = arguments[_key];
141    }
142
143    logByType('log', args);
144  };
145
146  /**
147   * Enumeration of available logging levels, where the keys are the level names
148   * and the values are `|`-separated strings containing logging methods allowed
149   * in that logging level. These strings are used to create a regular expression
150   * matching the function name being called.
151   *
152   * Levels provided by video.js are:
153   *
154   * - `off`: Matches no calls. Any value that can be cast to `false` will have
155   *   this effect. The most restrictive.
156   * - `all`: Matches only Video.js-provided functions (`debug`, `log`,
157   *   `log.warn`, and `log.error`).
158   * - `debug`: Matches `log.debug`, `log`, `log.warn`, and `log.error` calls.
159   * - `info` (default): Matches `log`, `log.warn`, and `log.error` calls.
160   * - `warn`: Matches `log.warn` and `log.error` calls.
161   * - `error`: Matches only `log.error` calls.
162   *
163   * @type {Object}
164   */
165  log.levels = {
166    all: 'debug|log|warn|error',
167    off: '',
168    debug: 'debug|log|warn|error',
169    info: 'log|warn|error',
170    warn: 'warn|error',
171    error: 'error',
172    DEFAULT: level
173  };
174
175  /**
176   * Get or set the current logging level. If a string matching a key from
177   * {@link log.levels} is provided, acts as a setter. Regardless of argument,
178   * returns the current logging level.
179   *
180   * @param  {string} [lvl]
181   *         Pass to set a new logging level.
182   *
183   * @return {string}
184   *         The current logging level.
185   */
186  log.level = function (lvl) {
187    if (typeof lvl === 'string') {
188      if (!log.levels.hasOwnProperty(lvl)) {
189        throw new Error('"' + lvl + '" in not a valid log level');
190      }
191      level = lvl;
192    }
193    return level;
194  };
195
196  /**
197   * Returns an array containing everything that has been logged to the history.
198   *
199   * This array is a shallow clone of the internal history record. However, its
200   * contents are _not_ cloned; so, mutating objects inside this array will
201   * mutate them in history.
202   *
203   * @return {Array}
204   */
205  log.history = function () {
206    return history ? [].concat(history) : [];
207  };
208
209  /**
210   * Clears the internal history tracking, but does not prevent further history
211   * tracking.
212   */
213  log.history.clear = function () {
214    if (history) {
215      history.length = 0;
216    }
217  };
218
219  /**
220   * Disable history tracking if it is currently enabled.
221   */
222  log.history.disable = function () {
223    if (history !== null) {
224      history.length = 0;
225      history = null;
226    }
227  };
228
229  /**
230   * Enable history tracking if it is currently disabled.
231   */
232  log.history.enable = function () {
233    if (history === null) {
234      history = [];
235    }
236  };
237
238  /**
239   * Logs error messages. Similar to `console.error`.
240   *
241   * @param {Mixed[]} args
242   *        One or more messages or objects that should be logged as an error
243   */
244  log.error = function () {
245    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
246      args[_key2] = arguments[_key2];
247    }
248
249    return logByType('error', args);
250  };
251
252  /**
253   * Logs warning messages. Similar to `console.warn`.
254   *
255   * @param {Mixed[]} args
256   *        One or more messages or objects that should be logged as a warning.
257   */
258  log.warn = function () {
259    for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
260      args[_key3] = arguments[_key3];
261    }
262
263    return logByType('warn', args);
264  };
265
266  /**
267   * Logs debug messages. Similar to `console.debug`, but may also act as a comparable
268   * log if `console.debug` is not available
269   *
270   * @param {Mixed[]} args
271   *        One or more messages or objects that should be logged as debug.
272   */
273  log.debug = function () {
274    for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
275      args[_key4] = arguments[_key4];
276    }
277
278    return logByType('debug', args);
279  };
280
281  var log$1 = log;
282
283  function clean(s) {
284    return s.replace(/\n\r?\s*/g, '');
285  }
286
287  var tsml = function tsml(sa) {
288    var s = '',
289        i = 0;
290
291    for (; i < arguments.length; i++) {
292      s += clean(sa[i]) + (arguments[i + 1] || '');
293    }return s;
294  };
295
296  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
297    return typeof obj;
298  } : function (obj) {
299    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
300  };
301
302  var classCallCheck = function (instance, Constructor) {
303    if (!(instance instanceof Constructor)) {
304      throw new TypeError("Cannot call a class as a function");
305    }
306  };
307
308  var inherits = function (subClass, superClass) {
309    if (typeof superClass !== "function" && superClass !== null) {
310      throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
311    }
312
313    subClass.prototype = Object.create(superClass && superClass.prototype, {
314      constructor: {
315        value: subClass,
316        enumerable: false,
317        writable: true,
318        configurable: true
319      }
320    });
321    if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
322  };
323
324  var possibleConstructorReturn = function (self, call) {
325    if (!self) {
326      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
327    }
328
329    return call && (typeof call === "object" || typeof call === "function") ? call : self;
330  };
331
332  var taggedTemplateLiteralLoose = function (strings, raw) {
333    strings.raw = raw;
334    return strings;
335  };
336
337  /**
338   * @file obj.js
339   * @module obj
340   */
341
342  /**
343   * @callback obj:EachCallback
344   *
345   * @param {Mixed} value
346   *        The current key for the object that is being iterated over.
347   *
348   * @param {string} key
349   *        The current key-value for object that is being iterated over
350   */
351
352  /**
353   * @callback obj:ReduceCallback
354   *
355   * @param {Mixed} accum
356   *        The value that is accumulating over the reduce loop.
357   *
358   * @param {Mixed} value
359   *        The current key for the object that is being iterated over.
360   *
361   * @param {string} key
362   *        The current key-value for object that is being iterated over
363   *
364   * @return {Mixed}
365   *         The new accumulated value.
366   */
367  var toString = Object.prototype.toString;
368
369  /**
370   * Get the keys of an Object
371   *
372   * @param {Object}
373   *        The Object to get the keys from
374   *
375   * @return {string[]}
376   *         An array of the keys from the object. Returns an empty array if the
377   *         object passed in was invalid or had no keys.
378   *
379   * @private
380   */
381  var keys = function keys(object) {
382    return isObject(object) ? Object.keys(object) : [];
383  };
384
385  /**
386   * Array-like iteration for objects.
387   *
388   * @param {Object} object
389   *        The object to iterate over
390   *
391   * @param {obj:EachCallback} fn
392   *        The callback function which is called for each key in the object.
393   */
394  function each(object, fn) {
395    keys(object).forEach(function (key) {
396      return fn(object[key], key);
397    });
398  }
399
400  /**
401   * Array-like reduce for objects.
402   *
403   * @param {Object} object
404   *        The Object that you want to reduce.
405   *
406   * @param {Function} fn
407   *         A callback function which is called for each key in the object. It
408   *         receives the accumulated value and the per-iteration value and key
409   *         as arguments.
410   *
411   * @param {Mixed} [initial = 0]
412   *        Starting value
413   *
414   * @return {Mixed}
415   *         The final accumulated value.
416   */
417  function reduce(object, fn) {
418    var initial = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
419
420    return keys(object).reduce(function (accum, key) {
421      return fn(accum, object[key], key);
422    }, initial);
423  }
424
425  /**
426   * Object.assign-style object shallow merge/extend.
427   *
428   * @param  {Object} target
429   * @param  {Object} ...sources
430   * @return {Object}
431   */
432  function assign(target) {
433    for (var _len = arguments.length, sources = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
434      sources[_key - 1] = arguments[_key];
435    }
436
437    if (Object.assign) {
438      return Object.assign.apply(Object, [target].concat(sources));
439    }
440
441    sources.forEach(function (source) {
442      if (!source) {
443        return;
444      }
445
446      each(source, function (value, key) {
447        target[key] = value;
448      });
449    });
450
451    return target;
452  }
453
454  /**
455   * Returns whether a value is an object of any kind - including DOM nodes,
456   * arrays, regular expressions, etc. Not functions, though.
457   *
458   * This avoids the gotcha where using `typeof` on a `null` value
459   * results in `'object'`.
460   *
461   * @param  {Object} value
462   * @return {Boolean}
463   */
464  function isObject(value) {
465    return !!value && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object';
466  }
467
468  /**
469   * Returns whether an object appears to be a "plain" object - that is, a
470   * direct instance of `Object`.
471   *
472   * @param  {Object} value
473   * @return {Boolean}
474   */
475  function isPlain(value) {
476    return isObject(value) && toString.call(value) === '[object Object]' && value.constructor === Object;
477  }
478
479  /**
480   * @file computed-style.js
481   * @module computed-style
482   */
483
484  /**
485   * A safe getComputedStyle.
486   *
487   * This is needed because in Firefox, if the player is loaded in an iframe with
488   * `display:none`, then `getComputedStyle` returns `null`, so, we do a null-check to
489   * make sure  that the player doesn't break in these cases.
490   *
491   * @param {Element} el
492   *        The element you want the computed style of
493   *
494   * @param {string} prop
495   *        The property name you want
496   *
497   * @see https://bugzilla.mozilla.org/show_bug.cgi?id=548397
498   *
499   * @static
500   * @const
501   */
502  function computedStyle(el, prop) {
503    if (!el || !prop) {
504      return '';
505    }
506
507    if (typeof window_1.getComputedStyle === 'function') {
508      var cs = window_1.getComputedStyle(el);
509
510      return cs ? cs[prop] : '';
511    }
512
513    return '';
514  }
515
516  var _templateObject = taggedTemplateLiteralLoose(['Setting attributes in the second argument of createEl()\n                has been deprecated. Use the third argument instead.\n                createEl(type, properties, attributes). Attempting to set ', ' to ', '.'], ['Setting attributes in the second argument of createEl()\n                has been deprecated. Use the third argument instead.\n                createEl(type, properties, attributes). Attempting to set ', ' to ', '.']);
517
518  /**
519   * Detect if a value is a string with any non-whitespace characters.
520   *
521   * @param {string} str
522   *        The string to check
523   *
524   * @return {boolean}
525   *         - True if the string is non-blank
526   *         - False otherwise
527   *
528   */
529  function isNonBlankString(str) {
530    return typeof str === 'string' && /\S/.test(str);
531  }
532
533  /**
534   * Throws an error if the passed string has whitespace. This is used by
535   * class methods to be relatively consistent with the classList API.
536   *
537   * @param {string} str
538   *         The string to check for whitespace.
539   *
540   * @throws {Error}
541   *         Throws an error if there is whitespace in the string.
542   *
543   */
544  function throwIfWhitespace(str) {
545    if (/\s/.test(str)) {
546      throw new Error('class has illegal whitespace characters');
547    }
548  }
549
550  /**
551   * Produce a regular expression for matching a className within an elements className.
552   *
553   * @param {string} className
554   *         The className to generate the RegExp for.
555   *
556   * @return {RegExp}
557   *         The RegExp that will check for a specific `className` in an elements
558   *         className.
559   */
560  function classRegExp(className) {
561    return new RegExp('(^|\\s)' + className + '($|\\s)');
562  }
563
564  /**
565   * Whether the current DOM interface appears to be real.
566   *
567   * @return {Boolean}
568   */
569  function isReal() {
570    // Both document and window will never be undefined thanks to `global`.
571    return document_1 === window_1.document;
572  }
573
574  /**
575   * Determines, via duck typing, whether or not a value is a DOM element.
576   *
577   * @param {Mixed} value
578   *        The thing to check
579   *
580   * @return {boolean}
581   *         - True if it is a DOM element
582   *         - False otherwise
583   */
584  function isEl(value) {
585    return isObject(value) && value.nodeType === 1;
586  }
587
588  /**
589   * Determines if the current DOM is embedded in an iframe.
590   *
591   * @return {boolean}
592   *
593   */
594  function isInFrame() {
595
596    // We need a try/catch here because Safari will throw errors when attempting
597    // to get either `parent` or `self`
598    try {
599      return window_1.parent !== window_1.self;
600    } catch (x) {
601      return true;
602    }
603  }
604
605  /**
606   * Creates functions to query the DOM using a given method.
607   *
608   * @param {string} method
609   *         The method to create the query with.
610   *
611   * @return {Function}
612   *         The query method
613   */
614  function createQuerier(method) {
615    return function (selector, context) {
616      if (!isNonBlankString(selector)) {
617        return document_1[method](null);
618      }
619      if (isNonBlankString(context)) {
620        context = document_1.querySelector(context);
621      }
622
623      var ctx = isEl(context) ? context : document_1;
624
625      return ctx[method] && ctx[method](selector);
626    };
627  }
628
629  /**
630   * Creates an element and applies properties.
631   *
632   * @param {string} [tagName='div']
633   *         Name of tag to be created.
634   *
635   * @param {Object} [properties={}]
636   *         Element properties to be applied.
637   *
638   * @param {Object} [attributes={}]
639   *         Element attributes to be applied.
640   *
641   * @param {String|Element|TextNode|Array|Function} [content]
642   *         Contents for the element (see: {@link dom:normalizeContent})
643   *
644   * @return {Element}
645   *         The element that was created.
646   */
647  function createEl() {
648    var tagName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'div';
649    var properties = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
650    var attributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
651    var content = arguments[3];
652
653    var el = document_1.createElement(tagName);
654
655    Object.getOwnPropertyNames(properties).forEach(function (propName) {
656      var val = properties[propName];
657
658      // See #2176
659      // We originally were accepting both properties and attributes in the
660      // same object, but that doesn't work so well.
661      if (propName.indexOf('aria-') !== -1 || propName === 'role' || propName === 'type') {
662        log$1.warn(tsml(_templateObject, propName, val));
663        el.setAttribute(propName, val);
664
665        // Handle textContent since it's not supported everywhere and we have a
666        // method for it.
667      } else if (propName === 'textContent') {
668        textContent(el, val);
669      } else {
670        el[propName] = val;
671      }
672    });
673
674    Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
675      el.setAttribute(attrName, attributes[attrName]);
676    });
677
678    if (content) {
679      appendContent(el, content);
680    }
681
682    return el;
683  }
684
685  /**
686   * Injects text into an element, replacing any existing contents entirely.
687   *
688   * @param {Element} el
689   *        The element to add text content into
690   *
691   * @param {string} text
692   *        The text content to add.
693   *
694   * @return {Element}
695   *         The element with added text content.
696   */
697  function textContent(el, text) {
698    if (typeof el.textContent === 'undefined') {
699      el.innerText = text;
700    } else {
701      el.textContent = text;
702    }
703    return el;
704  }
705
706  /**
707   * Insert an element as the first child node of another
708   *
709   * @param {Element} child
710   *        Element to insert
711   *
712   * @param {Element} parent
713   *        Element to insert child into
714   */
715  function prependTo(child, parent) {
716    if (parent.firstChild) {
717      parent.insertBefore(child, parent.firstChild);
718    } else {
719      parent.appendChild(child);
720    }
721  }
722
723  /**
724   * Check if an element has a CSS class
725   *
726   * @param {Element} element
727   *        Element to check
728   *
729   * @param {string} classToCheck
730   *        Class name to check for
731   *
732   * @return {boolean}
733   *         - True if the element had the class
734   *         - False otherwise.
735   *
736   * @throws {Error}
737   *         Throws an error if `classToCheck` has white space.
738   */
739  function hasClass(element, classToCheck) {
740    throwIfWhitespace(classToCheck);
741    if (element.classList) {
742      return element.classList.contains(classToCheck);
743    }
744    return classRegExp(classToCheck).test(element.className);
745  }
746
747  /**
748   * Add a CSS class name to an element
749   *
750   * @param {Element} element
751   *        Element to add class name to.
752   *
753   * @param {string} classToAdd
754   *        Class name to add.
755   *
756   * @return {Element}
757   *         The dom element with the added class name.
758   */
759  function addClass(element, classToAdd) {
760    if (element.classList) {
761      element.classList.add(classToAdd);
762
763      // Don't need to `throwIfWhitespace` here because `hasElClass` will do it
764      // in the case of classList not being supported.
765    } else if (!hasClass(element, classToAdd)) {
766      element.className = (element.className + ' ' + classToAdd).trim();
767    }
768
769    return element;
770  }
771
772  /**
773   * Remove a CSS class name from an element
774   *
775   * @param {Element} element
776   *        Element to remove a class name from.
777   *
778   * @param {string} classToRemove
779   *        Class name to remove
780   *
781   * @return {Element}
782   *         The dom element with class name removed.
783   */
784  function removeClass(element, classToRemove) {
785    if (element.classList) {
786      element.classList.remove(classToRemove);
787    } else {
788      throwIfWhitespace(classToRemove);
789      element.className = element.className.split(/\s+/).filter(function (c) {
790        return c !== classToRemove;
791      }).join(' ');
792    }
793
794    return element;
795  }
796
797  /**
798   * The callback definition for toggleElClass.
799   *
800   * @callback Dom~PredicateCallback
801   * @param {Element} element
802   *        The DOM element of the Component.
803   *
804   * @param {string} classToToggle
805   *        The `className` that wants to be toggled
806   *
807   * @return {boolean|undefined}
808   *         - If true the `classToToggle` will get added to `element`.
809   *         - If false the `classToToggle` will get removed from `element`.
810   *         - If undefined this callback will be ignored
811   */
812
813  /**
814   * Adds or removes a CSS class name on an element depending on an optional
815   * condition or the presence/absence of the class name.
816   *
817   * @param {Element} element
818   *        The element to toggle a class name on.
819   *
820   * @param {string} classToToggle
821   *        The class that should be toggled
822   *
823   * @param {boolean|PredicateCallback} [predicate]
824   *        See the return value for {@link Dom~PredicateCallback}
825   *
826   * @return {Element}
827   *         The element with a class that has been toggled.
828   */
829  function toggleClass(element, classToToggle, predicate) {
830
831    // This CANNOT use `classList` internally because IE11 does not support the
832    // second parameter to the `classList.toggle()` method! Which is fine because
833    // `classList` will be used by the add/remove functions.
834    var has = hasClass(element, classToToggle);
835
836    if (typeof predicate === 'function') {
837      predicate = predicate(element, classToToggle);
838    }
839
840    if (typeof predicate !== 'boolean') {
841      predicate = !has;
842    }
843
844    // If the necessary class operation matches the current state of the
845    // element, no action is required.
846    if (predicate === has) {
847      return;
848    }
849
850    if (predicate) {
851      addClass(element, classToToggle);
852    } else {
853      removeClass(element, classToToggle);
854    }
855
856    return element;
857  }
858
859  /**
860   * Apply attributes to an HTML element.
861   *
862   * @param {Element} el
863   *        Element to add attributes to.
864   *
865   * @param {Object} [attributes]
866   *        Attributes to be applied.
867   */
868  function setAttributes(el, attributes) {
869    Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
870      var attrValue = attributes[attrName];
871
872      if (attrValue === null || typeof attrValue === 'undefined' || attrValue === false) {
873        el.removeAttribute(attrName);
874      } else {
875        el.setAttribute(attrName, attrValue === true ? '' : attrValue);
876      }
877    });
878  }
879
880  /**
881   * Get an element's attribute values, as defined on the HTML tag
882   * Attributes are not the same as properties. They're defined on the tag
883   * or with setAttribute (which shouldn't be used with HTML)
884   * This will return true or false for boolean attributes.
885   *
886   * @param {Element} tag
887   *        Element from which to get tag attributes.
888   *
889   * @return {Object}
890   *         All attributes of the element.
891   */
892  function getAttributes(tag) {
893    var obj = {};
894
895    // known boolean attributes
896    // we can check for matching boolean properties, but not all browsers
897    // and not all tags know about these attributes, so, we still want to check them manually
898    var knownBooleans = ',' + 'autoplay,controls,playsinline,loop,muted,default,defaultMuted' + ',';
899
900    if (tag && tag.attributes && tag.attributes.length > 0) {
901      var attrs = tag.attributes;
902
903      for (var i = attrs.length - 1; i >= 0; i--) {
904        var attrName = attrs[i].name;
905        var attrVal = attrs[i].value;
906
907        // check for known booleans
908        // the matching element property will return a value for typeof
909        if (typeof tag[attrName] === 'boolean' || knownBooleans.indexOf(',' + attrName + ',') !== -1) {
910          // the value of an included boolean attribute is typically an empty
911          // string ('') which would equal false if we just check for a false value.
912          // we also don't want support bad code like autoplay='false'
913          attrVal = attrVal !== null ? true : false;
914        }
915
916        obj[attrName] = attrVal;
917      }
918    }
919
920    return obj;
921  }
922
923  /**
924   * Get the value of an element's attribute
925   *
926   * @param {Element} el
927   *        A DOM element
928   *
929   * @param {string} attribute
930   *        Attribute to get the value of
931   *
932   * @return {string}
933   *         value of the attribute
934   */
935  function getAttribute(el, attribute) {
936    return el.getAttribute(attribute);
937  }
938
939  /**
940   * Set the value of an element's attribute
941   *
942   * @param {Element} el
943   *        A DOM element
944   *
945   * @param {string} attribute
946   *        Attribute to set
947   *
948   * @param {string} value
949   *        Value to set the attribute to
950   */
951  function setAttribute(el, attribute, value) {
952    el.setAttribute(attribute, value);
953  }
954
955  /**
956   * Remove an element's attribute
957   *
958   * @param {Element} el
959   *        A DOM element
960   *
961   * @param {string} attribute
962   *        Attribute to remove
963   */
964  function removeAttribute(el, attribute) {
965    el.removeAttribute(attribute);
966  }
967
968  /**
969   * Attempt to block the ability to select text while dragging controls
970   */
971  function blockTextSelection() {
972    document_1.body.focus();
973    document_1.onselectstart = function () {
974      return false;
975    };
976  }
977
978  /**
979   * Turn off text selection blocking
980   */
981  function unblockTextSelection() {
982    document_1.onselectstart = function () {
983      return true;
984    };
985  }
986
987  /**
988   * Identical to the native `getBoundingClientRect` function, but ensures that
989   * the method is supported at all (it is in all browsers we claim to supp

1313   *        string in which case the first matching element will be used
1314   *        as context. If missing (or no element matches selector), falls
1315   *        back to `document`.
1316   *
1317   * @return {Element|null}
1318   *         The element that was found or null.
1319   */
1320  var $ = createQuerier('querySelector');
1321
1322  /**
1323   * Finds a all DOM elements matching `selector` within the optional
1324   * `context` of another DOM element (defaulting to `document`).
1325   *
1326   * @param {string} selector
1327   *           A valid CSS selector, which will be passed to `querySelectorAll`.
1328   *
1329   * @param {Element|String} [context=document]
1330   *           A DOM element within which to query. Can also be a selector
1331   *           string in which case the first matching element will be used
1332   *           as context. If missing (or no element matches selector), falls
1333   *           back to `document`.
1334   *
1335   * @return {NodeList}
1336   *         A element list of elements that were found. Will be empty if none were found.
1337   *
1338   */
1339  var $$ = createQuerier('querySelectorAll');
1340
1341  var Dom = /*#__PURE__*/Object.freeze({
1342    isReal: isReal,
1343    isEl: isEl,
1344    isInFrame: isInFrame,
1345    createEl: createEl,
1346    textContent: textContent,
1347    prependTo: prependTo,
1348    hasClass: hasClass,
1349    addClass: addClass,
1350    removeClass: removeClass,
1351    toggleClass: toggleClass,
1352    setAttributes: setAttributes,
1353    getAttributes: getAttributes,
1354    getAttribute: getAttribute,
1355    setAttribute: setAttribute,
1356    removeAttribute: removeAttribute,
1357    blockTextSelection: blockTextSelection,
1358    unblockTextSelection: unblockTextSelection,
1359    getBoundingClientRect: getBoundingClientRect,
1360    findPosition: findPosition,
1361    getPointerPosition: getPointerPosition,
1362    isTextNode: isTextNode,
1363    emptyEl: emptyEl,
1364    normalizeContent: normalizeContent,
1365    appendContent: appendContent,
1366    insertContent: insertContent,
1367    isSingleLeftClick: isSingleLeftClick,
1368    $: $,
1369    $$: $$
1370  });
1371
1372  /**
1373   * @file guid.js
1374   * @module guid
1375   */
1376
1377  /**
1378   * Unique ID for an element or function
1379   * @type {Number}
1380   */
1381  var _guid = 1;
1382
1383  /**
1384   * Get a unique auto-incrementing ID by number that has not been returned before.
1385   *
1386   * @return {number}
1387   *         A new unique ID.
1388   */
1389  function newGUID() {
1390    return _guid++;
1391  }
1392
1393  /**
1394   * @file dom-data.js
1395   * @module dom-data
1396   */
1397
1398  /**
1399   * Element Data Store.
1400   *
1401   * Allows for binding data to an element without putting it directly on the
1402   * element. Ex. Event listeners are stored here.
1403   * (also from jsninja.com, slightly modified and updated for closure compiler)
1404   *
1405   * @type {Object}
1406   * @private
1407   */
1408  var elData = {};
1409
1410  /*
1411   * Unique attribute name to store an element's guid in
1412   *
1413   * @type {String}
1414   * @constant
1415   * @private
1416   */
1417  var elIdAttr = 'vdata' + new Date().getTime();
1418
1419  /**
1420   * Returns the cache object where data for an element is stored
1421   *
1422   * @param {Element} el
1423   *        Element to store data for.
1424   *
1425   * @return {Object}
1426   *         The cache object for that el that was passed in.
1427   */
1428  function getData(el) {
1429    var id = el[elIdAttr];
1430
1431    if (!id) {
1432      id = el[elIdAttr] = newGUID();
1433    }
1434
1435    if (!elData[id]) {
1436      elData[id] = {};
1437    }
1438
1439    return elData[id];
1440  }
1441
1442  /**
1443   * Returns whether or not an element has cached data
1444   *
1445   * @param {Element} el
1446   *        Check if this element has cached data.
1447   *
1448   * @return {boolean}
1449   *         - True if the DOM element has cached data.
1450   *         - False otherwise.
1451   */
1452  function hasData(el) {
1453    var id = el[elIdAttr];
1454
1455    if (!id) {
1456      return false;
1457    }
1458
1459    return !!Object.getOwnPropertyNames(elData[id]).length;
1460  }
1461
1462  /**
1463   * Delete data for the element from the cache and the guid attr from getElementById
1464   *
1465   * @param {Element} el
1466   *        Remove cached data for this element.
1467   */
1468  function removeData(el) {
1469    var id = el[elIdAttr];
1470
1471    if (!id) {
1472      return;
1473    }
1474
1475    // Remove all stored data
1476    delete elData[id];
1477
1478    // Remove the elIdAttr property from the DOM node
1479    try {
1480      delete el[elIdAttr];
1481    } catch (e) {
1482      if (el.removeAttribute) {
1483        el.removeAttribute(elIdAttr);
1484      } else {
1485        // IE doesn't appear to support removeAttribute on the document element
1486        el[elIdAttr] = null;
1487      }
1488    }
1489  }
1490
1491  /**
1492   * @file events.js. An Event System (John Resig - Secrets of a JS Ninja http://jsninja.com/)
1493   * (Original book version wasn't completely usable, so fixed some things and made Closure Compiler compatible)
1494   * This should work very similarly to jQuery's events, however it's based off the book version which isn't as
1495   * robust as jquery's, so there's probably some differences.
1496   *
1497   * @module events
1498   */
1499
1500  /**
1501   * Clean up the listener cache and dispatchers
1502   *
1503   * @param {Element|Object} elem
1504   *        Element to clean up
1505   *
1506   * @param {string} type
1507   *        Type of event to clean up
1508   */
1509  function _cleanUpEvents(elem, type) {
1510    var data = getData(elem);
1511
1512    // Remove the events of a particular type if there are none left
1513    if (data.handlers[type].length === 0) {
1514      delete data.handlers[type];
1515      // data.handlers[type] = null;
1516      // Setting to null was causing an error with data.handlers
1517
1518      // Remove the meta-handler from the element
1519      if (elem.removeEventListener) {
1520        elem.removeEventListener(type, data.dispatcher, false);
1521      } else if (elem.detachEvent) {
1522        elem.detachEvent('on' + type, data.dispatcher);
1523      }
1524    }
1525
1526    // Remove the events object if there are no types left
1527    if (Object.getOwnPropertyNames(data.handlers).length <= 0) {
1528      delete data.handlers;
1529      delete data.dispatcher;
1530      delete data.disabled;
1531    }
1532
1533    // Finally remove the element data if there is no data left
1534    if (Object.getOwnPropertyNames(data).length === 0) {
1535      removeData(elem);
1536    }
1537  }
1538
1539  /**
1540   * Loops through an array of event types and calls the requested method for each type.
1541   *
1542   * @param {Function} fn
1543   *        The event method we want to use.
1544   *
1545   * @param {Element|Object} elem
1546   *        Element or object to bind listeners to
1547   *
1548   * @param {string} type
1549   *        Type of event to bind to.
1550   *
1551   * @param {EventTarget~EventListener} callback
1552   *        Event listener.
1553   */
1554  function _handleMultipleEvents(fn, elem, types, callback) {
1555    types.forEach(function (type) {
1556      // Call the event method for each one of the types
1557      fn(elem, type, callback);
1558    });
1559  }
1560
1561  /**
1562   * Fix a native event to have standard property values
1563   *
1564   * @param {Object} event
1565   *        Event object to fix.
1566   *
1567   * @return {Object}
1568   *         Fixed event object.
1569   */
1570  function fixEvent(event) {
1571
1572    function returnTrue() {
1573      return true;
1574    }
1575
1576    function returnFalse() {
1577      return false;
1578    }
1579
1580    // Test if fixing up is needed
1581    // Used to check if !event.stopPropagation instead of isPropagationStopped
1582    // But native events return true for stopPropagation, but don't have
1583    // other expected methods like isPropagationStopped. Seems to be a problem
1584    // with the Javascript Ninja code. So we're just overriding all events now.
1585    if (!event || !event.isPropagationStopped) {
1586      var old = event || window_1.event;
1587
1588      event = {};
1589      // Clone the old object so that we can modify the values event = {};
1590      // IE8 Doesn't like when you mess with native event properties
1591      // Firefox returns false for event.hasOwnProperty('type') and other props
1592      //  which makes copying more difficult.
1593      // TODO: Probably best to create a whitelist of event props
1594      for (var key in old) {
1595        // Safari 6.0.3 warns you if you try to copy deprecated layerX/Y
1596        // Chrome warns you if you try to copy deprecated keyboardEvent.keyLocation
1597        // and webkitMovementX/Y
1598        if (key !== 'layerX' && key !== 'layerY' && key !== 'keyLocation' && key !== 'webkitMovementX' && key !== 'webkitMovementY') {
1599          // Chrome 32+ warns if you try to copy deprecated returnValue, but
1600          // we still want to if preventDefault isn't supported (IE8).
1601          if (!(key === 'returnValue' && old.preventDefault)) {
1602            event[key] = old[key];
1603          }
1604        }
1605      }
1606
1607      // The event occurred on this element
1608      if (!event.target) {
1609        event.target = event.srcElement || document_1;
1610      }
1611
1612      // Handle which other element the event is related to
1613      if (!event.relatedTarget) {
1614        event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
1615      }
1616
1617      // Stop the default browser action
1618      event.preventDefault = function () {
1619        if (old.preventDefault) {
1620          old.preventDefault();
1621        }
1622        event.returnValue = false;
1623        old.returnValue = false;
1624        event.defaultPrevented = true;
1625      };
1626
1627      event.defaultPrevented = false;
1628
1629      // Stop the event from bubbling
1630      event.stopPropagation = function () {
1631        if (old.stopPropagation) {
1632          old.stopPropagation();
1633        }
1634        event.cancelBubble = true;
1635        old.cancelBubble = true;
1636        event.isPropagationStopped = returnTrue;
1637      };
1638
1639      event.isPropagationStopped = returnFalse;
1640
1641      // Stop the event from bubbling and executing other handlers
1642      event.stopImmediatePropagation = function () {
1643        if (old.stopImmediatePropagation) {
1644          old.stopImmediatePropagation();
1645        }
1646        event.isImmediatePropagationStopped = returnTrue;
1647        event.stopPropagation();
1648      };
1649
1650      event.isImmediatePropagationStopped = returnFalse;
1651
1652      // Handle mouse position
1653      if (event.clientX !== null && event.clientX !== undefined) {
1654        var doc = document_1.documentElement;
1655        var body = document_1.body;
1656
1657        event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1658        event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
1659      }
1660
1661      // Handle key presses
1662      event.which = event.charCode || event.keyCode;
1663
1664      // Fix button for mouse clicks:
1665      // 0 == left; 1 == middle; 2 == right
1666      if (event.button !== null && event.button !== undefined) {
1667
1668        // The following is disabled because it does not pass videojs-standard
1669        // and... yikes.
1670        /* eslint-disable */
1671        event.button = event.button & 1 ? 0 : event.button & 4 ? 1 : event.button & 2 ? 2 : 0;
1672        /* eslint-enable */
1673      }
1674    }
1675
1676    // Returns fixed-up instance
1677    return event;
1678  }
1679
1680  /**
1681   * Whether passive event listeners are supported
1682   */
1683  var _supportsPassive = false;
1684
1685  (function () {
1686    try {
1687      var opts = Object.defineProperty({}, 'passive', {
1688        get: function get() {
1689          _supportsPassive = true;
1690        }
1691      });
1692
1693      window_1.addEventListener('test', null, opts);
1694      window_1.removeEventListener('test', null, opts);
1695    } catch (e) {
1696      // disregard
1697    }
1698  })();
1699
1700  /**
1701   * Touch events Chrome expects to be passive
1702   */
1703  var passiveEvents = ['touchstart', 'touchmove'];
1704
1705  /**
1706   * Add an event listener to element
1707   * It stores the handler function in a separate cache object
1708   * and adds a generic handler to the element's event,
1709   * along with a unique id (guid) to the element.
1710   *
1711   * @param {Element|Object} elem
1712   *        Element or object to bind listeners to
1713   *
1714   * @param {string|string[]} type
1715   *        Type of event to bind to.
1716   *
1717   * @param {EventTarget~EventListener} fn
1718   *        Event listener.
1719   */
1720  function on(elem, type, fn) {
1721    if (Array.isArray(type)) {
1722      return _handleMultipleEvents(on, elem, type, fn);
1723    }
1724
1725    var data = getData(elem);
1726
1727    // We need a place to store all our handler data
1728    if (!data.handlers) {
1729      data.handlers = {};
1730    }
1731
1732    if (!data.handlers[type]) {
1733      data.handlers[type] = [];
1734    }
1735
1736    if (!fn.guid) {
1737      fn.guid = newGUID();
1738    }
1739
1740    data.handlers[type].push(fn);
1741
1742    if (!data.dispatcher) {
1743      data.disabled = false;
1744
1745      data.dispatcher = function (event, hash) {
1746
1747        if (data.disabled) {
1748          return;
1749        }
1750
1751        event = fixEvent(event);
1752
1753        var handlers = data.handlers[event.type];
1754
1755        if (handlers) {
1756          // Copy handlers so if handlers are added/removed during the process it doesn't throw everything off.
1757          var handlersCopy = handlers.slice(0);
1758
1759          for (var m = 0, n = handlersCopy.length; m < n; m++) {
1760            if (event.isImmediatePropagationStopped()) {
1761              break;
1762            } else {
1763              try {
1764                handlersCopy[m].call(elem, event, hash);
1765              } catch (e) {
1766                log$1.error(e);
1767              }
1768            }
1769          }
1770        }
1771      };
1772    }
1773
1774    if (data.handlers[type].length === 1) {
1775      if (elem.addEventListener) {
1776        var options = false;
1777
1778        if (_supportsPassive && passiveEvents.indexOf(type) > -1) {
1779          options = { passive: true };
1780        }
1781        elem.addEventListener(type, data.dispatcher, options);
1782      } else if (elem.attachEvent) {
1783        elem.attachEvent('on' + type, data.dispatcher);
1784      }
1785    }
1786  }
1787
1788  /**
1789   * Removes event listeners from an element
1790   *
1791   * @param {Element|Object} elem
1792   *        Object to remove listeners from.
1793   *
1794   * @param {string|string[]} [type]
1795   *        Type of listener to remove. Don't include to remove all events from element.
1796   *
1797   * @param {EventTarget~EventListener} [fn]
1798   *        Specific listener to remove. Don't include to remove listeners for an event
1799   *        type.
1800   */
1801  function off(elem, type, fn) {
1802    // Don't want to add a cache object through getElData if not needed
1803    if (!hasData(elem)) {
1804      return;
1805    }
1806
1807    var data = getData(elem);
1808
1809    // If no events exist, nothing to unbind
1810    if (!data.handlers) {
1811      return;
1812    }
1813
1814    if (Array.isArray(type)) {
1815      return _handleMultipleEvents(off, elem, type, fn);
1816    }
1817
1818    // Utility function
1819    var removeType = function removeType(el, t) {
1820      data.handlers[t] = [];
1821      _cleanUpEvents(el, t);
1822    };
1823
1824    // Are we removing all bound events?
1825    if (type === undefined) {
1826      for (var t in data.handlers) {
1827        if (Object.prototype.hasOwnProperty.call(data.handlers || {}, t)) {
1828          removeType(elem, t);
1829        }
1830      }
1831      return;
1832    }
1833
1834    var handlers = data.handlers[type];
1835
1836    // If no handlers exist, nothing to unbind
1837    if (!handlers) {
1838      return;
1839    }
1840
1841    // If no listener was provided, remove all listeners for type
1842    if (!fn) {
1843      removeType(elem, type);
1844      return;
1845    }
1846
1847    // We're only removing a single handler
1848    if (fn.guid) {
1849      for (var n = 0; n < handlers.length; n++) {
1850        if (handlers[n].guid === fn.guid) {
1851          handlers.splice(n--, 1);
1852        }
1853      }
1854    }
1855
1856    _cleanUpEvents(elem, type);
1857  }
1858
1859  /**
1860   * Trigger an event for an element
1861   *
1862   * @param {Element|Object} elem
1863   *        Element to trigger an event on
1864   *
1865   * @param {EventTarget~Event|string} event
1866   *        A string (the type) or an event object with a type attribute
1867   *
1868   * @param {Object} [hash]
1869   *        data hash to pass along with the event
1870   *
1871   * @return {boolean|undefined}
1872   *         - Returns the opposite of `defaultPrevented` if default was prevented
1873   *         - Otherwise returns undefined
1874   */
1875  function trigger(elem, event, hash) {
1876    // Fetches element data and a reference to the parent (for bubbling).
1877    // Don't want to add a data object to cache for every parent,
1878    // so checking hasElData first.
1879    var elemData = hasData(elem) ? getData(elem) : {};
1880    var parent = elem.parentNode || elem.ownerDocument;
1881    // type = event.type || event,
1882    // handler;
1883
1884    // If an event name was passed as a string, creates an event out of it
1885    if (typeof event === 'string') {
1886      event = { type: event, target: elem };
1887    } else if (!event.target) {
1888      event.target = elem;
1889    }
1890
1891    // Normalizes the event properties.
1892    event = fixEvent(event);
1893
1894    // If the passed element has a dispatcher, executes the established handlers.
1895    if (elemData.dispatcher) {
1896      elemData.dispatcher.call(elem, event, hash);
1897    }
1898
1899    // Unless explicitly stopped or the event does not bubble (e.g. media events)
1900    // recursively calls this function to bubble the event up the DOM.
1901    if (parent && !event.isPropagationStopped() && event.bubbles === true) {
1902      trigger.call(null, parent, event, hash);
1903
1904      // If at the top of the DOM, triggers the default action unless disabled.
1905    } else if (!parent && !event.defaultPrevented) {
1906      var targetData = getData(event.target);
1907
1908      // Checks if the target has a default action for this event.
1909      if (event.target[event.type]) {
1910        // Temporarily disables event dispatching on the target as we have already executed the handler.
1911        targetData.disabled = true;
1912        // Executes the default action.
1913        if (typeof event.target[event.type] === 'function') {
1914          event.target[event.type]();
1915        }
1916        // Re-enables event dispatching.
1917        targetData.disabled = false;
1918      }
1919    }
1920
1921    // Inform the triggerer if the default was prevented by returning false
1922    return !event.defaultPrevented;
1923  }
1924
1925  /**
1926   * Trigger a listener only once for an event
1927   *
1928   * @param {Element|Object} elem
1929   *        Element or object to bind to.
1930   *
1931   * @param {string|string[]} type
1932   *        Name/type of event
1933   *
1934   * @param {Event~EventListener} fn
1935   *        Event Listener function
1936   */
1937  function one(elem, type, fn) {
1938    if (Array.isArray(type)) {
1939      return _handleMultipleEvents(one, elem, type, fn);
1940    }
1941    var func = function func() {
1942      off(elem, type, func);
1943      fn.apply(this, arguments);
1944    };
1945
1946    // copy the guid to the new function so it can removed using the original function's ID
1947    func.guid = fn.guid = fn.guid || newGUID();
1948    on(elem, type, func);
1949  }
1950
1951  var Events = /*#__PURE__*/Object.freeze({
1952    fixEvent: fixEvent,
1953    on: on,
1954    off: off,
1955    trigger: trigger,
1956    one: one
1957  });
1958
1959  /**
1960   * @file setup.js - Functions for setting up a player without
1961   * user interaction based on the data-setup `attribute` of the video tag.
1962   *
1963   * @module setup
1964   */
1965
1966  var _windowLoaded = false;
1967  var videojs = void 0;
1968
1969  /**
1970   * Set up any tags that have a data-setup `attribute` when the player is started.
1971   */
1972  var autoSetup = function autoSetup() {
1973
1974    // Protect against breakage in non-browser environments and check global autoSetup option.
1975    if (!isReal() || videojs.options.autoSetup === false) {
1976      return;
1977    }
1978
1979    var vids = Array.prototype.slice.call(document_1.getElementsByTagName('video'));
1980    var audios = Array.prototype.slice.call(document_1.getElementsByTagName('audio'));
1981    var divs = Array.prototype.slice.call(document_1.getElementsByTagName('video-js'));
1982    var mediaEls = vids.concat(audios, divs);
1983
1984    // Check if any media elements exist
1985    if (mediaEls && mediaEls.length > 0) {
1986
1987      for (var i = 0, e = mediaEls.length; i < e; i++) {
1988        var mediaEl = mediaEls[i];
1989
1990        // Check if element exists, has getAttribute func.
1991        if (mediaEl && mediaEl.getAttribute) {
1992
1993          // Make sure this player hasn't already been set up.
1994          if (mediaEl.player === undefined) {
1995            var options = mediaEl.getAttribute('data-setup');
1996
1997            // Check if data-setup attr exists.
1998            // We only auto-setup if they've added the data-setup attr.
1999            if (options !== null) {
2000              // Create new video.js instance.
2001              videojs(mediaEl);
2002            }
2003          }
2004
2005          // If getAttribute isn't defined, we need to wait for the DOM.
2006        } else {
2007          autoSetupTimeout(1);
2008          break;
2009        }
2010      }
2011
2012      // No videos were found, so keep looping unless page is finished loading.
2013    } else if (!_windowLoaded) {
2014      autoSetupTimeout(1);
2015    }
2016  };
2017
2018  /**
2019   * Wait until the page is loaded before running autoSetup. This will be called in
2020   * autoSetup if `hasLoaded` returns false.
2021   *
2022   * @param {number} wait
2023   *        How long to wait in ms
2024   *
2025   * @param {module:videojs} [vjs]
2026   *        The videojs library function
2027   */
2028  function autoSetupTimeout(wait, vjs) {
2029    if (vjs) {
2030      videojs = vjs;
2031    }
2032
2033    window_1.setTimeout(autoSetup, wait);
2034  }
2035
2036  if (isReal() && document_1.readyState === 'complete') {
2037    _windowLoaded = true;
2038  } else {
2039    /**
2040     * Listen for the load event on window, and set _windowLoaded to true.
2041     *
2042     * @listens load
2043     */
2044    one(window_1, 'load', function () {
2045      _windowLoaded = true;
2046    });
2047  }
2048
2049  /**
2050   * @file stylesheet.js
2051   * @module stylesheet
2052   */
2053
2054  /**
2055   * Create a DOM syle element given a className for it.
2056   *
2057   * @param {string} className
2058   *        The className to add to the created style element.
2059   *
2060   * @return {Element}
2061   *         The element that was created.
2062   */
2063  var createStyleElement = function createStyleElement(className) {
2064    var style = document_1.createElement('style');
2065
2066    style.className = className;
2067
2068    return style;
2069  };
2070
2071  /**
2072   * Add text to a DOM element.
2073   *
2074   * @param {Element} el
2075   *        The Element to add text content to.
2076   *
2077   * @param {string} content
2078   *        The text to add to the element.
2079   */
2080  var setTextContent = function setTextContent(el, content) {
2081    if (el.styleSheet) {
2082      el.styleSheet.cssText = content;
2083    } else {
2084      el.textContent = content;
2085    }
2086  };
2087
2088  /**
2089   * @file fn.js
2090   * @module fn
2091   */
2092
2093  /**

2418  var validateTarget = function validateTarget(target) {
2419    if (!target.nodeName && !isEvented(target)) {
2420      throw new Error('Invalid target; must be a DOM node or evented object.');
2421    }
2422  };
2423
2424  /**
2425   * Validates a value to determine if it is a valid event target. Throws if not.
2426   *
2427   * @private
2428   * @throws {Error}
2429   *         If the type does not appear to be a valid event type.
2430   *
2431   * @param  {string|Array} type
2432   *         The type to test.
2433   */
2434  var validateEventType = function validateEventType(type) {
2435    if (!isValidEventType(type)) {
2436      throw new Error('Invalid event type; must be a non-empty string or array.');
2437    }
2438  };
2439
2440  /**
2441   * Validates a value to determine if it is a valid listener. Throws if not.
2442   *
2443   * @private
2444   * @throws {Error}
2445   *         If the listener is not a function.
2446   *
2447   * @param  {Function} listener
2448   *         The listener to test.
2449   */
2450  var validateListener = function validateListener(listener) {
2451    if (typeof listener !== 'function') {
2452      throw new Error('Invalid listener; must be a function.');
2453    }
2454  };
2455
2456  /**
2457   * Takes an array of arguments given to `on()` or `one()`, validates them, and
2458   * normalizes them into an object.
2459   *
2460   * @private
2461   * @param  {Object} self
2462   *         The evented object on which `on()` or `one()` was called. This
2463   *         object will be bound as the `this` value for the listener.
2464   *
2465   * @param  {Array} args
2466   *         An array of arguments passed to `on()` or `one()`.
2467   *
2468   * @return {Object}
2469   *         An object containing useful values for `on()` or `one()` calls.
2470   */
2471  var normalizeListenArgs = function normalizeListenArgs(self, args) {
2472
2473    // If the number of arguments is less than 3, the target is always the
2474    // evented object itself.
2475    var isTargetingSelf = args.length < 3 || args[0] === self || args[0] === self.eventBusEl_;
2476    var target = void 0;
2477    var type = void 0;
2478    var listener = void 0;
2479
2480    if (isTargetingSelf) {
2481      target = self.eventBusEl_;
2482
2483      // Deal with cases where we got 3 arguments, but we are still listening to
2484      // the evented object itself.
2485      if (args.length >= 3) {
2486        args.shift();
2487      }
2488
2489      type = args[0];
2490      listener = args[1];
2491    } else {
2492      target = args[0];
2493      type = args[1];
2494      listener = args[2];
2495    }
2496
2497    validateTarget(target);
2498    validateEventType(type);
2499    validateListener(listener);
2500
2501    listener = bind(self, listener);
2502
2503    return { isTargetingSelf: isTargetingSelf, target: target, type: type, listener: listener };
2504  };
2505
2506  /**
2507   * Adds the listener to the event type(s) on the target, normalizing for
2508   * the type of target.
2509   *
2510   * @private
2511   * @param  {Element|Object} target
2512   *         A DOM node or evented object.
2513   *
2514   * @param  {string} method
2515   *         The event binding method to use ("on" or "one").
2516   *
2517   * @param  {string|Array} type
2518   *         One or more event type(s).
2519   *
2520   * @param  {Function} listener
2521   *         A listener function.
2522   */
2523  var listen = function listen(target, method, type, listener) {
2524    validateTarget(target);
2525
2526    if (target.nodeName) {
2527      Events[method](target, type, listener);
2528    } else {
2529      target[method](type, listener);
2530    }
2531  };
2532
2533  /**
2534   * Contains methods that provide event capabilities to an object which is passed
2535   * to {@link module:evented|evented}.
2536   *
2537   * @mixin EventedMixin
2538   */
2539  var EventedMixin = {
2540
2541    /**
2542     * Add a listener to an event (or events) on this object or another evented
2543     * object.
2544     *
2545     * @param  {string|Array|Element|Object} targetOrType
2546     *         If this is a string or array, it represents the event type(s)
2547     *         that will trigger the listener.
2548     *
2549     *         Another evented object can be passed here instead, which will
2550     *         cause the listener to listen for events on _that_ object.
2551     *
2552     *         In either case, the listener's `this` value will be bound to
2553     *         this object.
2554     *
2555     * @param  {string|Array|Function} typeOrListener
2556     *         If the first argument was a string or array, this should be the
2557     *         listener function. Otherwise, this is a string or array of event
2558     *         type(s).
2559     *
2560     * @param  {Function} [listener]
2561     *         If the first argument was another evented object, this will be
2562     *         the listener function.
2563     */
2564    on: function on$$1() {
2565      var _this = this;
2566
2567      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
2568        args[_key] = arguments[_key];
2569      }
2570
2571      var _normalizeListenArgs = normalizeListenArgs(this, args),
2572          isTargetingSelf = _normalizeListenArgs.isTargetingSelf,
2573          target = _normalizeListenArgs.target,
2574          type = _normalizeListenArgs.type,
2575          listener = _normalizeListenArgs.listener;
2576
2577      listen(target, 'on', type, listener);
2578
2579      // If this object is listening to another evented object.
2580      if (!isTargetingSelf) {
2581
2582        // If this object is disposed, remove the listener.
2583        var removeListenerOnDispose = function removeListenerOnDispose() {
2584          return _this.off(target, type, listener);
2585        };
2586
2587        // Use the same function ID as the listener so we can remove it later it
2588        // using the ID of the original listener.
2589        removeListenerOnDispose.guid = listener.guid;
2590
2591        // Add a listener to the target's dispose event as well. This ensures
2592        // that if the target is disposed BEFORE this object, we remove the
2593        // removal listener that was just added. Otherwise, we create a memory leak.
2594        var removeRemoverOnTargetDispose = function removeRemoverOnTargetDispose() {
2595          return _this.off('dispose', removeListenerOnDispose);
2596        };
2597
2598        // Use the same function ID as the listener so we can remove it later
2599        // it using the ID of the original listener.
2600        removeRemoverOnTargetDispose.guid = listener.guid;
2601
2602        listen(this, 'on', 'dispose', removeListenerOnDispose);
2603        listen(target, 'on', 'dispose', removeRemoverOnTargetDispose);
2604      }
2605    },
2606
2607
2608    /**
2609     * Add a listener to an event (or events) on this object or another evented
2610     * object. The listener will only be called once and then removed.
2611     *