https://dvd-rom.netlify.app/static/video.js

178      logByType('log', level, args);
179    }; // This is the logByType helper that the logging methods below use
180
181
182    logByType = LogByTypeFactory(name, log);
183    /**
184     * Create a new sublogger which chains the old name to the new name.
185     *
186     * For example, doing `videojs.log.createLogger('player')` and then using that logger will log the following:
187     * ```js
188     *  mylogger('foo');
189     *  // > VIDEOJS: player: foo
190     * ```
191     *
192     * @param {string} name
193     *        The name to add call the new logger
194     * @return {Object}
195     */
196
197    log.createLogger = function (subname) {
198      return createLogger(name + ': ' + subname);
199    };
200    /**
201     * Enumeration of available logging levels, where the keys are the level names
202     * and the values are `|`-separated strings containing logging methods allowed
203     * in that logging level. These strings are used to create a regular expression
204     * matching the function name being called.
205     *
206     * Levels provided by Video.js are:
207     *
208     * - `off`: Matches no calls. Any value that can be cast to `false` will have
209     *   this effect. The most restrictive.
210     * - `all`: Matches only Video.js-provided functions (`debug`, `log`,
211     *   `log.warn`, and `log.error`).
212     * - `debug`: Matches `log.debug`, `log`, `log.warn`, and `log.error` calls.
213     * - `info` (default): Matches `log`, `log.warn`, and `log.error` calls.
214     * - `warn`: Matches `log.warn` and `log.error` calls.
215     * - `error`: Matches only `log.error` calls.
216     *
217     * @type {Object}
218     */
219
220
221    log.levels = {
222      all: 'debug|log|warn|error',
223      off: '',
224      debug: 'debug|log|warn|error',
225      info: 'log|warn|error',
226      warn: 'warn|error',
227      error: 'error',
228      DEFAULT: level
229    };
230    /**
231     * Get or set the current logging level.
232     *
233     * If a string matching a key from {@link module:log.levels} is provided, acts
234     * as a setter.
235     *
236     * @param  {string} [lvl]
237     *         Pass a valid level to set a new logging level.
238     *
239     * @return {string}
240     *         The current logging level.
241     */
242
243    log.level = function (lvl) {
244      if (typeof lvl === 'string') {
245        if (!log.levels.hasOwnProperty(lvl)) {
246          throw new Error("\"" + lvl + "\" in not a valid log level");
247        }
248
249        level = lvl;
250      }
251
252      return level;
253    };
254    /**
255     * Returns an array containing everything that has been logged to the history.
256     *
257     * This array is a shallow clone of the internal history record. However, its
258     * contents are _not_ cloned; so, mutating objects inside this array will
259     * mutate them in history.
260     *
261     * @return {Array}
262     */
263
264
265    log.history = function () {
266      return history ? [].concat(history) : [];
267    };
268    /**
269     * Allows you to filter the history by the given logger name
270     *
271     * @param {string} fname
272     *        The name to filter by
273     *
274     * @return {Array}
275     *         The filtered list to return
276     */
277
278
279    log.history.filter = function (fname) {
280      return (history || []).filter(function (historyItem) {
281        // if the first item in each historyItem includes `fname`, then it's a match
282        return new RegExp(".*" + fname + ".*").test(historyItem[0]);
283      });
284    };
285    /**
286     * Clears the internal history tracking, but does not prevent further history
287     * tracking.
288     */
289
290
291    log.history.clear = function () {
292      if (history) {
293        history.length = 0;
294      }
295    };
296    /**
297     * Disable history tracking if it is currently enabled.
298     */
299
300
301    log.history.disable = function () {
302      if (history !== null) {
303        history.length = 0;
304        history = null;
305      }
306    };
307    /**
308     * Enable history tracking if it is currently disabled.
309     */
310
311
312    log.history.enable = function () {
313      if (history === null) {
314        history = [];
315      }
316    };
317    /**
318     * Logs error messages. Similar to `console.error`.
319     *
320     * @param {Mixed[]} args
321     *        One or more messages or objects that should be logged as an error
322     */
323
324
325    log.error = function () {
326      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
327        args[_key2] = arguments[_key2];
328      }
329
330      return logByType('error', level, args);
331    };
332    /**
333     * Logs warning messages. Similar to `console.warn`.
334     *
335     * @param {Mixed[]} args
336     *        One or more messages or objects that should be logged as a warning.
337     */
338
339
340    log.warn = function () {
341      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
342        args[_key3] = arguments[_key3];
343      }
344
345      return logByType('warn', level, args);
346    };
347    /**
348     * Logs debug messages. Similar to `console.debug`, but may also act as a comparable
349     * log if `console.debug` is not available
350     *
351     * @param {Mixed[]} args
352     *        One or more messages or objects that should be logged as debug.
353     */
354
355
356    log.debug = function () {
357      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
358        args[_key4] = arguments[_key4];
359      }
360
361      return logByType('debug', level, args);
362    };
363
364    return log;
365  }
366
367  /**
368   * @file log.js
369   * @module log
370   */
371  var log = createLogger('VIDEOJS');
372  var createLogger$1 = log.createLogger;
373
374  function clean(s) {
375    return s.replace(/\n\r?\s*/g, '');
376  }
377
378  var tsml = function tsml(sa) {
379    var s = '',
380        i = 0;
381
382    for (; i < arguments.length; i++) {
383      s += clean(sa[i]) + (arguments[i + 1] || '');
384    }
385
386    return s;
387  };
388
389  /**
390   * @file obj.js
391   * @module obj
392   */
393
394  /**
395   * @callback obj:EachCallback
396   *
397   * @param {Mixed} value
398   *        The current key for the object that is being iterated over.
399   *
400   * @param {string} key
401   *        The current key-value for object that is being iterated over
402   */
403
404  /**
405   * @callback obj:ReduceCallback
406   *
407   * @param {Mixed} accum
408   *        The value that is accumulating over the reduce loop.
409   *
410   * @param {Mixed} value
411   *        The current key for the object that is being iterated over.
412   *
413   * @param {string} key
414   *        The current key-value for object that is being iterated over
415   *
416   * @return {Mixed}
417   *         The new accumulated value.
418   */
419  var toString = Object.prototype.toString;
420  /**
421   * Get the keys of an Object
422   *
423   * @param {Object}
424   *        The Object to get the keys from
425   *
426   * @return {string[]}
427   *         An array of the keys from the object. Returns an empty array if the
428   *         object passed in was invalid or had no keys.
429   *
430   * @private
431   */
432
433  var keys = function keys(object) {
434    return isObject(object) ? Object.keys(object) : [];
435  };
436  /**
437   * Array-like iteration for objects.
438   *
439   * @param {Object} object
440   *        The object to iterate over
441   *
442   * @param {obj:EachCallback} fn
443   *        The callback function which is called for each key in the object.
444   */
445
446
447  function each(object, fn) {
448    keys(object).forEach(function (key) {
449      return fn(object[key], key);
450    });
451  }
452  /**
453   * Array-like reduce for objects.
454   *
455   * @param {Object} object
456   *        The Object that you want to reduce.
457   *
458   * @param {Function} fn
459   *         A callback function which is called for each key in the object. It
460   *         receives the accumulated value and the per-iteration value and key
461   *         as arguments.
462   *
463   * @param {Mixed} [initial = 0]
464   *        Starting value
465   *
466   * @return {Mixed}
467   *         The final accumulated value.
468   */
469
470  function reduce(object, fn, initial) {
471    if (initial === void 0) {
472      initial = 0;
473    }
474
475    return keys(object).reduce(function (accum, key) {
476      return fn(accum, object[key], key);
477    }, initial);
478  }
479  /**
480   * Object.assign-style object shallow merge/extend.
481   *
482   * @param  {Object} target
483   * @param  {Object} ...sources
484   * @return {Object}
485   */
486
487  function assign(target) {
488    for (var _len = arguments.length, sources = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
489      sources[_key - 1] = arguments[_key];
490    }
491
492    if (Object.assign) {
493      return Object.assign.apply(Object, [target].concat(sources));
494    }
495
496    sources.forEach(function (source) {
497      if (!source) {
498        return;
499      }
500
501      each(source, function (value, key) {
502        target[key] = value;
503      });
504    });
505    return target;
506  }
507  /**
508   * Returns whether a value is an object of any kind - including DOM nodes,
509   * arrays, regular expressions, etc. Not functions, though.
510   *
511   * This avoids the gotcha where using `typeof` on a `null` value
512   * results in `'object'`.
513   *
514   * @param  {Object} value
515   * @return {boolean}
516   */
517
518  function isObject(value) {
519    return !!value && typeof value === 'object';
520  }
521  /**
522   * Returns whether an object appears to be a "plain" object - that is, a

726    Object.getOwnPropertyNames(properties).forEach(function (propName) {
727      var val = properties[propName]; // See #2176
728      // We originally were accepting both properties and attributes in the
729      // same object, but that doesn't work so well.
730
731      if (propName.indexOf('aria-') !== -1 || propName === 'role' || propName === 'type') {
732        log.warn(tsml(_templateObject(), propName, val));
733        el.setAttribute(propName, val); // Handle textContent since it's not supported everywhere and we have a
734        // method for it.
735      } else if (propName === 'textContent') {
736        textContent(el, val);
737      } else {
738        el[propName] = val;
739      }
740    });
741    Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
742      el.setAttribute(attrName, attributes[attrName]);
743    });
744
745    if (content) {
746      appendContent(el, content);
747    }
748
749    return el;
750  }
751  /**
752   * Injects text into an element, replacing any existing contents entirely.
753   *
754   * @param  {Element} el
755   *         The element to add text content into
756   *
757   * @param  {string} text
758   *         The text content to add.
759   *
760   * @return {Element}
761   *         The element with added text content.
762   */
763
764  function textContent(el, text) {
765    if (typeof el.textContent === 'undefined') {
766      el.innerText = text;
767    } else {
768      el.textContent = text;
769    }
770
771    return el;
772  }
773  /**
774   * Insert an element as the first child node of another
775   *
776   * @param {Element} child
777   *        Element to insert
778   *
779   * @param {Element} parent
780   *        Element to insert child into
781   */
782
783  function prependTo(child, parent) {
784    if (parent.firstChild) {
785      parent.insertBefore(child, parent.firstChild);
786    } else {
787      parent.appendChild(child);
788    }
789  }
790  /**
791   * Check if an element has a class name.
792   *
793   * @param  {Element} element
794   *         Element to check
795   *
796   * @param  {string} classToCheck
797   *         Class name to check for
798   *
799   * @return {boolean}
800   *         Will be `true` if the element has a class, `false` otherwise.
801   *
802   * @throws {Error}
803   *         Throws an error if `classToCheck` has white space.
804   */
805
806  function hasClass(element, classToCheck) {
807    throwIfWhitespace(classToCheck);
808
809    if (element.classList) {
810      return element.classList.contains(classToCheck);
811    }
812
813    return classRegExp(classToCheck).test(element.className);
814  }
815  /**
816   * Add a class name to an element.
817   *
818   * @param  {Element} element
819   *         Element to add class name to.
820   *
821   * @param  {string} classToAdd
822   *         Class name to add.
823   *
824   * @return {Element}
825   *         The DOM element with the added class name.
826   */
827
828  function addClass(element, classToAdd) {
829    if (element.classList) {
830      element.classList.add(classToAdd); // Don't need to `throwIfWhitespace` here because `hasElClass` will do it
831      // in the case of classList not being supported.
832    } else if (!hasClass(element, classToAdd)) {
833      element.className = (element.className + ' ' + classToAdd).trim();
834    }
835
836    return element;
837  }
838  /**
839   * Remove a class name from an element.
840   *
841   * @param  {Element} element
842   *         Element to remove a class name from.
843   *
844   * @param  {string} classToRemove
845   *         Class name to remove
846   *
847   * @return {Element}
848   *         The DOM element with class name removed.
849   */
850
851  function removeClass(element, classToRemove) {
852    if (element.classList) {
853      element.classList.remove(classToRemove);
854    } else {
855      throwIfWhitespace(classToRemove);
856      element.className = element.className.split(/\s+/).filter(function (c) {
857        return c !== classToRemove;
858      }).join(' ');
859    }
860
861    return element;
862  }
863  /**
864   * The callback definition for toggleClass.
865   *
866   * @callback module:dom~PredicateCallback
867   * @param    {Element} element
868   *           The DOM element of the Component.
869   *
870   * @param    {string} classToToggle
871   *           The `className` that wants to be toggled
872   *
873   * @return   {boolean|undefined}
874   *           If `true` is returned, the `classToToggle` will be added to the
875   *           `element`. If `false`, the `classToToggle` will be removed from
876   *           the `element`. If `undefined`, the callback will be ignored.
877   */
878
879  /**
880   * Adds or removes a class name to/from an element depending on an optional
881   * condition or the presence/absence of the class name.
882   *
883   * @param  {Element} element
884   *         The element to toggle a class name on.
885   *
886   * @param  {string} classToToggle
887   *         The class that should be toggled.
888   *
889   * @param  {boolean|module:dom~PredicateCallback} [predicate]
890   *         See the return value for {@link module:dom~PredicateCallback}
891   *
892   * @return {Element}
893   *         The element with a class that has been toggled.
894   */
895
896  function toggleClass(element, classToToggle, predicate) {
897    // This CANNOT use `classList` internally because IE11 does not support the

898    // second parameter to the `classList.toggle()` method! Which is fine because
899    // `classList` will be used by the add/remove functions.
900    var has = hasClass(element, classToToggle);
901
902    if (typeof predicate === 'function') {
903      predicate = predicate(element, classToToggle);
904    }
905
906    if (typeof predicate !== 'boolean') {
907      predicate = !has;
908    } // If the necessary class operation matches the current state of the
909    // element, no action is required.
910
911
912    if (predicate === has) {
913      return;
914    }
915
916    if (predicate) {
917      addClass(element, classToToggle);
918    } else {
919      removeClass(element, classToToggle);
920    }
921
922    return element;
923  }
924  /**
925   * Apply attributes to an HTML element.
926   *
927   * @param {Element} el
928   *        Element to add attributes to.
929   *
930   * @param {Object} [attributes]
931   *        Attributes to be applied.
932   */
933
934  function setAttributes(el, attributes) {
935    Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
936      var attrValue = attributes[attrName];
937
938      if (attrValue === null || typeof attrValue === 'undefined' || attrValue === false) {
939        el.removeAttribute(attrName);
940      } else {
941        el.setAttribute(attrName, attrValue === true ? '' : attrValue);
942      }
943    });
944  }
945  /**
946   * Get an element's attribute values, as defined on the HTML tag.
947   *
948   * Attributes are not the same as properties. They're defined on the tag
949   * or with setAttribute.
950   *
951   * @param  {Element} tag
952   *         Element from which to get tag attributes.
953   *
954   * @return {Object}
955   *         All attributes of the element. Boolean attributes will be `true` or
956   *         `false`, others will be strings.
957   */
958
959  function getAttributes(tag) {
960    var obj = {}; // known boolean attributes
961    // we can check for matching boolean properties, but not all browsers
962    // and not all tags know about these attributes, so, we still want to check them manually
963
964    var knownBooleans = ',' + 'autoplay,controls,playsinline,loop,muted,default,defaultMuted' + ',';
965
966    if (tag && tag.attributes && tag.attributes.length > 0) {
967      var attrs = tag.attributes;
968
969      for (var i = attrs.length - 1; i >= 0; i--) {
970        var attrName = attrs[i].name;
971        var attrVal = attrs[i].value; // check for known booleans
972        // the matching element property will return a value for typeof
973
974        if (typeof tag[attrName] === 'boolean' || knownBooleans.indexOf(',' + attrName + ',') !== -1) {
975          // the value of an included boolean attribute is typically an empty
976          // string ('') which would equal false if we just check for a false value.
977          // we also don't want support bad code like autoplay='false'
978          attrVal = attrVal !== null ? true : false;
979        }
980
981        obj[attrName] = attrVal;
982      }
983    }
984
985    return obj;
986  }
987  /**
988   * Get the value of an element's attribute.
989   *
990   * @param {Element} el
991   *        A DOM element.
992   *
993   * @param {string} attribute
994   *        Attribute to get the value of.
995   *
996   * @return {string}
997   *         The value of the attribute.
998   */
999
1000  function getAttribute(el, attribute) {
1001    return el.getAttribute(attribute);
1002  }
1003  /**
1004   * Set the value of an element's attribute.
1005   *
1006   * @param {Element} el
1007   *        A DOM element.
1008   *
1009   * @param {string} attribute
1010   *        Attribute to set.
1011   *
1012   * @param {string} value
1013   *        Value to set the attribute to.
1014   */
1015
1016  function setAttribute(el, attribute, value) {
1017    el.setAttribute(attribute, value);
1018  }
1019  /**
1020   * Remove an element's attribute.
1021   *
1022   * @param {Element} el
1023   *        A DOM element.
1024   *
1025   * @param {string} attribute
1026   *        Attribute to remove.
1027   */
1028
1029  function removeAttribute(el, attribute) {
1030    el.removeAttribute(attribute);
1031  }
1032  /**
1033   * Attempt to block the ability to select text.
1034   */
1035
1036  function blockTextSelection() {
1037    document.body.focus();
1038
1039    document.onselectstart = function () {
1040      return false;
1041    };
1042  }
1043  /**
1044   * Turn off text selection blocking.
1045   */
1046
1047  function unblockTextSelection() {
1048    document.onselectstart = function () {
1049      return true;
1050    };
1051  }
1052  /**
1053   * Identical to the native `getBoundingClientRect` function, but ensures that
1054   * the method is supported at all (it is in all browsers we claim to supp

1344      // I want to support this as well
1345      return true;
1346    }
1347
1348    if (event.button === 0 && event.buttons === undefined) {
1349      // Touch screen, sometimes on some specific device, `buttons`
1350      // doesn't have anything (safari on ios, blackberry...)
1351      return true;
1352    }
1353
1354    if (event.button !== 0 || event.buttons !== 1) {
1355      // This is the reason we have those if else block above
1356      // if any special case we can catch and let it slide
1357      // we do it above, when get to here, this definitely
1358      // is-not-left-click
1359      return false;
1360    }
1361
1362    return true;
1363  }
1364  /**
1365   * Finds a single DOM element matching `selector` within the optional
1366   * `context` of another DOM element (defaulting to `document`).
1367   *
1368   * @param  {string} selector
1369   *         A valid CSS selector, which will be passed to `querySelector`.
1370   *
1371   * @param  {Element|String} [context=document]
1372   *         A DOM element within which to query. Can also be a selector
1373   *         string in which case the first matching element will be used
1374   *         as context. If missing (or no element matches selector), falls
1375   *         back to `document`.
1376   *
1377   * @return {Element|null}
1378   *         The element that was found or null.
1379   */
1380
1381  var $ = createQuerier('querySelector');
1382  /**
1383   * Finds a all DOM elements matching `selector` within the optional
1384   * `context` of another DOM element (defaulting to `document`).
1385   *
1386   * @param  {string} selector
1387   *         A valid CSS selector, which will be passed to `querySelectorAll`.
1388   *
1389   * @param  {Element|String} [context=document]
1390   *         A DOM element within which to query. Can also be a selector
1391   *         string in which case the first matching element will be used
1392   *         as context. If missing (or no element matches selector), falls
1393   *         back to `document`.
1394   *
1395   * @return {NodeList}
1396   *         A element list of elements that were found. Will be empty if none
1397   *         were found.
1398   *
1399   */
1400
1401  var $$ = createQuerier('querySelectorAll');
1402
1403  var Dom = /*#__PURE__*/Object.freeze({
1404    isReal: isReal,
1405    isEl: isEl,
1406    isInFrame: isInFrame,
1407    createEl: createEl,
1408    textContent: textContent,
1409    prependTo: prependTo,
1410    hasClass: hasClass,
1411    addClass: addClass,
1412    removeClass: removeClass,
1413    toggleClass: toggleClass,
1414    setAttributes: setAttributes,
1415    getAttributes: getAttributes,
1416    getAttribute: getAttribute,
1417    setAttribute: setAttribute,
1418    removeAttribute: removeAttribute,
1419    blockTextSelection: blockTextSelection,
1420    unblockTextSelection: unblockTextSelection,
1421    getBoundingClientRect: getBoundingClientRect,
1422    findPosition: findPosition,
1423    getPointerPosition: getPointerPosition,
1424    isTextNode: isTextNode,
1425    emptyEl: emptyEl,
1426    normalizeContent: normalizeContent,
1427    appendContent: appendContent,
1428    insertContent: insertContent,
1429    isSingleLeftClick: isSingleLeftClick,
1430    $: $,
1431    $$: $$
1432  });
1433
1434  /**
1435   * @file guid.js
1436   * @module guid
1437   */
1438
1439  /**
1440   * Unique ID for an element or function
1441   * @type {Number}
1442   */
1443  var _guid = 1;
1444  /**
1445   * Get a unique auto-incrementing ID by number that has not been returned before.
1446   *
1447   * @return {number}
1448   *         A new unique ID.
1449   */
1450
1451  function newGUID() {
1452    return _guid++;
1453  }
1454
1455  /**
1456   * @file dom-data.js
1457   * @module dom-data
1458   */
1459  /**
1460   * Element Data Store.
1461   *
1462   * Allows for binding data to an element without putting it directly on the
1463   * element. Ex. Event listeners are stored here.
1464   * (also from jsninja.com, slightly modified and updated for closure compiler)
1465   *
1466   * @type {Object}
1467   * @private
1468   */
1469
1470  var elData = {};
1471  /*
1472   * Unique attribute name to store an element's guid in
1473   *
1474   * @type {String}
1475   * @constant
1476   * @private
1477   */
1478
1479  var elIdAttr = 'vdata' + new Date().getTime();
1480  /**
1481   * Returns the cache object where data for an element is stored
1482   *
1483   * @param {Element} el
1484   *        Element to store data for.
1485   *
1486   * @return {Object}
1487   *         The cache object for that el that was passed in.
1488   */
1489
1490  function getData(el) {
1491    var id = el[elIdAttr];
1492
1493    if (!id) {
1494      id = el[elIdAttr] = newGUID();
1495    }
1496
1497    if (!elData[id]) {
1498      elData[id] = {};
1499    }
1500
1501    return elData[id];
1502  }
1503  /**
1504   * Returns whether or not an element has cached data
1505   *
1506   * @param {Element} el
1507   *        Check if this element has cached data.
1508   *
1509   * @return {boolean}
1510   *         - True if the DOM element has cached data.
1511   *         - False otherwise.
1512   */
1513
1514  function hasData(el) {
1515    var id = el[elIdAttr];
1516
1517    if (!id) {
1518      return false;
1519    }
1520
1521    return !!Object.getOwnPropertyNames(elData[id]).length;
1522  }
1523  /**
1524   * Delete data for the element from the cache and the guid attr from getElementById
1525   *
1526   * @param {Element} el
1527   *        Remove cached data for this element.
1528   */
1529
1530  function removeData(el) {
1531    var id = el[elIdAttr];
1532
1533    if (!id) {
1534      return;
1535    } // Remove all stored data
1536
1537
1538    delete elData[id]; // Remove the elIdAttr property from the DOM node
1539
1540    try {
1541      delete el[elIdAttr];
1542    } catch (e) {
1543      if (el.removeAttribute) {
1544        el.removeAttribute(elIdAttr);
1545      } else {
1546        // IE doesn't appear to support removeAttribute on the document element
1547        el[elIdAttr] = null;
1548      }
1549    }
1550  }
1551
1552  /**
1553   * @file events.js. An Event System (John Resig - Secrets of a JS Ninja http://jsninja.com/)
1554   * (Original book version wasn't completely usable, so fixed some things and made Closure Compiler compatible)
1555   * This should work very similarly to jQuery's events, however it's based off the book version which isn't as
1556   * robust as jquery's, so there's probably some differences.
1557   *
1558   * @file events.js
1559   * @module events
1560   */
1561  /**
1562   * Clean up the listener cache and dispatchers
1563   *
1564   * @param {Element|Object} elem
1565   *        Element to clean up
1566   *
1567   * @param {string} type
1568   *        Type of event to clean up
1569   */
1570
1571  function _cleanUpEvents(elem, type) {
1572    var data = getData(elem); // Remove the events of a particular type if there are none left
1573
1574    if (data.handlers[type].length === 0) {
1575      delete data.handlers[type]; // data.handlers[type] = null;
1576      // Setting to null was causing an error with data.handlers
1577      // Remove the meta-handler from the element
1578
1579      if (elem.removeEventListener) {
1580        elem.removeEventListener(type, data.dispatcher, false);
1581      } else if (elem.detachEvent) {
1582        elem.detachEvent('on' + type, data.dispatcher);
1583      }
1584    } // Remove the events object if there are no types left
1585
1586
1587    if (Object.getOwnPropertyNames(data.handlers).length <= 0) {
1588      delete data.handlers;
1589      delete data.dispatcher;
1590      delete data.disabled;
1591    } // Finally remove the element data if there is no data left
1592
1593
1594    if (Object.getOwnPropertyNames(data).length === 0) {
1595      removeData(elem);
1596    }
1597  }
1598  /**
1599   * Loops through an array of event types and calls the requested method for each type.
1600   *
1601   * @param {Function} fn
1602   *        The event method we want to use.
1603   *
1604   * @param {Element|Object} elem
1605   *        Element or object to bind listeners to
1606   *
1607   * @param {string} type
1608   *        Type of event to bind to.
1609   *
1610   * @param {EventTarget~EventListener} callback
1611   *        Event listener.
1612   */
1613
1614
1615  function _handleMultipleEvents(fn, elem, types, callback) {
1616    types.forEach(function (type) {
1617      // Call the event method for each one of the types
1618      fn(elem, type, callback);
1619    });
1620  }
1621  /**
1622   * Fix a native event to have standard property values
1623   *
1624   * @param {Object} event
1625   *        Event object to fix.
1626   *
1627   * @return {Object}
1628   *         Fixed event object.
1629   */
1630
1631
1632  function fixEvent(event) {
1633    function returnTrue() {
1634      return true;
1635    }
1636
1637    function returnFalse() {
1638      return false;
1639    } // Test if fixing up is needed
1640    // Used to check if !event.stopPropagation instead of isPropagationStopped
1641    // But native events return true for stopPropagation, but don't have
1642    // other expected methods like isPropagationStopped. Seems to be a problem
1643    // with the Javascript Ninja code. So we're just overriding all events now.
1644
1645
1646    if (!event || !event.isPropagationStopped) {
1647      var old = event || window$1.event;
1648      event = {}; // Clone the old object so that we can modify the values event = {};
1649      // IE8 Doesn't like when you mess with native event properties
1650      // Firefox returns false for event.hasOwnProperty('type') and other props
1651      //  which makes copying more difficult.
1652      // TODO: Probably best to create a whitelist of event props
1653
1654      for (var key in old) {
1655        // Safari 6.0.3 warns you if you try to copy deprecated layerX/Y

1656        // Chrome warns you if you try to copy deprecated keyboardEvent.keyLocation
1657        // and webkitMovementX/Y
1658        if (key !== 'layerX' && key !== 'layerY' && key !== 'keyLocation' && key !== 'webkitMovementX' && key !== 'webkitMovementY') {
1659          // Chrome 32+ warns if you try to copy deprecated returnValue, but
1660          // we still want to if preventDefault isn't supported (IE8).
1661          if (!(key === 'returnValue' && old.preventDefault)) {
1662            event[key] = old[key];
1663          }
1664        }
1665      } // The event occurred on this element
1666
1667
1668      if (!event.target) {
1669        event.target = event.srcElement || document;
1670      } // Handle which other element the event is related to
1671
1672
1673      if (!event.relatedTarget) {
1674        event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
1675      } // Stop the default browser action
1676
1677
1678      event.preventDefault = function () {
1679        if (old.preventDefault) {
1680          old.preventDefault();
1681        }
1682
1683        event.returnValue = false;
1684        old.returnValue = false;
1685        event.defaultPrevented = true;
1686      };
1687
1688      event.defaultPrevented = false; // Stop the event from bubbling
1689
1690      event.stopPropagation = function () {
1691        if (old.stopPropagation) {
1692          old.stopPropagation();
1693        }
1694
1695        event.cancelBubble = true;
1696        old.cancelBubble = true;
1697        event.isPropagationStopped = returnTrue;
1698      };
1699
1700      event.isPropagationStopped = returnFalse; // Stop the event from bubbling and executing other handlers
1701
1702      event.stopImmediatePropagation = function () {
1703        if (old.stopImmediatePropagation) {
1704          old.stopImmediatePropagation();
1705        }
1706
1707        event.isImmediatePropagationStopped = returnTrue;
1708        event.stopPropagation();
1709      };
1710
1711      event.isImmediatePropagationStopped = returnFalse; // Handle mouse position
1712
1713      if (event.clientX !== null && event.clientX !== undefined) {
1714        var doc = document.documentElement;
1715        var body = document.body;
1716        event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1717        event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
1718      } // Handle key presses
1719
1720
1721      event.which = event.charCode || event.keyCode; // Fix button for mouse clicks:
1722      // 0 == left; 1 == middle; 2 == right
1723
1724      if (event.button !== null && event.button !== undefined) {
1725        // The following is disabled because it does not pass videojs-standard
1726        // and... yikes.
1727
1728        /* eslint-disable */
1729        event.button = event.button & 1 ? 0 : event.button & 4 ? 1 : event.button & 2 ? 2 : 0;
1730        /* eslint-enable */
1731      }
1732    } // Returns fixed-up instance
1733
1734
1735    return event;
1736  }
1737  /**
1738   * Whether passive event listeners are supported
1739   */
1740
1741  var _supportsPassive = false;
1742
1743  (function () {
1744    try {
1745      var opts = Object.defineProperty({}, 'passive', {
1746        get: function get() {
1747          _supportsPassive = true;
1748        }
1749      });
1750      window$1.addEventListener('test', null, opts);
1751      window$1.removeEventListener('test', null, opts);
1752    } catch (e) {// disregard
1753    }
1754  })();
1755  /**
1756   * Touch events Chrome expects to be passive
1757   */
1758
1759
1760  var passiveEvents = ['touchstart', 'touchmove'];
1761  /**
1762   * Add an event listener to element
1763   * It stores the handler function in a separate cache object
1764   * and adds a generic handler to the element's event,
1765   * along with a unique id (guid) to the element.
1766   *
1767   * @param {Element|Object} elem
1768   *        Element or object to bind listeners to
1769   *
1770   * @param {string|string[]} type
1771   *        Type of event to bind to.
1772   *
1773   * @param {EventTarget~EventListener} fn
1774   *        Event listener.
1775   */
1776
1777  function on(elem, type, fn) {
1778    if (Array.isArray(type)) {
1779      return _handleMultipleEvents(on, elem, type, fn);
1780    }
1781
1782    var data = getData(elem); // We need a place to store all our handler data
1783
1784    if (!data.handlers) {
1785      data.handlers = {};
1786    }
1787
1788    if (!data.handlers[type]) {
1789      data.handlers[type] = [];
1790    }
1791
1792    if (!fn.guid) {
1793      fn.guid = newGUID();
1794    }
1795
1796    data.handlers[type].push(fn);
1797
1798    if (!data.dispatcher) {
1799      data.disabled = false;

1800
1801      data.dispatcher = function (event, hash) {
1802        if (data.disabled) {
1803          return;
1804        }
1805
1806        event = fixEvent(event);
1807        var handlers = data.handlers[event.type];
1808
1809        if (handlers) {
1810          // Copy handlers so if handlers are added/removed during the process it doesn't throw everything off.
1811          var handlersCopy = handlers.slice(0);
1812
1813          for (var m = 0, n = handlersCopy.length; m < n; m++) {
1814            if (event.isImmediatePropagationStopped()) {
1815              break;
1816            } else {
1817              try {
1818                handlersCopy[m].call(elem, event, hash);
1819              } catch (e) {
1820                log.error(e);
1821              }
1822            }
1823          }
1824        }
1825      };
1826    }
1827
1828    if (data.handlers[type].length === 1) {
1829      if (elem.addEventListener) {
1830        var options = false;
1831
1832        if (_supportsPassive && passiveEvents.indexOf(type) > -1) {
1833          options = {
1834            passive: true
1835          };
1836        }
1837
1838        elem.addEventListener(type, data.dispatcher, options);
1839      } else if (elem.attachEvent) {
1840        elem.attachEvent('on' + type, data.dispatcher);
1841      }
1842    }
1843  }
1844  /**
1845   * Removes event listeners from an element
1846   *
1847   * @param {Element|Object} elem
1848   *        Object to remove listeners from.
1849   *
1850   * @param {string|string[]} [type]
1851   *        Type of listener to remove. Don't include to remove all events from element.
1852   *
1853   * @param {EventTarget~EventListener} [fn]
1854   *        Specific listener to remove. Don't include to remove listeners for an event
1855   *        type.
1856   */
1857
1858  function off(elem, type, fn) {
1859    // Don't want to add a cache object through getElData if not needed
1860    if (!hasData(elem)) {
1861      return;
1862    }
1863
1864    var data = getData(elem); // If no events exist, nothing to unbind
1865
1866    if (!data.handlers) {
1867      return;
1868    }
1869
1870    if (Array.isArray(type)) {
1871      return _handleMultipleEvents(off, elem, type, fn);
1872    } // Utility function
1873
1874
1875    var removeType = function removeType(el, t) {
1876      data.handlers[t] = [];
1877
1878      _cleanUpEvents(el, t);
1879    }; // Are we removing all bound events?
1880
1881
1882    if (type === undefined) {
1883      for (var t in data.handlers) {
1884        if (Object.prototype.hasOwnProperty.call(data.handlers || {}, t)) {
1885          removeType(elem, t);
1886        }
1887      }
1888
1889      return;
1890    }
1891
1892    var handlers = data.handlers[type]; // If no handlers exist, nothing to unbind
1893
1894    if (!handlers) {
1895      return;
1896    } // If no listener was provided, remove all listeners for type
1897
1898
1899    if (!fn) {
1900      removeType(elem, type);
1901      return;
1902    } // We're only removing a single handler
1903
1904
1905    if (fn.guid) {
1906      for (var n = 0; n < handlers.length; n++) {
1907        if (handlers[n].guid === fn.guid) {
1908          handlers.splice(n--, 1);
1909        }
1910      }
1911    }
1912
1913    _cleanUpEvents(elem, type);
1914  }
1915  /**
1916   * Trigger an event for an element
1917   *
1918   * @param {Element|Object} elem
1919   *        Element to trigger an event on
1920   *
1921   * @param {EventTarget~Event|string} event
1922   *        A string (the type) or an event object with a type attribute
1923   *
1924   * @param {Object} [hash]
1925   *        data hash to pass along with the event
1926   *
1927   * @return {boolean|undefined}
1928   *         Returns the opposite of `defaultPrevented` if default was
1929   *         prevented. Otherwise, returns `undefined`
1930   */
1931
1932  function trigger(elem, event, hash) {
1933    // Fetches element data and a reference to the parent (for bubbling).
1934    // Don't want to add a data object to cache for every parent,
1935    // so checking hasElData first.
1936    var elemData = hasData(elem) ? getData(elem) : {};
1937    var parent = elem.parentNode || elem.ownerDocument; // type = event.type || event,
1938    // handler;
1939    // If an event name was passed as a string, creates an event out of it
1940
1941    if (typeof event === 'string') {
1942      event = {
1943        type: event,
1944        target: elem
1945      };
1946    } else if (!event.target) {
1947      event.target = elem;
1948    } // Normalizes the event properties.
1949
1950
1951    event = fixEvent(event); // If the passed element has a dispatcher, executes the established handlers.
1952
1953    if (elemData.dispatcher) {
1954      elemData.dispatcher.call(elem, event, hash);
1955    } // Unless explicitly stopped or the event does not bubble (e.g. media events)
1956    // recursively calls this function to bubble the event up the DOM.
1957
1958
1959    if (parent && !event.isPropagationStopped() && event.bubbles === true) {
1960      trigger.call(null, parent, event, hash); // If at the top of the DOM, triggers the default action unless disabled.
1961    } else if (!parent && !event.defaultPrevented && event.target && event.target[event.type]) {
1962      var targetData = getData(event.target); // Checks if the target has a default action for this event.
1963
1964      if (event.target[event.type]) {
1965        // Temporarily disables event dispatching on the target as we have already executed the handler.
1966        targetData.disabled = true; // Executes the default action.
1967
1968        if (typeof event.target[event.type] === 'function') {
1969          event.target[event.type]();
1970        } // Re-enables event dispatching.
1971
1972
1973        targetData.disabled = false;
1974      }
1975    } // Inform the triggerer if the default was prevented by returning false
1976
1977
1978    return !event.defaultPrevented;
1979  }
1980  /**
1981   * Trigger a listener only once for an event.
1982   *
1983   * @param {Element|Object} elem
1984   *        Element or object to bind to.
1985   *
1986   * @param {string|string[]} type
1987   *        Name/type of event
1988   *
1989   * @param {Event~EventListener} fn
1990   *        Event listener function
1991   */
1992
1993  function one(elem, type, fn) {
1994    if (Array.isArray(type)) {
1995      return _handleMultipleEvents(one, elem, type, fn);
1996    }
1997
1998    var func = function func() {
1999      off(elem, type, func);
2000      fn.apply(this, arguments);
2001    }; // copy the guid to the new function so it can removed using the original function's ID
2002
2003
2004    func.guid = fn.guid = fn.guid || newGUID();
2005    on(elem, type, func);
2006  }
2007
2008  var Events = /*#__PURE__*/Object.freeze({
2009    fixEvent: fixEvent,
2010    on: on,
2011    off: off,
2012    trigger: trigger,
2013    one: one
2014  });
2015
2016  /**
2017   * @file setup.js - Functions for setting up a player without
2018   * user interaction based on the data-setup `attribute` of the video tag.
2019   *
2020   * @module setup
2021   */
2022  var _windowLoaded = false;
2023  var videojs;
2024  /**
2025   * Set up any tags that have a data-setup `attribute` when the player is started.
2026   */
2027
2028  var autoSetup = function autoSetup() {
2029    // Protect against breakage in non-browser environments and check global autoSetup option.
2030    if (!isReal() || videojs.options.autoSetup === false) {
2031      return;
2032    }
2033
2034    var vids = Array.prototype.slice.call(document.getElementsByTagName('video'));
2035    var audios = Array.prototype.slice.call(document.getElementsByTagName('audio'));
2036    var divs = Array.prototype.slice.call(document.getElementsByTagName('video-js'));
2037    var mediaEls = vids.concat(audios, divs); // Check if any media elements exist
2038
2039    if (mediaEls && mediaEls.length > 0) {
2040      for (var i = 0, e = mediaEls.length; i < e; i++) {
2041        var mediaEl = mediaEls[i]; // Check if element exists, has getAttribute func.
2042
2043        if (mediaEl && mediaEl.getAttribute) {
2044          // Make sure this player hasn't already been set up.
2045          if (mediaEl.player === undefined) {
2046            var options = mediaEl.getAttribute('data-setup'); // Check if data-setup attr exists.
2047            // We only auto-setup if they've added the data-setup attr.
2048
2049            if (options !== null) {
2050              // Create new video.js instance.
2051              videojs(mediaEl);
2052            }
2053          } // If getAttribute isn't defined, we need to wait for the DOM.
2054
2055        } else {
2056          autoSetupTimeout(1);
2057          break;
2058        }
2059      } // No videos were found, so keep looping unless page is finished loading.
2060
2061    } else if (!_windowLoaded) {
2062      autoSetupTimeout(1);
2063    }
2064  };
2065  /**
2066   * Wait until the page is loaded before running autoSetup. This will be called in
2067   * autoSetup if `hasLoaded` returns false.
2068   *
2069   * @param {number} wait
2070   *        How long to wait in ms
2071   *
2072   * @param {module:videojs} [vjs]
2073   *        The videojs library function
2074   */
2075
2076
2077  function autoSetupTimeout(wait, vjs) {
2078    if (vjs) {
2079      videojs = vjs;
2080    }
2081
2082    window$1.setTimeout(autoSetup, wait);
2083  }
2084
2085  if (isReal() && document.readyState === 'complete') {
2086    _windowLoaded = true;
2087  } else {
2088    /**
2089     * Listen for the load event on window, and set _windowLoaded to true.
2090     *
2091     * @listens load
2092     */
2093    one(window$1, 'load', function () {
2094      _windowLoaded = true;
2095    });
2096  }
2097
2098  /**
2099   * @file stylesheet.js
2100   * @module stylesheet
2101   */
2102  /**
2103   * Create a DOM syle element given a className for it.
2104   *
2105   * @param {string} className
2106   *        The className to add to the created style element.
2107   *
2108   * @return {Element}
2109   *         The element that was created.
2110   */
2111
2112  var createStyleElement = function createStyleElement(className) {
2113    var style = document.createElement('style');
2114    style.className = className;
2115    return style;
2116  };
2117  /**
2118   * Add text to a DOM element.
2119   *
2120   * @param {Element} el
2121   *        The Element to add text content to.
2122   *
2123   * @param {string} content
2124   *        The text to add to the element.
2125   */
2126
2127  var setTextContent = function setTextContent(el, content) {
2128    if (el.styleSheet) {
2129      el.styleSheet.cssText = content;
2130    } else {
2131      el.textContent = content;
2132    }
2133  };
2134
2135  /**
2136   * @file fn.js
2137   * @module fn
2138   */
2139  /**

2290   * A Custom DOM event.
2291   *
2292   * @typedef {Object} EventTarget~Event
2293   * @see [Properties]{@link https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent}
2294   */
2295
2296  /**
2297   * All event listeners should follow the following format.
2298   *
2299   * @callback EventTarget~EventListener
2300   * @this {EventTarget}
2301   *
2302   * @param {EventTarget~Event} event
2303   *        the event that triggered this function
2304   *
2305   * @param {Object} [hash]
2306   *        hash of data sent during the event
2307   */
2308
2309  /**
2310   * An object containing event names as keys and booleans as values.
2311   *
2312   * > NOTE: If an event name is set to a true value here {@link EventTarget#trigger}
2313   *         will have extra functionality. See that function for more information.
2314   *
2315   * @property EventTarget.prototype.allowedEvents_
2316   * @private
2317   */
2318
2319
2320  EventTarget.prototype.allowedEvents_ = {};
2321  /**
2322   * Adds an `event listener` to an instance of an `EventTarget`. An `event listener` is a
2323   * function that will get called when an event with a certain name gets triggered.
2324   *
2325   * @param {string|string[]} type
2326   *        An event name or an array of event names.
2327   *
2328   * @param {EventTarget~EventListener} fn
2329   *        The function to call with `EventTarget`s
2330   */
2331
2332  EventTarget.prototype.on = function (type, fn) {
2333    // Remove the addEventListener alias before calling Events.on
2334    // so we don't get into an infinite type loop
2335    var ael = this.addEventListener;
2336
2337    this.addEventListener = function () {};
2338
2339    on(this, type, fn);
2340    this.addEventListener = ael;
2341  };
2342  /**
2343   * An alias of {@link EventTarget#on}. Allows `EventTarget` to mimic
2344   * the standard DOM API.
2345   *
2346   * @function
2347   * @see {@link EventTarget#on}
2348   */
2349
2350
2351  EventTarget.prototype.addEventListener = EventTarget.prototype.on;
2352  /**
2353   * Removes an `event listener` for a specific event from an instance of `EventTarget`.
2354   * This makes it so that the `event listener` will no longer get called when the
2355   * named event happens.
2356   *
2357   * @param {string|string[]} type
2358   *        An event name or an array of event names.
2359   *
2360   * @param {EventTarget~EventListener} fn
2361   *        The function to remove.
2362   */
2363
2364  EventTarget.prototype.off = function (type, fn) {
2365    off(this, type, fn);
2366  };
2367  /**
2368   * An alias of {@link EventTarget#off}. Allows `EventTarget` to mimic
2369   * the standard DOM API.
2370   *
2371   * @function
2372   * @see {@link EventTarget#off}
2373   */
2374
2375
2376  EventTarget.prototype.removeEventListener = EventTarget.prototype.off;
2377  /**
2378   * This function will add an `event listener` that gets triggered only once. After the
2379   * first trigger it will get removed. This is like adding an `event listener`
2380   * with {@link EventTarget#on} that calls {@link EventTarget#off} on itself.
2381   *
2382   * @param {string|string[]} type
2383   *        An event name or an array of event names.
2384   *
2385   * @param {EventTarget~EventListener} fn
2386   *        The function to be called once for each event name.
2387   */
2388
2389  EventTarget.prototype.one = function (type, fn) {
2390    // Remove the addEventListener alialing Events.on
2391    // so we don't get into an infinite type loop
2392    var ael = this.addEventListener;
2393
2394    this.addEventListener = function () {};
2395
2396    one(this, type, fn);
2397    this.addEventListener = ael;
2398  };
2399  /**
2400   * This function causes an event to happen. This will then cause any `event listeners`
2401   * that are waiting for that event, to get called. If there are no `event listeners`
2402   * for an event then nothing will happen.
2403   *
2404   * If the name of the `Event` that is being triggered is in `EventTarget.allowedEvents_`.
2405   * Trigger will also call the `on` + `uppercaseEventName` function.
2406   *
2407   * Example:
2408   * 'click' is in `EventTarget.allowedEvents_`, so, trigger will attempt to call
2409   * `onClick` if it exists.
2410   *
2411   * @param {string|EventTarget~Event|Object} event
2412   *        The name of the event, an `Event`, or an object with a key of type set to
2413   *        an event name.
2414   */
2415
2416
2417  EventTarget.prototype.trigger = function (event) {
2418    var type = event.type || event; // deprecation
2419    // In a future version we should default target to `this`
2420    // similar to how we default the target to `elem` in
2421    // `Events.trigger`. Right now the default `target` will be
2422    // `document` due to the `Event.fixEvent` call.
2423
2424    if (typeof event === 'string') {
2425      event = {
2426        type: type
2427      };
2428    }
2429
2430    event = fixEvent(event);
2431
2432    if (this.allowedEvents_[type] && this['on' + type]) {
2433      this['on' + type](event);
2434    }
2435
2436    trigger(this, event);
2437  };
2438  /**
2439   * An alias of {@link EventTarget#trigger}. Allows `EventTarget` to mimic
2440   * the standard DOM API.
2441   *
2442   * @function
2443   * @see {@link EventTarget#trigger}
2444   */
2445
2446
2447  EventTarget.prototype.dispatchEvent = EventTarget.prototype.trigger;
2448  var EVENT_MAP;
2449
2450  EventTarget.prototype.queueTrigger = function (event) {
2451    var _this = this;
2452
2453    // only set up EVENT_MAP if it'll be used
2454    if (!EVENT_MAP) {
2455      EVENT_MAP = new Map();
2456    }
2457
2458    var type = event.type || event;
2459    var map = EVENT_MAP.get(this);
2460
2461    if (!map) {
2462      map = new Map();
2463      EVENT_MAP.set(this, map);
2464    }
2465
2466    var oldTimeout = map.get(type);
2467    map.delete(type);
2468    window$1.clearTimeout(oldTimeout);
2469    var timeout = window$1.setTimeout(function () {
2470      // if we cleared out all timeouts for the current target, delete its map
2471      if (map.size === 0) {
2472        map = null;
2473        EVENT_MAP.delete(_this);
2474      }
2475
2476      _this.trigger(event);
2477    }, 0);
2478    map.set(type, timeout);
2479  };
2480
2481  /**
2482   * @file mixins/evented.js
2483   * @module evented
2484   */
2485  /**
2486   * Returns whether or not an object has had the evented mixin applied.
2487   *
2488   * @param  {Object} object
2489   *         An object to test.
2490   *
2491   * @return {boolean}
2492   *         Whether or not the object appears to be evented.
2493   */
2494
2495  var isEvented = function isEvented(object) {
2496    return object instanceof EventTarget || !!object.eventBusEl_ && ['on', 'one', 'off', 'trigger'].every(function (k) {
2497      return typeof object[k] === 'function';
2498    });
2499  };
2500  /**
2501   * Adds a callback to run after the evented mixin applied.
2502   *
2503   * @param  {Object} object
2504   *         An object to Add
2505   * @param  {Function} callback
2506   *         The callback to run.
2507   */
2508
2509
2510  var addEventedCallback = function addEventedCallback(target, callback) {
2511    if (isEvented(target)) {
2512      callback();
2513    } else {
2514      if (!target.eventedCallbacks) {
2515        target.eventedCallbacks = [];
2516      }
2517
2518      target.eventedCallbacks.push(callback);
2519    }
2520  };
2521  /**
2522   * Whether a value is a valid event type - non-empty string or array.
2523   *
2524   * @private
2525   * @param  {string|Array} type
2526   *         The type value to test.
2527   *
2528   * @return {boolean}
2529   *         Whether or not the type is a valid event type.
2530   */
2531
2532
2533  var isValidEventType = function isValidEventType(type) {
2534    return (// The regex here verifies that the `type` contains at least one non-
2535      // whitespace character.
2536      typeof type === 'string' && /\S/.test(type) || Array.isArray(type) && !!type.length
2537    );
2538  };
2539  /**
2540   * Validates a value to determine if it is a valid event target. Throws if not.
2541   *
2542   * @private
2543   * @throws {Error}
2544   *         If the target does not appear to be a valid event target.
2545   *
2546   * @param  {Object} target
2547   *         The object to test.
2548   */
2549
2550

2551  var validateTarget = function validateTarget(target) {
2552    if (!target.nodeName && !isEvented(target)) {
2553      throw new Error('Invalid target; must be a DOM node or evented object.');
2554    }
2555  };
2556  /**
2557   * Validates a value to determine if it is a valid event target. Throws if not.
2558   *
2559   * @private
2560   * @throws {Error}
2561   *         If the type does not appear to be a valid event type.
2562   *
2563   * @param  {string|Array} type
2564   *         The type to test.
2565   */
2566
2567
2568  var validateEventType = function validateEventType(type) {
2569    if (!isValidEventType(type)) {
2570      throw new Error('Invalid event type; must be a non-empty string or array.');
2571    }
2572  };
2573  /**
2574   * Validates a value to determine if it is a valid listener. Throws if not.
2575   *
2576   * @private
2577   * @throws {Error}
2578   *         If the listener is not a function.
2579   *
2580   * @param  {Function} listener
2581   *         The listener to test.
2582   */
2583
2584
2585  var validateListener = function validateListener(listener) {
2586    if (typeof listener !== 'function') {
2587      throw new Error('Invalid listener; must be a function.');
2588    }
2589  };
2590  /**
2591   * Takes an array of arguments given to `on()` or `one()`, validates them, and
2592   * normalizes them into an object.
2593   *
2594   * @private
2595   * @param  {Object} self
2596   *         The evented object on which `on()` or `one()` was called. This
2597   *         object will be bound as the `this` value for the listener.
2598   *
2599   * @param  {Array} args
2600   *         An array of arguments passed to `on()` or `one()`.
2601   *
2602   * @return {Object}
2603   *         An object containing useful values for `on()` or `one()` calls.
2604   */
2605
2606
2607  var normalizeListenArgs = function normalizeListenArgs(self, args) {
2608    // If the number of arguments is less than 3, the target is always the
2609    // evented object itself.
2610    var isTargetingSelf = args.length < 3 || args[0] === self || args[0] === self.eventBusEl_;
2611    var target;
2612    var type;
2613    var listener;
2614
2615    if (isTargetingSelf) {
2616      target = self.eventBusEl_; // Deal with cases where we got 3 arguments, but we are still listening to
2617      // the evented object itself.
2618
2619      if (args.length >= 3) {
2620        args.shift();
2621      }
2622
2623      type = args[0];
2624      listener = args[1];
2625    } else {
2626      target = args[0];
2627      type = args[1];
2628      listener = args[2];
2629    }
2630
2631    validateTarget(target);
2632    validateEventType(type);
2633    validateListener(listener);
2634    listener = bind(self, listener);
2635    return {
2636      isTargetingSelf: isTargetingSelf,
2637      target: target,
2638      type: type,
2639      listener: listener
2640    };
2641  };
2642  /**
2643   * Adds the listener to the event type(s) on the target, normalizing for
2644   * the type of target.
2645   *
2646   * @private
2647   * @param  {Element|Object} target
2648   *         A DOM node or evented object.
2649   *
2650   * @param  {string} method
2651   *         The event binding method to use ("on" or "one").
2652   *
2653   * @param  {string|Array} type
2654   *         One or more event type(s).
2655   *
2656   * @param  {Function} listener
2657   *         A listener function.
2658   */
2659
2660
2661  var listen = function listen(target, method, type, listener) {
2662    validateTarget(target);
2663
2664    if (target.nodeName) {
2665      Events[method](target, type, listener);
2666    } else {
2667      target[method](type, listener);
2668    }
2669  };
2670  /**
2671   * Contains methods that provide event capabilities to an object which is passed
2672   * to {@link module:evented|evented}.
2673   *
2674   * @mixin EventedMixin
2675   */
2676
2677
2678  var EventedMixin = {
2679    /**
2680     * Add a listener to an event (or events) on this object or another evented
2681     * object.
2682     *
2683     * @param  {string|Array|Element|Object} targetOrType
2684     *         If this is a string or array, it represents the event type(s)
2685     *         that will trigger the listener.
2686     *
2687     *         Another evented object can be passed here instead, which will
2688     *         cause the listener to listen for events on _that_ object.
2689     *
2690     *         In either case, the listener's `this` value will be bound to
2691     *         this object.
2692     *
2693     * @param  {string|Array|Function} typeOrListener
2694     *         If the first argument was a string or array, this should be the
2695     *         listener function. Otherwise, this is a string or array of event
2696     *         type(s).
2697     *
2698     * @param  {Function} [listener]
2699     *         If the first argument was another evented object, this will be
2700     *         the listener function.
2701     */
2702    on: function on$$1() {
2703      var _this = this;
2704
2705      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
2706        args[_key] = arguments[_key];
2707      }
2708
2709      var _normalizeListenArgs = normalizeListenArgs(this, args),
2710          isTargetingSelf = _normalizeListenArgs.isTargetingSelf,
2711          target = _normalizeListenArgs.target,
2712          type = _normalizeListenArgs.type,
2713          listener = _normalizeListenArgs.listener;
2714
2715      listen(target, 'on', type, listener); // If this object is listening to another evented object.
2716
2717      if (!isTargetingSelf) {
2718        // If this object is disposed, remove the listener.
2719        var removeListenerOnDispose = function removeListenerOnDispose() {
2720          return _this.off(target, type, listener);
2721        }; // Use the same function ID as the listener so we can remove it later it
2722        // using the ID of the original listener.
2723
2724
2725        removeListenerOnDispose.guid = listener.guid; // Add a listener to the target's dispose event as well. This ensures
2726        // that if the target is disposed BEFORE this object, we remove the
2727        // removal listener that was just added. Otherwise, we create a memory leak.
2728
2729        var removeRemoverOnTargetDispose = function removeRemoverOnTargetDispose() {
2730          return _this.off('dispose', removeListenerOnDispose);
2731        }; // Use the same function ID as the listener so we can remove it later
2732        // it using the ID of the original listener.
2733
2734
2735        removeRemoverOnTargetDispose.guid = listener.guid;
2736        listen(this, 'on', 'dispose', removeListenerOnDispose);
2737        listen(target, 'on', 'dispose', removeRemoverOnTargetDispose);
2738      }
2739    },
2740
2741    /**
2742     * Add a listener to an event (or events) on this object or another evented
2743     * object. The listener will only be called once and then removed.
2744     *