https://www.pullmanparistoureiffel.fr/js/addons/video.js

120      logByType('log', level, args);
121    }; // This is the logByType helper that the logging methods below use
122
123
124    logByType = LogByTypeFactory(name, log);
125    /**
126     * Create a new sublogger which chains the old name to the new name.
127     *
128     * For example, doing `videojs.log.createLogger('player')` and then using that logger will log the following:
129     * ```js
130     *  mylogger('foo');
131     *  // > VIDEOJS: player: foo
132     * ```
133     *
134     * @param {string} name
135     *        The name to add call the new logger
136     * @return {Object}
137     */
138
139    log.createLogger = function (subname) {
140      return createLogger(name + ': ' + subname);
141    };
142    /**
143     * Enumeration of available logging levels, where the keys are the level names
144     * and the values are `|`-separated strings containing logging methods allowed
145     * in that logging level. These strings are used to create a regular expression
146     * matching the function name being called.
147     *
148     * Levels provided by Video.js are:
149     *
150     * - `off`: Matches no calls. Any value that can be cast to `false` will have
151     *   this effect. The most restrictive.
152     * - `all`: Matches only Video.js-provided functions (`debug`, `log`,
153     *   `log.warn`, and `log.error`).
154     * - `debug`: Matches `log.debug`, `log`, `log.warn`, and `log.error` calls.
155     * - `info` (default): Matches `log`, `log.warn`, and `log.error` calls.
156     * - `warn`: Matches `log.warn` and `log.error` calls.
157     * - `error`: Matches only `log.error` calls.
158     *
159     * @type {Object}
160     */
161
162
163    log.levels = {
164      all: 'debug|log|warn|error',
165      off: '',
166      debug: 'debug|log|warn|error',
167      info: 'log|warn|error',
168      warn: 'warn|error',
169      error: 'error',
170      DEFAULT: level
171    };
172    /**
173     * Get or set the current logging level.
174     *
175     * If a string matching a key from {@link module:log.levels} is provided, acts
176     * as a setter.
177     *
178     * @param  {string} [lvl]
179     *         Pass a valid level to set a new logging level.
180     *
181     * @return {string}
182     *         The current logging level.
183     */
184
185    log.level = function (lvl) {
186      if (typeof lvl === 'string') {
187        if (!log.levels.hasOwnProperty(lvl)) {
188          throw new Error("\"" + lvl + "\" in not a valid log level");
189        }
190
191        level = lvl;
192      }
193
194      return level;
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
206
207    log.history = function () {
208      return history ? [].concat(history) : [];
209    };
210    /**
211     * Allows you to filter the history by the given logger name
212     *
213     * @param {string} fname
214     *        The name to filter by
215     *
216     * @return {Array}
217     *         The filtered list to return
218     */
219
220
221    log.history.filter = function (fname) {
222      return (history || []).filter(function (historyItem) {
223        // if the first item in each historyItem includes `fname`, then it's a match
224        return new RegExp(".*" + fname + ".*").test(historyItem[0]);
225      });
226    };
227    /**
228     * Clears the internal history tracking, but does not prevent further history
229     * tracking.
230     */
231
232
233    log.history.clear = function () {
234      if (history) {
235        history.length = 0;
236      }
237    };
238    /**
239     * Disable history tracking if it is currently enabled.
240     */
241
242
243    log.history.disable = function () {
244      if (history !== null) {
245        history.length = 0;
246        history = null;
247      }
248    };
249    /**
250     * Enable history tracking if it is currently disabled.
251     */
252
253
254    log.history.enable = function () {
255      if (history === null) {
256        history = [];
257      }
258    };
259    /**
260     * Logs error messages. Similar to `console.error`.
261     *
262     * @param {Mixed[]} args
263     *        One or more messages or objects that should be logged as an error
264     */
265
266
267    log.error = function () {
268      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
269        args[_key2] = arguments[_key2];
270      }
271

453    sources.forEach(function (source) {
454      if (!source) {
455        return;
456      }
457
458      each(source, function (value, key) {
459        target[key] = value;
460      });
461    });
462    return target;
463  }
464  /**
465   * Returns whether a value is an object of any kind - including DOM nodes,
466   * arrays, regular expressions, etc. Not functions, though.
467   *
468   * This avoids the gotcha where using `typeof` on a `null` value
469   * results in `'object'`.
470   *
471   * @param  {Object} value
472   * @return {boolean}
473   */
474
475  function isObject(value) {
476    return !!value && typeof value === 'object';
477  }
478  /**
479   * Returns whether an object appears to be a "plain" object - that is, a
480   * direct instance of `Object`.
481   *
482   * @param  {Object} value
483   * @return {boolean}
484   */
485
486  function isPlain(value) {
487    return isObject(value) && toString.call(value) === '[object Object]' && value.constructor === Object;
488  }
489
490  /**
491   * @file computed-style.js
492   * @module computed-style
493   */
494  /**
495   * A safe getComputedStyle.
496   *
497   * This is needed because in Firefox, if the player is loaded in an iframe with
498   * `display:none`, then `getComputedStyle` returns `null`, so, we do a
499   * null-check to make sure that the player doesn't break in these cases.
500   *
501   * @function
502   * @param    {Element} el
503   *           The element you want the computed style of
504   *
505   * @param    {string} prop
506   *           The property name you want
507   *
508   * @see      https://bugzilla.mozilla.org/show_bug.cgi?id=548397
509   */
510
511  function computedStyle(el, prop) {
512    if (!el || !prop) {
513      return '';
514    }
515
516    if (typeof window$1.getComputedStyle === 'function') {
517      var computedStyleValue = window$1.getComputedStyle(el);
518      return computedStyleValue ? computedStyleValue.getPropertyValue(prop) || computedStyleValue[prop] : '';
519    }
520
521    return '';
522  }
523
524  /**
525   * @file dom.js
526   * @module dom
527   */
528  /**
529   * Detect if a value is a string with any non-whitespace characters.
530   *
531   * @private
532   * @param  {string} str
533   *         The string to check
534   *
535   * @return {boolean}
536   *         Will be `true` if the string is non-blank, `false` otherwise.
537   *
538   */
539
540  function isNonBlankString(str) {
541    // we use str.trim as it will trim any whitespace characters
542    // from the front or back of non-whitespace characters. aka
543    // Any string that contains non-whitespace characters will
544    // still contain them after `trim` but whitespace only strings
545    // will have a length of 0, failing this check.
546    return typeof str === 'string' && Boolean(str.trim());
547  }
548  /**
549   * Throws an error if the passed string has whitespace. This is used by
550   * class methods to be relatively consistent with the classList API.
551   *
552   * @private
553   * @param  {string} str
554   *         The string to check for whitespace.
555   *
556   * @throws {Error}
557   *         Throws an error if there is whitespace in the string.
558   */
559
560
561  function throwIfWhitespace(str) {
562    // str.indexOf instead of regex because str.indexOf is faster performance wise.
563    if (str.indexOf(' ') >= 0) {
564      throw new Error('class has illegal whitespace characters');
565    }
566  }
567  /**
568   * Produce a regular expression for matching a className within an elements className.
569   *
570   * @private
571   * @param  {string} className
572   *         The className to generate the RegExp for.
573   *
574   * @return {RegExp}
575   *         The RegExp that will check for a specific `className` in an elements
576   *         className.
577   */
578
579
580  function classRegExp(className) {
581    return new RegExp('(^|\\s)' + className + '($|\\s)');
582  }
583  /**
584   * Whether the current DOM interface appears to be real (i.e. not simulated).
585   *
586   * @return {boolean}
587   *         Will be `true` if the DOM appears to be real, `false` otherwise.
588   */
589
590
591  function isReal() {
592    // Both document and window will never be undefined thanks to `global`.
593    return document === window$1.document;
594  }
595  /**
596   * Determines, via duck typing, whether or not a value is a DOM element.
597   *
598   * @param  {Mixed} value
599   *         The value to check.
600   *
601   * @return {boolean}
602   *         Will be `true` if the value is a DOM element, `false` otherwise.
603   */
604
605  function isEl(value) {
606    return isObject(value) && value.nodeType === 1;
607  }
608  /**
609   * Determines if the current DOM is embedded in an iframe.
610   *
611   * @return {boolean}
612   *         Will be `true` if the DOM is embedded in an iframe, `false`
613   *         otherwise.
614   */
615
616  function isInFrame() {
617    // We need a try/catch here because Safari will throw errors when attempting
618    // to get either `parent` or `self`
619    try {
620      return window$1.parent !== window$1.self;
621    } catch (x) {
622      return true;
623    }
624  }
625  /**
626   * Creates functions to query the DOM using a given method.
627   *
628   * @private
629   * @param   {string} method
630   *          The method to create the query with.
631   *
632   * @return  {Function}
633   *          The query method
634   */
635
636  function createQuerier(method) {
637    return function (selector, context) {
638      if (!isNonBlankString(selector)) {
639        return document[method](null);
640      }
641
642      if (isNonBlankString(context)) {
643        context = document.querySelector(context);
644      }
645
646      var ctx = isEl(context) ? context : document;
647      return ctx[method] && ctx[method](selector);
648    };
649  }
650  /**
651   * Creates an element and applies properties, attributes, and inserts content.
652   *
653   * @param  {string} [tagName='div']
654   *         Name of tag to be created.
655   *
656   * @param  {Object} [properties={}]
657   *         Element properties to be applied.
658   *
659   * @param  {Object} [attributes={}]
660   *         Element attributes to be applied.
661   *
662   * @param {module:dom~ContentDescriptor} content
663   *        A content descriptor object.
664   *
665   * @return {Element}
666   *         The element that was created.
667   */
668
669
670  function createEl(tagName, properties, attributes, content) {
671    if (tagName === void 0) {
672      tagName = 'div';
673    }
674
675    if (properties === void 0) {
676      properties = {};
677    }
678
679    if (attributes === void 0) {
680      attributes = {};
681    }
682
683    var el = document.createElement(tagName);
684    Object.getOwnPropertyNames(properties).forEach(function (propName) {
685      var val = properties[propName]; // See #2176
686      // We originally were accepting both properties and attributes in the
687      // same object, but that doesn't work so well.
688
689      if (propName.indexOf('aria-') !== -1 || propName === 'role' || propName === 'type') {
690        log.warn('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 " + propName + " to " + val + "."));
691        el.setAttribute(propName, val); // Handle textContent since it's not supported everywhere and we have a
692        // method for it.
693      } else if (propName === 'textContent') {
694        textContent(el, val);
695      } else if (el[propName] !== val) {
696        el[propName] = val;
697      }
698    });
699    Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
700      el.setAttribute(attrName, attributes[attrName]);
701    });
702
703    if (content) {
704      appendContent(el, content);
705    }
706
707    return el;
708  }
709  /**
710   * Injects text into an element, replacing any existing contents entirely.
711   *
712   * @param  {Element} el
713   *         The element to add text content into
714   *
715   * @param  {string} text
716   *         The text content to add.
717   *
718   * @return {Element}
719   *         The element with added text content.
720   */
721
722  function textContent(el, text) {
723    if (typeof el.textContent === 'undefined') {
724      el.innerText = text;
725    } else {
726      el.textContent = text;
727    }
728
729    return el;
730  }
731  /**
732   * Insert an element as the first child node of another
733   *
734   * @param {Element} child
735   *        Element to insert
736   *
737   * @param {Element} parent
738   *        Element to insert child into
739   */
740
741  function prependTo(child, parent) {
742    if (parent.firstChild) {
743      parent.insertBefore(child, parent.firstChild);
744    } else {
745      parent.appendChild(child);
746    }
747  }
748  /**
749   * Check if an element has a class name.
750   *
751   * @param  {Element} element
752   *         Element to check
753   *
754   * @param  {string} classToCheck
755   *         Class name to check for
756   *
757   * @return {boolean}
758   *         Will be `true` if the element has a class, `false` otherwise.
759   *
760   * @throws {Error}
761   *         Throws an error if `classToCheck` has white space.
762   */
763
764  function hasClass(element, classToCheck) {
765    throwIfWhitespace(classToCheck);
766
767    if (element.classList) {
768      return element.classList.contains(classToCheck);
769    }
770
771    return classRegExp(classToCheck).test(element.className);
772  }
773  /**
774   * Add a class name to an element.
775   *
776   * @param  {Element} element
777   *         Element to add class name to.
778   *
779   * @param  {string} classToAdd
780   *         Class name to add.
781   *
782   * @return {Element}
783   *         The DOM element with the added class name.
784   */
785
786  function addClass(element, classToAdd) {
787    if (element.classList) {
788      element.classList.add(classToAdd); // Don't need to `throwIfWhitespace` here because `hasElClass` will do it
789      // in the case of classList not being supported.
790    } else if (!hasClass(element, classToAdd)) {
791      element.className = (element.className + ' ' + classToAdd).trim();
792    }
793
794    return element;
795  }
796  /**
797   * Remove a class name from an element.
798   *
799   * @param  {Element} element
800   *         Element to remove a class name from.
801   *
802   * @param  {string} classToRemove
803   *         Class name to remove
804   *
805   * @return {Element}
806   *         The DOM element with class name removed.
807   */
808
809  function removeClass(element, classToRemove) {
810    if (element.classList) {
811      element.classList.remove(classToRemove);
812    } else {
813      throwIfWhitespace(classToRemove);
814      element.className = element.className.split(/\s+/).filter(function (c) {
815        return c !== classToRemove;
816      }).join(' ');
817    }
818
819    return element;
820  }
821  /**
822   * The callback definition for toggleClass.
823   *
824   * @callback module:dom~PredicateCallback
825   * @param    {Element} element
826   *           The DOM element of the Component.
827   *
828   * @param    {string} classToToggle
829   *           The `className` that wants to be toggled
830   *
831   * @return   {boolean|undefined}
832   *           If `true` is returned, the `classToToggle` will be added to the
833   *           `element`. If `false`, the `classToToggle` will be removed from
834   *           the `element`. If `undefined`, the callback will be ignored.
835   */
836
837  /**
838   * Adds or removes a class name to/from an element depending on an optional
839   * condition or the presence/absence of the class name.
840   *
841   * @param  {Element} element
842   *         The element to toggle a class name on.
843   *
844   * @param  {string} classToToggle
845   *         The class that should be toggled.
846   *
847   * @param  {boolean|module:dom~PredicateCallback} [predicate]
848   *         See the return value for {@link module:dom~PredicateCallback}
849   *
850   * @return {Element}
851   *         The element with a class that has been toggled.
852   */
853
854  function toggleClass(element, classToToggle, predicate) {
855    // This CANNOT use `classList` internally because IE11 does not support the
856    // second parameter to the `classList.toggle()` method! Which is fine because
857    // `classList` will be used by the add/remove functions.
858    var has = hasClass(element, classToToggle);
859
860    if (typeof predicate === 'function') {
861      predicate = predicate(element, classToToggle);
862    }
863
864    if (typeof predicate !== 'boolean') {
865      predicate = !has;
866    } // If the necessary class operation matches the current state of the
867    // element, no action is required.
868
869
870    if (predicate === has) {
871      return;
872    }
873
874    if (predicate) {
875      addClass(element, classToToggle);
876    } else {
877      removeClass(element, classToToggle);
878    }
879
880    return element;
881  }
882  /**
883   * Apply attributes to an HTML element.
884   *
885   * @param {Element} el
886   *        Element to add attributes to.
887   *
888   * @param {Object} [attributes]
889   *        Attributes to be applied.
890   */
891
892  function setAttributes(el, attributes) {
893    Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
894      var attrValue = attributes[attrName];
895
896      if (attrValue === null || typeof attrValue === 'undefined' || attrValue === false) {
897        el.removeAttribute(attrName);
898      } else {
899        el.setAttribute(attrName, attrValue === true ? '' : attrValue);
900      }
901    });
902  }
903  /**
904   * Get an element's attribute values, as defined on the HTML tag.
905   *
906   * Attributes are not the same as properties. They're defined on the tag
907   * or with setAttribute.
908   *
909   * @param  {Element} tag
910   *         Element from which to get tag attributes.
911   *
912   * @return {Object}
913   *         All attributes of the element. Boolean attributes will be `true` or
914   *         `false`, others will be strings.
915   */
916
917  function getAttributes(tag) {
918    var obj = {}; // known boolean attributes
919    // we can check for matching boolean properties, but not all browsers
920    // and not all tags know about these attributes, so, we still want to check them manually
921
922    var knownBooleans = ',' + 'autoplay,controls,playsinline,loop,muted,default,defaultMuted' + ',';
923
924    if (tag && tag.attributes && tag.attributes.length > 0) {
925      var attrs = tag.attributes;
926
927      for (var i = attrs.length - 1; i >= 0; i--) {
928        var attrName = attrs[i].name;
929        var attrVal = attrs[i].value; // check for known booleans
930        // the matching element property will return a value for typeof
931
932        if (typeof tag[attrName] === 'boolean' || knownBooleans.indexOf(',' + attrName + ',') !== -1) {
933          // the value of an included boolean attribute is typically an empty
934          // string ('') which would equal false if we just check for a false value.
935          // we also don't want support bad code like autoplay='false'
936          attrVal = attrVal !== null ? true : false;
937        }
938
939        obj[attrName] = attrVal;
940      }
941    }
942
943    return obj;
944  }
945  /**
946   * Get the value of an element's attribute.
947   *
948   * @param {Element} el
949   *        A DOM element.
950   *
951   * @param {string} attribute
952   *        Attribute to get the value of.
953   *
954   * @return {string}
955   *         The value of the attribute.
956   */
957
958  function getAttribute(el, attribute) {
959    return el.getAttribute(attribute);
960  }
961  /**
962   * Set the value of an element's attribute.
963   *
964   * @param {Element} el
965   *        A DOM element.
966   *
967   * @param {string} attribute
968   *        Attribute to set.
969   *
970   * @param {string} value
971   *        Value to set the attribute to.
972   */
973
974  function setAttribute(el, attribute, value) {
975    el.setAttribute(attribute, value);
976  }
977  /**
978   * Remove an element's attribute.
979   *
980   * @param {Element} el
981   *        A DOM element.
982   *
983   * @param {string} attribute
984   *        Attribute to remove.
985   */
986
987  function removeAttribute(el, attribute) {
988    el.removeAttribute(attribute);
989  }
990  /**
991   * Attempt to block the ability to select text.
992   */
993
994  function blockTextSelection() {
995    document.body.focus();
996
997    document.onselectstart = function () {
998      return false;
999    };
1000  }
1001  /**
1002   * Turn off text selection blocking.
1003   */
1004
1005  function unblockTextSelection() {
1006    document.onselectstart = function () {
1007      return true;
1008    };
1009  }
1010  /**
1011   * Identical to the native `getBoundingClientRect` function, but ensures that
1012   * the method is supported at all (it is in all browsers we claim to supp

1301      // I want to support this as well
1302      return true;
1303    }
1304
1305    if (event.button === 0 && event.buttons === undefined) {
1306      // Touch screen, sometimes on some specific device, `buttons`
1307      // doesn't have anything (safari on ios, blackberry...)
1308      return true;
1309    } // `mouseup` event on a single left click has
1310    // `button` and `buttons` equal to 0
1311
1312
1313    if (event.type === 'mouseup' && event.button === 0 && event.buttons === 0) {
1314      return true;
1315    }
1316
1317    if (event.button !== 0 || event.buttons !== 1) {
1318      // This is the reason we have those if else block above
1319      // if any special case we can catch and let it slide
1320      // we do it above, when get to here, this definitely
1321      // is-not-left-click
1322      return false;
1323    }
1324
1325    return true;
1326  }
1327  /**
1328   * Finds a single DOM element matching `selector` within the optional
1329   * `context` of another DOM element (defaulting to `document`).
1330   *
1331   * @param  {string} selector
1332   *         A valid CSS selector, which will be passed to `querySelector`.
1333   *
1334   * @param  {Element|String} [context=document]
1335   *         A DOM element within which to query. Can also be a selector
1336   *         string in which case the first matching element will be used
1337   *         as context. If missing (or no element matches selector), falls
1338   *         back to `document`.
1339   *
1340   * @return {Element|null}
1341   *         The element that was found or null.
1342   */
1343
1344  var $ = createQuerier('querySelector');
1345  /**
1346   * Finds a all DOM elements matching `selector` within the optional
1347   * `context` of another DOM element (defaulting to `document`).
1348   *
1349   * @param  {string} selector
1350   *         A valid CSS selector, which will be passed to `querySelectorAll`.
1351   *
1352   * @param  {Element|String} [context=document]
1353   *         A DOM element within which to query. Can also be a selector
1354   *         string in which case the first matching element will be used
1355   *         as context. If missing (or no element matches selector), falls
1356   *         back to `document`.
1357   *
1358   * @return {NodeList}
1359   *         A element list of elements that were found. Will be empty if none
1360   *         were found.
1361   *
1362   */
1363
1364  var $$ = createQuerier('querySelectorAll');
1365
1366  var Dom = /*#__PURE__*/Object.freeze({
1367    __proto__: null,
1368    isReal: isReal,
1369    isEl: isEl,
1370    isInFrame: isInFrame,
1371    createEl: createEl,
1372    textContent: textContent,
1373    prependTo: prependTo,
1374    hasClass: hasClass,
1375    addClass: addClass,
1376    removeClass: removeClass,
1377    toggleClass: toggleClass,
1378    setAttributes: setAttributes,
1379    getAttributes: getAttributes,
1380    getAttribute: getAttribute,
1381    setAttribute: setAttribute,
1382    removeAttribute: removeAttribute,
1383    blockTextSelection: blockTextSelection,
1384    unblockTextSelection: unblockTextSelection,
1385    getBoundingClientRect: getBoundingClientRect,
1386    findPosition: findPosition,
1387    getPointerPosition: getPointerPosition,
1388    isTextNode: isTextNode,
1389    emptyEl: emptyEl,
1390    normalizeContent: normalizeContent,
1391    appendContent: appendContent,
1392    insertContent: insertContent,
1393    isSingleLeftClick: isSingleLeftClick,
1394    $: $,
1395    $$: $$
1396  });
1397
1398  /**
1399   * @file setup.js - Functions for setting up a player without
1400   * user interaction based on the data-setup `attribute` of the video tag.
1401   *
1402   * @module setup
1403   */
1404  var _windowLoaded = false;
1405  var videojs;
1406  /**
1407   * Set up any tags that have a data-setup `attribute` when the player is started.
1408   */
1409
1410  var autoSetup = function autoSetup() {
1411    // Protect against breakage in non-browser environments and check global autoSetup option.
1412    if (!isReal() || videojs.options.autoSetup === false) {
1413      return;
1414    }
1415
1416    var vids = Array.prototype.slice.call(document.getElementsByTagName('video'));
1417    var audios = Array.prototype.slice.call(document.getElementsByTagName('audio'));
1418    var divs = Array.prototype.slice.call(document.getElementsByTagName('video-js'));
1419    var mediaEls = vids.concat(audios, divs); // Check if any media elements exist
1420
1421    if (mediaEls && mediaEls.length > 0) {
1422      for (var i = 0, e = mediaEls.length; i < e; i++) {
1423        var mediaEl = mediaEls[i]; // Check if element exists, has getAttribute func.
1424
1425        if (mediaEl && mediaEl.getAttribute) {
1426          // Make sure this player hasn't already been set up.
1427          if (mediaEl.player === undefined) {
1428            var options = mediaEl.getAttribute('data-setup'); // Check if data-setup attr exists.
1429            // We only auto-setup if they've added the data-setup attr.
1430
1431            if (options !== null) {
1432              // Create new video.js instance.
1433              videojs(mediaEl);
1434            }
1435          } // If getAttribute isn't defined, we need to wait for the DOM.
1436
1437        } else {
1438          autoSetupTimeout(1);
1439          break;
1440        }
1441      } // No videos were found, so keep looping unless page is finished loading.
1442
1443    } else if (!_windowLoaded) {
1444      autoSetupTimeout(1);
1445    }
1446  };
1447  /**
1448   * Wait until the page is loaded before running autoSetup. This will be called in
1449   * autoSetup if `hasLoaded` returns false.
1450   *
1451   * @param {number} wait
1452   *        How long to wait in ms
1453   *
1454   * @param {module:videojs} [vjs]
1455   *        The videojs library function
1456   */
1457
1458
1459  function autoSetupTimeout(wait, vjs) {
1460    if (vjs) {
1461      videojs = vjs;
1462    }
1463
1464    window$1.setTimeout(autoSetup, wait);
1465  }
1466  /**
1467   * Used to set the internal tracking of window loaded state to true.
1468   *
1469   * @private
1470   */
1471
1472
1473  function setWindowLoaded() {
1474    _windowLoaded = true;
1475    window$1.removeEventListener('load', setWindowLoaded);
1476  }
1477
1478  if (isReal()) {
1479    if (document.readyState === 'complete') {
1480      setWindowLoaded();
1481    } else {
1482      /**
1483       * Listen for the load event on window, and set _windowLoaded to true.
1484       *
1485       * We use a standard event listener here to avoid incrementing the GUID
1486       * before any players are created.
1487       *
1488       * @listens load
1489       */
1490      window$1.addEventListener('load', setWindowLoaded);
1491    }
1492  }
1493
1494  /**
1495   * @file stylesheet.js
1496   * @module stylesheet
1497   */
1498  /**
1499   * Create a DOM syle element given a className for it.
1500   *
1501   * @param {string} className
1502   *        The className to add to the created style element.
1503   *
1504   * @return {Element}
1505   *         The element that was created.
1506   */
1507
1508  var createStyleElement = function createStyleElement(className) {
1509    var style = document.createElement('style');
1510    style.className = className;
1511    return style;
1512  };
1513  /**
1514   * Add text to a DOM element.
1515   *
1516   * @param {Element} el
1517   *        The Element to add text content to.
1518   *
1519   * @param {string} content
1520   *        The text to add to the element.
1521   */
1522
1523  var setTextContent = function setTextContent(el, content) {
1524    if (el.styleSheet) {
1525      el.styleSheet.cssText = content;
1526    } else {
1527      el.textContent = content;
1528    }
1529  };
1530
1531  /**
1532   * @file guid.js
1533   * @module guid
1534   */
1535  // Default value for GUIDs. This allows us to reset the GUID counter in tests.
1536  //
1537  // The initial GUID is 3 because some users have come to rely on the first
1538  // default player ID ending up as `vjs_video_3`.
1539  //
1540  // See: https://github.com/videojs/video.js/pull/6216
1541  var _initialGuid = 3;
1542  /**
1543   * Unique ID for an element or function
1544   *
1545   * @type {Number}
1546   */
1547
1548  var _guid = _initialGuid;
1549  /**
1550   * Get a unique auto-incrementing ID by number that has not been returned before.
1551   *
1552   * @return {number}
1553   *         A new unique ID.
1554   */
1555
1556  function newGUID() {
1557    return _guid++;
1558  }
1559
1560  /**
1561   * @file dom-data.js
1562   * @module dom-data
1563   */
1564  var FakeWeakMap;
1565
1566  if (!window$1.WeakMap) {
1567    FakeWeakMap = /*#__PURE__*/function () {
1568      function FakeWeakMap() {
1569        this.vdata = 'vdata' + Math.floor(window$1.performance && window$1.performance.now() || Date.now());
1570        this.data = {};
1571      }
1572
1573      var _proto = FakeWeakMap.prototype;
1574
1575      _proto.set = function set(key, value) {
1576        var access = key[this.vdata] || newGUID();
1577
1578        if (!key[this.vdata]) {
1579          key[this.vdata] = access;
1580        }
1581
1582        this.data[access] = value;
1583        return this;
1584      };
1585
1586      _proto.get = function get(key) {
1587        var access = key[this.vdata]; // we have data, return it
1588
1589        if (access) {
1590          return this.data[access];
1591        } // we don't have data, return nothing.
1592        // return undefined explicitly as that's the contract for this method
1593
1594
1595        log('We have no data for this element', key);
1596        return undefined;
1597      };
1598
1599      _proto.has = function has(key) {
1600        var access = key[this.vdata];
1601        return access in this.data;
1602      };
1603
1604      _proto["delete"] = function _delete(key) {
1605        var access = key[this.vdata];
1606
1607        if (access) {
1608          delete this.data[access];
1609          delete key[this.vdata];
1610        }
1611      };
1612
1613      return FakeWeakMap;
1614    }();
1615  }
1616  /**
1617   * Element Data Store.
1618   *
1619   * Allows for binding data to an element without putting it directly on the
1620   * element. Ex. Event listeners are stored here.
1621   * (also from jsninja.com, slightly modified and updated for closure compiler)
1622   *
1623   * @type {Object}
1624   * @private
1625   */
1626
1627
1628  var DomData = window$1.WeakMap ? new WeakMap() : new FakeWeakMap();
1629
1630  /**
1631   * @file events.js. An Event System (John Resig - Secrets of a JS Ninja http://jsninja.com/)
1632   * (Original book version wasn't completely usable, so fixed some things and made Closure Compiler compatible)
1633   * This should work very similarly to jQuery's events, however it's based off the book version which isn't as
1634   * robust as jquery's, so there's probably some differences.
1635   *
1636   * @file events.js
1637   * @module events
1638   */
1639  /**
1640   * Clean up the listener cache and dispatchers
1641   *
1642   * @param {Element|Object} elem
1643   *        Element to clean up
1644   *
1645   * @param {string} type
1646   *        Type of event to clean up
1647   */
1648
1649  function _cleanUpEvents(elem, type) {
1650    if (!DomData.has(elem)) {
1651      return;
1652    }
1653
1654    var data = DomData.get(elem); // Remove the events of a particular type if there are none left
1655
1656    if (data.handlers[type].length === 0) {
1657      delete data.handlers[type]; // data.handlers[type] = null;
1658      // Setting to null was causing an error with data.handlers
1659      // Remove the meta-handler from the element
1660
1661      if (elem.removeEventListener) {
1662        elem.removeEventListener(type, data.dispatcher, false);
1663      } else if (elem.detachEvent) {
1664        elem.detachEvent('on' + type, data.dispatcher);
1665      }
1666    } // Remove the events object if there are no types left
1667
1668
1669    if (Object.getOwnPropertyNames(data.handlers).length <= 0) {
1670      delete data.handlers;
1671      delete data.dispatcher;
1672      delete data.disabled;
1673    } // Finally remove the element data if there is no data left
1674
1675
1676    if (Object.getOwnPropertyNames(data).length === 0) {
1677      DomData["delete"](elem);
1678    }
1679  }
1680  /**
1681   * Loops through an array of event types and calls the requested method for each type.
1682   *
1683   * @param {Function} fn
1684   *        The event method we want to use.
1685   *
1686   * @param {Element|Object} elem
1687   *        Element or object to bind listeners to
1688   *
1689   * @param {string} type
1690   *        Type of event to bind to.
1691   *
1692   * @param {EventTarget~EventListener} callback
1693   *        Event listener.
1694   */
1695
1696
1697  function _handleMultipleEvents(fn, elem, types, callback) {
1698    types.forEach(function (type) {
1699      // Call the event method for each one of the types
1700      fn(elem, type, callback);
1701    });
1702  }
1703  /**
1704   * Fix a native event to have standard property values
1705   *
1706   * @param {Object} event
1707   *        Event object to fix.
1708   *
1709   * @return {Object}
1710   *         Fixed event object.
1711   */
1712
1713
1714  function fixEvent(event) {
1715    if (event.fixed_) {
1716      return event;
1717    }
1718
1719    function returnTrue() {
1720      return true;
1721    }
1722
1723    function returnFalse() {
1724      return false;
1725    } // Test if fixing up is needed
1726    // Used to check if !event.stopPropagation instead of isPropagationStopped
1727    // But native events return true for stopPropagation, but don't have
1728    // other expected methods like isPropagationStopped. Seems to be a problem
1729    // with the Javascript Ninja code. So we're just overriding all events now.
1730
1731
1732    if (!event || !event.isPropagationStopped) {
1733      var old = event || window$1.event;
1734      event = {}; // Clone the old object so that we can modify the values event = {};
1735      // IE8 Doesn't like when you mess with native event properties
1736      // Firefox returns false for event.hasOwnProperty('type') and other props
1737      //  which makes copying more difficult.
1738      // TODO: Probably best to create a whitelist of event props
1739
1740      for (var key in old) {
1741        // Safari 6.0.3 warns you if you try to copy deprecated layerX/Y
1742        // Chrome warns you if you try to copy deprecated keyboardEvent.keyLocation
1743        // and webkitMovementX/Y
1744        if (key !== 'layerX' && key !== 'layerY' && key !== 'keyLocation' && key !== 'webkitMovementX' && key !== 'webkitMovementY') {
1745          // Chrome 32+ warns if you try to copy deprecated returnValue, but
1746          // we still want to if preventDefault isn't supported (IE8).
1747          if (!(key === 'returnValue' && old.preventDefault)) {
1748            event[key] = old[key];
1749          }
1750        }
1751      } // The event occurred on this element
1752
1753
1754      if (!event.target) {
1755        event.target = event.srcElement || document;
1756      } // Handle which other element the event is related to
1757
1758
1759      if (!event.relatedTarget) {
1760        event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
1761      } // Stop the default browser action
1762
1763
1764      event.preventDefault = function () {
1765        if (old.preventDefault) {
1766          old.preventDefault();
1767        }
1768
1769        event.returnValue = false;
1770        old.returnValue = false;
1771        event.defaultPrevented = true;
1772      };
1773
1774      event.defaultPrevented = false; // Stop the event from bubbling
1775
1776      event.stopPropagation = function () {
1777        if (old.stopPropagation) {
1778          old.stopPropagation();
1779        }
1780
1781        event.cancelBubble = true;
1782        old.cancelBubble = true;
1783        event.isPropagationStopped = returnTrue;
1784      };
1785
1786      event.isPropagationStopped = returnFalse; // Stop the event from bubbling and executing other handlers
1787
1788      event.stopImmediatePropagation = function () {
1789        if (old.stopImmediatePropagation) {
1790          old.stopImmediatePropagation();
1791        }
1792
1793        event.isImmediatePropagationStopped = returnTrue;
1794        event.stopPropagation();
1795      };
1796
1797      event.isImmediatePropagationStopped = returnFalse; // Handle mouse position
1798
1799      if (event.clientX !== null && event.clientX !== undefined) {
1800        var doc = document.documentElement;
1801        var body = document.body;
1802        event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1803        event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
1804      } // Handle key presses
1805
1806
1807      event.which = event.charCode || event.keyCode; // Fix button for mouse clicks:
1808      // 0 == left; 1 == middle; 2 == right
1809
1810      if (event.button !== null && event.button !== undefined) {
1811        // The following is disabled because it does not pass videojs-standard
1812        // and... yikes.
1813
1814        /* eslint-disable */
1815        event.button = event.button & 1 ? 0 : event.button & 4 ? 1 : event.button & 2 ? 2 : 0;
1816        /* eslint-enable */
1817      }
1818    }
1819
1820    event.fixed_ = true; // Returns fixed-up instance
1821
1822    return event;
1823  }
1824  /**
1825   * Whether passive event listeners are supported
1826   */
1827
1828  var _supportsPassive;
1829
1830  var supportsPassive = function supportsPassive() {
1831    if (typeof _supportsPassive !== 'boolean') {
1832      _supportsPassive = false;
1833
1834      try {
1835        var opts = Object.defineProperty({}, 'passive', {
1836          get: function get() {
1837            _supportsPassive = true;
1838          }
1839        });
1840        window$1.addEventListener('test', null, opts);
1841        window$1.removeEventListener('test', null, opts);
1842      } catch (e) {// disregard
1843      }
1844    }
1845
1846    return _supportsPassive;
1847  };
1848  /**
1849   * Touch events Chrome expects to be passive
1850   */
1851
1852
1853  var passiveEvents = ['touchstart', 'touchmove'];
1854  /**
1855   * Add an event listener to element
1856   * It stores the handler function in a separate cache object
1857   * and adds a generic handler to the element's event,
1858   * along with a unique id (guid) to the element.
1859   *
1860   * @param {Element|Object} elem
1861   *        Element or object to bind listeners to
1862   *
1863   * @param {string|string[]} type
1864   *        Type of event to bind to.
1865   *
1866   * @param {EventTarget~EventListener} fn
1867   *        Event listener.
1868   */
1869
1870  function on(elem, type, fn) {
1871    if (Array.isArray(type)) {
1872      return _handleMultipleEvents(on, elem, type, fn);
1873    }
1874
1875    if (!DomData.has(elem)) {
1876      DomData.set(elem, {});
1877    }
1878
1879    var data = DomData.get(elem); // We need a place to store all our handler data
1880
1881    if (!data.handlers) {
1882      data.handlers = {};
1883    }
1884
1885    if (!data.handlers[type]) {
1886      data.handlers[type] = [];
1887    }
1888
1889    if (!fn.guid) {
1890      fn.guid = newGUID();
1891    }
1892
1893    data.handlers[type].push(fn);
1894
1895    if (!data.dispatcher) {
1896      data.disabled = false;
1897
1898      data.dispatcher = function (event, hash) {
1899        if (data.disabled) {
1900          return;
1901        }
1902
1903        event = fixEvent(event);
1904        var handlers = data.handlers[event.type];
1905
1906        if (handlers) {
1907          // Copy handlers so if handlers are added/removed during the process it doesn't throw everything off.
1908          var handlersCopy = handlers.slice(0);
1909
1910          for (var m = 0, n = handlersCopy.length; m < n; m++) {
1911            if (event.isImmediatePropagationStopped()) {
1912              break;
1913            } else {
1914              try {
1915                handlersCopy[m].call(elem, event, hash);
1916              } catch (e) {
1917                log.error(e);
1918              }
1919            }
1920          }
1921        }
1922      };
1923    }
1924
1925    if (data.handlers[type].length === 1) {
1926      if (elem.addEventListener) {
1927        var options = false;
1928
1929        if (supportsPassive() && passiveEvents.indexOf(type) > -1) {
1930          options = {
1931            passive: true
1932          };
1933        }
1934
1935        elem.addEventListener(type, data.dispatcher, options);
1936      } else if (elem.attachEvent) {
1937        elem.attachEvent('on' + type, data.dispatcher);
1938      }
1939    }
1940  }
1941  /**
1942   * Removes event listeners from an element
1943   *
1944   * @param {Element|Object} elem
1945   *        Object to remove listeners from.
1946   *
1947   * @param {string|string[]} [type]
1948   *        Type of listener to remove. Don't include to remove all events from element.
1949   *
1950   * @param {EventTarget~EventListener} [fn]
1951   *        Specific listener to remove. Don't include to remove listeners for an event
1952   *        type.
1953   */
1954
1955  function off(elem, type, fn) {
1956    // Don't want to add a cache object through getElData if not needed
1957    if (!DomData.has(elem)) {
1958      return;
1959    }
1960
1961    var data = DomData.get(elem); // If no events exist, nothing to unbind
1962
1963    if (!data.handlers) {
1964      return;
1965    }
1966
1967    if (Array.isArray(type)) {
1968      return _handleMultipleEvents(off, elem, type, fn);
1969    } // Utility function
1970
1971
1972    var removeType = function removeType(el, t) {
1973      data.handlers[t] = [];
1974
1975      _cleanUpEvents(el, t);
1976    }; // Are we removing all bound events?
1977
1978
1979    if (type === undefined) {
1980      for (var t in data.handlers) {
1981        if (Object.prototype.hasOwnProperty.call(data.handlers || {}, t)) {
1982          removeType(elem, t);
1983        }
1984      }
1985
1986      return;
1987    }
1988
1989    var handlers = data.handlers[type]; // If no handlers exist, nothing to unbind
1990
1991    if (!handlers) {
1992      return;
1993    } // If no listener was provided, remove all listeners for type
1994
1995
1996    if (!fn) {
1997      removeType(elem, type);
1998      return;
1999    } // We're only removing a single handler
2000
2001
2002    if (fn.guid) {
2003      for (var n = 0; n < handlers.length; n++) {
2004        if (handlers[n].guid === fn.guid) {
2005          handlers.splice(n--, 1);
2006        }
2007      }
2008    }
2009
2010    _cleanUpEvents(elem, type);
2011  }
2012  /**
2013   * Trigger an event for an element
2014   *
2015   * @param {Element|Object} elem
2016   *        Element to trigger an event on
2017   *
2018   * @param {EventTarget~Event|string} event
2019   *        A string (the type) or an event object with a type attribute
2020   *
2021   * @param {Object} [hash]
2022   *        data hash to pass along with the event
2023   *
2024   * @return {boolean|undefined}
2025   *         Returns the opposite of `defaultPrevented` if default was
2026   *         prevented. Otherwise, returns `undefined`
2027   */
2028
2029  function trigger(elem, event, hash) {
2030    // Fetches element data and a reference to the parent (for bubbling).
2031    // Don't want to add a data object to cache for every parent,
2032    // so checking hasElData first.
2033    var elemData = DomData.has(elem) ? DomData.get(elem) : {};
2034    var parent = elem.parentNode || elem.ownerDocument; // type = event.type || event,
2035    // handler;
2036    // If an event name was passed as a string, creates an event out of it
2037
2038    if (typeof event === 'string') {
2039      event = {
2040        type: event,
2041        target: elem
2042      };
2043    } else if (!event.target) {
2044      event.target = elem;
2045    } // Normalizes the event properties.
2046
2047
2048    event = fixEvent(event); // If the passed element has a dispatcher, executes the established handlers.
2049
2050    if (elemData.dispatcher) {
2051      elemData.dispatcher.call(elem, event, hash);
2052    } // Unless explicitly stopped or the event does not bubble (e.g. media events)
2053    // recursively calls this function to bubble the event up the DOM.
2054
2055
2056    if (parent && !event.isPropagationStopped() && event.bubbles === true) {
2057      trigger.call(null, parent, event, hash); // If at the top of the DOM, triggers the default action unless disabled.
2058    } else if (!parent && !event.defaultPrevented && event.target && event.target[event.type]) {
2059      if (!DomData.has(event.target)) {
2060        DomData.set(event.target, {});
2061      }
2062
2063      var targetData = DomData.get(event.target); // Checks if the target has a default action for this event.
2064
2065      if (event.target[event.type]) {
2066        // Temporarily disables event dispatching on the target as we have already executed the handler.
2067        targetData.disabled = true; // Executes the default action.
2068
2069        if (typeof event.target[event.type] === 'function') {
2070          event.target[event.type]();
2071        } // Re-enables event dispatching.
2072
2073
2074        targetData.disabled = false;
2075      }
2076    } // Inform the triggerer if the default was prevented by returning false
2077
2078
2079    return !event.defaultPrevented;
2080  }
2081  /**
2082   * Trigger a listener only once for an event.
2083   *
2084   * @param {Element|Object} elem
2085   *        Element or object to bind to.
2086   *
2087   * @param {string|string[]} type
2088   *        Name/type of event
2089   *
2090   * @param {Event~EventListener} fn
2091   *        Event listener function
2092   */
2093
2094  function one(elem, type, fn) {
2095    if (Array.isArray(type)) {
2096      return _handleMultipleEvents(one, elem, type, fn);
2097    }
2098
2099    var func = function func() {
2100      off(elem, type, func);
2101      fn.apply(this, arguments);
2102    }; // copy the guid to the new function so it can removed using the original function's ID
2103
2104
2105    func.guid = fn.guid = fn.guid || newGUID();
2106    on(elem, type, func);
2107  }
2108  /**
2109   * Trigger a listener only once and then turn if off for all
2110   * configured events
2111   *
2112   * @param {Element|Object} elem
2113   *        Element or object to bind to.
2114   *
2115   * @param {string|string[]} type
2116   *        Name/type of event
2117   *
2118   * @param {Event~EventListener} fn
2119   *        Event listener function
2120   */
2121
2122  function any(elem, type, fn) {
2123    var func = function func() {
2124      off(elem, type, func);
2125      fn.apply(this, arguments);
2126    }; // copy the guid to the new function so it can removed using the original function's ID
2127
2128
2129    func.guid = fn.guid = fn.guid || newGUID(); // multiple ons, but one off for everything
2130
2131    on(elem, type, func);
2132  }
2133
2134  var Events = /*#__PURE__*/Object.freeze({
2135    __proto__: null,
2136    fixEvent: fixEvent,
2137    on: on,
2138    off: off,
2139    trigger: trigger,
2140    one: one,
2141    any: any
2142  });
2143
2144  /**
2145   * @file fn.js
2146   * @module fn
2147   */
2148  var UPDATE_REFRESH_INTERVAL = 30;
2149  /**
2150   * Bind (a.k.a proxy or context). A simple method for changing the context of
2151   * a function.
2152   *
2153   * It also stores a unique id on the function so it can be easily removed from
2154   * events.
2155   *
2156   * @function
2157   * @param    {Mixed} context
2158   *           The object to bind as scope.
2159   *
2160   * @param    {Function} fn
2161   *           The function to be bound to a scope.
2162   *
2163   * @param    {number} [uid]
2164   *           An optional unique ID for the function to be set
2165   *
2166   * @return   {Function}
2167   *           The new function that will be bound into the context given
2168   */
2169
2170  var bind = function bind(context, fn, uid) {
2171    // Make sure the function has a unique ID
2172    if (!fn.guid) {
2173      fn.guid = newGUID();
2174    } // Create the new function that changes the context
2175
2176
2177    var bound = fn.bind(context); // Allow for the ability to individualize this function
2178    // Needed in the case where multiple objects might share the same prototype
2179    // IF both items add an event listener with the same function, then you try to remove just one
2180    // it will remove both because they both have the same guid.
2181    // when using this, you need to use the bind method when you remove the listener as well.
2182    // currently used in text tracks
2183
2184    bound.guid = uid ? uid + '_' + fn.guid : fn.guid;
2185    return bound;
2186  };
2187  /**
2188   * Wraps the given function, `fn`, with a new function that only invokes `fn`
2189   * at most once per every `wait` milliseconds.
2190   *
2191   * @function
2192   * @param    {Function} fn
2193   *           The function to be throttled.
2194   *
2195   * @param    {number}   wait
2196   *           The number of milliseconds by which to throttle.
2197   *
2198   * @return   {Function}
2199   */
2200
2201  var throttle = function throttle(fn, wait) {
2202    var last = window$1.performance.now();
2203
2204    var throttled = function throttled() {
2205      var now = window$1.performance.now();
2206
2207      if (now - last >= wait) {
2208        fn.apply(void 0, arguments);
2209        last = now;
2210      }
2211    };
2212
2213    return throttled;
2214  };
2215  /**
2216   * Creates a debounced function that delays invoking `func` until after `wait`
2217   * milliseconds have elapsed since the last time the debounced function was
2218   * invoked.
2219   *
2220   * Inspired by lodash and underscore implementations.
2221   *
2222   * @function
2223   * @param    {Function} func
2224   *           The function to wrap with debounce behavior.
2225   *
2226   * @param    {number} wait
2227   *           The number of milliseconds to wait after the last invocation.
2228   *
2229   * @param    {boolean} [immediate]
2230   *           Whether or not to invoke the function immediately upon creation.
2231   *
2232   * @param    {Object} [context=window]
2233   *           The "context" in which the debounced function should debounce. For
2234   *           example, if this function should be tied to a Video.js player,
2235   *           the player can be passed here. Alternatively, defaults to the
2236   *           global `window` object.
2237   *
2238   * @return   {Function}
2239   *           A debounced function.
2240   */
2241
2242  var debounce = function debounce(func, wait, immediate, context) {
2243    if (context === void 0) {
2244      context = window$1;
2245    }
2246
2247    var timeout;
2248
2249    var cancel = function cancel() {
2250      context.clearTimeout(timeout);
2251      timeout = null;
2252    };
2253    /* eslint-disable consistent-this */
2254
2255
2256    var debounced = function debounced() {
2257      var self = this;
2258      var args = arguments;
2259
2260      var _later = function later() {
2261        timeout = null;
2262        _later = null;
2263
2264        if (!immediate) {
2265          func.apply(self, args);
2266        }
2267      };
2268
2269      if (!timeout && immediate) {
2270        func.apply(self, args);
2271      }
2272
2273      context.clearTimeout(timeout);
2274      timeout = context.setTimeout(_later, wait);
2275    };
2276    /* eslint-enable consistent-this */
2277
2278
2279    debounced.cancel = cancel;
2280    return debounced;
2281  };
2282
2283  /**
2284   * @file src/js/event-target.js
2285   */
2286  /**
2287   * `EventTarget` is a class that can have the same API as the DOM `EventTarget`. It
2288   * adds shorthand functions that wrap around lengthy functions. For example:
2289   * the `on` function is a wrapper around `addEventListener`.
2290   *
2291   * @see [EventTarget Spec]{@link https://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-EventTarget}
2292   * @class EventTarget
2293   */
2294
2295  var EventTarget = function EventTarget() {};
2296  /**
2297   * A Custom DOM event.
2298   *
2299   * @typedef {Object} EventTarget~Event
2300   * @see [Properties]{@link https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent}
2301   */
2302
2303  /**
2304   * All event listeners should follow the following format.
2305   *
2306   * @callback EventTarget~EventListener
2307   * @this {EventTarget}
2308   *
2309   * @param {EventTarget~Event} event
2310   *        the event that triggered this function
2311   *
2312   * @param {Object} [hash]
2313   *        hash of data sent during the event
2314   */
2315
2316  /**
2317   * An object containing event names as keys and booleans as values.
2318   *
2319   * > NOTE: If an event name is set to a true value here {@link EventTarget#trigger}
2320   *         will have extra functionality. See that function for more information.
2321   *
2322   * @property EventTarget.prototype.allowedEvents_
2323   * @private
2324   */
2325
2326
2327  EventTarget.prototype.allowedEvents_ = {};
2328  /**
2329   * Adds an `event listener` to an instance of an `EventTarget`. An `event listener` is a
2330   * function that will get called when an event with a certain name gets triggered.
2331   *
2332   * @param {string|string[]} type
2333   *        An event name or an array of event names.
2334   *
2335   * @param {EventTarget~EventListener} fn
2336   *        The function to call with `EventTarget`s
2337   */
2338
2339  EventTarget.prototype.on = function (type, fn) {
2340    // Remove the addEventListener alias before calling Events.on
2341    // so we don't get into an infinite type loop
2342    var ael = this.addEventListener;
2343
2344    this.addEventListener = function () {};
2345
2346    on(this, type, fn);
2347    this.addEventListener = ael;
2348  };
2349  /**
2350   * An alias of {@link EventTarget#on}. Allows `EventTarget` to mimic
2351   * the standard DOM API.
2352   *
2353   * @function
2354   * @see {@link EventTarget#on}
2355   */
2356
2357
2358  EventTarget.prototype.addEventListener = EventTarget.prototype.on;
2359  /**
2360   * Removes an `event listener` for a specific event from an instance of `EventTarget`.
2361   * This makes it so that the `event listener` will no longer get called when the
2362   * named event happens.
2363   *
2364   * @param {string|string[]} type
2365   *        An event name or an array of event names.
2366   *
2367   * @param {EventTarget~EventListener} fn
2368   *        The function to remove.
2369   */
2370
2371  EventTarget.prototype.off = function (type, fn) {
2372    off(this, type, fn);
2373  };
2374  /**
2375   * An alias of {@link EventTarget#off}. Allows `EventTarget` to mimic
2376   * the standard DOM API.
2377   *
2378   * @function
2379   * @see {@link EventTarget#off}
2380   */
2381
2382
2383  EventTarget.prototype.removeEventListener = EventTarget.prototype.off;
2384  /**
2385   * This function will add an `event listener` that gets triggered only once. After the
2386   * first trigger it will get removed. This is like adding an `event listener`
2387   * with {@link EventTarget#on} that calls {@link EventTarget#off} on itself.
2388   *
2389   * @param {string|string[]} type
2390   *        An event name or an array of event names.
2391   *
2392   * @param {EventTarget~EventListener} fn
2393   *        The function to be called once for each event name.
2394   */
2395
2396  EventTarget.prototype.one = function (type, fn) {
2397    // Remove the addEventListener aliasing Events.on
2398    // so we don't get into an infinite type loop
2399    var ael = this.addEventListener;
2400
2401    this.addEventListener = function () {};
2402
2403    one(this, type, fn);
2404    this.addEventListener = ael;
2405  };
2406
2407  EventTarget.prototype.any = function (type, fn) {
2408    // Remove the addEventListener aliasing Events.on
2409    // so we don't get into an infinite type loop
2410    var ael = this.addEventListener;
2411
2412    this.addEventListener = function () {};
2413
2414    any(this, type, fn);
2415    this.addEventListener = ael;
2416  };
2417  /**
2418   * This function causes an event to happen. This will then cause any `event listeners`
2419   * that are waiting for that event, to get called. If there are no `event listeners`
2420   * for an event then nothing will happen.
2421   *
2422   * If the name of the `Event` that is being triggered is in `EventTarget.allowedEvents_`.
2423   * Trigger will also call the `on` + `uppercaseEventName` function.
2424   *
2425   * Example:
2426   * 'click' is in `EventTarget.allowedEvents_`, so, trigger will attempt to call
2427   * `onClick` if it exists.
2428   *
2429   * @param {string|EventTarget~Event|Object} event
2430   *        The name of the event, an `Event`, or an object with a key of type set to
2431   *        an event name.
2432   */
2433
2434
2435  EventTarget.prototype.trigger = function (event) {
2436    var type = event.type || event; // deprecation
2437    // In a future version we should default target to `this`
2438    // similar to how we default the target to `elem` in
2439    // `Events.trigger`. Right now the default `target` will be
2440    // `document` due to the `Event.fixEvent` call.
2441
2442    if (typeof event === 'string') {
2443      event = {
2444        type: type
2445      };
2446    }
2447
2448    event = fixEvent(event);
2449
2450    if (this.allowedEvents_[type] && this['on' + type]) {
2451      this['on' + type](event);
2452    }
2453
2454    trigger(this, event);
2455  };
2456  /**
2457   * An alias of {@link EventTarget#trigger}. Allows `EventTarget` to mimic
2458   * the standard DOM API.
2459   *
2460   * @function
2461   * @see {@link EventTarget#trigger}
2462   */
2463
2464
2465  EventTarget.prototype.dispatchEvent = EventTarget.prototype.trigger;
2466  var EVENT_MAP;
2467
2468  EventTarget.prototype.queueTrigger = function (event) {
2469    var _this = this;
2470
2471    // only set up EVENT_MAP if it'll be used
2472    if (!EVENT_MAP) {
2473      EVENT_MAP = new Map();
2474    }
2475
2476    var type = event.type || event;
2477    var map = EVENT_MAP.get(this);
2478
2479    if (!map) {
2480      map = new Map();
2481      EVENT_MAP.set(this, map);
2482    }
2483
2484    var oldTimeout = map.get(type);
2485    map["delete"](type);
2486    window$1.clearTimeout(oldTimeout);
2487    var timeout = window$1.setTimeout(function () {
2488      // if we cleared out all timeouts for the current target, delete its map
2489      if (map.size === 0) {
2490        map = null;
2491        EVENT_MAP["delete"](_this);
2492      }
2493
2494      _this.trigger(event);
2495    }, 0);
2496    map.set(type, timeout);
2497  };
2498
2499  /**
2500   * @file mixins/evented.js
2501   * @module evented
2502   */
2503  /**
2504   * Returns whether or not an object has had the evented mixin applied.
2505   *
2506   * @param  {Object} object
2507   *         An object to test.
2508   *
2509   * @return {boolean}
2510   *         Whether or not the object appears to be evented.
2511   */
2512
2513  var isEvented = function isEvented(object) {
2514    return object instanceof EventTarget || !!object.eventBusEl_ && ['on', 'one', 'off', 'trigger'].every(function (k) {
2515      return typeof object[k] === 'function';
2516    });
2517  };
2518  /**
2519   * Adds a callback to run after the evented mixin applied.
2520   *
2521   * @param  {Object} object
2522   *         An object to Add
2523   * @param  {Function} callback
2524   *         The callback to run.
2525   */
2526
2527
2528  var addEventedCallback = function addEventedCallback(target, callback) {
2529    if (isEvented(target)) {
2530      callback();
2531    } else {
2532      if (!target.eventedCallbacks) {
2533        target.eventedCallbacks = [];
2534      }
2535
2536      target.eventedCallbacks.push(callback);
2537    }
2538  };
2539  /**
2540   * Whether a value is a valid event type - non-empty string or array.
2541   *
2542   * @private
2543   * @param  {string|Array} type
2544   *         The type value to test.
2545   *
2546   * @return {boolean}
2547   *         Whether or not the type is a valid event type.
2548   */
2549
2550
2551  var isValidEventType = function isValidEventType(type) {
2552    return (// The regex here verifies that the `type` contains at least one non-
2553      // whitespace character.
2554      typeof type === 'string' && /\S/.test(type) || Array.isArray(type) && !!type.length
2555    );
2556  };
2557  /**
2558   * Validates a value to determine if it is a valid event target. Throws if not.
2559   *
2560   * @private
2561   * @throws {Error}
2562   *         If the target does not appear to be a valid event target.
2563   *
2564   * @param  {Object} target
2565   *         The object to test.
2566   */
2567
2568

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