https://mkurnali.ge/static/videojs/video.js?rhmmg3fkr8il7ul

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$3.pageXOffset || body.scrollLeft;
1091      var left = box.left + scrollLeft - clientLeft;
1092      var clientTop = docEl.clientTop || body.clientTop || 0;
1093      var scrollTop = window$3.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.
1187     * `Array`    | A one-dimensional array of strings, elements, text nodes, or functions. These functions should return a string, element, or text node (any other return value, like an array, will be ignored).
1188     * `Function` | A function, which is expected to return a string, element, text node, or array - any of the other possible values described above. This means that a content descriptor could be a function that returns an array of functions, but those second-level functions must return strings, elements, or text nodes.
1189     *
1190     * @typedef {string|Element|TextNode|Array|Function} module:dom~ContentDescriptor
1191     */
1192  
1193    /**
1194     * Normalizes content for eventual insertion into the DOM.
1195     *
1196     * This allows a wide range of content definition methods, but helps protect
1197     * from falling into the trap of simply writing to `innerHTML`, which could
1198     * be an XSS concern.
1199     *
1200     * The content for an element can be passed in multiple types and
1201     * combinations, whose behavior is as follows:
1202     *
1203     * @param {module:dom~ContentDescriptor} content
1204     *        A content descriptor value.
1205     *
1206     * @return {Array}
1207     *         All of the content that was passed in, normalized to an array of
1208     *         elements or text nodes.
1209     */
1210  
1211    function normalizeContent(content) {
1212      // First, invoke content if it is a function. If it produces an array,
1213      // that needs to happen before normalization.
1214      if (typeof content === 'function') {
1215        content = content();
1216      } // Next up, normalize to an array, so one or many items can be normalized,
1217      // filtered, and returned.
1218  
1219  
1220      return (Array.isArray(content) ? content : [content]).map(function (value) {
1221        // First, invoke value if it is a function to produce a new value,
1222        // which will be subsequently normalized to a Node of some kind.
1223        if (typeof value === 'function') {
1224          value = value();
1225        }
1226  
1227        if (isEl(value) || isTextNode(value)) {
1228          return value;
1229        }
1230  
1231        if (typeof value === 'string' && /\S/.test(value)) {
1232          return document.createTextNode(value);
1233        }
1234      }).filter(function (value) {
1235        return value;
1236      });
1237    }
1238    /**
1239     * Normalizes and appends content to an element.
1240     *
1241     * @param  {Element} el
1242     *         Element to append normalized content to.
1243     *
1244     * @param {module:dom~ContentDescriptor} content
1245     *        A content descriptor value.
1246     *
1247     * @return {Element}
1248     *         The element with appended normalized content.
1249     */
1250  
1251    function appendContent(el, content) {
1252      normalizeContent(content).forEach(function (node) {
1253        return el.appendChild(node);
1254      });
1255      return el;
1256    }
1257    /**
1258     * Normalizes and inserts content into an element; this is identical to
1259     * `appendContent()`, except it empties the element first.
1260     *
1261     * @param {Element} el
1262     *        Element to insert normalized content into.
1263     *
1264     * @param {module:dom~ContentDescriptor} content
1265     *        A content descriptor value.
1266     *
1267     * @return {Element}
1268     *         The element with inserted normalized content.
1269     */
1270  
1271    function insertContent(el, content) {
1272      return appendContent(emptyEl(el), content);
1273    }
1274    /**
1275     * Check if an event was a single left click.
1276     *
1277     * @param  {EventTarget~Event} event
1278     *         Event object.
1279     *
1280     * @return {boolean}
1281     *         Will be `true` if a single left click, `false` otherwise.
1282     */
1283  
1284    function isSingleLeftClick(event) {
1285      // Note: if you create something draggable, be sure to
1286      // call it on both `mousedown` and `mousemove` event,
1287      // otherwise `mousedown` should be enough for a button
1288      if (event.button === undefined && event.buttons === undefined) {
1289        // Why do we need `buttons` ?
1290        // Because, middle mouse sometimes have this:
1291        // e.button === 0 and e.buttons === 4
1292        // Furthermore, we want to prevent combination click, something like
1293        // HOLD middlemouse then left click, that would be
1294        // e.button === 0, e.buttons === 5
1295        // just `button` is not gonna work
1296        // Alright, then what this block does ?
1297        // this is for chrome `simulate mobile devices`
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      __proto__: null,
1365      isReal: isReal,
1366      isEl: isEl,
1367      isInFrame: isInFrame,
1368      createEl: createEl,
1369      textContent: textContent,
1370      prependTo: prependTo,
1371      hasClass: hasClass,
1372      addClass: addClass,
1373      removeClass: removeClass,
1374      toggleClass: toggleClass,
1375      setAttributes: setAttributes,
1376      getAttributes: getAttributes,
1377      getAttribute: getAttribute,
1378      setAttribute: setAttribute,
1379      removeAttribute: removeAttribute,
1380      blockTextSelection: blockTextSelection,
1381      unblockTextSelection: unblockTextSelection,
1382      getBoundingClientRect: getBoundingClientRect,
1383      findPosition: findPosition,
1384      getPointerPosition: getPointerPosition,
1385      isTextNode: isTextNode,
1386      emptyEl: emptyEl,
1387      normalizeContent: normalizeContent,
1388      appendContent: appendContent,
1389      insertContent: insertContent,
1390      isSingleLeftClick: isSingleLeftClick,
1391      $: $,
1392      $$: $$
1393    });
1394  
1395    /**
1396     * @file setup.js - Functions for setting up a player without
1397     * user interaction based on the data-setup `attribute` of the video tag.
1398     *
1399     * @module setup
1400     */
1401    var _windowLoaded = false;
1402    var videojs;
1403    /**
1404     * Set up any tags that have a data-setup `attribute` when the player is started.
1405     */
1406  
1407    var autoSetup = function autoSetup() {
1408      // Protect against breakage in non-browser environments and check global autoSetup option.
1409      if (!isReal() || videojs.options.autoSetup === false) {
1410        return;
1411      }
1412  
1413      var vids = Array.prototype.slice.call(document.getElementsByTagName('video'));
1414      var audios = Array.prototype.slice.call(document.getElementsByTagName('audio'));
1415      var divs = Array.prototype.slice.call(document.getElementsByTagName('video-js'));
1416      var mediaEls = vids.concat(audios, divs); // Check if any media elements exist
1417  
1418      if (mediaEls && mediaEls.length > 0) {
1419        for (var i = 0, e = mediaEls.length; i < e; i++) {
1420          var mediaEl = mediaEls[i]; // Check if element exists, has getAttribute func.
1421  
1422          if (mediaEl && mediaEl.getAttribute) {
1423            // Make sure this player hasn't already been set up.
1424            if (mediaEl.player === undefined) {
1425              var options = mediaEl.getAttribute('data-setup'); // Check if data-setup attr exists.
1426              // We only auto-setup if they've added the data-setup attr.
1427  
1428              if (options !== null) {
1429                // Create new video.js instance.
1430                videojs(mediaEl);
1431              }
1432            } // If getAttribute isn't defined, we need to wait for the DOM.
1433  

1767          old.returnValue = false;
1768          event.defaultPrevented = true;
1769        };
1770  
1771        event.defaultPrevented = false; // Stop the event from bubbling
1772  
1773        event.stopPropagation = function () {
1774          if (old.stopPropagation) {
1775            old.stopPropagation();
1776          }
1777  
1778          event.cancelBubble = true;
1779          old.cancelBubble = true;
1780          event.isPropagationStopped = returnTrue;
1781        };
1782  
1783        event.isPropagationStopped = returnFalse; // Stop the event from bubbling and executing other handlers
1784  
1785        event.stopImmediatePropagation = function () {
1786          if (old.stopImmediatePropagation) {
1787            old.stopImmediatePropagation();
1788          }
1789  
1790          event.isImmediatePropagationStopped = returnTrue;
1791          event.stopPropagation();
1792        };
1793  
1794        event.isImmediatePropagationStopped = returnFalse; // Handle mouse position
1795  
1796        if (event.clientX !== null && event.clientX !== undefined) {
1797          var doc = document.documentElement;
1798          var body = document.body;
1799          event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1800          event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
1801        } // Handle key presses
1802  
1803  
1804        event.which = event.charCode || event.keyCode; // Fix button for mouse clicks:
1805        // 0 == left; 1 == middle; 2 == right
1806  
1807        if (event.button !== null && event.button !== undefined) {
1808          // The following is disabled because it does not pass videojs-standard
1809          // and... yikes.
1810  
1811          /* eslint-disable */
1812          event.button = event.button & 1 ? 0 : event.button & 4 ? 1 : event.button & 2 ? 2 : 0;
1813          /* eslint-enable */
1814        }
1815      }
1816  
1817      event.fixed_ = true; // Returns fixed-up instance
1818  
1819      return event;
1820    }
1821    /**
1822     * Whether passive event listeners are supported
1823     */
1824  
1825    var _supportsPassive;
1826  
1827    var supportsPassive = function supportsPassive() {
1828      if (typeof _supportsPassive !== 'boolean') {
1829        _supportsPassive = false;
1830  
1831        try {
1832          var opts = Object.defineProperty({}, 'passive', {
1833            get: function get() {
1834              _supportsPassive = true;
1835            }
1836          });
1837          window$3.addEventListener('test', null, opts);
1838          window$3.removeEventListener('test', null, opts);
1839        } catch (e) {// disregard
1840        }
1841      }
1842  
1843      return _supportsPassive;
1844    };
1845    /**
1846     * Touch events Chrome expects to be passive
1847     */
1848  
1849  
1850    var passiveEvents = ['touchstart', 'touchmove'];
1851    /**
1852     * Add an event listener to element
1853     * It stores the handler function in a separate cache object
1854     * and adds a generic handler to the element's event,
1855     * along with a unique id (guid) to the element.
1856     *
1857     * @param {Element|Object} elem
1858     *        Element or object to bind listeners to
1859     *
1860     * @param {string|string[]} type
1861     *        Type of event to bind to.
1862     *
1863     * @param {EventTarget~EventListener} fn
1864     *        Event listener.
1865     */
1866  
1867    function on(elem, type, fn) {
1868      if (Array.isArray(type)) {
1869        return _handleMultipleEvents(on, elem, type, fn);
1870      }
1871  
1872      if (!DomData.has(elem)) {
1873        DomData.set(elem, {});
1874      }
1875  
1876      var data = DomData.get(elem); // We need a place to store all our handler data
1877  
1878      if (!data.handlers) {
1879        data.handlers = {};
1880      }
1881  
1882      if (!data.handlers[type]) {
1883        data.handlers[type] = [];
1884      }
1885  
1886      if (!fn.guid) {
1887        fn.guid = newGUID();
1888      }
1889  
1890      data.handlers[type].push(fn);
1891  
1892      if (!data.dispatcher) {
1893        data.disabled = false;
1894  
1895        data.dispatcher = function (event, hash) {
1896          if (data.disabled) {
1897            return;
1898          }
1899  
1900          event = fixEvent(event);
1901          var handlers = data.handlers[event.type];
1902  
1903          if (handlers) {
1904            // Copy handlers so if handlers are added/removed during the process it doesn't throw everything off.
1905            var handlersCopy = handlers.slice(0);
1906  
1907            for (var m = 0, n = handlersCopy.length; m < n; m++) {
1908              if (event.isImmediatePropagationStopped()) {
1909                break;
1910              } else {
1911                try {
1912                  handlersCopy[m].call(elem, event, hash);
1913                } catch (e) {
1914                  log.error(e);
1915                }
1916              }
1917            }
1918          }
1919        };
1920      }
1921  
1922      if (data.handlers[type].length === 1) {
1923        if (elem.addEventListener) {
1924          var options = false;

1925  
1926          if (supportsPassive() && passiveEvents.indexOf(type) > -1) {
1927            options = {
1928              passive: true
1929            };
1930          }
1931  
1932          elem.addEventListener(type, data.dispatcher, options);
1933        } else if (elem.attachEvent) {
1934          elem.attachEvent('on' + type, data.dispatcher);
1935        }
1936      }
1937    }
1938    /**
1939     * Removes event listeners from an element
1940     *
1941     * @param {Element|Object} elem
1942     *        Object to remove listeners from.
1943     *
1944     * @param {string|string[]} [type]
1945     *        Type of listener to remove. Don't include to remove all events from element.
1946     *
1947     * @param {EventTarget~EventListener} [fn]
1948     *        Specific listener to remove. Don't include to remove listeners for an event
1949     *        type.
1950     */
1951  
1952    function off(elem, type, fn) {
1953      // Don't want to add a cache object through getElData if not needed
1954      if (!DomData.has(elem)) {
1955        return;
1956      }
1957  
1958      var data = DomData.get(elem); // If no events exist, nothing to unbind
1959  
1960      if (!data.handlers) {
1961        return;
1962      }
1963  
1964      if (Array.isArray(type)) {
1965        return _handleMultipleEvents(off, elem, type, fn);
1966      } // Utility function
1967  
1968  
1969      var removeType = function removeType(el, t) {
1970        data.handlers[t] = [];
1971  
1972        _cleanUpEvents(el, t);
1973      }; // Are we removing all bound events?
1974  
1975  
1976      if (type === undefined) {
1977        for (var t in data.handlers) {
1978          if (Object.prototype.hasOwnProperty.call(data.handlers || {}, t)) {
1979            removeType(elem, t);
1980          }
1981        }
1982  
1983        return;
1984      }
1985  
1986      var handlers = data.handlers[type]; // If no handlers exist, nothing to unbind
1987  
1988      if (!handlers) {
1989        return;
1990      } // If no listener was provided, remove all listeners for type
1991  
1992  
1993      if (!fn) {
1994        removeType(elem, type);
1995        return;
1996      } // We're only removing a single handler
1997  
1998  
1999      if (fn.guid) {
2000        for (var n = 0; n < handlers.length; n++) {
2001          if (handlers[n].guid === fn.guid) {
2002            handlers.splice(n--, 1);
2003          }
2004        }
2005      }
2006  
2007      _cleanUpEvents(elem, type);
2008    }
2009    /**
2010     * Trigger an event for an element
2011     *
2012     * @param {Element|Object} elem
2013     *        Element to trigger an event on
2014     *
2015     * @param {EventTarget~Event|string} event
2016     *        A string (the type) or an event object with a type attribute
2017     *
2018     * @param {Object} [hash]
2019     *        data hash to pass along with the event
2020     *
2021     * @return {boolean|undefined}
2022     *         Returns the opposite of `defaultPrevented` if default was
2023     *         prevented. Otherwise, returns `undefined`
2024     */
2025  
2026    function trigger(elem, event, hash) {
2027      // Fetches element data and a reference to the parent (for bubbling).
2028      // Don't want to add a data object to cache for every parent,
2029      // so checking hasElData first.
2030      var elemData = DomData.has(elem) ? DomData.get(elem) : {};
2031      var parent = elem.parentNode || elem.ownerDocument; // type = event.type || event,
2032      // handler;
2033      // If an event name was passed as a string, creates an event out of it
2034  
2035      if (typeof event === 'string') {
2036        event = {
2037          type: event,
2038          target: elem
2039        };
2040      } else if (!event.target) {
2041        event.target = elem;
2042      } // Normalizes the event properties.
2043  
2044  
2045      event = fixEvent(event); // If the passed element has a dispatcher, executes the established handlers.
2046  
2047      if (elemData.dispatcher) {
2048        elemData.dispatcher.call(elem, event, hash);
2049      } // Unless explicitly stopped or the event does not bubble (e.g. media events)
2050      // recursively calls this function to bubble the event up the DOM.
2051  
2052  
2053      if (parent && !event.isPropagationStopped() && event.bubbles === true) {
2054        trigger.call(null, parent, event, hash); // If at the top of the DOM, triggers the default action unless disabled.
2055      } else if (!parent && !event.defaultPrevented && event.target && event.target[event.type]) {
2056        if (!DomData.has(event.target)) {
2057          DomData.set(event.target, {});
2058        }
2059  
2060        var targetData = DomData.get(event.target); // Checks if the target has a default action for this event.
2061  
2062        if (event.target[event.type]) {
2063          // Temporarily disables event dispatching on the target as we have already executed the handler.
2064          targetData.disabled = true; // Executes the default action.
2065  
2066          if (typeof event.target[event.type] === 'function') {
2067            event.target[event.type]();
2068          } // Re-enables event dispatching.
2069  
2070  
2071          targetData.disabled = false;
2072        }
2073      } // Inform the triggerer if the default was prevented by returning false
2074  
2075  
2076      return !event.defaultPrevented;
2077    }
2078    /**
2079     * Trigger a listener only once for an event.
2080     *
2081     * @param {Element|Object} elem
2082     *        Element or object to bind to.
2083     *
2084     * @param {string|string[]} type
2085     *        Name/type of event
2086     *
2087     * @param {Event~EventListener} fn
2088     *        Event listener function
2089     */
2090  
2091    function one(elem, type, fn) {
2092      if (Array.isArray(type)) {
2093        return _handleMultipleEvents(one, elem, type, fn);
2094      }
2095  
2096      var func = function func() {
2097        off(elem, type, func);
2098        fn.apply(this, arguments);
2099      }; // copy the guid to the new function so it can removed using the original function's ID
2100  
2101  
2102      func.guid = fn.guid = fn.guid || newGUID();
2103      on(elem, type, func);
2104    }
2105    /**
2106     * Trigger a listener only once and then turn if off for all
2107     * configured events
2108     *
2109     * @param {Element|Object} elem
2110     *        Element or object to bind to.
2111     *
2112     * @param {string|string[]} type
2113     *        Name/type of event
2114     *
2115     * @param {Event~EventListener} fn
2116     *        Event listener function
2117     */
2118  
2119    function any(elem, type, fn) {
2120      var func = function func() {
2121        off(elem, type, func);
2122        fn.apply(this, arguments);
2123      }; // copy the guid to the new function so it can removed using the original function's ID
2124  
2125  
2126      func.guid = fn.guid = fn.guid || newGUID(); // multiple ons, but one off for everything
2127  
2128      on(elem, type, func);
2129    }
2130  
2131    var Events = /*#__PURE__*/Object.freeze({
2132      __proto__: null,
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$3.performance.now();
2200  
2201      var throttled = function throttled() {
2202        var now = window$3.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$3;
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    /**

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$3.clearTimeout(oldTimeout);
2484      var timeout = window$3.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       *
2760       * @param  {string|Array|Element|Object} targetOrType
2761       *         If this is a string or array, it represents the event type(s)
2762       *         that will trigger the listener.
2763       *
2764       *         Another evented object can be passed here instead, which will
2765       *         cause the listener to listen for events on _that_ object.
2766       *
2767       *         In either case, the listener's `this` value will be bound to
2768       *         this object.
2769       *
2770       * @param  {string|Array|Function} typeOrListener
2771       *         If the first argument was a string or array, this should be the
2772       *         listener function. Otherwise, this is a string or array of event
2773       *         type(s).
2774       *
2775       * @param  {Function} [listener]
2776       *         If the first argument was another evented object, this will be
2777       *         the listener function.
2778       */
2779      one: function one() {
2780        var _this2 = this;
2781  
2782        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
2783          args[_key2] = arguments[_key2];
2784        }
2785  
2786        var _normalizeListenArgs2 = normalizeListenArgs(this, args),
2787            isTargetingSelf = _normalizeListenArgs2.isTargetingSelf,
2788            target = _normalizeListenArgs2.target,
2789            type = _normalizeListenArgs2.type,
2790            listener = _normalizeListenArgs2.listener; // Targeting this evented object.
2791  
2792  
2793        if (isTargetingSelf) {
2794          listen(target, 'one', type, listener); // Targeting another evented object.
2795        } else {
2796          // TODO: This wrapper is incorrect! It should only
2797          //       remove the wrapper for the event type that called it.
2798          //       Instead all listners are removed on the first trigger!
2799          //       see https://github.com/videojs/video.js/issues/5962
2800          var wrapper = function wrapper() {
2801            _this2.off(target, type, wrapper);
2802  
2803            for (var _len3 = arguments.length, largs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
2804              largs[_key3] = arguments[_key3];
2805            }
2806  
2807            listener.apply(null, largs);
2808          }; // Use the same function ID as the listener so we can remove it later
2809          // it using the ID of the original listener.
2810  
2811  
2812          wrapper.guid = listener.guid;
2813          listen(target, 'one', type, wrapper);
2814        }
2815      },
2816  
2817      /**
2818       * Add a listener to an event (or events) on this object or another evented
2819       * object. The listener will only be called once for the first event that is triggered
2820       * then removed.
2821       *
2822       * @param  {string|Array|Element|Object} targetOrType
2823       *         If this is a string or array, it represents the event type(s)
2824       *         that will trigger the listener.
2825       *
2826       *         Another evented object can be passed here instead, which will
2827       *         cause the listener to listen for events on _that_ object.
2828       *
2829       *         In either case, the listener's `this` value will be bound to
2830       *         this object.
2831       *
2832       * @param  {string|Array|Function} typeOrListener
2833       *         If the first argument was a string or array, this should be the
2834       *         listener function. Otherwise, this is a string or array of event
2835       *         type(s).
2836       *
2837       * @param  {Function} [listener]
2838       *         If the first argument was another evented object, this will be
2839       *         the listener function.
2840       */
2841      any: function any() {
2842        var _this3 = this;
2843  
2844        for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
2845          args[_key4] = arguments[_key4];
2846        }
2847  
2848        var _normalizeListenArgs3 = normalizeListenArgs(this, args),
2849            isTargetingSelf = _normalizeListenArgs3.isTargetingSelf,
2850            target = _normalizeListenArgs3.target,
2851            type = _normalizeListenArgs3.type,
2852            listener = _normalizeListenArgs3.listener; // Targeting this evented object.
2853  
2854  
2855        if (isTargetingSelf) {
2856          listen(target, 'any', type, listener); // Targeting another evented object.
2857        } else {
2858          var wrapper = function wrapper() {
2859            _this3.off(target, type, wrapper);
2860  
2861            for (var _len5 = arguments.length, largs = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
2862              largs[_key5] = arguments[_key5];
2863            }
2864  
2865            listener.apply(null, largs);
2866          }; // Use the same function ID as the listener so we can remove it later
2867          // it using the ID of the original listener.
2868  
2869  
2870          wrapper.guid = listener.guid;
2871          listen(target, 'any', type, wrapper);
2872        }
2873      },
2874  
2875      /**
2876       * Removes listener(s) from event(s) on an evented object.
2877       *
2878       * @param  {string|Array|Element|Object} [targetOrType]
2879       *         If this is a string or array, it represents the event type(s).
2880       *
2881       *         Another evented object can be passed here instead, in which case
2882       *         ALL 3 arguments are _required_.
2883       *
2884       * @param  {string|Array|Function} [typeOrListener]
2885       *         If the first argument was a string or array, this may be the
2886       *         listener function. Otherwise, this is a string or array of event
2887       *         type(s).
2888       *
2889       * @param  {Function} [listener]
2890       *         If the first argument was another evented object, this will be
2891       *         the listener function; otherwise, _all_ listeners bound to the
2892       *         event type(s) will be removed.
2893       */
2894      off: function off$1(targetOrType, typeOrListener, listener) {
2895        // Targeting this evented object.
2896        if (!targetOrType || isValidEventType(targetOrType)) {
2897          off(this.eventBusEl_, targetOrType, typeOrListener); // Targeting another evented object.
2898        } else {
2899          var target = targetOrType;
2900          var type = typeOrListener; // Fail fast and in a meaningful way!
2901  
2902          validateTarget(target);
2903          validateEventType(type);
2904          validateListener(listener); // Ensure there's at least a guid, even if the function hasn't been used
2905  
2906          listener = bind(this, listener); // Remove the dispose listener on this evented object, which was given
2907          // the same guid as the event listener in on().
2908  
2909          this.off('dispose', listener);
2910  
2911          if (target.nodeName) {
2912            off(target, type, listener);
2913            off(target, 'dispose', listener);
2914          } else if (isEvented(target)) {
2915            target.off(type, listener);
2916            target.off('dispose', listener);
2917          }
2918        }
2919      },
2920  
2921      /**
2922       * Fire an event on this evented object, causing its listeners to be called.
2923       *
2924       * @param   {string|Object} event
2925       *          An event type or an object with a type property.
2926       *
2927       * @param   {Object} [hash]
2928       *          An additional object to pass along to listeners.
2929       *
2930       * @return {boolean}
2931       *          Whether or not the default behavior was prevented.
2932       */
2933      trigger: function trigger$1(event, hash) {
2934        return trigger(this.eventBusEl_, event, hash);
2935      }
2936    };
2937    /**
2938     * Applies {@link module:evented~EventedMixin|EventedMixin} to a target object.
2939     *
2940     * @param  {Object} target
2941     *         The object to which to add event methods.
2942     *
2943     * @param  {Object} [options={}]
2944     *         Options for customizing the mixin behavior.
2945     *
2946     * @param  {string} [options.eventBusKey]
2947     *         By default, adds a `eventBusEl_` DOM element to the target object,
2948     *         which is used as an event bus. If the target object already has a
2949     *         DOM element that should be used, pass its key here.
2950     *
2951     * @return {Object}
2952     *         The target object.
2953     */
2954  
2955    function evented(target, options) {
2956      if (options === void 0) {
2957        options = {};
2958      }
2959  
2960      var _options = options,
2961          eventBusKey = _options.eventBusKey; // Set or create the eventBusEl_.
2962  
2963      if (eventBusKey) {
2964        if (!target[eventBusKey].nodeName) {
2965          throw new Error("The eventBusKey \"" + eventBusKey + "\" does not refer to an element.");
2966        }
2967  
2968        target.eventBusEl_ = target[eventBusKey];
2969      } else {
2970        target.eventBusEl_ = createEl('span', {
2971          className: 'vjs-event-bus'
2972        });
2973      }
2974  
2975      assign(target, EventedMixin);
2976  
2977      if (target.eventedCallbacks) {
2978        target.eventedCallbacks.forEach(function (callback) {
2979          callback();
2980        });
2981      } // When any evented object is disposed, it removes all its listeners.
2982  
2983  
2984      target.on('dispose', function () {
2985        target.off();
2986        window$3.setTimeout(function () {
2987          target.eventBusEl_ = null;
2988        }, 0);
2989      });
2990      return target;
2991    }
2992  
2993    /**
2994     * @file mixins/stateful.js
2995     * @module stateful
2996     */
2997    /**
2998     * Contains methods that provide statefulness to an object which is passed
2999     * to {@link module:stateful}.
3000     *
3001     * @mixin StatefulMixin
3002     */
3003  
3004    var StatefulMixin = {
3005      /**
3006       * A hash containing arbitrary keys and values representing the state of
3007       * the object.
3008       *
3009       * @type {Object}
3010       */
3011      state: {},
3012  
3013      /**
3014       * Set the state of an object by mutating its
3015       * {@link module:stateful~StatefulMixin.state|state} object in place.
3016       *
3017       * @fires   module:stateful~StatefulMixin#statechanged
3018       * @param   {Object|Function} stateUpdates
3019       *          A new set of properties to shallow-merge into the plugin state.
3020       *          Can be a plain object or a function returning a plain object.
3021       *
3022       * @return {Object|undefined}
3023       *          An object containing changes that occurred. If no changes
3024       *          occurred, returns `undefined`.
3025       */
3026      setState: function setState(stateUpdates) {
3027        var _this = this;
3028  
3029        // Support providing the `stateUpdates` state as a function.
3030        if (typeof stateUpdates === 'function') {
3031          stateUpdates = stateUpdates();
3032        }
3033  
3034        var changes;
3035        each(stateUpdates, function (value, key) {
3036          // Record the change if the value is different from what's in the
3037          // current state.
3038          if (_this.state[key] !== value) {
3039            changes = changes || {};
3040            changes[key] = {
3041              from: _this.state[key],
3042              to: value
3043            };
3044          }
3045  
3046          _this.state[key] = value;
3047        }); // Only trigger "statechange" if there were changes AND we have a trigger
3048        // function. This allows us to not require that the target object be an
3049        // evented object.
3050  
3051        if (changes && isEvented(this)) {
3052          /**
3053           * An event triggered on an object that is both
3054           * {@link module:stateful|stateful} and {@link module:evented|evented}
3055           * indicating that its state has changed.
3056           *
3057           * @event    module:stateful~StatefulMixin#statechanged
3058           * @type     {Object}
3059           * @property {Object} changes
3060           *           A hash containing the properties that were changed and
3061           *           the values they were changed `from` and `to`.
3062           */
3063          this.trigger({
3064            changes: changes,
3065            type: 'statechanged'
3066          });
3067        }
3068  
3069        return changes;
3070      }
3071    };
3072    /**
3073     * Applies {@link module:stateful~StatefulMixin|StatefulMixin} to a target
3074     * object.
3075     *
3076     * If the target object is {@link module:evented|evented} and has a
3077     * `handleStateChanged` method, that method will be automatically bound to the
3078     * `statechanged` event on itself.
3079     *
3080     * @param   {Object} target
3081     *          The object to be made stateful.
3082     *
3083     * @param   {Object} [defaultState]
3084     *          A default set of properties to populate the newly-stateful object's
3085     *          `state` property.
3086     *
3087     * @return {Object}
3088     *          Returns the `target`.
3089     */
3090  
3091    function stateful(target, defaultState) {
3092      assign(target, StatefulMixin); // This happens after the mixing-in because we need to replace the `state`
3093      // added in that step.
3094  
3095      target.state = assign({}, target.state, defaultState); // Auto-bind the `handleStateChanged` method of the target object if it exists.
3096  
3097      if (typeof target.handleStateChanged === 'function' && isEvented(target)) {
3098        target.on('statechanged', target.handleStateChanged);
3099      }
3100  
3101      return target;
3102    }
3103  
3104    /**
3105     * @file string-cases.js
3106     * @module to-lower-case
3107     */
3108  
3109    /**
3110     * Lowercase the first letter of a string.
3111     *
3112     * @param {string} string
3113     *        String to be lowercased
3114     *
3115     * @return {string}
3116     *         The string with a lowercased first letter
3117     */
3118    var toLowerCase = function toLowerCase(string) {
3119      if (typeof string !== 'string') {
3120        return string;
3121      }
3122  
3123      return string.replace(/./, function (w) {
3124        return w.toLowerCase();
3125      });
3126    };
3127    /**
3128     * Uppercase the first letter of a string.
3129     *
3130     * @param {string} string
3131     *        String to be uppercased
3132     *
3133     * @return {string}
3134     *         The string with an uppercased first letter
3135     */
3136  
3137    var toTitleCase = function toTitleCase(string) {
3138      if (typeof string !== 'string') {
3139        return string;
3140      }
3141  
3142      return string.replace(/./, function (w) {
3143        return w.toUpperCase();
3144      });
3145    };
3146    /**
3147     * Compares the TitleCase versions of the two strings for equality.
3148     *
3149     * @param {string} str1
3150     *        The first string to compare
3151     *
3152     * @param {string} str2
3153     *        The second string to compare
3154     *
3155     * @return {boolean}
3156     *         Whether the TitleCase versions of the strings are equal
3157     */
3158  
3159    var titleCaseEquals = function titleCaseEquals(str1, str2) {
3160      return toTitleCase(str1) === toTitleCase(str2);
3161    };
3162  
3163    /**
3164     * @file merge-options.js
3165     * @module merge-options
3166     */
3167    /**
3168     * Merge two objects recursively.
3169     *
3170     * Performs a deep merge like
3171     * {@link https://lodash.com/docs/4.17.10#merge|lodash.merge}, but only merges
3172     * plain objects (not arrays, elements, or anything else).
3173     *
3174     * Non-plain object values will be copied directly from the right-most
3175     * argument.
3176     *
3177     * @static
3178     * @param   {Object[]} sources