cloudinary-video-player 2.4.1-edge.8 → 2.4.1

package/dist/cld-video-player.js

@@ -9389,7 +9389,7 @@ class CloudinaryAnalytics {
       this.cloudinaryAnalytics.startManualTracking(metadata, {
         ...(lodash_isPlainObject__WEBPACK_IMPORTED_MODULE_1___default()(this.analyticsOptions) ? this.analyticsOptions : {}),
         videoPlayerType: 'cloudinary video player',
-        videoPlayerVersion: "2.4.1-edge.8"
+        videoPlayerVersion: "2.4.1"
       });
     } else if (this.currentVideMetadata.cloudName !== metadata.cloudName || this.currentVideMetadata.publicId !== metadata.publicId) {
       this.cloudinaryAnalytics.stopManualTracking();
@@ -9762,7 +9762,7 @@ class CloudinaryContext {
       options.sourceTypes = options.sourceTypes || _this.sourceTypes();
       options.poster = options.poster || posterOptionsForCurrent();
       options.queryParams = Object.assign(options.queryParams || {}, options.usageReport ? {
-        _s: `vp-${"2.4.1-edge.8"}`
+        _s: `vp-${"2.4.1"}`
       } : {});
       if (options.sourceTypes.indexOf('audio') > -1) {
         builtSrc = new _models_audio_source_audio_source__WEBPACK_IMPORTED_MODULE_7__["default"](publicId, options);
@@ -11029,7 +11029,7 @@ const contextMenuContent = player => {
   const isFullscreen = player.isFullscreen();
   const aboutMenuItem = {
     class: 'player-version',
-    label: 'Cloudinary Player v' + "2.4.1-edge.8"
+    label: 'Cloudinary Player v' + "2.4.1"
   };
   if (!player.controls()) {
     return [aboutMenuItem];
@@ -13812,7 +13812,7 @@ class VideoPlayer extends _utils__WEBPACK_IMPORTED_MODULE_9__["default"].mixin(_
       const analyticsData = (0,_utils_get_analytics_player_options__WEBPACK_IMPORTED_MODULE_18__.getAnalyticsFromPlayerOptions)(options);
       const analyticsParams = new URLSearchParams(analyticsData).toString();
       const baseParams = new URLSearchParams({
-        vpVersion: "2.4.1-edge.8",
+        vpVersion: "2.4.1",
         vpInstanceId: this.getVPInstanceId(),
         // #if (process.env.WEBPACK_BUILD_LIGHT)
         //         vpLightBuild: true,
@@ -26488,7 +26488,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var mux_js_lib_utils_clock__WEBPACK_IMPORTED_MODULE_14___default = /*#__PURE__*/__webpack_require__.n(mux_js_lib_utils_clock__WEBPACK_IMPORTED_MODULE_14__);
 /**
  * @license
- * Video.js 8.21.0 <http://videojs.com/>
+ * Video.js 8.23.3 <http://videojs.com/>
  * Copyright Brightcove, Inc. <https://www.brightcove.com/>
  * Available under Apache License Version 2.0
  * <https://github.com/videojs/video.js/blob/main/LICENSE>
@@ -26514,7 +26514,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-var version$6 = "8.21.0";
+var version$6 = "8.23.3";
 
 /**
  * An Object that contains lifecycle hooks as keys which point to an array
@@ -31865,10 +31865,14 @@ class Component$1 {
 
       // If we have players that were disposed, then their name will still be
       // in Players.players. So, we must loop through and verify that the value
-      // for each item is not null. This allows registration of the Player component
+      // for each item is null. This allows registration of the Player component
       // after all players have been disposed or before any were created.
-      if (players && playerNames.length > 0 && playerNames.map(pname => players[pname]).every(Boolean)) {
-        throw new Error('Can not register Player component after player has been created.');
+      if (players && playerNames.length > 0) {
+        for (let i = 0; i < playerNames.length; i++) {
+          if (players[playerNames[i]] !== null) {
+            throw new Error('Can not register Player component after player has been created.');
+          }
+        }
       }
     }
     Component$1.components_[name] = ComponentToRegister;
@@ -32447,7 +32451,7 @@ function silencePromise(value) {
  *         A serializable javascript representation of the TextTrack.
  * @private
  */
-const trackToJson_ = function (track) {
+const trackToJson = function (track) {
   const ret = ['kind', 'label', 'language', 'id', 'inBandMetadataTrackDispatchType', 'mode', 'src'].reduce((acc, prop, i) => {
     if (track[prop]) {
       acc[prop] = track[prop];
@@ -32482,7 +32486,7 @@ const textTracksToJson = function (tech) {
   const trackEls = tech.$$('track');
   const trackObjs = Array.prototype.map.call(trackEls, t => t.track);
   const tracks = Array.prototype.map.call(trackEls, function (trackEl) {
-    const json = trackToJson_(trackEl.track);
+    const json = trackToJson(trackEl.track);
     if (trackEl.src) {
       json.src = trackEl.src;
     }
@@ -32490,7 +32494,7 @@ const textTracksToJson = function (tech) {
   });
   return tracks.concat(Array.prototype.filter.call(tech.textTracks(), function (track) {
     return trackObjs.indexOf(track) === -1;
-  }).map(trackToJson_));
+  }).map(trackToJson));
 };
 
 /**
@@ -32516,7 +32520,7 @@ const jsonToTextTracks = function (json, tech) {
 var textTrackConverter = {
   textTracksToJson,
   jsonToTextTracks,
-  trackToJson_
+  trackToJson
 };
 
 /**
@@ -33480,6 +33484,16 @@ class TextTrackList extends TrackList {
       }
     }
   }
+
+  /**
+   * Creates a serializable array of objects that contains serialized copies
+   * of each text track.
+   *
+   * @return {Object[]} A serializable list of objects for the text track list
+   */
+  toJSON() {
+    return this.tracks_.map(track => track.toJSON());
+  }
 }
 
 /**
@@ -33913,11 +33927,9 @@ const getAbsoluteURL = function (url) {
  */
 const getFileExtension = function (path) {
   if (typeof path === 'string') {
-    const splitPathRe = /^(\/?)([\s\S]*?)((?:\.{1,2}|[^\/]+?)(\.([^\.\/\?]+)))(?:[\/]*|[\?].*)$/;
-    const pathParts = splitPathRe.exec(path);
-    if (pathParts) {
-      return pathParts.pop().toLowerCase();
-    }
+    const cleanPath = path.split('?')[0].replace(/\/+$/, '');
+    const match = cleanPath.match(/\.([^.\/]+)$/);
+    return match ? match[1].toLowerCase() : '';
   }
   return '';
 };
@@ -34308,6 +34320,16 @@ class TextTrack extends Track {
     this.cues.setCues_(this.cues_);
   }
 
+  /**
+   * Creates a copy of the text track and makes it serializable
+   * by removing circular dependencies.
+   *
+   * @return {Object} The track information as a serializable object
+   */
+  toJSON() {
+    return textTrackConverter.trackToJson(this);
+  }
+
   /**
    * Remove a cue from our internal list
    *
@@ -36528,7 +36550,7 @@ const SpatialNavKeyCodes = {
 /** @import Player from './player' */
 
 // The number of seconds the `step*` functions move the timeline.
-const STEP_SECONDS$1 = 5;
+const STEP_SECONDS = 5;
 
 /**
  * Spatial Navigation in Video.js enhances user experience and accessibility on smartTV devices,
@@ -36662,10 +36684,10 @@ class SpatialNavigation extends EventTarget$2 {
           }
           break;
         case 'ff':
-          this.userSeek_(this.player_.currentTime() + STEP_SECONDS$1);
+          this.userSeek_(this.player_.currentTime() + STEP_SECONDS);
           break;
         case 'rw':
-          this.userSeek_(this.player_.currentTime() - STEP_SECONDS$1);
+          this.userSeek_(this.player_.currentTime() - STEP_SECONDS);
           break;
       }
     }
@@ -37722,6 +37744,8 @@ class TextTrackDisplay extends Component$1 {
       this.updateDisplay(e);
     };
     player.on('loadstart', e => this.toggleDisplay(e));
+    player.on('useractive', updateDisplayTextHandler);
+    player.on('userinactive', updateDisplayTextHandler);
     player.on('texttrackchange', updateDisplayTextHandler);
     player.on('loadedmetadata', e => {
       this.updateDisplayOverlay();
@@ -37850,11 +37874,14 @@ class TextTrackDisplay extends Component$1 {
   }
 
   /**
-   * Update the displayed TextTrack when a either a {@link Player#texttrackchange} or
-   * a {@link Player#fullscreenchange} is fired.
+   * Update the displayed {@link TextTrack} when either a {@link Player#texttrackchange},
+   * a {@link Player#fullscreenchange}, a {@link Player#useractive}, or a
+   * {@link Player#userinactive} is fired.
    *
    * @listens Player#texttrackchange
    * @listens Player#fullscreenchange
+   * @listens Player#useractive
+   * @listens Player#userinactive
    */
   updateDisplay() {
     const tracks = this.player_.textTracks();
@@ -38276,8 +38303,8 @@ class BigPlayButton extends Button {
   handleClick(event) {
     const playPromise = this.player_.play();
 
-    // exit early if clicked via the mouse
-    if (this.mouseused_ && 'clientX' in event && 'clientY' in event) {
+    // exit early if tapped or clicked via the mouse
+    if (event.type === 'tap' || this.mouseused_ && 'clientX' in event && 'clientY' in event) {
       silencePromise(playPromise);
       if (this.player_.tech(true)) {
         this.player_.tech(true).focus();
@@ -38742,6 +38769,8 @@ class CurrentTimeDisplay extends TimeDisplay {
     let time;
     if (this.player_.ended()) {
       time = this.player_.duration();
+    } else if (event && event.target && typeof event.target.pendingSeekTime === 'function') {
+      time = event.target.pendingSeekTime();
     } else {
       time = this.player_.scrubbing() ? this.player_.getCache().currentTime : this.player_.currentTime();
     }
@@ -39488,6 +39517,10 @@ class Slider extends Component$1 {
         event.stopPropagation();
         this.stepForward();
       } else {
+        if (this.pendingSeekTime()) {
+          this.pendingSeekTime(null);
+          this.userSeek_(this.player_.currentTime());
+        }
         super.handleKeyDown(event);
       }
 
@@ -39873,13 +39906,18 @@ class PlayProgressBar extends Component$1 {
    * @param {number} seekBarPoint
    *        A number from 0 to 1, representing a horizontal reference point
    *        from the left edge of the {@link SeekBar}
+   *
+   * @param {Event} [event]
+   *        The `timeupdate` event that caused this function to run.
    */
-  update(seekBarRect, seekBarPoint) {
+  update(seekBarRect, seekBarPoint, event) {
     const timeTooltip = this.getChild('timeTooltip');
     if (!timeTooltip) {
       return;
     }
-    const time = this.player_.scrubbing() ? this.player_.getCache().currentTime : this.player_.currentTime();
+
+    // Combined logic: if an event with a valid pendingSeekTime getter exists, use it.
+    const time = event && event.target && typeof event.target.pendingSeekTime === 'function' ? event.target.pendingSeekTime() : this.player_.scrubbing() ? this.player_.getCache().currentTime : this.player_.currentTime();
     timeTooltip.updateTime(seekBarRect, seekBarPoint, time);
   }
 }
@@ -39973,12 +40011,6 @@ Component$1.registerComponent('MouseTimeDisplay', MouseTimeDisplay);
  * @file seek-bar.js
  */
 
-// The number of seconds the `step*` functions move the timeline.
-const STEP_SECONDS = 5;
-
-// The multiplier of STEP_SECONDS that PgUp/PgDown move the timeline.
-const PAGE_KEY_MULTIPLIER = 12;
-
 /**
  * Seek bar and container for the progress bars. Uses {@link PlayProgressBar}
  * as its `bar`.
@@ -39994,20 +40026,24 @@ class SeekBar extends Slider {
    *
    * @param {Object} [options]
    *        The key/value store of player options.
+   * @param {number} [options.stepSeconds=5]
+   *        The number of seconds to increment on keyboard control
+   * @param {number} [options.pageMultiplier=12]
+   *        The multiplier of stepSeconds that PgUp/PgDown move the timeline.
    */
   constructor(player, options) {
     options = merge$1(SeekBar.prototype.options_, options);
 
     // Avoid mutating the prototype's `children` array by creating a copy
     options.children = [...options.children];
-    const shouldDisableSeekWhileScrubbingOnMobile = player.options_.disableSeekWhileScrubbingOnMobile && (IS_IOS || IS_ANDROID);
+    const shouldDisableSeekWhileScrubbing = player.options_.disableSeekWhileScrubbingOnMobile && (IS_IOS || IS_ANDROID) || player.options_.disableSeekWhileScrubbingOnSTV;
 
     // Add the TimeTooltip as a child if we are on desktop, or on mobile with `disableSeekWhileScrubbingOnMobile: true`
-    if (!IS_IOS && !IS_ANDROID || shouldDisableSeekWhileScrubbingOnMobile) {
+    if (!IS_IOS && !IS_ANDROID || shouldDisableSeekWhileScrubbing) {
       options.children.splice(1, 0, 'mouseTimeDisplay');
     }
     super(player, options);
-    this.shouldDisableSeekWhileScrubbingOnMobile_ = shouldDisableSeekWhileScrubbingOnMobile;
+    this.shouldDisableSeekWhileScrubbing_ = shouldDisableSeekWhileScrubbing;
     this.pendingSeekTime_ = null;
     this.setEventHandlers_();
   }
@@ -40124,7 +40160,7 @@ class SeekBar extends Slider {
 
       // update the progress bar time tooltip with the current time
       if (this.bar) {
-        this.bar.update(getBoundingClientRect(this.el()), this.getProgress());
+        this.bar.update(getBoundingClientRect(this.el()), this.getProgress(), event);
       }
     });
     return percent;
@@ -40157,6 +40193,25 @@ class SeekBar extends Slider {
     return this.player_.scrubbing() ? this.player_.getCache().currentTime : this.player_.currentTime();
   }
 
+  /**
+   * Getter and setter for pendingSeekTime.
+   * Ensures the value is clamped between 0 and duration.
+   *
+   * @param {number|null} [time] - Optional. The new pending seek time, can be a number or null.
+   * @return {number|null} - The current pending seek time.
+   */
+  pendingSeekTime(time) {
+    if (time !== undefined) {
+      if (time !== null) {
+        const duration = this.player_.duration();
+        this.pendingSeekTime_ = Math.max(0, Math.min(time, duration));
+      } else {
+        this.pendingSeekTime_ = null;
+      }
+    }
+    return this.pendingSeekTime_;
+  }
+
   /**
    * Get the percentage of media played so far.
    *
@@ -40166,8 +40221,8 @@ class SeekBar extends Slider {
   getPercent() {
     // If we have a pending seek time, we are scrubbing on mobile and should set the slider percent
     // to reflect the current scrub location.
-    if (this.pendingSeekTime_) {
-      return this.pendingSeekTime_ / this.player_.duration();
+    if (this.pendingSeekTime() !== null) {
+      return this.pendingSeekTime() / this.player_.duration();
     }
     const currentTime = this.getCurrentTime_();
     let percent;
@@ -40204,7 +40259,7 @@ class SeekBar extends Slider {
 
     // Don't pause if we are on mobile and `disableSeekWhileScrubbingOnMobile: true`.
     // In that case, playback should continue while the player scrubs to a new location.
-    if (!this.shouldDisableSeekWhileScrubbingOnMobile_) {
+    if (!this.shouldDisableSeekWhileScrubbing_) {
       this.player_.pause();
     }
     super.handleMouseDown(event);
@@ -40265,8 +40320,8 @@ class SeekBar extends Slider {
     }
 
     // if on mobile and `disableSeekWhileScrubbingOnMobile: true`, keep track of the desired seek point but we won't initiate the seek until 'touchend'
-    if (this.shouldDisableSeekWhileScrubbingOnMobile_) {
-      this.pendingSeekTime_ = newTime;
+    if (this.shouldDisableSeekWhileScrubbing_) {
+      this.pendingSeekTime(newTime);
     } else {
       this.userSeek_(newTime);
     }
@@ -40309,9 +40364,9 @@ class SeekBar extends Slider {
     this.player_.scrubbing(false);
 
     // If we have a pending seek time, then we have finished scrubbing on mobile and should initiate a seek.
-    if (this.pendingSeekTime_) {
-      this.userSeek_(this.pendingSeekTime_);
-      this.pendingSeekTime_ = null;
+    if (this.pendingSeekTime() !== null) {
+      this.userSeek_(this.pendingSeekTime());
+      this.pendingSeekTime(null);
     }
 
     /**
@@ -40335,18 +40390,46 @@ class SeekBar extends Slider {
     }
   }
 
+  /**
+   * Handles pending seek time when `disableSeekWhileScrubbingOnSTV` is enabled.
+   *
+   * @param {number} stepAmount - The number of seconds to step (positive for forward, negative for backward).
+   */
+  handlePendingSeek_(stepAmount) {
+    if (!this.player_.paused()) {
+      this.player_.pause();
+    }
+    const currentPos = this.pendingSeekTime() !== null ? this.pendingSeekTime() : this.player_.currentTime();
+    this.pendingSeekTime(currentPos + stepAmount);
+    this.player_.trigger({
+      type: 'timeupdate',
+      target: this,
+      manuallyTriggered: true
+    });
+  }
+
   /**
    * Move more quickly fast forward for keyboard-only users
    */
   stepForward() {
-    this.userSeek_(this.player_.currentTime() + STEP_SECONDS);
+    // if `disableSeekWhileScrubbingOnSTV: true`, keep track of the desired seek point but we won't initiate the seek
+    if (this.shouldDisableSeekWhileScrubbing_) {
+      this.handlePendingSeek_(this.options().stepSeconds);
+    } else {
+      this.userSeek_(this.player_.currentTime() + this.options().stepSeconds);
+    }
   }
 
   /**
    * Move more quickly rewind for keyboard-only users
    */
   stepBack() {
-    this.userSeek_(this.player_.currentTime() - STEP_SECONDS);
+    // if `disableSeekWhileScrubbingOnSTV: true`, keep track of the desired seek point but we won't initiate the seek
+    if (this.shouldDisableSeekWhileScrubbing_) {
+      this.handlePendingSeek_(-this.options().stepSeconds);
+    } else {
+      this.userSeek_(this.player_.currentTime() - this.options().stepSeconds);
+    }
   }
 
   /**
@@ -40358,6 +40441,10 @@ class SeekBar extends Slider {
    *
    */
   handleAction(event) {
+    if (this.pendingSeekTime() !== null) {
+      this.userSeek_(this.pendingSeekTime());
+      this.pendingSeekTime(null);
+    }
     if (this.player_.paused()) {
       this.player_.play();
     } else {
@@ -40411,11 +40498,11 @@ class SeekBar extends Slider {
     } else if (event.key === 'PageDown') {
       event.preventDefault();
       event.stopPropagation();
-      this.userSeek_(this.player_.currentTime() - STEP_SECONDS * PAGE_KEY_MULTIPLIER);
+      this.userSeek_(this.player_.currentTime() - this.options().stepSeconds * this.options().pageMultiplier);
     } else if (event.key === 'PageUp') {
       event.preventDefault();
       event.stopPropagation();
-      this.userSeek_(this.player_.currentTime() + STEP_SECONDS * PAGE_KEY_MULTIPLIER);
+      this.userSeek_(this.player_.currentTime() + this.options().stepSeconds * this.options().pageMultiplier);
     } else {
       // Pass keydown handling up for unsupported keys
       super.handleKeyDown(event);
@@ -40448,7 +40535,9 @@ class SeekBar extends Slider {
  */
 SeekBar.prototype.options_ = {
   children: ['loadProgressBar', 'playProgressBar'],
-  barName: 'playProgressBar'
+  barName: 'playProgressBar',
+  stepSeconds: 5,
+  pageMultiplier: 12
 };
 Component$1.registerComponent('SeekBar', SeekBar);
 
@@ -44735,22 +44824,22 @@ class TrackSettingsControls extends Component$1 {
     super(player, options);
 
     // Create DOM elements
-    const defaultsDescription = this.localize('restore all settings to the default values');
     const resetButton = new Button(player, {
-      controlText: defaultsDescription,
+      controlText: this.localize('restore all settings to the default values'),
       className: 'vjs-default-button'
     });
     resetButton.el().classList.remove('vjs-control', 'vjs-button');
     resetButton.el().textContent = this.localize('Reset');
     this.addChild(resetButton);
+    const doneText = this.localize('Done');
     const doneButton = new Button(player, {
-      controlText: defaultsDescription,
+      controlText: doneText,
       className: 'vjs-done-button'
     });
 
     // Remove unrequired style classes
     doneButton.el().classList.remove('vjs-control', 'vjs-button');
-    doneButton.el().textContent = this.localize('Done');
+    doneButton.el().textContent = doneText;
     this.addChild(doneButton);
   }
 
@@ -48088,8 +48177,12 @@ Tech.registerTech('Html5', Html5);
  * @file player.js
  */
 
-/** @import { TimeRange } from './utils/time' */
+/** @import AudioTrackList from './tracks/audio-track-list' */
 /** @import HtmlTrackElement from './tracks/html-track-element' */
+/** @import HtmlTrackElementList from './tracks/html-track-element-list' */
+/** @import TextTrackList from './tracks/text-track-list' */
+/** @import { TimeRange } from './utils/time' */
+/** @import VideoTrackList from './tracks/video-track-list' */
 
 /**
  * @callback PlayerReadyCallback
@@ -53079,6 +53172,7 @@ class Player extends Component$1 {
  *
  * @method Player.prototype.videoTracks
  */
+Player.prototype.videoTracks = () => {};
 
 /**
  * Get the {@link AudioTrackList}
@@ -53090,6 +53184,7 @@ class Player extends Component$1 {
  *
  * @method Player.prototype.audioTracks
  */
+Player.prototype.audioTracks = () => {};
 
 /**
  * Get the {@link TextTrackList}
@@ -53101,6 +53196,7 @@ class Player extends Component$1 {
  *
  * @method Player.prototype.textTracks
  */
+Player.prototype.textTracks = () => {};
 
 /**
  * Get the remote {@link TextTrackList}
@@ -53110,6 +53206,7 @@ class Player extends Component$1 {
  *
  * @method Player.prototype.remoteTextTracks
  */
+Player.prototype.remoteTextTracks = () => {};
 
 /**
  * Get the remote {@link HtmlTrackElementList} tracks.
@@ -53119,7 +53216,7 @@ class Player extends Component$1 {
  *
  * @method Player.prototype.remoteTextTrackEls
  */
-
+Player.prototype.remoteTextTrackEls = () => {};
 ALL.names.forEach(function (name) {
   const props = ALL[name];
   Player.prototype[props.getterName] = function () {
@@ -53206,7 +53303,8 @@ Player.prototype.options_ = {
   },
   // Default smooth seeking to false
   enableSmoothSeeking: false,
-  disableSeekWhileScrubbingOnMobile: false
+  disableSeekWhileScrubbingOnMobile: false,
+  disableSeekWhileScrubbingOnSTV: false
 };
 TECH_EVENTS_RETRIGGER.forEach(function (event) {
   Player.prototype[`handleTech${toTitleCase$1(event)}_`] = function () {
@@ -54298,9 +54396,13 @@ videojs.trigger = trigger;
  * @see      https://github.com/Raynos/xhr
  */
 videojs.xhr = (_videojs_xhr__WEBPACK_IMPORTED_MODULE_2___default());
+videojs.TrackList = TrackList;
 videojs.TextTrack = TextTrack;
+videojs.TextTrackList = TextTrackList;
 videojs.AudioTrack = AudioTrack;
+videojs.AudioTrackList = AudioTrackList;
 videojs.VideoTrack = VideoTrack;
+videojs.VideoTrackList = VideoTrackList;
 ['isEl', 'isTextNode', 'createEl', 'hasClass', 'addClass', 'removeClass', 'toggleClass', 'setAttributes', 'getAttributes', 'emptyEl', 'appendContent', 'insertContent'].forEach(k => {
   videojs[k] = function () {
     log$1.warn(`videojs.${k}() is deprecated; use videojs.dom.${k}() instead`);
@@ -54624,7 +54726,7 @@ videojs.registerPlugin('qualityLevels', qualityLevels);
 // Include the version number.
 qualityLevels.VERSION = version$5;
 
-/*! @name @videojs/http-streaming @version 3.16.2 @license Apache-2.0 */
+/*! @name @videojs/http-streaming @version 3.17.0 @license Apache-2.0 */
 
 /**
  * @file resolve-url.js - Handling how URLs are resolved and manipulated
@@ -56137,6 +56239,110 @@ const getStreamingNetworkErrorMetadata = ({
   }
   return errorMetadata;
 };
+
+/**
+ * @file - codecs.js - Handles tasks regarding codec strings such as translating them to
+ * codec strings, or translating codec strings into objects that can be examined.
+ */
+const logFn$1 = logger('CodecUtils');
+/**
+ * Returns a set of codec strings parsed from the playlist or the default
+ * codec strings if no codecs were specified in the playlist
+ *
+ * @param {Playlist} media the current media playlist
+ * @return {Object} an object with the video and audio codecs
+ */
+
+const getCodecs = function (media) {
+  // if the codecs were explicitly specified, use them instead of the
+  // defaults
+  const mediaAttributes = media.attributes || {};
+  if (mediaAttributes.CODECS) {
+    return (0,_videojs_vhs_utils_es_codecs_js__WEBPACK_IMPORTED_MODULE_7__.parseCodecs)(mediaAttributes.CODECS);
+  }
+};
+const isMaat = (main, media) => {
+  const mediaAttributes = media.attributes || {};
+  return main && main.mediaGroups && main.mediaGroups.AUDIO && mediaAttributes.AUDIO && main.mediaGroups.AUDIO[mediaAttributes.AUDIO];
+};
+const isMuxed = (main, media) => {
+  if (!isMaat(main, media)) {
+    return true;
+  }
+  const mediaAttributes = media.attributes || {};
+  const audioGroup = main.mediaGroups.AUDIO[mediaAttributes.AUDIO];
+  for (const groupId in audioGroup) {
+    // If an audio group has a URI (the case for HLS, as HLS will use external playlists),
+    // or there are listed playlists (the case for DASH, as the manifest will have already
+    // provided all of the details necessary to generate the audio playlist, as opposed to
+    // HLS' externally requested playlists), then the content is demuxed.
+    if (!audioGroup[groupId].uri && !audioGroup[groupId].playlists) {
+      return true;
+    }
+  }
+  return false;
+};
+const unwrapCodecList = function (codecList) {
+  const codecs = {};
+  codecList.forEach(({
+    mediaType,
+    type,
+    details
+  }) => {
+    codecs[mediaType] = codecs[mediaType] || [];
+    codecs[mediaType].push((0,_videojs_vhs_utils_es_codecs_js__WEBPACK_IMPORTED_MODULE_7__.translateLegacyCodec)(`${type}${details}`));
+  });
+  Object.keys(codecs).forEach(function (mediaType) {
+    if (codecs[mediaType].length > 1) {
+      logFn$1(`multiple ${mediaType} codecs found as attributes: ${codecs[mediaType].join(', ')}. Setting playlist codecs to null so that we wait for mux.js to probe segments for real codecs.`);
+      codecs[mediaType] = null;
+      return;
+    }
+    codecs[mediaType] = codecs[mediaType][0];
+  });
+  return codecs;
+};
+const codecCount = function (codecObj) {
+  let count = 0;
+  if (codecObj.audio) {
+    count++;
+  }
+  if (codecObj.video) {
+    count++;
+  }
+  return count;
+};
+/**
+ * Calculates the codec strings for a working configuration of
+ * SourceBuffers to play variant streams in a main playlist. If
+ * there is no possible working configuration, an empty object will be
+ * returned.
+ *
+ * @param main {Object} the m3u8 object for the main playlist
+ * @param media {Object} the m3u8 object for the variant playlist
+ * @return {Object} the codec strings.
+ *
+ * @private
+ */
+
+const codecsForPlaylist = function (main, media) {
+  const mediaAttributes = media.attributes || {};
+  const codecInfo = unwrapCodecList(getCodecs(media) || []); // HLS with multiple-audio tracks must always get an audio codec.
+  // Put another way, there is no way to have a video-only multiple-audio HLS!
+
+  if (isMaat(main, media) && !codecInfo.audio) {
+    if (!isMuxed(main, media)) {
+      // It is possible for codecs to be specified on the audio media group playlist but
+      // not on the rendition playlist. This is mostly the case for DASH, where audio and
+      // video are always separate (and separately specified).
+      const defaultCodecs = unwrapCodecList((0,_videojs_vhs_utils_es_codecs_js__WEBPACK_IMPORTED_MODULE_7__.codecsFromDefault)(main, mediaAttributes.AUDIO) || []);
+      if (defaultCodecs.audio) {
+        codecInfo.audio = defaultCodecs.audio;
+      }
+    }
+  }
+  return codecInfo;
+};
 const {
   EventTarget: EventTarget$1
 } = videojs;
@@ -56572,7 +56778,7 @@ class PlaylistLoader extends EventTarget$1 {
     manifestString
   }) {
     try {
-      return parseManifest({
+      const parsed = parseManifest({
         onwarn: ({
           message
         }) => this.logger_(`m3u8-parser warn for ${url}: ${message}`),
@@ -56584,6 +56790,16 @@ class PlaylistLoader extends EventTarget$1 {
         customTagMappers: this.customTagMappers,
         llhls: this.llhls
       });
+      /**
+       * VHS does not support switching between variants with and without audio and video
+       * so we want to filter out audio-only variants when variants with video and(or) audio are also detected.
+       */
+
+      if (!parsed.playlists || !parsed.playlists.length) {
+        return parsed;
+      }
+      this.excludeAudioOnlyVariants(parsed.playlists);
+      return parsed;
     } catch (error) {
       this.error = error;
       this.error.metadata = {
@@ -56592,6 +56808,31 @@ class PlaylistLoader extends EventTarget$1 {
       };
     }
   }
+  excludeAudioOnlyVariants(playlists) {
+    // helper function
+    const hasVideo = playlist => {
+      const attributes = playlist.attributes || {};
+      const {
+        width,
+        height
+      } = attributes.RESOLUTION || {};
+      if (width && height) {
+        return true;
+      } // parse codecs string from playlist attributes
+
+      const codecsList = getCodecs(playlist) || []; // unwrap list
+
+      const codecsInfo = unwrapCodecList(codecsList);
+      return Boolean(codecsInfo.video);
+    };
+    if (playlists.some(hasVideo)) {
+      playlists.forEach(playlist => {
+        if (!hasVideo(playlist)) {
+          playlist.excludeUntil = Infinity;
+        }
+      });
+    }
+  }
   /**
    * Update the playlist loader's state in response to a new or updated playlist.
    *
@@ -69827,110 +70068,6 @@ const mediaSegmentRequest = ({
   });
   return () => abortAll(activeXhrs);
 };
-
-/**
- * @file - codecs.js - Handles tasks regarding codec strings such as translating them to
- * codec strings, or translating codec strings into objects that can be examined.
- */
-const logFn$1 = logger('CodecUtils');
-/**
- * Returns a set of codec strings parsed from the playlist or the default
- * codec strings if no codecs were specified in the playlist
- *
- * @param {Playlist} media the current media playlist
- * @return {Object} an object with the video and audio codecs
- */
-
-const getCodecs = function (media) {
-  // if the codecs were explicitly specified, use them instead of the
-  // defaults
-  const mediaAttributes = media.attributes || {};
-  if (mediaAttributes.CODECS) {
-    return (0,_videojs_vhs_utils_es_codecs_js__WEBPACK_IMPORTED_MODULE_7__.parseCodecs)(mediaAttributes.CODECS);
-  }
-};
-const isMaat = (main, media) => {
-  const mediaAttributes = media.attributes || {};
-  return main && main.mediaGroups && main.mediaGroups.AUDIO && mediaAttributes.AUDIO && main.mediaGroups.AUDIO[mediaAttributes.AUDIO];
-};
-const isMuxed = (main, media) => {
-  if (!isMaat(main, media)) {
-    return true;
-  }
-  const mediaAttributes = media.attributes || {};
-  const audioGroup = main.mediaGroups.AUDIO[mediaAttributes.AUDIO];
-  for (const groupId in audioGroup) {
-    // If an audio group has a URI (the case for HLS, as HLS will use external playlists),
-    // or there are listed playlists (the case for DASH, as the manifest will have already
-    // provided all of the details necessary to generate the audio playlist, as opposed to
-    // HLS' externally requested playlists), then the content is demuxed.
-    if (!audioGroup[groupId].uri && !audioGroup[groupId].playlists) {
-      return true;
-    }
-  }
-  return false;
-};
-const unwrapCodecList = function (codecList) {
-  const codecs = {};
-  codecList.forEach(({
-    mediaType,
-    type,
-    details
-  }) => {
-    codecs[mediaType] = codecs[mediaType] || [];
-    codecs[mediaType].push((0,_videojs_vhs_utils_es_codecs_js__WEBPACK_IMPORTED_MODULE_7__.translateLegacyCodec)(`${type}${details}`));
-  });
-  Object.keys(codecs).forEach(function (mediaType) {
-    if (codecs[mediaType].length > 1) {
-      logFn$1(`multiple ${mediaType} codecs found as attributes: ${codecs[mediaType].join(', ')}. Setting playlist codecs to null so that we wait for mux.js to probe segments for real codecs.`);
-      codecs[mediaType] = null;
-      return;
-    }
-    codecs[mediaType] = codecs[mediaType][0];
-  });
-  return codecs;
-};
-const codecCount = function (codecObj) {
-  let count = 0;
-  if (codecObj.audio) {
-    count++;
-  }
-  if (codecObj.video) {
-    count++;
-  }
-  return count;
-};
-/**
- * Calculates the codec strings for a working configuration of
- * SourceBuffers to play variant streams in a main playlist. If
- * there is no possible working configuration, an empty object will be
- * returned.
- *
- * @param main {Object} the m3u8 object for the main playlist
- * @param media {Object} the m3u8 object for the variant playlist
- * @return {Object} the codec strings.
- *
- * @private
- */
-
-const codecsForPlaylist = function (main, media) {
-  const mediaAttributes = media.attributes || {};
-  const codecInfo = unwrapCodecList(getCodecs(media) || []); // HLS with multiple-audio tracks must always get an audio codec.
-  // Put another way, there is no way to have a video-only multiple-audio HLS!
-
-  if (isMaat(main, media) && !codecInfo.audio) {
-    if (!isMuxed(main, media)) {
-      // It is possible for codecs to be specified on the audio media group playlist but
-      // not on the rendition playlist. This is mostly the case for DASH, where audio and
-      // video are always separate (and separately specified).
-      const defaultCodecs = unwrapCodecList((0,_videojs_vhs_utils_es_codecs_js__WEBPACK_IMPORTED_MODULE_7__.codecsFromDefault)(main, mediaAttributes.AUDIO) || []);
-      if (defaultCodecs.audio) {
-        codecInfo.audio = defaultCodecs.audio;
-      }
-    }
-  }
-  return codecInfo;
-};
 const logFn = logger('PlaylistSelector');
 const representationToString = function (representation) {
   if (!representation || !representation.playlist) {
@@ -70041,25 +70178,40 @@ const comparePlaylistResolution = function (left, right) {
 /**
  * Chooses the appropriate media playlist based on bandwidth and player size
  *
- * @param {Object} main
+ * @param {Object} settings
+ *        Object of information required to use this selector
+ * @param {Object} settings.main
  *        Object representation of the main manifest
- * @param {number} playerBandwidth
+ * @param {number} settings.bandwidth
  *        Current calculated bandwidth of the player
- * @param {number} playerWidth
+ * @param {number} settings.playerWidth
  *        Current width of the player element (should account for the device pixel ratio)
- * @param {number} playerHeight
+ * @param {number} settings.playerHeight
  *        Current height of the player element (should account for the device pixel ratio)
- * @param {boolean} limitRenditionByPlayerDimensions
+ * @param {number} settings.playerObjectFit
+ *        Current value of the video element's object-fit CSS property. Allows taking into
+ *        account that the video might be scaled up to cover the media element when selecting
+ *        media playlists based on player size.
+ * @param {boolean} settings.limitRenditionByPlayerDimensions
  *        True if the player width and height should be used during the selection, false otherwise
- * @param {Object} playlistController
+ * @param {Object} settings.playlistController
  *        the current playlistController object
  * @return {Playlist} the highest bitrate playlist less than the
  * currently detected bandwidth, accounting for some amount of
  * bandwidth variance
  */
 
-let simpleSelector = function (main, playerBandwidth, playerWidth, playerHeight, limitRenditionByPlayerDimensions, playlistController) {
-  // If we end up getting called before `main` is available, exit early
+let simpleSelector = function (settings) {
+  const {
+    main,
+    bandwidth: playerBandwidth,
+    playerWidth,
+    playerHeight,
+    playerObjectFit,
+    limitRenditionByPlayerDimensions,
+    playlistController
+  } = settings; // If we end up getting called before `main` is available, exit early
+
   if (!main) {
     return;
   }
@@ -70143,7 +70295,17 @@ let simpleSelector = function (main, playerBandwidth, playerWidth, playerHeight,
   // if there is no match of exact resolution
 
   if (!resolutionBestRep) {
-    resolutionPlusOneList = haveResolution.filter(rep => rep.width > playerWidth || rep.height > playerHeight); // find all the variants have the same smallest resolution
+    resolutionPlusOneList = haveResolution.filter(rep => {
+      if (playerObjectFit === 'cover') {
+        // video will be scaled up to cover the player. We need to
+        // make sure rendition is at least as wide and as high as the
+        // player.
+        return rep.width > playerWidth && rep.height > playerHeight;
+      } // video will be scaled down to fit inside the player soon as
+      // its resolution exceeds player size in at least one dimension.
+
+      return rep.width > playerWidth || rep.height > playerHeight;
+    }); // find all the variants have the same smallest resolution
 
     resolutionPlusOneSmallest = resolutionPlusOneList.filter(rep => rep.width === resolutionPlusOneList[0].width && rep.height === resolutionPlusOneList[0].height); // ensure that we also pick the highest bandwidth variant that
     // is just-larger-than the video player
@@ -70209,7 +70371,15 @@ const lastBandwidthSelector = function () {
   if (!isNaN(this.customPixelRatio)) {
     pixelRatio = this.customPixelRatio;
   }
-  return simpleSelector(this.playlists.main, this.systemBandwidth, parseInt(safeGetComputedStyle(this.tech_.el(), 'width'), 10) * pixelRatio, parseInt(safeGetComputedStyle(this.tech_.el(), 'height'), 10) * pixelRatio, this.limitRenditionByPlayerDimensions, this.playlistController_);
+  return simpleSelector({
+    main: this.playlists.main,
+    bandwidth: this.systemBandwidth,
+    playerWidth: parseInt(safeGetComputedStyle(this.tech_.el(), 'width'), 10) * pixelRatio,
+    playerHeight: parseInt(safeGetComputedStyle(this.tech_.el(), 'height'), 10) * pixelRatio,
+    playerObjectFit: this.usePlayerObjectFit ? safeGetComputedStyle(this.tech_.el(), 'objectFit') : '',
+    limitRenditionByPlayerDimensions: this.limitRenditionByPlayerDimensions,
+    playlistController: this.playlistController_
+  });
 };
 /**
  * Chooses the appropriate media playlist based on an
@@ -70250,7 +70420,15 @@ const movingAverageBandwidthSelector = function (decay) {
       average = decay * this.systemBandwidth + (1 - decay) * average;
       lastSystemBandwidth = this.systemBandwidth;
     }
-    return simpleSelector(this.playlists.main, average, parseInt(safeGetComputedStyle(this.tech_.el(), 'width'), 10) * pixelRatio, parseInt(safeGetComputedStyle(this.tech_.el(), 'height'), 10) * pixelRatio, this.limitRenditionByPlayerDimensions, this.playlistController_);
+    return simpleSelector({
+      main: this.playlists.main,
+      bandwidth: average,
+      playerWidth: parseInt(safeGetComputedStyle(this.tech_.el(), 'width'), 10) * pixelRatio,
+      playerHeight: parseInt(safeGetComputedStyle(this.tech_.el(), 'height'), 10) * pixelRatio,
+      playerObjectFit: this.usePlayerObjectFit ? safeGetComputedStyle(this.tech_.el(), 'objectFit') : '',
+      limitRenditionByPlayerDimensions: this.limitRenditionByPlayerDimensions,
+      playlistController: this.playlistController_
+    });
   };
 };
 /**
@@ -78307,6 +78485,7 @@ class PlaylistController extends videojs.EventTarget {
       kind: 'metadata',
       label: 'segment-metadata'
     }, false).track;
+    this.segmentMetadataTrack_.mode = 'hidden';
     this.decrypter_ = new Decrypter();
     this.sourceUpdater_ = new SourceUpdater(this.mediaSource);
     this.inbandTextTracks_ = {};
@@ -79544,12 +79723,9 @@ class PlaylistController extends videojs.EventTarget {
       if (!isFinite(start) || !isFinite(end)) {
         return null;
       }
-      const liveEdgeDelay = Vhs$1.Playlist.liveEdgeDelay(this.mainPlaylistLoader_.main, media); // Make sure our seekable end is not negative
+      const liveEdgeDelay = Vhs$1.Playlist.liveEdgeDelay(this.mainPlaylistLoader_.main, media); // Make sure our seekable end is not less than the seekable start
 
-      const calculatedEnd = Math.max(0, end - liveEdgeDelay);
-      if (calculatedEnd < start) {
-        return null;
-      }
+      const calculatedEnd = Math.max(start, end - liveEdgeDelay);
       return createTimeRanges([[start, calculatedEnd]]);
     }
     const expired = this.syncController_.getExpiredTime(media, this.duration());
@@ -81144,7 +81320,7 @@ const initPlugin = function (player, options) {
 const reloadSourceOnError = function (options) {
   initPlugin(this, options);
 };
-var version$4 = "3.16.2";
+var version$4 = "3.17.0";
 var version$3 = "7.1.0";
 var version$2 = "1.3.1";
 var version$1 = "7.2.0";
@@ -81703,9 +81879,10 @@ class VhsHandler extends Component {
     this.options_.withCredentials = this.options_.withCredentials || false;
     this.options_.limitRenditionByPlayerDimensions = this.options_.limitRenditionByPlayerDimensions === false ? false : true;
     this.options_.useDevicePixelRatio = this.options_.useDevicePixelRatio || false;
+    this.options_.usePlayerObjectFit = this.options_.usePlayerObjectFit || false;
     this.options_.useBandwidthFromLocalStorage = typeof this.source_.useBandwidthFromLocalStorage !== 'undefined' ? this.source_.useBandwidthFromLocalStorage : this.options_.useBandwidthFromLocalStorage || false;
     this.options_.useForcedSubtitles = this.options_.useForcedSubtitles || false;
-    this.options_.useNetworkInformationApi = this.options_.useNetworkInformationApi || false;
+    this.options_.useNetworkInformationApi = typeof this.options_.useNetworkInformationApi !== 'undefined' ? this.options_.useNetworkInformationApi : true;
     this.options_.useDtsForTimestampOffset = this.options_.useDtsForTimestampOffset || false;
     this.options_.customTagParsers = this.options_.customTagParsers || [];
     this.options_.customTagMappers = this.options_.customTagMappers || [];
@@ -81743,13 +81920,14 @@ class VhsHandler extends Component {
 
     this.options_.enableLowInitialPlaylist = this.options_.enableLowInitialPlaylist && this.options_.bandwidth === Config.INITIAL_BANDWIDTH; // grab options passed to player.src
 
-    ['withCredentials', 'useDevicePixelRatio', 'customPixelRatio', 'limitRenditionByPlayerDimensions', 'bandwidth', 'customTagParsers', 'customTagMappers', 'cacheEncryptionKeys', 'playlistSelector', 'initialPlaylistSelector', 'bufferBasedABR', 'liveRangeSafeTimeDelta', 'llhls', 'useForcedSubtitles', 'useNetworkInformationApi', 'useDtsForTimestampOffset', 'exactManifestTimings', 'leastPixelDiffSelector'].forEach(option => {
+    ['withCredentials', 'useDevicePixelRatio', 'usePlayerObjectFit', 'customPixelRatio', 'limitRenditionByPlayerDimensions', 'bandwidth', 'customTagParsers', 'customTagMappers', 'cacheEncryptionKeys', 'playlistSelector', 'initialPlaylistSelector', 'bufferBasedABR', 'liveRangeSafeTimeDelta', 'llhls', 'useForcedSubtitles', 'useNetworkInformationApi', 'useDtsForTimestampOffset', 'exactManifestTimings', 'leastPixelDiffSelector'].forEach(option => {
       if (typeof this.source_[option] !== 'undefined') {
         this.options_[option] = this.source_[option];
       }
     });
     this.limitRenditionByPlayerDimensions = this.options_.limitRenditionByPlayerDimensions;
     this.useDevicePixelRatio = this.options_.useDevicePixelRatio;
+    this.usePlayerObjectFit = this.options_.usePlayerObjectFit;
     const customPixelRatio = this.options_.customPixelRatio; // Ensure the custom pixel ratio is a number greater than or equal to 0
 
     if (typeof customPixelRatio === 'number' && customPixelRatio >= 0) {