https://midlandloftskc.com/wp-content/plugins/wpvr/public/js/video.js?ver=1

1/**
2 * @license
3 * Video.js 7.7.4 <http://videojs.com/>
4 * Copyright Brightcove, Inc. <https://www.brightcove.com/>
5 * Available under Apache License Version 2.0
6 * <https://github.com/videojs/video.js/blob/master/LICENSE>
7 *
8 * Includes vtt.js <https://github.com/mozilla/vtt.js>
9 * Available under Apache License Version 2.0
10 * <https://github.com/mozilla/vtt.js/blob/master/LICENSE>
11 */
12
13(function (global, factory) {
14   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('global/window'), require('global/document')) :
15   typeof define === 'function' && define.amd ? define(['global/window', 'global/document'], factory) :
16   (global = global || self, global.videojs = factory(global.window, global.document));
17 }(this, function (window$1, document) { 'use strict';
18 
19   window$1 = window$1 && window$1.hasOwnProperty('default') ? window$1['default'] : window$1;
20   document = document && document.hasOwnProperty('default') ? document['default'] : document;
21 
22   var version = "7.7.4";
23 
24   /**
25    * @file create-logger.js
26    * @module create-logger
27    */
28 
29   var history = [];
30   /**
31    * Log messages to the console and history based on the type of message
32    *
33    * @private
34    * @param  {string} type
35    *         The name of the console method to use.
36    *
37    * @param  {Array} args
38    *         The arguments to be passed to the matching console method.
39    */
40 
41   var LogByTypeFactory = function LogByTypeFactory(name, log) {
42     return function (type, level, args) {
43       var lvl = log.levels[level];
44       var lvlRegExp = new RegExp("^(" + lvl + ")$");
45 
46       if (type !== 'log') {
47         // Add the type to the front of the message when it's not "log".
48         args.unshift(type.toUpperCase() + ':');
49       } // Add console prefix after adding to history.
50 
51 
52       args.unshift(name + ':'); // Add a clone of the args at this point to history.
53 
54       if (history) {
55         history.push([].concat(args)); // only store 1000 history entries
56 
57         var splice = history.length - 1000;
58         history.splice(0, splice > 0 ? splice : 0);
59       } // If there's no console then don't try to output messages, but they will
60       // still be stored in history.
61 
62 
63       if (!window$1.console) {
64         return;
65       } // Was setting these once outside of this function, but containing them
66       // in the function makes it easier to test cases where console doesn't exist
67       // when the module is executed.
68 
69 
70       var fn = window$1.console[type];
71 
72       if (!fn && type === 'debug') {
73         // Certain browsers don't have support for console.debug. For those, we
74         // should default to the closest comparable log.
75         fn = window$1.console.info || window$1.console.log;
76       } // Bail out if there's no console or if this type is not allowed by the
77       // current logging level.
78 
79 
80       if (!fn || !lvl || !lvlRegExp.test(type)) {
81         return;
82       }
83 
84       fn[Array.isArray(args) ? 'apply' : 'call'](window$1.console, args);
85     };
86   };
87 
88   function createLogger(name) {
89     // This is the private tracking variable for logging level.
90     var level = 'info'; // the curried logByType bound to the specific log and history
91 
92     var logByType;
93     /**
94      * Logs plain debug messages. Similar to `console.log`.
95      *
96      * Due to [limitations](https://github.com/jsdoc3/jsdoc/issues/955#issuecomment-313829149)
97      * of our JSDoc template, we cannot properly document this as both a function
98      * and a namespace, so its function signature is documented here.
99      *
100      * #### Arguments
101      * ##### *args
102      * Mixed[]
103      *
104      * Any combination of values that could be passed to `console.log()`.
105      *
106      * #### Return Value
107      *
108      * `undefined`
109      *
110      * @namespace
111      * @param    {Mixed[]} args
112      *           One or more messages or objects that should be logged.
113      */
114 
115     var log = function log() {
116       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
117         args[_key] = arguments[_key];
118       }
119 
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 

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

995     };
996   }
997   /**
998    * Turn off text selection blocking.
999    */
1000 
1001   function unblockTextSelection() {
1002     document.onselectstart = function () {
1003       return true;
1004     };
1005   }
1006   /**
1007    * Identical to the native `getBoundingClientRect` function, but ensures that
1008    * the method is supported at all (it is in all browsers we claim to support)
1009    * and that the element is in the DOM before continuing.
1010    *
1011    * This wrapper function also shims properties which are not provided by some
1012    * older browsers (namely, IE8).
1013    *
1014    * Additionally, some browsers do not support adding properties to a
1015    * `ClientRect`/`DOMRect` object; so, we shallow-copy it with the standard
1016    * properties (except `x` and `y` which are not widely supported). This helps
1017    * avoid implementations where keys are non-enumerable.
1018    *
1019    * @param  {Element} el
1020    *         Element whose `ClientRect` we want to calculate.
1021    *
1022    * @return {Object|undefined}
1023    *         Always returns a plain object - or `undefined` if it cannot.
1024    */
1025 
1026   function getBoundingClientRect(el) {
1027     if (el && el.getBoundingClientRect && el.parentNode) {
1028       var rect = el.getBoundingClientRect();
1029       var result = {};
1030       ['bottom', 'height', 'left', 'right', 'top', 'width'].forEach(function (k) {
1031         if (rect[k] !== undefined) {
1032           result[k] = rect[k];
1033         }
1034       });
1035 
1036       if (!result.height) {
1037         result.height = parseFloat(computedStyle(el, 'height'));
1038       }
1039 
1040       if (!result.width) {
1041         result.width = parseFloat(computedStyle(el, 'width'));
1042       }
1043 
1044       return result;
1045     }
1046   }
1047   /**
1048    * Represents the position of a DOM element on the page.
1049    *
1050    * @typedef  {Object} module:dom~Position
1051    *
1052    * @property {number} left
1053    *           Pixels to the left.
1054    *
1055    * @property {number} top
1056    *           Pixels from the top.
1057    */
1058 
1059   /**
1060    * Get the position of an element in the DOM.
1061    *
1062    * Uses `getBoundingClientRect` technique from John Resig.
1063    *
1064    * @see http://ejohn.org/blog/getboundingclientrect-is-awesome/
1065    *
1066    * @param  {Element} el
1067    *         Element from which to get offset.
1068    *
1069    * @return {module:dom~Position}
1070    *         The position of the element that was passed in.
1071    */
1072 
1073   function findPosition(el) {
1074     var box;
1075 
1076     if (el.getBoundingClientRect && el.parentNode) {
1077       box = el.getBoundingClientRect();
1078     }
1079 
1080     if (!box) {
1081       return {
1082         left: 0,
1083         top: 0
1084       };
1085     }
1086 
1087     var docEl = document.documentElement;
1088     var body = document.body;
1089     var clientLeft = docEl.clientLeft || body.clientLeft || 0;
1090     var scrollLeft = window$1.pageXOffset || body.scrollLeft;
1091     var left = box.left + scrollLeft - clientLeft;
1092     var clientTop = docEl.clientTop || body.clientTop || 0;
1093     var scrollTop = window$1.pageYOffset || body.scrollTop;
1094     var top = box.top + scrollTop - clientTop; // Android sometimes returns slightly off decimal values, so need to round
1095 
1096     return {
1097       left: Math.round(left),
1098       top: Math.round(top)
1099     };
1100   }
1101   /**
1102    * Represents x and y coordinates for a DOM element or mouse pointer.
1103    *
1104    * @typedef  {Object} module:dom~Coordinates
1105    *
1106    * @property {number} x
1107    *           x coordinate in pixels
1108    *
1109    * @property {number} y
1110    *           y coordinate in pixels
1111    */
1112 
1113   /**
1114    * Get the pointer position within an element.
1115    *
1116    * The base on the coordinates are the bottom left of the element.
1117    *
1118    * @param  {Element} el
1119    *         Element on which to get the pointer position on.
1120    *
1121    * @param  {EventTarget~Event} event
1122    *         Event object.
1123    *
1124    * @return {module:dom~Coordinates}
1125    *         A coordinates object corresponding to the mouse position.
1126    *
1127    */
1128 
1129   function getPointerPosition(el, event) {
1130     var position = {};
1131     var box = findPosition(el);
1132     var boxW = el.offsetWidth;
1133     var boxH = el.offsetHeight;
1134     var boxY = box.top;
1135     var boxX = box.left;
1136     var pageY = event.pageY;
1137     var pageX = event.pageX;
1138 
1139     if (event.changedTouches) {
1140       pageX = event.changedTouches[0].pageX;
1141       pageY = event.changedTouches[0].pageY;
1142     }
1143 
1144     position.y = Math.max(0, Math.min(1, (boxY - pageY + boxH) / boxH));
1145     position.x = Math.max(0, Math.min(1, (pageX - boxX) / boxW));
1146     return position;
1147   }
1148   /**
1149    * Determines, via duck typing, whether or not a value is a text node.
1150    *
1151    * @param  {Mixed} value
1152    *         Check if this value is a text node.
1153    *
1154    * @return {boolean}
1155    *         Will be `true` if the value is a text node, `false` otherwise.
1156    */
1157 
1158   function isTextNode(value) {
1159     return isObject(value) && value.nodeType === 3;
1160   }
1161   /**
1162    * Empties the contents of an element.
1163    *
1164    * @param  {Element} el
1165    *         The element to empty children from
1166    *
1167    * @return {Element}
1168    *         The element with no children
1169    */
1170 
1171   function emptyEl(el) {
1172     while (el.firstChild) {
1173       el.removeChild(el.firstChild);
1174     }
1175 
1176     return el;
1177   }
1178   /**
1179    * This is a mixed value that describes content to be injected into the DOM
1180    * via some method. It can be of the following types:
1181    *
1182    * Type       | Description
1183    * -----------|-------------
1184    * `string`   | The value will be normalized into a text node.
1185    * `Element`  | The value will be accepted as-is.
1186    * `TextNode` | The value will be accepted as-is.

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

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