j1-template 2024.0.2 → 2024.0.3

data/assets/themes/j1/modules/videojs/js/video.js

@@ -1,6 +1,6 @@
 /**
  * @license
- * Video.js 8.6.0 <http://videojs.com/>
+ * Video.js 8.6.1 <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>
@@ -8,7 +8,7 @@
  * Includes vtt.js <https://github.com/mozilla/vtt.js>
  * Available under Apache License Version 2.0
  * <https://github.com/mozilla/vtt.js/blob/main/LICENSE>
- */
+*/
 
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -16,7 +16,7 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.videojs = factory());
 })(this, (function () { 'use strict';
 
-  var version$5 = "8.6.0";
+  var version$5 = "8.6.1";
 
   /**
    * An Object that contains lifecycle hooks as keys which point to an array
@@ -1996,7 +1996,7 @@
    * @param {Element|Object} elem
    *        Element or object to bind listeners to
    *
-   * @param {string} type
+   * @param {string[]} types
    *        Type of event to bind to.
    *
    * @param {Function} callback
@@ -2719,7 +2719,7 @@
   /**
    * All event listeners should follow the following format.
    *
-   * @callback EventTarget~EventListener
+   * @callback EventListener
    * @this {EventTarget}
    *
    * @param {Event} event
@@ -2736,7 +2736,7 @@
    *         will have extra functionality. See that function for more information.
    *
    * @property EventTarget.prototype.allowedEvents_
-   * @private
+   * @protected
    */
   EventTarget$2.prototype.allowedEvents_ = {};
 
@@ -4169,7 +4169,6 @@
     /**
      * Add a child `Component` inside the current `Component`.
      *
-     *
      * @param {string|Component} child
      *        The name or instance of a child to add.
      *
@@ -4180,6 +4179,7 @@
      * @param {number} [index=this.children_.length]
      *        The index to attempt to add a child into.
      *
+     *
      * @return {Component}
      *         The `Component` that gets added as a child. When using a string the
      *         `Component` will get created by this process.
@@ -4634,9 +4634,8 @@
      * @param {boolean} [skipListeners]
      *        Skip the componentresize event trigger
      *
-     * @return {number|string}
-     *         The width when getting, zero if there is no width. Can be a string
-     *           postpixed with '%' or 'px'.
+     * @return {number|undefined}
+     *         The width when getting, zero if there is no width
      */
     width(num, skipListeners) {
       return this.dimension('width', num, skipListeners);
@@ -4652,9 +4651,8 @@
      * @param {boolean} [skipListeners]
      *        Skip the componentresize event trigger
      *
-     * @return {number|string}
-     *         The width when getting, zero if there is no width. Can be a string
-     *         postpixed with '%' or 'px'.
+     * @return {number|undefined}
+     *         The height when getting, zero if there is no height
      */
     height(num, skipListeners) {
       return this.dimension('height', num, skipListeners);
@@ -4700,7 +4698,7 @@
      * @param  {boolean} [skipListeners]
      *         Skip componentresize event trigger
      *
-     * @return {number}
+     * @return {number|undefined}
      *         The dimension when getting or 0 if unset
      */
     dimension(widthOrHeight, num, skipListeners) {
@@ -4875,7 +4873,7 @@
      * delegates to `handleKeyDown`. This means anyone calling `handleKeyPress`
      * will not see their method calls stop working.
      *
-     * @param {Event} event
+     * @param {KeyboardEvent} event
      *        The event that caused this function to be called.
      */
     handleKeyPress(event) {
@@ -4887,7 +4885,7 @@
      * support toggling the controls through a tap on the video. They get enabled
      * because every sub-component would have extra overhead otherwise.
      *
-     * @private
+     * @protected
      * @fires Component#tap
      * @listens Component#touchstart
      * @listens Component#touchmove
@@ -6524,7 +6522,7 @@
    * Events that can be called with on + eventName. See {@link EventHandler}.
    *
    * @property {Object} TrackList#allowedEvents_
-   * @private
+   * @protected
    */
   TrackList.prototype.allowedEvents_ = {
     change: 'change',
@@ -6574,7 +6572,7 @@
     /**
      * Create an instance of this class.
      *
-     * @param {AudioTrack[]} [tracks=[]]
+     * @param { import('./audio-track').default[] } [tracks=[]]
      *        A list of `AudioTrack` to instantiate the list with.
      */
     constructor(tracks = []) {
@@ -8012,7 +8010,9 @@
      */
     addCue(originalCue) {
       let cue = originalCue;
-      if (cue.constructor && cue.constructor.name !== 'VTTCue') {
+
+      // Testing if the cue is a VTTCue in a way that survives minification
+      if (!('getCueAsHTML' in cue)) {
         cue = new window.vttjs.VTTCue(originalCue.startTime, originalCue.endTime, originalCue.text);
         for (const prop in originalCue) {
           if (!(prop in cue)) {
@@ -8055,6 +8055,7 @@
 
   /**
    * cuechange - One or more cues in the track have become active or stopped being active.
+   * @protected
    */
   TextTrack.prototype.allowedEvents_ = {
     cuechange: 'cuechange'
@@ -8313,6 +8314,10 @@
       });
     }
   }
+
+  /**
+   * @protected
+   */
   HTMLTrackElement.prototype.allowedEvents_ = {
     load: 'load'
   };
@@ -10110,7 +10115,7 @@
    * * `var SourceObject = {src: 'http://ex.com/video.mp4', type: 'video/mp4'};`
      * `var SourceString = 'http://example.com/some-video.mp4';`
    *
-   * @typedef {Object|string} Tech~SourceObject
+   * @typedef {Object|string} SourceObject
    *
    * @property {string} src
    *           The url to the source
@@ -10546,7 +10551,7 @@
      * > NOTE: This implementation is incomplete. It does not track the played `TimeRange`.
      *         It only checks whether the source has played at all or not.
      *
-     * @return {TimeRange}
+     * @return { import('../utils/time').TimeRange }
      *         - A single time range if this video has played
      *         - An empty set of ranges if not.
      */
@@ -11310,7 +11315,7 @@
      *
      * TODO: Answer question: should 'probably' be prioritized over 'maybe'
      *
-     * @param {Tech~SourceObject} source
+     * @param {SourceObject} source
      *        The source object
      *
      * @param {Object} options
@@ -11335,7 +11340,7 @@
     /**
      * Check if the tech can support the given source.
      *
-     * @param {Tech~SourceObject} srcObj
+     * @param {SourceObject} srcObj
      *        The source object
      *
      * @param {Object} options
@@ -11390,7 +11395,7 @@
      * and source handlers.
      * Should never be called unless a source handler was found.
      *
-     * @param {Tech~SourceObject} source
+     * @param {SourceObject} source
      *        A source object with src and type keys
      */
     _Tech.prototype.setSource = function (source) {
@@ -12169,7 +12174,7 @@
      *
      * By default, if the key is Space or Enter, it will trigger a `click` event.
      *
-     * @param {Event} event
+     * @param {KeyboardEvent} event
      *        The `keydown` event that caused this function to be called.
      *
      * @listens keydown
@@ -12925,7 +12930,7 @@
      * This gets called when a `Button` has focus and `keydown` is triggered via a key
      * press.
      *
-     * @param {Event} event
+     * @param {KeyboardEvent} event
      *        The event that caused this function to get called.
      *
      * @listens keydown
@@ -12979,7 +12984,7 @@
      * This gets called when a `BigPlayButton` "clicked". See {@link ClickableComponent}
      * for more detailed information on what a click can be.
      *
-     * @param {KeyboardEvent} event
+     * @param {KeyboardEvent|MouseEvent|TouchEvent} event
      *        The `keydown`, `tap`, or `click` event that caused this function to be
      *        called.
      *
@@ -12990,7 +12995,7 @@
       const playPromise = this.player_.play();
 
       // exit early if clicked via the mouse
-      if (this.mouseused_ && event.clientX && event.clientY) {
+      if (this.mouseused_ && 'clientX' in event && 'clientY' in event) {
         silencePromise(playPromise);
         if (this.player_.tech(true)) {
           this.player_.tech(true).focus();
@@ -13010,10 +13015,29 @@
         this.setTimeout(playFocus, 1);
       }
     }
+
+    /**
+     * Event handler that is called when a `BigPlayButton` receives a
+     * `keydown` event.
+     *
+     * @param {KeyboardEvent} event
+     *        The `keydown` event that caused this function to be called.
+     *
+     * @listens keydown
+     */
     handleKeyDown(event) {
       this.mouseused_ = false;
       super.handleKeyDown(event);
     }
+
+    /**
+     * Handle `mousedown` events on the `BigPlayButton`.
+     *
+     * @param {MouseEvent} event
+     *        `mousedown` or `touchstart` event that triggered this function
+     *
+     * @listens mousedown
+     */
     handleMouseDown(event) {
       this.mouseused_ = true;
     }
@@ -13099,7 +13123,7 @@
      *
      * By default, if the key is Esc, it will trigger a `click` event.
      *
-     * @param {Event} event
+     * @param {KeyboardEvent} event
      *        The `keydown` event that caused this function to be called.
      *
      * @listens keydown
@@ -16726,7 +16750,7 @@
     /**
      * Handle a `keydown` event on this menu. This listener is added in the constructor.
      *
-     * @param {Event} event
+     * @param {KeyboardEvent} event
      *        A `keydown` event that happened on the menu.
      *
      * @listens keydown
@@ -17323,7 +17347,7 @@
      * Ignore keys which are used by the menu, but pass any other ones up. See
      * {@link ClickableComponent#handleKeyDown} for instances where this is called.
      *
-     * @param {Event} event
+     * @param {KeyboardEvent} event
      *        The `keydown` event that caused this function to be called.
      *
      * @listens keydown
@@ -22382,8 +22406,8 @@
    *
    * After an instance has been created it can be accessed globally in three ways:
    * 1. By calling `videojs.getPlayer('example_video_1');`
-   * 2. By calling `videojs('example_video_1');` (not recomended)
-   * 2. By using it directly via  `videojs.players.example_video_1;`
+   * 2. By calling `videojs('example_video_1');` (not recommended)
+   * 2. By using it directly via `videojs.players.example_video_1;`
    *
    * @extends Component
    * @global
@@ -24122,7 +24146,9 @@
      */
     handleTechError_() {
       const error = this.tech_.error();
-      this.error(error);
+      if (error) {
+        this.error(error);
+      }
     }
 
     /**
@@ -25078,7 +25104,7 @@
      * This allows player-wide hotkeys (either as defined below, or optionally
      * by an external function).
      *
-     * @param {Event} event
+     * @param {KeyboardEvent} event
      *        The `keydown` event that caused this function to be called.
      *
      * @listens keydown
@@ -27282,7 +27308,7 @@
    * @param  {Player} player
    *         A Video.js player instance.
    *
-   * @param  {Plugin~PluginEventHash} hash
+   * @param  {PluginEventHash} hash
    *         A plugin event hash.
    *
    * @param  {boolean} [before]
@@ -27435,7 +27461,7 @@
      * @param   {Object} [hash={}]
      *          An object to be used as event an event hash.
      *
-     * @return {Plugin~PluginEventHash}
+     * @return {PluginEventHash}
      *          An event hash object with provided properties mixed-in.
      */
     getEventHash(hash = {}) {
@@ -27454,7 +27480,7 @@
      *
      * @param   {Object} [hash={}]
      *          Additional data hash to merge with a
-     *          {@link Plugin~PluginEventHash|PluginEventHash}.
+     *          {@link PluginEventHash|PluginEventHash}.
      *
      * @return {boolean}
      *          Whether or not default was prevented.
@@ -27670,7 +27696,7 @@
    * Signals that a plugin is about to be set up on a player.
    *
    * @event    Player#beforepluginsetup
-   * @type     {Plugin~PluginEventHash}
+   * @type     {PluginEventHash}
    */
 
   /**
@@ -27678,14 +27704,14 @@
    * is the name of the plugin.
    *
    * @event    Player#beforepluginsetup:$name
-   * @type     {Plugin~PluginEventHash}
+   * @type     {PluginEventHash}
    */
 
   /**
    * Signals that a plugin has just been set up on a player.
    *
    * @event    Player#pluginsetup
-   * @type     {Plugin~PluginEventHash}
+   * @type     {PluginEventHash}
    */
 
   /**
@@ -27693,11 +27719,11 @@
    * is the name of the plugin.
    *
    * @event    Player#pluginsetup:$name
-   * @type     {Plugin~PluginEventHash}
+   * @type     {PluginEventHash}
    */
 
   /**
-   * @typedef  {Object} Plugin~PluginEventHash
+   * @typedef  {Object} PluginEventHash
    *
    * @property {string} instance
    *           For basic plugins, the return value of the plugin function. For
@@ -28024,10 +28050,10 @@
    * @param {string} name
    *        The class name of the component
    *
-   * @param {Component} comp
+   * @param {typeof Component} comp
    *        The component class
    *
-   * @return {Component}
+   * @return {typeof Component}
    *         The newly registered component
    */
   videojs.registerComponent = (name, comp) => {
@@ -28110,9 +28136,11 @@
    *
    * @param {string} name
    *        The plugin name
-   *
-   * @param {Plugin|Function} plugin
+  *
+   * @param {typeof Plugin|Function} plugin
    *         The plugin sub-class or function
+   *
+   * @return {typeof Plugin|Function}
    */
   videojs.plugin = (name, plugin) => {
     log$1.warn('videojs.plugin() is deprecated; use videojs.registerPlugin() instead');
@@ -39079,7 +39107,7 @@
   };
   var clock_1 = clock.ONE_SECOND_IN_TS;
 
-  /*! @name @videojs/http-streaming @version 3.6.0 @license Apache-2.0 */
+  /*! @name @videojs/http-streaming @version 3.7.0 @license Apache-2.0 */
 
   /**
    * @file resolve-url.js - Handling how URLs are resolved and manipulated
@@ -39813,9 +39841,13 @@
   const seekable = function (playlist, expired, liveEdgePadding) {
     const useSafeLiveEnd = true;
     const seekableStart = expired || 0;
-    const seekableEnd = playlistEnd(playlist, expired, useSafeLiveEnd, liveEdgePadding);
+    let seekableEnd = playlistEnd(playlist, expired, useSafeLiveEnd, liveEdgePadding);
     if (seekableEnd === null) {
       return createTimeRanges();
+    } // Clamp seekable end since it can not be less than the seekable start
+
+    if (seekableEnd < seekableStart) {
+      seekableEnd = seekableStart;
     }
     return createTimeRanges(seekableStart, seekableEnd);
   };
@@ -42253,7 +42285,10 @@
       }); // live playlist staleness timeout
 
       this.on('mediaupdatetimeout', () => {
-        this.refreshMedia_(this.media().id);
+        // We handle live content steering in the playlist controller
+        if (!this.media().attributes.serviceLocation) {
+          this.refreshMedia_(this.media().id);
+        }
       });
       this.state = 'HAVE_NOTHING';
       this.loadedPlaylists_ = {};
@@ -45083,18 +45118,31 @@
       var nextByte = packetData[i + 1];
       var win = service.currentWindow;
       var char;
-      var charCodeArray; // Use the TextDecoder if one was created for this service
+      var charCodeArray; // Converts an array of bytes to a unicode hex string.
+
+      function toHexString(byteArray) {
+        return byteArray.map(byte => {
+          return ('0' + (byte & 0xFF).toString(16)).slice(-2);
+        }).join('');
+      }
+      if (isMultiByte) {
+        charCodeArray = [currentByte, nextByte];
+        i++;
+      } else {
+        charCodeArray = [currentByte];
+      } // Use the TextDecoder if one was created for this service
 
       if (service.textDecoder_ && !isExtended) {
+        char = service.textDecoder_.decode(new Uint8Array(charCodeArray));
+      } else {
+        // We assume any multi-byte char without a decoder is unicode.
         if (isMultiByte) {
-          charCodeArray = [currentByte, nextByte];
-          i++;
+          const unicode = toHexString(charCodeArray); // Takes a unicode hex string and creates a single character.
+
+          char = String.fromCharCode(parseInt(unicode, 16));
         } else {
-          charCodeArray = [currentByte];
+          char = get708CharFromCode(extended | currentByte);
         }
-        char = service.textDecoder_.decode(new Uint8Array(charCodeArray));
-      } else {
-        char = get708CharFromCode(extended | currentByte);
       }
       if (win.pendingNewLine && !win.isEmpty()) {
         win.newLine(this.getPts(i));
@@ -52091,7 +52139,7 @@
               segment.bytes = bytesAsUint8Array = emsgData; // Run through the CaptionParser in case there are captions.
               // Initialize CaptionParser if it hasn't been yet
 
-              if (!tracks.video || !data.byteLength || !segment.transmuxer) {
+              if (!tracks.video || !emsgData.byteLength || !segment.transmuxer) {
                 finishLoading(undefined, id3Frames);
                 return;
               }
@@ -59082,15 +59130,11 @@
      */
     AUDIO: (type, settings) => () => {
       const {
-        segmentLoaders: {
-          [type]: segmentLoader
-        },
         mediaTypes: {
           [type]: mediaType
         },
         excludePlaylist
-      } = settings;
-      stopLoaders(segmentLoader, mediaType); // switch back to default audio track
+      } = settings; // switch back to default audio track
 
       const activeTrack = mediaType.activeTrack();
       const activeGroup = mediaType.activeGroup();
@@ -59126,15 +59170,11 @@
      */
     SUBTITLES: (type, settings) => () => {
       const {
-        segmentLoaders: {
-          [type]: segmentLoader
-        },
         mediaTypes: {
           [type]: mediaType
         }
       } = settings;
       videojs.log.warn('Problem encountered loading the subtitle track.' + 'Disabling subtitle track.');
-      stopLoaders(segmentLoader, mediaType);
       const track = mediaType.activeTrack();
       if (track) {
         track.mode = 'disabled';
@@ -59721,6 +59761,388 @@
     return mediaTypes;
   };
 
+  /**
+   * A utility class for setting properties and maintaining the state of the content steering manifest.
+   *
+   * Content Steering manifest format:
+   * VERSION: number (required) currently only version 1 is supported.
+   * TTL: number in seconds (optional) until the next content steering manifest reload.
+   * RELOAD-URI: string (optional) uri to fetch the next content steering manifest.
+   * SERVICE-LOCATION-PRIORITY or PATHWAY-PRIORITY a non empty array of unique string values.
+   */
+
+  class SteeringManifest {
+    constructor() {
+      this.priority_ = [];
+    }
+    set version(number) {
+      // Only version 1 is currently supported for both DASH and HLS.
+      if (number === 1) {
+        this.version_ = number;
+      }
+    }
+    set ttl(seconds) {
+      // TTL = time-to-live, default = 300 seconds.
+      this.ttl_ = seconds || 300;
+    }
+    set reloadUri(uri) {
+      if (uri) {
+        // reload URI can be relative to the previous reloadUri.
+        this.reloadUri_ = resolveUrl(this.reloadUri_, uri);
+      }
+    }
+    set priority(array) {
+      // priority must be non-empty and unique values.
+      if (array && array.length) {
+        this.priority_ = array;
+      }
+    }
+    get version() {
+      return this.version_;
+    }
+    get ttl() {
+      return this.ttl_;
+    }
+    get reloadUri() {
+      return this.reloadUri_;
+    }
+    get priority() {
+      return this.priority_;
+    }
+  }
+  /**
+   * This class represents a content steering manifest and associated state. See both HLS and DASH specifications.
+   * HLS: https://developer.apple.com/streaming/HLSContentSteeringSpecification.pdf and
+   * https://datatracker.ietf.org/doc/draft-pantos-hls-rfc8216bis/ section 4.4.6.6.
+   * DASH: https://dashif.org/docs/DASH-IF-CTS-00XX-Content-Steering-Community-Review.pdf
+   *
+   * @param {function} xhr for making a network request from the browser.
+   * @param {function} bandwidth for fetching the current bandwidth from the main segment loader.
+   */
+
+  class ContentSteeringController extends videojs.EventTarget {
+    constructor(xhr, bandwidth) {
+      super();
+      this.currentPathway = null;
+      this.defaultPathway = null;
+      this.queryBeforeStart = null;
+      this.availablePathways_ = new Set();
+      this.excludedPathways_ = new Set();
+      this.steeringManifest = new SteeringManifest();
+      this.proxyServerUrl_ = null;
+      this.manifestType_ = null;
+      this.ttlTimeout_ = null;
+      this.request_ = null;
+      this.excludedSteeringManifestURLs = new Set();
+      this.logger_ = logger('Content Steering');
+      this.xhr_ = xhr;
+      this.getBandwidth_ = bandwidth;
+    }
+    /**
+     * Assigns the content steering tag properties to the steering controller
+     *
+     * @param {string} baseUrl the baseURL from the manifest for resolving the steering manifest url
+     * @param {Object} steeringTag the content steering tag from the main manifest
+     */
+
+    assignTagProperties(baseUrl, steeringTag) {
+      this.manifestType_ = steeringTag.serverUri ? 'HLS' : 'DASH'; // serverUri is HLS serverURL is DASH
+
+      const steeringUri = steeringTag.serverUri || steeringTag.serverURL;
+      if (!steeringUri) {
+        this.logger_(`steering manifest URL is ${steeringUri}, cannot request steering manifest.`);
+        this.trigger('error');
+        return;
+      } // Content steering manifests can be encoded as a data URI. We can decode, parse and return early if that's the case.
+
+      if (steeringUri.startsWith('data:')) {
+        this.decodeDataUriManifest_(steeringUri.substring(steeringUri.indexOf(',') + 1));
+        return;
+      } // With DASH queryBeforeStart, we want to use the steeringUri as soon as possible for the request.
+
+      this.steeringManifest.reloadUri = this.queryBeforeStart ? steeringUri : resolveUrl(baseUrl, steeringUri); // pathwayId is HLS defaultServiceLocation is DASH
+
+      this.defaultPathway = steeringTag.pathwayId || steeringTag.defaultServiceLocation; // currently only DASH supports the following properties on <ContentSteering> tags.
+
+      this.queryBeforeStart = steeringTag.queryBeforeStart || false;
+      this.proxyServerUrl_ = steeringTag.proxyServerURL || null; // trigger a steering event if we have a pathway from the content steering tag.
+      // this tells VHS which segment pathway to start with.
+      // If queryBeforeStart is true we need to wait for the steering manifest response.
+
+      if (this.defaultPathway && !this.queryBeforeStart) {
+        this.trigger('content-steering');
+      }
+      if (this.queryBeforeStart) {
+        this.requestSteeringManifest(this.steeringManifest.reloadUri);
+      }
+    }
+    /**
+     * Requests the content steering manifest and parse the response. This should only be called after
+     * assignTagProperties was called with a content steering tag.
+     *
+     * @param {string} initialUri The optional uri to make the request with.
+     *    If set, the request should be made with exactly what is passed in this variable.
+     *    This scenario is specific to DASH when the queryBeforeStart parameter is true.
+     *    This scenario should only happen once on initalization.
+     */
+
+    requestSteeringManifest(initialUri) {
+      const reloadUri = this.steeringManifest.reloadUri;
+      if (!initialUri && !reloadUri) {
+        return;
+      } // We currently don't support passing MPD query parameters directly to the content steering URL as this requires
+      // ExtUrlQueryInfo tag support. See the DASH content steering spec section 8.1.
+      // This request URI accounts for manifest URIs that have been excluded.
+
+      const uri = initialUri || this.getRequestURI(reloadUri); // If there are no valid manifest URIs, we should stop content steering.
+
+      if (!uri) {
+        this.logger_('No valid content steering manifest URIs. Stopping content steering.');
+        this.trigger('error');
+        this.dispose();
+        return;
+      }
+      this.request_ = this.xhr_({
+        uri
+      }, (error, errorInfo) => {
+        if (error) {
+          // If the client receives HTTP 410 Gone in response to a manifest request,
+          // it MUST NOT issue another request for that URI for the remainder of the
+          // playback session. It MAY continue to use the most-recently obtained set
+          // of Pathways.
+          if (errorInfo.status === 410) {
+            this.logger_(`manifest request 410 ${error}.`);
+            this.logger_(`There will be no more content steering requests to ${uri} this session.`);
+            this.excludedSteeringManifestURLs.add(uri);
+            return;
+          } // If the client receives HTTP 429 Too Many Requests with a Retry-After
+          // header in response to a manifest request, it SHOULD wait until the time
+          // specified by the Retry-After header to reissue the request.
+
+          if (errorInfo.status === 429) {
+            const retrySeconds = errorInfo.responseHeaders['retry-after'];
+            this.logger_(`manifest request 429 ${error}.`);
+            this.logger_(`content steering will retry in ${retrySeconds} seconds.`);
+            this.startTTLTimeout_(parseInt(retrySeconds, 10));
+            return;
+          } // If the Steering Manifest cannot be loaded and parsed correctly, the
+          // client SHOULD continue to use the previous values and attempt to reload
+          // it after waiting for the previously-specified TTL (or 5 minutes if
+          // none).
+
+          this.logger_(`manifest failed to load ${error}.`);
+          this.startTTLTimeout_();
+          return;
+        }
+        const steeringManifestJson = JSON.parse(this.request_.responseText);
+        this.startTTLTimeout_();
+        this.assignSteeringProperties_(steeringManifestJson);
+      });
+    }
+    /**
+     * Set the proxy server URL and add the steering manifest url as a URI encoded parameter.
+     *
+     * @param {string} steeringUrl the steering manifest url
+     * @return the steering manifest url to a proxy server with all parameters set
+     */
+
+    setProxyServerUrl_(steeringUrl) {
+      const steeringUrlObject = new window.URL(steeringUrl);
+      const proxyServerUrlObject = new window.URL(this.proxyServerUrl_);
+      proxyServerUrlObject.searchParams.set('url', encodeURI(steeringUrlObject.toString()));
+      return this.setSteeringParams_(proxyServerUrlObject.toString());
+    }
+    /**
+     * Decodes and parses the data uri encoded steering manifest
+     *
+     * @param {string} dataUri the data uri to be decoded and parsed.
+     */
+
+    decodeDataUriManifest_(dataUri) {
+      const steeringManifestJson = JSON.parse(window.atob(dataUri));
+      this.assignSteeringProperties_(steeringManifestJson);
+    }
+    /**
+     * Set the HLS or DASH content steering manifest request query parameters. For example:
+     * _HLS_pathway="<CURRENT-PATHWAY-ID>" and _HLS_throughput=<THROUGHPUT>
+     * _DASH_pathway and _DASH_throughput
+     *
+     * @param {string} uri to add content steering server parameters to.
+     * @return a new uri as a string with the added steering query parameters.
+     */
+
+    setSteeringParams_(url) {
+      const urlObject = new window.URL(url);
+      const path = this.getPathway();
+      const networkThroughput = this.getBandwidth_();
+      if (path) {
+        const pathwayKey = `_${this.manifestType_}_pathway`;
+        urlObject.searchParams.set(pathwayKey, path);
+      }
+      if (networkThroughput) {
+        const throughputKey = `_${this.manifestType_}_throughput`;
+        urlObject.searchParams.set(throughputKey, networkThroughput);
+      }
+      return urlObject.toString();
+    }
+    /**
+     * Assigns the current steering manifest properties and to the SteeringManifest object
+     *
+     * @param {Object} steeringJson the raw JSON steering manifest
+     */
+
+    assignSteeringProperties_(steeringJson) {
+      this.steeringManifest.version = steeringJson.VERSION;
+      if (!this.steeringManifest.version) {
+        this.logger_(`manifest version is ${steeringJson.VERSION}, which is not supported.`);
+        this.trigger('error');
+        return;
+      }
+      this.steeringManifest.ttl = steeringJson.TTL;
+      this.steeringManifest.reloadUri = steeringJson['RELOAD-URI']; // HLS = PATHWAY-PRIORITY required. DASH = SERVICE-LOCATION-PRIORITY optional
+
+      this.steeringManifest.priority = steeringJson['PATHWAY-PRIORITY'] || steeringJson['SERVICE-LOCATION-PRIORITY']; // TODO: HLS handle PATHWAY-CLONES. See section 7.2 https://datatracker.ietf.org/doc/draft-pantos-hls-rfc8216bis/
+      // 1. apply first pathway from the array.
+      // 2. if first pathway doesn't exist in manifest, try next pathway.
+      //    a. if all pathways are exhausted, ignore the steering manifest priority.
+      // 3. if segments fail from an established pathway, try all variants/renditions, then exclude the failed pathway.
+      //    a. exclude a pathway for a minimum of the last TTL duration. Meaning, from the next steering response,
+      //       the excluded pathway will be ignored.
+      //       See excludePathway usage in excludePlaylist().
+      // If there are no available pathways, we need to stop content steering.
+
+      if (!this.availablePathways_.size) {
+        this.logger_('There are no available pathways for content steering. Ending content steering.');
+        this.trigger('error');
+        this.dispose();
+      }
+      const chooseNextPathway = pathwaysByPriority => {
+        for (const path of pathwaysByPriority) {
+          if (this.availablePathways_.has(path)) {
+            return path;
+          }
+        } // If no pathway matches, ignore the manifest and choose the first available.
+
+        return [...this.availablePathways_][0];
+      };
+      const nextPathway = chooseNextPathway(this.steeringManifest.priority);
+      if (this.currentPathway !== nextPathway) {
+        this.currentPathway = nextPathway;
+        this.trigger('content-steering');
+      }
+    }
+    /**
+     * Returns the pathway to use for steering decisions
+     *
+     * @return {string} returns the current pathway or the default
+     */
+
+    getPathway() {
+      return this.currentPathway || this.defaultPathway;
+    }
+    /**
+     * Chooses the manifest request URI based on proxy URIs and server URLs.
+     * Also accounts for exclusion on certain manifest URIs.
+     *
+     * @param {string} reloadUri the base uri before parameters
+     *
+     * @return {string} the final URI for the request to the manifest server.
+     */
+
+    getRequestURI(reloadUri) {
+      if (!reloadUri) {
+        return null;
+      }
+      const isExcluded = uri => this.excludedSteeringManifestURLs.has(uri);
+      if (this.proxyServerUrl_) {
+        const proxyURI = this.setProxyServerUrl_(reloadUri);
+        if (!isExcluded(proxyURI)) {
+          return proxyURI;
+        }
+      }
+      const steeringURI = this.setSteeringParams_(reloadUri);
+      if (!isExcluded(steeringURI)) {
+        return steeringURI;
+      } // Return nothing if all valid manifest URIs are excluded.
+
+      return null;
+    }
+    /**
+     * Start the timeout for re-requesting the steering manifest at the TTL interval.
+     *
+     * @param {number} ttl time in seconds of the timeout. Defaults to the
+     *        ttl interval in the steering manifest
+     */
+
+    startTTLTimeout_(ttl = this.steeringManifest.ttl) {
+      // 300 (5 minutes) is the default value.
+      const ttlMS = ttl * 1000;
+      this.ttlTimeout_ = window.setTimeout(() => {
+        this.requestSteeringManifest();
+      }, ttlMS);
+    }
+    /**
+     * Clear the TTL timeout if necessary.
+     */
+
+    clearTTLTimeout_() {
+      window.clearTimeout(this.ttlTimeout_);
+      this.ttlTimeout_ = null;
+    }
+    /**
+     * aborts any current steering xhr and sets the current request object to null
+     */
+
+    abort() {
+      if (this.request_) {
+        this.request_.abort();
+      }
+      this.request_ = null;
+    }
+    /**
+     * aborts steering requests clears the ttl timeout and resets all properties.
+     */
+
+    dispose() {
+      this.off('content-steering');
+      this.off('error');
+      this.abort();
+      this.clearTTLTimeout_();
+      this.currentPathway = null;
+      this.defaultPathway = null;
+      this.queryBeforeStart = null;
+      this.proxyServerUrl_ = null;
+      this.manifestType_ = null;
+      this.ttlTimeout_ = null;
+      this.request_ = null;
+      this.excludedSteeringManifestURLs = new Set();
+      this.availablePathways_ = new Set();
+      this.excludedPathways_ = new Set();
+      this.steeringManifest = new SteeringManifest();
+    }
+    /**
+     * adds a pathway to the available pathways set
+     *
+     * @param {string} pathway the pathway string to add
+     */
+
+    addAvailablePathway(pathway) {
+      if (pathway) {
+        this.availablePathways_.add(pathway);
+      }
+    }
+    /**
+     * clears all pathways from the available pathways set
+     */
+
+    clearAvailablePathways() {
+      this.availablePathways_.clear();
+    }
+    excludePathway(pathway) {
+      return this.availablePathways_.delete(pathway);
+    }
+  }
+
   /**
    * @file playlist-controller.js
    */
@@ -59948,6 +60370,10 @@
           tech.addWebVttScript_();
         })
       }), options);
+      const getBandwidth = () => {
+        return this.mainSegmentLoader_.bandwidth;
+      };
+      this.contentSteeringController_ = new ContentSteeringController(this.vhs_.xhr, getBandwidth);
       this.setupSegmentLoaderListeners_();
       if (this.bufferBasedABR) {
         this.mainPlaylistLoader_.one('loadedplaylist', () => this.startABRTimer_());
@@ -60033,6 +60459,32 @@
       }
       this.mainPlaylistLoader_.media(playlist, delay);
     }
+    /**
+     * A function that ensures we switch our playlists inside of `mediaTypes`
+     * to match the current `serviceLocation` provided by the contentSteering controller.
+     * We want to check media types of `AUDIO`, `SUBTITLES`, and `CLOSED-CAPTIONS`.
+     *
+     * This should only be called on a DASH playback scenario while using content steering.
+     * This is necessary due to differences in how media in HLS manifests are generally tied to
+     * a video playlist, where in DASH that is not always the case.
+     */
+
+    switchMediaForDASHContentSteering_() {
+      ['AUDIO', 'SUBTITLES', 'CLOSED-CAPTIONS'].forEach(type => {
+        const mediaType = this.mediaTypes_[type];
+        const activeGroup = mediaType ? mediaType.activeGroup() : null;
+        const pathway = this.contentSteeringController_.getPathway();
+        if (activeGroup && pathway) {
+          // activeGroup can be an array or a single group
+          const mediaPlaylists = activeGroup.length ? activeGroup[0].playlists : activeGroup.playlists;
+          const dashMediaPlaylists = mediaPlaylists.filter(p => p.attributes.serviceLocation === pathway); // Switch the current active playlist to the correct CDN
+
+          if (dashMediaPlaylists.length) {
+            this.mediaTypes_[type].activePlaylistLoader.media(dashMediaPlaylists[0]);
+          }
+        }
+      });
+    }
     /**
      * Start a timer that periodically calls checkABR_
      *
@@ -60181,8 +60633,9 @@
         }
         let updatedPlaylist = this.mainPlaylistLoader_.media();
         if (!updatedPlaylist) {
-          // exclude any variants that are not supported by the browser before selecting
+          this.initContentSteeringController_(); // exclude any variants that are not supported by the browser before selecting
           // an initial media as the playlist selectors do not consider browser support
+
           this.excludeUnsupportedVariants_();
           let selectedMedia;
           if (this.enableLowInitialPlaylist) {
@@ -60763,10 +61216,22 @@
         return this.mainPlaylistLoader_.load(isFinalRendition);
       }
       if (isFinalRendition) {
-        // Since we're on the final non-excluded playlist, and we're about to exclude
+        // If we're content steering, try other pathways.
+        if (this.main().contentSteering) {
+          const pathway = this.pathwayAttribute_(playlistToExclude); // Ignore at least 1 steering manifest refresh.
+
+          const reIncludeDelay = this.contentSteeringController_.steeringManifest.ttl * 1000;
+          this.contentSteeringController_.excludePathway(pathway);
+          this.excludeThenChangePathway_();
+          setTimeout(() => {
+            this.contentSteeringController_.addAvailablePathway(pathway);
+          }, reIncludeDelay);
+          return;
+        } // Since we're on the final non-excluded playlist, and we're about to exclude
         // it, instead of erring the player or retrying this playlist, clear out the current
         // exclusion list. This allows other playlists to be attempted in case any have been
         // fixed.
+
         let reincluded = false;
         playlists.forEach(playlist => {
           // skip current playlist which is about to be excluded
@@ -61104,6 +61569,7 @@
       this.decrypter_.terminate();
       this.mainPlaylistLoader_.dispose();
       this.mainSegmentLoader_.dispose();
+      this.contentSteeringController_.dispose();
       if (this.loadOnPlay_) {
         this.tech_.off('play', this.loadOnPlay_);
       }
@@ -61444,6 +61910,110 @@
         videoDuration
       });
     }
+    pathwayAttribute_(playlist) {
+      return playlist.attributes['PATHWAY-ID'] || playlist.attributes.serviceLocation;
+    }
+    /**
+     * Initialize content steering listeners and apply the tag properties.
+     */
+
+    initContentSteeringController_() {
+      const initialMain = this.main();
+      if (!initialMain.contentSteering) {
+        return;
+      }
+      const updateSteeringValues = main => {
+        for (const playlist of main.playlists) {
+          this.contentSteeringController_.addAvailablePathway(this.pathwayAttribute_(playlist));
+        }
+        this.contentSteeringController_.assignTagProperties(main.uri, main.contentSteering);
+      };
+      updateSteeringValues(initialMain);
+      this.contentSteeringController_.on('content-steering', this.excludeThenChangePathway_.bind(this)); // We need to ensure we update the content steering values when a new
+      // manifest is loaded in live DASH with content steering.
+
+      if (this.sourceType_ === 'dash') {
+        this.mainPlaylistLoader_.on('mediaupdatetimeout', () => {
+          this.mainPlaylistLoader_.refreshMedia_(this.mainPlaylistLoader_.media().id); // clear past values
+
+          this.contentSteeringController_.abort();
+          this.contentSteeringController_.clearTTLTimeout_();
+          this.contentSteeringController_.clearAvailablePathways();
+          updateSteeringValues(this.main());
+        });
+      } // Do this at startup only, after that the steering requests are managed by the Content Steering class.
+      // DASH queryBeforeStart scenarios will be handled by the Content Steering class.
+
+      if (!this.contentSteeringController_.queryBeforeStart) {
+        this.tech_.one('canplay', () => {
+          this.contentSteeringController_.requestSteeringManifest();
+        });
+      }
+    }
+    /**
+     * Simple exclude and change playlist logic for content steering.
+     */
+
+    excludeThenChangePathway_() {
+      const currentPathway = this.contentSteeringController_.getPathway();
+      if (!currentPathway) {
+        return;
+      }
+      const main = this.main();
+      const playlists = main.playlists;
+      const ids = new Set();
+      let didEnablePlaylists = false;
+      Object.keys(playlists).forEach(key => {
+        const variant = playlists[key];
+        const pathwayId = this.pathwayAttribute_(variant);
+        const differentPathwayId = pathwayId && currentPathway !== pathwayId;
+        const steeringExclusion = variant.excludeUntil === Infinity && variant.lastExcludeReason_ === 'content-steering';
+        if (steeringExclusion && !differentPathwayId) {
+          delete variant.excludeUntil;
+          delete variant.lastExcludeReason_;
+          didEnablePlaylists = true;
+        }
+        const noExcludeUntil = !variant.excludeUntil && variant.excludeUntil !== Infinity;
+        const shouldExclude = !ids.has(variant.id) && differentPathwayId && noExcludeUntil;
+        if (!shouldExclude) {
+          return;
+        }
+        ids.add(variant.id);
+        variant.excludeUntil = Infinity;
+        variant.lastExcludeReason_ = 'content-steering'; // TODO: kind of spammy, maybe move this.
+
+        this.logger_(`excluding ${variant.id} for ${variant.lastExcludeReason_}`);
+      });
+      if (this.contentSteeringController_.manifestType_ === 'DASH') {
+        Object.keys(this.mediaTypes_).forEach(key => {
+          const type = this.mediaTypes_[key];
+          if (type.activePlaylistLoader) {
+            const currentPlaylist = type.activePlaylistLoader.media_; // Check if the current media playlist matches the current CDN
+
+            if (currentPlaylist && currentPlaylist.attributes.serviceLocation !== currentPathway) {
+              didEnablePlaylists = true;
+            }
+          }
+        });
+      }
+      if (didEnablePlaylists) {
+        this.changeSegmentPathway_();
+      }
+    }
+    /**
+     * Changes the current playlists for audio, video and subtitles after a new pathway
+     * is chosen from content steering.
+     */
+
+    changeSegmentPathway_() {
+      const nextPlaylist = this.selectPlaylist();
+      this.pauseLoading(); // Switch audio and text track playlists if necessary in DASH
+
+      if (this.contentSteeringController_.manifestType_ === 'DASH') {
+        this.switchMediaForDASHContentSteering_();
+      }
+      this.switchMedia_(nextPlaylist, 'content-steering');
+    }
   }
 
   /**
@@ -62192,8 +62762,8 @@
   const reloadSourceOnError = function (options) {
     initPlugin(this, options);
   };
-  var version$4 = "3.6.0";
-  var version$3 = "7.0.0";
+  var version$4 = "3.7.0";
+  var version$3 = "7.0.1";
   var version$2 = "1.2.2";
   var version$1 = "7.1.0";
   var version = "4.0.1";